WIP: Add support for --registry

Cargo.toml

@@ -1,32 +1,24 @@
 [package]
-authors = [
-    "Without Boats <[email protected]>",
-    "Pascal Hertleif <[email protected]>",
-    "Sebastian Garrido <[email protected]>",
-    "Jonas Platte <[email protected]>",
-    "Benjamin Gill <[email protected]>",
-    "Andronik Ordian <[email protected]>",
-]
-categories = [
-    "development-tools",
-    "development-tools::cargo-plugins",
-]
+authors = ["Without Boats <[email protected]>", "Pascal Hertleif <[email protected]>", "Sebastian Garrido <[email protected]>", "Jonas Platte <[email protected]>", "Benjamin Gill <[email protected]>", "Andronik Ordian <[email protected]>"]
+categories = ["development-tools", "development-tools::cargo-plugins"]
 description = "This extends Cargo to allow you to add and remove dependencies by modifying your `Cargo.toml` file from the command line. It contains `cargo add`, `cargo rm`, and `cargo upgrade`."
 documentation = "https://github.com/killercup/cargo-edit/blob/master/README.md#available-subcommands"
 homepage = "https://github.com/killercup/cargo-edit"
-keywords = [
-    "cargo",
-    "cargo-subcommand",
-    "cli",
-    "dependencies",
-    "crates",
-]
+keywords = ["cargo", "cargo-subcommand", "cli", "dependencies", "crates"]
 license = "Apache-2.0/MIT"
 name = "cargo-edit"
 readme = "README.md"
 repository = "https://github.com/killercup/cargo-edit"
 version = "0.3.1"
 
+[badges]
+
+[badges.appveyor]
+repository = "killercup/cargo-edit"
+
+[badges.travis-ci]
+repository = "killercup/cargo-edit"
+
 [[bin]]
 name = "cargo-add"
 path = "src/bin/add/main.rs"
@@ -42,26 +34,23 @@ name = "cargo-upgrade"
 path = "src/bin/upgrade/main.rs"
 required-features = ["upgrade"]
 
-[badges.appveyor]
-repository = "killercup/cargo-edit"
-
-[badges.travis-ci]
-repository = "killercup/cargo-edit"
-
 [dependencies]
+atty = "0.2"
+cargo = "0.30.0"
 cargo_metadata = "0.6.0"
 docopt = "1.0"
 env_proxy = "0.2"
 error-chain = "0.12.0"
+git2 = "0.7.5"
 pad = "0.1"
 regex = "1.0"
 reqwest = "0.9"
 serde = "1.0"
 serde_derive = "1.0"
 serde_json = "1.0"
+tempdir = "0.3.7"
 termcolor = "1.0.4"
 toml_edit = "0.1.2"
-atty = "0.2"
 
 [dependencies.semver]
 features = ["serde"]
@@ -74,11 +63,7 @@ tempdir = "0.3"
 
 [features]
 add = []
-default = [
-    "add",
-    "rm",
-    "upgrade",
-]
+default = ["add", "rm", "upgrade"]
 rm = []
 test-external-apis = []
 unstable = []

src/bin/add/args.rs

@@ -4,6 +4,10 @@ use cargo_edit::Dependency;
 use cargo_edit::{get_latest_dependency, CrateName};
 use semver;
 use std::path::PathBuf;
+use cargo;
+use git2;
+use serde_json;
+use tempdir;
 
 use errors::*;
 
@@ -38,6 +42,8 @@ pub struct Args {
     pub flag_allow_prerelease: bool,
     /// '--quiet'
     pub flag_quiet: bool,
+    /// '--registry'
+    pub flag_registry: Option<String>,
 }
 
 fn parse_version_req(s: &str) -> Result<&str> {
@@ -68,6 +74,8 @@ impl Args {
 
     /// Build dependencies from arguments
     pub fn parse_dependencies(&self) -> Result<Vec<Dependency>> {
+        let registry = self.flag_registry.clone();
+
         if !self.arg_crates.is_empty() {
             return self.arg_crates
                 .iter()
@@ -76,8 +84,8 @@ impl Args {
                         if let Some(krate) = CrateName::new(crate_name).parse_as_version()? {
                             krate
                         } else {
-                            get_latest_dependency(crate_name, self.flag_allow_prerelease)?
-                        }.set_optional(self.flag_optional),
+                            get_latest_dependency(crate_name, self.flag_allow_prerelease, registry.clone())?
+                        }.set_optional(self.flag_optional).set_registry(registry.clone())
                     )
                 })
                 .collect();
@@ -119,15 +127,16 @@ impl Args {
                 }
                 (&None, &None, &Some(ref path)) => dependency.set_path(path.to_str().unwrap()),
                 (&None, &None, &None) => {
-                    let dep = get_latest_dependency(&self.arg_crate, self.flag_allow_prerelease)?;
+                    let registry = self.flag_registry.clone();
+                    let dep = get_latest_dependency(&self.arg_crate, self.flag_allow_prerelease, registry.clone())?;
                     let v = format!(
                         "{prefix}{version}",
                         prefix = self.get_upgrade_prefix().unwrap_or(""),
                         // If version is unavailable `get_latest_dependency` must have
                         // returned `Err(FetchVersionError::GetVersion)`
                         version = dep.version().unwrap_or_else(|| unreachable!())
                     );
-                    dep.set_version(&v)
+                    dep.set_version(&v).set_registry(registry)
                 }
             }
         } else {
@@ -173,6 +182,7 @@ impl Default for Args {
             flag_upgrade: None,
             flag_allow_prerelease: false,
             flag_quiet: false,
+            flag_registry: None,
         }
     }
 }

