upgrade cargo and start fixing upgrade errors

Author: QuietMisdreavus

Cargo.lock

@@ -12,11 +12,11 @@ log = "0.3"
 rustc-serialize = "0.3"
 regex = "0.2"
 clap = "2"
-crates-index-diff = "3"
-git2 = "0.6"
+crates-index-diff = "4"
+git2 = "0.7"
 time = "0.1"
-reqwest = "0.5"
-semver = "0.6"
+reqwest = "0.9"
+semver = "0.9"
 slug = "=0.1.1"
 env_logger = "0.4"
 magic = "0.12"
@@ -25,10 +25,11 @@ r2d2_postgres = "0.12"
 url = "1.4"
 libc = "0.2"
 badge = { version = "0", path = "src/web/badge" }
-error-chain = "0.10"
+error-chain = "0.12"
 comrak = { version = "0.2.10", default-features = false }
 toml = "0.4"
 html5ever = "0.22"
+cargo = "0.30"
 
 # iron dependencies
 iron = "0.5"
@@ -37,10 +38,6 @@ handlebars-iron = "0.22"
 params = "0.6"
 staticfile = { version = "0.4", features = [ "cache" ] }
 
-[dependencies.cargo]
-git = "https://github.com/onur/cargo.git"
-branch = "docs.rs"
-
 [dependencies.postgres]
 version = "0.14"
 features = [ "with-time", "with-rustc-serialize" ]
@@ -50,8 +47,8 @@ tempdir = "0.3"
 
 [build-dependencies]
 time = "0.1"
-git2 = "0.6"
-sass-rs = "0.0.18"
+git2 = "0.7"
+sass-rs = "0.2"
 
 [[bin]]
 name = "cratesfyi"

Cargo.toml

@@ -40,10 +40,10 @@ fn get_git_hash() -> Option<String> {
 
 
 fn compile_sass() {
-    use sass_rs::sass_context::SassFileContext;
+    use sass_rs::Context;
 
-    let mut file_context = SassFileContext::new(concat!(env!("CARGO_MANIFEST_DIR"),
-                                                        "/templates/style.scss"));
+    let mut file_context = Context::new_file(concat!(env!("CARGO_MANIFEST_DIR"),
+                                                     "/templates/style.scss")).unwrap();
     let css = file_context.compile().unwrap();
     let dest_path = Path::new(&env::var("OUT_DIR").unwrap()).join("style.css");
     let mut file = File::create(&dest_path).unwrap();

build.rs

@@ -13,7 +13,7 @@ use cargo::core::{Package, TargetKind};
 use rustc_serialize::json::{Json, ToJson};
 use slug::slugify;
 use reqwest::Client;
-use reqwest::header::{Accept, qitem};
+use reqwest::header::ACCEPT;
 use semver;
 use postgres::Connection;
 use time;
@@ -197,11 +197,11 @@ pub fn add_build_into_database(conn: &Connection,
 
 fn initialize_package_in_database(conn: &Connection, pkg: &Package) -> Result<i32> {
     let mut rows = try!(conn.query("SELECT id FROM crates WHERE name = $1",
-                                   &[&pkg.manifest().name()]));
+                                   &[&pkg.manifest().name().as_str()]));
     // insert crate into database if it is not exists
     if rows.len() == 0 {
         rows = try!(conn.query("INSERT INTO crates (name) VALUES ($1) RETURNING id",
-                               &[&pkg.manifest().name()]));
+                               &[&pkg.manifest().name().as_str()]));
     }
     Ok(rows.get(0).get(0))
 }
@@ -212,7 +212,7 @@ fn initialize_package_in_database(conn: &Connection, pkg: &Package) -> Result<i3
 fn convert_dependencies(pkg: &Package) -> Vec<(String, String)> {
     let mut dependencies: Vec<(String, String)> = Vec::new();
     for dependency in pkg.manifest().dependencies() {
-        let name = dependency.name().to_string();
+        let name = dependency.package_name().to_string();
         let version = format!("{}", dependency.version_req());
         dependencies.push((name, version));
     }
@@ -279,9 +279,9 @@ fn get_release_time_yanked_downloads
                       pkg.manifest().name());
     // FIXME: There is probably better way to do this
     //        and so many unwraps...
