Implement cargo install

src/bin/cargo.rs

@@ -69,6 +69,7 @@ macro_rules! each_subcommand{ ($mac:ident) => ({
     $mac!(generate_lockfile);
     $mac!(git_checkout);
     $mac!(help);
+    $mac!(install);
     $mac!(locate_project);
     $mac!(login);
     $mac!(new);
@@ -81,6 +82,7 @@ macro_rules! each_subcommand{ ($mac:ident) => ({
     $mac!(rustc);
     $mac!(search);
     $mac!(test);
+    $mac!(uninstall);
     $mac!(update);
     $mac!(verify_project);
     $mac!(version);

src/bin/install.rs

@@ -0,0 +1,130 @@
+use std::path::Path;
+
+use cargo::ops;
+use cargo::core::{SourceId, GitReference};
+use cargo::util::{CliResult, Config, ToUrl, human};
+
+#[derive(RustcDecodable)]
+struct Options {
+    flag_jobs: Option<u32>,
+    flag_features: Vec<String>,
+    flag_no_default_features: bool,
+    flag_debug: bool,
+    flag_bin: Vec<String>,
+    flag_example: Vec<String>,
+    flag_verbose: bool,
+    flag_quiet: bool,
+    flag_color: Option<String>,
+    flag_root: Option<String>,
+    flag_list: bool,
+
+    arg_crate: Option<String>,
+    flag_vers: Option<String>,
+
+    flag_git: Option<String>,
+    flag_branch: Option<String>,
+    flag_tag: Option<String>,
+    flag_rev: Option<String>,
+
+    flag_path: Option<String>,
+}
+
+pub const USAGE: &'static str = "
+Install a Rust binary
+
+Usage:
+    cargo install [options] [<crate>]
+    cargo install [options] --list
+
+Specifying what crate to install:
+    --vers VERS               Specify a version to install from crates.io
+    --git URL                 Git URL to install the specified crate from
+    --branch BRANCH           Branch to use when installing from git
+    --tag TAG                 Tag to use when installing from git
+    --rev SHA                 Specific commit to use when installing from git
+    --path PATH               Filesystem path to local crate to install
+
+Build and install options:
+    -h, --help                Print this message
+    -j N, --jobs N            The number of jobs to run in parallel
+    --features FEATURES       Space-separated list of features to activate
+    --no-default-features     Do not build the `default` feature
+    --debug                   Build in debug mode instead of release mode
+    --bin NAME                Only install the binary NAME
+    --example EXAMPLE         Install the example EXAMPLE instead of binaries
+    --root DIR                Directory to install packages into
+    -v, --verbose             Use verbose output
+    -q, --quiet               Less output printed to stdout
+    --color WHEN              Coloring: auto, always, never
+
+This command manages Cargo's local set of install binary crates. Only packages
+which have [[bin]] targets can be installed, and all binaries are installed into
+the installation root's `bin` folder. The installation root is determined, in
+order of precedence, by `--root`, `$CARGO_INSTALL_ROOT`, the `install.root`
+configuration key, and finally the home directory (which is either
+`$CARGO_HOME` if set or `$HOME/.cargo` by default).
+
+There are multiple sources from which a crate can be installed. The default
+location is crates.io but the `--git` and `--path` flags can change this source.
+If the source contains more than one package (such as crates.io or a git
+repository with multiple crates) the `<crate>` argument is required to indicate
+which crate should be installed.
+
+Crates from crates.io can optionally specify the version they wish to install
+via the `--vers` flags, and similarly packages from git repositories can
+optionally specify the branch, tag, or revision that should be installed. If a
+crate has multiple binaries, the `--bin` argument can selectively install only
+one of them, and if you'd rather install examples the `--example` argument can
+be used as well.
+
+The `--list` option will list all installed packages (and their versions).
+";
+
+pub fn execute(options: Options, config: &Config) -> CliResult<Option<()>> {
+    try!(config.shell().set_verbosity(options.flag_verbose, options.flag_quiet));
+    try!(config.shell().set_color_config(options.flag_color.as_ref().map(|s| &s[..])));
+
+    let compile_opts = ops::CompileOptions {
+        config: config,
+        jobs: options.flag_jobs,
+        target: None,
+        features: &options.flag_features,
+        no_default_features: options.flag_no_default_features,
+        spec: &[],
+        exec_engine: None,
+        mode: ops::CompileMode::Build,
+        release: !options.flag_debug,
+        filter: ops::CompileFilter::new(false, &options.flag_bin, &[],
+                                        &options.flag_example, &[]),
+        target_rustc_args: None,
+    };
+
+    let source = if let Some(url) = options.flag_git {
+        let url = try!(url.to_url().map_err(human));
+        let gitref = if let Some(branch) = options.flag_branch {
+            GitReference::Branch(branch)
+        } else if let Some(tag) = options.flag_tag {
+            GitReference::Tag(tag)
+        } else if let Some(rev) = options.flag_rev {
+            GitReference::Rev(rev)
+        } else {
+            GitReference::Branch("master".to_string())
+        };
+        SourceId::for_git(&url, gitref)
+    } else if let Some(path) = options.flag_path {
+        try!(SourceId::for_path(Path::new(&path)))
+    } else {
+        try!(SourceId::for_central(config))
+    };
+
+    let krate = options.arg_crate.as_ref().map(|s| &s[..]);
+    let vers = options.flag_vers.as_ref().map(|s| &s[..]);
+    let root = options.flag_root.as_ref().map(|s| &s[..]);
+
+    if options.flag_list {
+        try!(ops::install_list(root, config));
+    } else {
+        try!(ops::install(root, krate, &source, vers, &compile_opts));
+    }
+    Ok(None)
+}

src/bin/uninstall.rs

@@ -0,0 +1,43 @@
+use cargo::ops;
+use cargo::util::{CliResult, Config};
+
+#[derive(RustcDecodable)]
+struct Options {
+    flag_bin: Vec<String>,
+    flag_root: Option<String>,
+    flag_verbose: bool,
+    flag_quiet: bool,
+    flag_color: Option<String>,
+
+    arg_spec: String,
+}
+
+pub const USAGE: &'static str = "
+Remove a Rust binary
+
+Usage:
+    cargo uninstall [options] <spec>
+
+Options:
+    -h, --help                Print this message
+    --root DIR                Directory to uninstall packages from
+    --bin NAME                Only uninstall the binary NAME
+    -v, --verbose             Use verbose output
+    -q, --quiet               Less output printed to stdout
+    --color WHEN              Coloring: auto, always, never
+
+The argument SPEC is a package id specification (see `cargo help pkgid`) to
+specify which crate should be uninstalled. By default all binaries are
+uninstalled for a crate but the `--bin` and `--example` flags can be used to
+only uninstall particular binaries.
+";
+
+pub fn execute(options: Options, config: &Config) -> CliResult<Option<()>> {
+    try!(config.shell().set_verbosity(options.flag_verbose, options.flag_quiet));
+    try!(config.shell().set_color_config(options.flag_color.as_ref().map(|s| &s[..])));
+
+    let root = options.flag_root.as_ref().map(|s| &s[..]);
+    try!(ops::uninstall(root, &options.arg_spec, &options.flag_bin, config));
+    Ok(None)
+}
+

src/cargo/core/package_id_spec.rs

@@ -1,4 +1,6 @@
+use std::collections::HashMap;
 use std::fmt;
+
 use semver::Version;
 use url::{self, Url, UrlParser};
 
@@ -45,6 +47,15 @@ impl PackageIdSpec {
         })
     }
 
+    pub fn query_str<'a, I>(spec: &str, i: I) -> CargoResult<&'a PackageId>
+        where I: IntoIterator<Item=&'a PackageId>
+    {
+        let spec = try!(PackageIdSpec::parse(spec).chain_error(|| {
+            human(format!("invalid package id specification: `{}`", spec))
+        }));
+        spec.query(i)
+    }
+
     pub fn from_package_id(package_id: &PackageId) -> PackageIdSpec {
         PackageIdSpec {
             name: package_id.name().to_string(),
@@ -115,6 +126,51 @@ impl PackageIdSpec {
             None => true
         }
     }
+
+    pub fn query<'a, I>(&self, i: I) -> CargoResult<&'a PackageId>
+        where I: IntoIterator<Item=&'a PackageId>
+    {
+        let mut ids = i.into_iter().filter(|p| self.matches(*p));
+        let ret = match ids.next() {
+            Some(id) => id,
+            None => return Err(human(format!("package id specification `{}` \
+                                              matched no packages", self))),
+        };
+        return match ids.next() {
+            Some(other) => {
+                let mut msg = format!("There are multiple `{}` packages in \
+                                       your project, and the specification \
+                                       `{}` is ambiguous.\n\
+                                       Please re-run this command \
+                                       with `-p <spec>` where `<spec>` is one \
+                                       of the following:",
+                                      self.name(), self);
+                let mut vec = vec![ret, other];
+                vec.extend(ids);
+                minimize(&mut msg, vec, self);
+                Err(human(msg))
+            }
+            None => Ok(ret)
+        };
+
+        fn minimize(msg: &mut String,
+                    ids: Vec<&PackageId>,
+                    spec: &PackageIdSpec) {
+            let mut version_cnt = HashMap::new();
+            for id in ids.iter() {
+                *version_cnt.entry(id.version()).or_insert(0) += 1;
+            }
+            for id in ids.iter() {
+                if version_cnt[id.version()] == 1 {
+                    msg.push_str(&format!("\n  {}:{}", spec.name(),
+                                          id.version()));
+                } else {
+                    msg.push_str(&format!("\n  {}",
+                                          PackageIdSpec::from_package_id(*id)));
+                }
+            }
+        }
+    }
 }
 
 fn url(s: &str) -> url::ParseResult<Url> {

src/cargo/core/registry.rs

@@ -154,6 +154,16 @@ impl<'cfg> PackageRegistry<'cfg> {
         Ok(())
     }
 
+    pub fn add_preloaded(&mut self, id: &SourceId, source: Box<Source + 'cfg>) {
+        self.add_source(id, source, Kind::Locked);
+    }
+
+    fn add_source(&mut self, id: &SourceId, source: Box<Source + 'cfg>,
+                  kind: Kind) {
+        self.sources.insert(id, source);
+        self.source_ids.insert(id.clone(), (id.clone(), kind));
+    }
+
     pub fn add_overrides(&mut self, ids: Vec<SourceId>) -> CargoResult<()> {
         for id in ids.iter() {
             try!(self.load(id, Kind::Override));
@@ -183,8 +193,7 @@ impl<'cfg> PackageRegistry<'cfg> {
             }
 
             // Save off the source
-            self.sources.insert(source_id, source);
-            self.source_ids.insert(source_id.clone(), (source_id.clone(), kind));
+            self.add_source(source_id, source, kind);
 
             Ok(())
         }).chain_error(|| human(format!("Unable to update {}", source_id)))

src/cargo/core/resolver/mod.rs

@@ -55,7 +55,7 @@ use semver;
 
 use core::{PackageId, Registry, SourceId, Summary, Dependency};
 use core::PackageIdSpec;
-use util::{CargoResult, Graph, human, ChainError, CargoError};
+use util::{CargoResult, Graph, human, CargoError};
 use util::profile;
 use util::graph::{Nodes, Edges};
 
@@ -118,55 +118,13 @@ impl Resolve {
         self.graph.edges(pkg)
     }
 
-    pub fn query(&self, spec: &str) -> CargoResult<&PackageId> {
-        let spec = try!(PackageIdSpec::parse(spec).chain_error(|| {
-            human(format!("invalid package id specification: `{}`", spec))
-        }));
-        let mut ids = self.iter().filter(|p| spec.matches(*p));
-        let ret = match ids.next() {
-            Some(id) => id,
-            None => return Err(human(format!("package id specification `{}` \
-                                              matched no packages", spec))),
-        };
-        return match ids.next() {
-            Some(other) => {
-                let mut msg = format!("There are multiple `{}` packages in \
-                                       your project, and the specification \
-                                       `{}` is ambiguous.\n\
-                                       Please re-run this command \
-                                       with `-p <spec>` where `<spec>` is one \
-                                       of the following:",
-                                      spec.name(), spec);
-                let mut vec = vec![ret, other];
-                vec.extend(ids);
-                minimize(&mut msg, vec, &spec);
-                Err(human(msg))
-            }
-            None => Ok(ret)
-        };
-
-        fn minimize(msg: &mut String,
-                    ids: Vec<&PackageId>,
-                    spec: &PackageIdSpec) {
-            let mut version_cnt = HashMap::new();
-            for id in ids.iter() {
-                *version_cnt.entry(id.version()).or_insert(0) += 1;
-            }
-            for id in ids.iter() {
-                if version_cnt[id.version()] == 1 {
-                    msg.push_str(&format!("\n  {}:{}", spec.name(),
-                                          id.version()));
-                } else {
-                    msg.push_str(&format!("\n  {}",
-                                          PackageIdSpec::from_package_id(*id)));
-                }
-            }
-        }
-    }
-
     pub fn features(&self, pkg: &PackageId) -> Option<&HashSet<String>> {
         self.features.get(pkg)
     }
+
+    pub fn query(&self, spec: &str) -> CargoResult<&PackageId> {
+        PackageIdSpec::query_str(spec, self.iter())
+    }
 }
 
 impl fmt::Debug for Resolve {

src/cargo/core/source.rs

@@ -129,17 +129,19 @@ impl SourceId {
                 SourceId::new(Kind::Registry, url)
                          .with_precise(Some("locked".to_string()))
             }
-            "path" => SourceId::for_path(Path::new(&url[5..])).unwrap(),
+            "path" => {
+                let url = url.to_url().unwrap();
+                SourceId::new(Kind::Path, url)
+            }
             _ => panic!("Unsupported serialized SourceId")
         }
     }
 
     pub fn to_url(&self) -> String {
         match *self.inner {
-            SourceIdInner { kind: Kind::Path, .. } => {
-                panic!("Path sources are not included in the lockfile, \
-                       so this is unimplemented")
-            },
+            SourceIdInner { kind: Kind::Path, ref url, .. } => {
+                format!("path+{}", url)
+            }
             SourceIdInner {
                 kind: Kind::Git(ref reference), ref url, ref precise, ..
             } => {