src/bin/add/main.rs

@@ -6,12 +6,16 @@
 )]
 
 extern crate atty;
+extern crate cargo;
 extern crate docopt;
 #[macro_use]
 extern crate error_chain;
+extern crate git2;
 extern crate semver;
 #[macro_use]
 extern crate serde_derive;
+extern crate serde_json;
+extern crate tempdir;
 extern crate termcolor;
 
 use std::io::Write;
@@ -62,6 +66,7 @@ Specify what crate to add:
     --git <uri>             Specify a git repository to download the crate from. This does not work
                             if either a version or path (or both) is specified.
     --path <uri>            Specify the path the crate should be loaded from.
+    --registry <registry>   Specify the crate registry to use.
 
 Specify where to add the crate:
     -D --dev                Add crate as development dependency.

src/bin/rm/main.rs

@@ -6,11 +6,15 @@
 )]
 
 extern crate atty;
+extern crate cargo;
 extern crate docopt;
 #[macro_use]
 extern crate error_chain;
+extern crate git2;
 #[macro_use]
 extern crate serde_derive;
+extern crate serde_json;
+extern crate tempdir;
 extern crate termcolor;
 
 use std::io::Write;

src/bin/upgrade/main.rs

@@ -5,12 +5,16 @@
     unused_qualifications
 )]
 
+extern crate cargo;
 extern crate cargo_metadata;
 extern crate docopt;
 #[macro_use]
 extern crate error_chain;
+extern crate git2;
 #[macro_use]
 extern crate serde_derive;
+extern crate serde_json;
+extern crate tempdir;
 extern crate toml_edit;
 
 use std::collections::HashMap;