-    let client = try!(Client::new());
+    let client = Client::new();
     let mut res = try!(client.get(&url[..])
-        .header(Accept(vec![qitem("application/json".parse().unwrap())]))
+        .header(ACCEPT, "application/json")
         .send());
     let mut body = String::new();
     res.read_to_string(&mut body).unwrap();
@@ -387,9 +387,9 @@ fn add_owners_into_database(conn: &Connection, pkg: &Package, crate_id: &i32) ->
     // owners available in: https://crates.io/api/v1/crates/rand/owners
     let owners_url = format!("https://crates.io/api/v1/crates/{}/owners",
                              &pkg.manifest().name());
-    let client = try!(Client::new());
+    let client = Client::new();
     let mut res = try!(client.get(&owners_url[..])
-        .header(Accept(vec![qitem("application/json".parse().unwrap())]))
+        .header(ACCEPT, "application/json")
         .send());
     // FIXME: There is probably better way to do this
     //        and so many unwraps...

src/db/add_package.rs

@@ -239,7 +239,7 @@ impl DocBuilder {
         debug!("Cleaning package");
         use std::fs::remove_dir_all;
         let documentation_path = PathBuf::from(&self.options.destination)
-            .join(package.manifest().name());
+            .join(package.manifest().name().as_str());
         let source_path = source_path(&package).unwrap();
         // Some crates don't have documentation, so we don't care if removing_dir_all fails
         let _ = self.remove_build_dir();

src/docbuilder/chroot_builder.rs

@@ -19,7 +19,7 @@ error_chain! {
         ReqwestError(reqwest::Error);
         Git2Error(git2::Error);
         MagicError(MagicError);
-        CargoError(Box<cargo::CargoError>);
+        CargoError(cargo::CargoError);
         RegexError(regex::Error);
     }
 }

src/error.rs

@@ -8,9 +8,10 @@ use std::env;
 use std::sync::Arc;
 
 use cargo::core::{SourceId, Dependency, Registry, Source, Package, Workspace};
-use cargo::util::{CargoResult, Config, human, Filesystem};
+use cargo::core::compiler::{DefaultExecutor, CompileMode, MessageFormat, BuildConfig, Executor};
+use cargo::util::{CargoResult, Config, internal, Filesystem};
 use cargo::sources::SourceConfigMap;
-use cargo::ops::{self, Packages, DefaultExecutor};
+use cargo::ops::{self, Packages};
 
 use utils::{get_current_versions, parse_rustc_version};
 use error::Result;
@@ -37,17 +38,17 @@ pub fn build_doc(name: &str, vers: Option<&str>, target: Option<&str>) -> Result
     try!(source.update());
 
     let dep = try!(Dependency::parse_no_deprecated(name, vers, &source_id));
-    let deps = try!(source.query(&dep));
+    let deps = try!(source.query_vec(&dep));
     let pkg = try!(deps.iter().map(|p| p.package_id()).max()
                    // FIXME: This is probably not a rusty way to handle options and results
                    //        or maybe it is who knows...
                    .map(|pkgid| source.download(pkgid))
-                   .unwrap_or(Err(human("PKG download error"))));
+                   .unwrap_or(Err(internal("PKG download error"))));
 
     let current_dir = try!(env::current_dir());
     let target_dir = PathBuf::from(current_dir).join("cratesfyi");
 
-    let metadata = Metadata::from_package(&pkg).map_err(|e| human(e.description()))?;
+    let metadata = Metadata::from_package(&pkg).map_err(|e| internal(e.description()))?;
 
     // This is only way to pass rustc_args to cargo.
     // CompileOptions::target_rustc_args is used only for the current crate,
@@ -60,6 +61,8 @@ pub fn build_doc(name: &str, vers: Option<&str>, target: Option<&str>) -> Result
 
     // since https://github.com/rust-lang/rust/pull/48511 we can pass --resource-suffix to
     // add correct version numbers to css and javascript files
+    // TODO: we can add --extern-html-root-url too, thanks to
+    // https://github.com/rust-lang/rust/pull/51384
     let mut rustdoc_args: Vec<String> =
         vec!["-Z".to_string(), "unstable-options".to_string(),
              "--resource-suffix".to_string(),
@@ -68,28 +71,34 @@ pub fn build_doc(name: &str, vers: Option<&str>, target: Option<&str>) -> Result
         rustdoc_args.append(&mut package_rustdoc_args.iter().map(|s| s.to_owned()).collect());
     }
 