@@ -213,7 +217,7 @@ impl DesiredUpgrades {
                 if let Some(v) = version {
                     Ok((name, v))
                 } else {
-                    get_latest_dependency(&name, allow_prerelease)
+                    get_latest_dependency(&name, allow_prerelease, None)
                         .map(|new_dep| {
                             (
                                 name,

src/dependency.rs

@@ -16,6 +16,7 @@ pub struct Dependency {
     pub name: String,
     optional: bool,
     source: DependencySource,
+    registry: Option<String>,
 }
 
 impl Default for Dependency {
@@ -27,6 +28,7 @@ impl Default for Dependency {
                 version: None,
                 path: None,
             },
+            registry: None,
         }
     }
 }
@@ -80,6 +82,12 @@ impl Dependency {
         self
     }
 
+    /// Set dependency to a given repository
+    pub fn set_registry(mut self, registry: Option<String>) -> Dependency {
+        self.registry = registry;
+        self
+    }
+
     /// Get version of dependency
     pub fn version(&self) -> Option<&str> {
         if let DependencySource::Version {
@@ -99,17 +107,18 @@ impl Dependency {
     /// or the path/git repository as an `InlineTable`.
     /// (If the dependency is set as `optional`, an `InlineTable` is returned in any case.)
     pub fn to_toml(&self) -> (String, toml_edit::Item) {
-        let data: toml_edit::Item = match (self.optional, self.source.clone()) {
+        let data: toml_edit::Item = match (self.optional, self.source.clone(), self.registry.clone()) {
             // Extra short when version flag only
             (
                 false,
                 DependencySource::Version {
                     version: Some(v),
                     path: None,
                 },
+                None,
             ) => toml_edit::value(v),
             // Other cases are represented as an inline table
-            (optional, source) => {
+            (optional, source, registry) => {
                 let mut data = toml_edit::InlineTable::default();
 
                 match source {
@@ -120,6 +129,9 @@ impl Dependency {
                         if let Some(p) = path {
                             data.get_or_insert("path", p);
                         }
+                        if let Some(r) = registry {
+                            data.get_or_insert("registry", r);
+                        }
                     }
                     DependencySource::Git(v) => {
                         data.get_or_insert("git", v);

src/errors.rs

@@ -47,5 +47,9 @@ error_chain!{
             description("non existent dependency")
             display("The dependency `{}` could not be found in `{}`.", name, table)
         }
+        /// Failed to lookup the API endpoint for the registry
+        LookupApiFailure {
+            description("Failed to lookup the API endpoint for the registry")
+        }
     }
 }

src/fetch.rs

@@ -1,12 +1,16 @@
+use cargo;
 use env_proxy;
+use git2;
 use regex::Regex;
 use reqwest;
 use semver;
 use serde_json as json;
 use std::env;
+use std::fs::File;
 use std::io::Read;
 use std::path::Path;
 use std::time::Duration;
+use tempdir;
 use {Dependency, Manifest};
 
 use errors::*;
@@ -27,14 +31,19 @@ struct CrateVersion {
     yanked: bool,
 }
 
+#[derive(Deserialize)]
+struct RegistryConfig {
+    api: String,
+}
+
 /// Query latest version from crates.io
 ///
 /// The latest version will be returned as a `Dependency`. This will fail, when
 ///
 /// - there is no Internet connection,
 /// - the response from crates.io is an error or in an incorrect format,
 /// - or when a crate with the given name does not exist on crates.io.
-pub fn get_latest_dependency(crate_name: &str, flag_allow_prerelease: bool) -> Result<Dependency> {
+pub fn get_latest_dependency(crate_name: &str, flag_allow_prerelease: bool, registry: Option<String>) -> Result<Dependency> {
     if env::var("CARGO_IS_TEST").is_ok() {
         // We are in a simulated reality. Nothing is real here.
         // FIXME: Use actual test handling code.
@@ -47,7 +56,9 @@ pub fn get_latest_dependency(crate_name: &str, flag_allow_prerelease: bool) -> R
         return Ok(Dependency::new(crate_name).set_version(&new_version));
     }
 
-    let crate_versions = fetch_cratesio(crate_name)?;
+    let api = get_registry_api(registry)?;
+
+    let crate_versions = fetch_crate_versions(&api, crate_name)?;
 
     let dep = read_latest_version(&crate_versions, flag_allow_prerelease)?;
 
@@ -58,6 +69,32 @@ pub fn get_latest_dependency(crate_name: &str, flag_allow_prerelease: bool) -> R
     Ok(dep)
 }
 
+fn get_registry_api(registry: Option<String>) -> Result<String> {
+
+    let tmp_dir = tempdir::TempDir::new("registry").chain_err(|| ErrorKind::LookupApiFailure)?;
+
+    let cargo_config = cargo::Config::default().map_err(|_err| ErrorKind::LookupApiFailure)?;
+
+    // First lets work out what the git index is for the registry
+    let index = if let Some(registry) = registry {    
+        cargo_config.get_registry_index(&registry).map_err(|_err| ErrorKind::LookupApiFailure)?.to_string()
+    } else {
+        match cargo_config.get_string("registry.index").map_err(|_err| ErrorKind::LookupApiFailure)? {
+            None => return Ok(REGISTRY_HOST.to_string()),
+            Some(index) => index.val,
+        }
+    };
+
+    // Now to clone the registry
+    let _repo = git2::Repository::clone(&index, tmp_dir.path().clone()).chain_err(|| ErrorKind::LookupApiFailure)?;
+
+    let file = File::open(tmp_dir.path().join("config.json")).chain_err(|| ErrorKind::LookupApiFailure)?;
+
+    let registry_config : RegistryConfig = json::from_reader(file).chain_err(|| ErrorKind::LookupApiFailure)?;
+
+    Ok(registry_config.api)
+}
+
 // Checks whether a version object is a stable release
 fn version_is_stable(version: &CrateVersion) -> bool {
     !version.version.is_prerelease()
@@ -186,10 +223,10 @@ fn get_no_latest_version_from_json_when_all_are_yanked() {
     assert!(read_latest_version(&versions, false).is_err());
 }
 
-fn fetch_cratesio(crate_name: &str) -> Result<Versions> {
+fn fetch_crate_versions(api: &str, crate_name: &str) -> Result<Versions> {
     let url = format!(
-        "{host}/api/v1/crates/{crate_name}",
-        host = REGISTRY_HOST,
+        "{api}/api/v1/crates/{crate_name}",
+        api = api,
         crate_name = crate_name
     );