+    let mut build_config = try!(BuildConfig::new(&config,
+                                                 None,
+                                                 &target.map(|t| t.to_string()),
+                                                 CompileMode::Doc { deps: false }));
+    build_config.release = false;
+    build_config.message_format = MessageFormat::Human;
+
     let opts = ops::CompileOptions {
         config: &config,
-        jobs: None,
-        target: target,
-        features: &metadata.features.unwrap_or(Vec::new()),
+        build_config,
+        features: metadata.features.unwrap_or(Vec::new()),
         all_features: metadata.all_features,
         no_default_features: metadata.no_default_features,
-        spec: Packages::Packages(&[]),
-        mode: ops::CompileMode::Doc { deps: false },
-        release: false,
-        message_format: ops::MessageFormat::Human,
+        spec: Packages::Packages(Vec::new()),
         filter: ops::CompileFilter::new(true,
-                                        &[], false,
-                                        &[], false,
-                                        &[], false,
-                                        &[], false),
+                                        Vec::new(), false,
+                                        Vec::new(), false,
+                                        Vec::new(), false,
+                                        Vec::new(), false,
+                                        false),
         target_rustc_args: None,
-        target_rustdoc_args: Some(rustdoc_args.as_slice()),
+        target_rustdoc_args: Some(rustdoc_args),
+        export_dir: None,
     };
 
     let ws = try!(Workspace::ephemeral(pkg, &config, Some(Filesystem::new(target_dir)), false));
-    try!(ops::compile_ws(&ws, Some(source), &opts, Arc::new(DefaultExecutor)));
+    let exec: Arc<Executor> = Arc::new(DefaultExecutor);
+    try!(ops::compile_ws(&ws, Some(source), &opts, &exec));
 
     Ok(try!(ws.current()).clone())
 }
@@ -108,12 +117,12 @@ pub fn get_package(name: &str, vers: Option<&str>) -> CargoResult<Package> {
     try!(source.update());
 
     let dep = try!(Dependency::parse_no_deprecated(name, vers, &source_id));
-    let deps = try!(source.query(&dep));
+    let deps = try!(source.query_vec(&dep));
     let pkg = try!(deps.iter().map(|p| p.package_id()).max()
                    // FIXME: This is probably not a rusty way to handle options and results
                    //        or maybe it is who knows...
                    .map(|pkgid| source.download(pkgid))
-                   .unwrap_or(Err(human("PKG download error"))));
+                   .unwrap_or(Err(internal("PKG download error"))));
 
     Ok(pkg)
 }

src/utils/build_doc.rs

@@ -74,24 +74,24 @@ fn get_github_fields(path: &str) -> Result<GitHubFields> {
     let body = {
         use std::io::Read;
         use reqwest::{Client, StatusCode};
-        use reqwest::header::{UserAgent, Authorization, Basic};
+        use reqwest::header::USER_AGENT;
         use std::env;
 
-        let client = try!(Client::new());
+        let client = Client::new();
         let mut body = String::new();
 
         let mut resp = try!(client.get(&format!("https://api.github.com/repos/{}", path)[..])
-            .header(UserAgent(format!("cratesfyi/{}", env!("CARGO_PKG_VERSION"))))
-            .header(Authorization(Basic {
-                username: env::var("CRATESFYI_GITHUB_USERNAME")
+            .header(USER_AGENT, format!("cratesfyi/{}", env!("CARGO_PKG_VERSION")))
+            .basic_auth(
+                env::var("CRATESFYI_GITHUB_USERNAME")
                     .ok()
                     .and_then(|u| Some(u.to_string()))
                     .unwrap_or("".to_string()),
-                password: env::var("CRATESFYI_GITHUB_ACCESSTOKEN").ok(),
-            }))
+                env::var("CRATESFYI_GITHUB_ACCESSTOKEN").ok(),
+            )
             .send());
 
-        if resp.status() != &StatusCode::Ok {
+        if resp.status() != StatusCode::OK {
             return Err("Failed to get github data".into());
         }
 

src/utils/github_updater.rs

@@ -6,7 +6,7 @@ fn ping_hub(url: &str) -> Result<Response> {
     let mut params = HashMap::new();
     params.insert("hub.mode", "publish");
     params.insert("hub.url", "https://docs.rs/releases/feed");
-    let client = try!(Client::new());
+    let client = Client::new();
     client.post(url).form(&params).send()
 }