Merge branch 'gnzlbg-fix'

Author: ibabushkin

.travis.yml

@@ -1,33 +1,33 @@
 language: rust
-
 rust: nightly
+sudo: false
 
-os:
-  - linux
-# coming soon:
-# - osx
-
-env:
-  global:
-    - RUST_BACKTRACE=full
-
-script:
-  - |
-    set -e
-    if [ "$TRAVIS_OS_NAME" == "osx" ]; then
-      # test output for a different libc is expected to be different
-      mv tests/full_cases/libc-0.2.28-0.2.31.osx tests/full_cases/libc-0.2.28-0.2.31
-    fi
-
-    cargo build
-    cargo test --verbose
+matrix:
+  fast_finish: true
+  include:
+    # Targets
+    - name: "linux"
+      os: linux
+      env: RUST_BACKTRACE=full
+    - name: "osx"
+      os: osx
+      osx_image: xcode10
+      env: RUST_BACKTRACE=full
+    - name: "windows"
+      os: windows
 
-    # install
-    mkdir -p ~/rust/cargo/bin
-    cp target/debug/cargo-semver ~/rust/cargo/bin
-    cp target/debug/rust-semverver ~/rust/cargo/bin
+    # Tools:
+    - name: "rustfmt"
+      install: rustup component add rustfmt-preview
+      script: cargo fmt --all -- --check
+    - name: "clippy"
+      script: |
+        if rustup component add clippy-preview; then
+            cargo clippy --all -- -D clippy::pedantic
+        fi
+    - name: "Shellcheck"
+      script:
+        - shellcheck --version
+        - shellcheck ci/*.sh
 
-    # become semververver
-    eval "current_version=$(grep -e '^version = .*$' Cargo.toml | cut -d ' ' -f 3)"
-    PATH=~/rust/cargo/bin:$PATH cargo semver | tee semver_out
-    (head -n 1 semver_out | grep "\-> $current_version") || (echo "versioning mismatch" && return 1)
+script: sh ci/run.sh

Cargo.toml

@@ -25,12 +25,12 @@ name = "rust-semverver"
 path = "src/bin/rust_semverver.rs"
 
 [dependencies]
-cargo = "0.29"
-crates-io = "0.17"
-env_logger = "0.5"
+cargo = "0.31"
+crates-io = "0.19"
+env_logger = "0.6"
 log = "0.4"
 semver = "0.9"
-rand = "0.5"
+rand = "0.6"
 
 [dev-dependencies]
 quickcheck = "0.7"

appveyor.yml

@@ -14,10 +14,7 @@ install:
 
 build: false
 
-test_script:
-  - set RUST_BACKTRACE=full
-  - cargo build
-# - cargo test --verbose
+test_script: C:\msys64\usr\bin\sh ci\run.sh
 
 notifications:
   - provider: Email

ci/run.sh

@@ -0,0 +1,31 @@
+#!/usr/bin/env sh
+
+set -ex
+
+export RUST_TEST_THREADS=1
+export RUST_BACKTRACE=full
+#export RUST_TEST_NOCAPTURE=1
+
+cargo build
+cargo test --verbose -- --nocapture
+
+# install
+mkdir -p ~/rust/cargo/bin
+cp target/debug/cargo-semver ~/rust/cargo/bin
+cp target/debug/rust-semverver ~/rust/cargo/bin
+
+# become semververver
+PATH=~/rust/cargo/bin:$PATH cargo semver | tee semver_out
+current_version="$(grep -e '^version = .*$' Cargo.toml | cut -d ' ' -f 3)"
+current_version="${current_version%\"}"
+current_version="${current_version#\"}"
+result="$(head -n 1 semver_out)"
+if echo "$result" | grep -- "-> $current_version"; then
+    echo "version ok"
+    exit 0
+else
+    echo "versioning mismatch"
+    cat semver_out
+    echo "versioning mismatch"
+    exit 1
+fi

src/bin/cargo_semver.rs

@@ -8,24 +8,23 @@ extern crate getopts;
 #[macro_use]
 extern crate log;
 
+use cargo::{
+    core::{compiler::CompileMode, Package, PackageId, Source, SourceId, Workspace},
+    exit_with_error,
+    ops::{compile, CompileOptions},
+    util::{
+        config::Config, important_paths::find_root_manifest_for_wd, CargoError, CargoResult,
+        CliError,
+    },
+};
 use crates_io::{Crate, Registry};
-
-use cargo::exit_with_error;
-use cargo::core::{Package, PackageId, Source, SourceId, Workspace};
-use cargo::core::compiler::CompileMode;
-use cargo::ops::{compile, CompileOptions};
-use cargo::util::{CargoError, CargoResult, CliError};
-use cargo::util::config::Config;
-use cargo::util::important_paths::find_root_manifest_for_wd;
-
 use getopts::{Matches, Options};
-
-use std::env;
-use std::error;
-use std::fmt;
-use std::io::Write;
-use std::path::PathBuf;
-use std::process::{Stdio, Command};
+use std::{
+    env, error, fmt,
+    io::Write,
+    path::PathBuf,
+    process::{Command, Stdio},
+};
 
 /// Very simple error representation.
 #[derive(Debug)]
@@ -51,15 +50,18 @@ fn exact_search(query: &str) -> CargoResult<Crate> {
 
     registry
         .search(query, 1)
-        .map_err(|e|
-                 Error(format!("failed to retrieve search results from the registry: {}", e))
-                     .into())
+        .map_err(|e| {
+            Error(format!(
+                "failed to retrieve search results from the registry: {}",
+                e
+            ))
+            .into()
+        })
         .and_then(|(mut crates, _)| {
             crates
                 .drain(..)
                 .find(|krate| krate.name == query)
-                .ok_or_else(|| Error(format!("failed to find a matching crate `{}`", query))
-                                .into())
+                .ok_or_else(|| Error(format!("failed to find a matching crate `{}`", query)).into())
         })
 }
 
@@ -87,9 +89,9 @@ impl<'a> SourceInfo<'a> {
 
         debug!("source id loaded: {:?}", source_id);
 
-        Ok(SourceInfo {
+        Ok(Self {
             id: source_id,
-            source: source,
+            source,
         })
     }
 }
@@ -114,34 +116,33 @@ impl<'a> WorkInfo<'a> {
         let workspace = Workspace::new(&manifest_path, config)?;
         let package = workspace.load(&manifest_path)?;
 
-        Ok(WorkInfo {
-            package,
-            workspace,
-        })
+        Ok(Self { package, workspace })
     }
 
     /// Construct a package/workspace pair by fetching the package of a specified name and
     /// version.
-    fn remote(config: &'a Config, source: &mut SourceInfo<'a>, info: &NameAndVersion)
-        -> CargoResult<WorkInfo<'a>>
-    {
+    fn remote(
+        config: &'a Config,
+        source: &mut SourceInfo<'a>,
+        info: &NameAndVersion,
+    ) -> CargoResult<WorkInfo<'a>> {
         // TODO: fall back to locally cached package instance, or better yet, search for it
         // first.
         let package_id = PackageId::new(info.name, info.version, &source.id)?;
         debug!("(remote) package id: {:?}", package_id);
         let package = source.source.download(&package_id)?;
         let workspace = Workspace::ephemeral(package.clone(), config, None, false)?;
 
-        Ok(WorkInfo {
-            package: package,
-            workspace: workspace,
-        })
+        Ok(Self { package, workspace })
     }
 
     /// Obtain the paths to the produced rlib and the dependency output directory.
-    fn rlib_and_dep_output(&self, config: &'a Config, name: &str, current: bool)
-        -> CargoResult<(PathBuf, PathBuf)>
-    {
+    fn rlib_and_dep_output(
+        &self,
+        config: &'a Config,
+        name: &str,
+        current: bool,
+    ) -> CargoResult<(PathBuf, PathBuf)> {
         let opts = CompileOptions::new(config, CompileMode::Build).unwrap();
 
         if current {
@@ -161,7 +162,6 @@ impl<'a> WorkInfo<'a> {
 
         Ok((rlib.1.clone(), compilation.deps_output))
     }
-
 }
 
 /// Perform the heavy lifting.
@@ -170,7 +170,6 @@ impl<'a> WorkInfo<'a> {
 /// and/or defaults, and dispatch the actual analysis.
 // TODO: possibly reduce the complexity by finding where some info can be taken from directly
 fn do_main(config: &Config, matches: &Matches, explain: bool) -> CargoResult<()> {
-    debug!("running cargo-semver");
     fn parse_arg(opt: &str) -> CargoResult<NameAndVersion> {
         let mut split = opt.split(':');
         let name = if let Some(n) = split.next() {
@@ -188,9 +187,11 @@ fn do_main(config: &Config, matches: &Matches, explain: bool) -> CargoResult<()>
             return Err(Error("spec has to be of form `name:version`".to_owned()).into());
         }
 
-        Ok(NameAndVersion { name: name, version: version })
+        Ok(NameAndVersion { name, version })
     }
 
+    debug!("running cargo-semver");
+
     let mut source = SourceInfo::new(config)?;
 
     let current = if let Some(opt) = matches.opt_str("C") {
@@ -214,7 +215,10 @@ fn do_main(config: &Config, matches: &Matches, explain: bool) -> CargoResult<()>
         (work_info, version)
     } else {
         let stable_crate = exact_search(&name)?;
-        let info = NameAndVersion { name: &name, version: &stable_crate.max_version };
+        let info = NameAndVersion {
+            name: &name,
+            version: &stable_crate.max_version,
+        };
         let work_info = WorkInfo::remote(config, &mut source, &info)?;
 
         (work_info, stable_crate.max_version.clone())
@@ -224,11 +228,13 @@ fn do_main(config: &Config, matches: &Matches, explain: bool) -> CargoResult<()>
     let (stable_rlib, stable_deps_output) = stable.rlib_and_dep_output(config, &name, false)?;
 
     if matches.opt_present("d") {
-        println!("--extern old={} -L{} --extern new={} -L{}",
-                 stable_rlib.display(),
-                 stable_deps_output.display(),
-                 current_rlib.display(),
-                 current_deps_output.display());
+        println!(
+            "--extern old={} -L{} --extern new={} -L{}",
+            stable_rlib.display(),
+            stable_deps_output.display(),
+            current_rlib.display(),
+            current_deps_output.display()
+        );
         return Ok(());
     }
 
@@ -250,10 +256,12 @@ fn do_main(config: &Config, matches: &Matches, explain: bool) -> CargoResult<()>
     if let Some(ref mut stdin) = child.stdin {
         // The order of the `extern crate` declaration is important here: it will later
         // be used to select the `old` and `new` crates.
-        stdin.write_fmt(format_args!("#[allow(unused_extern_crates)] \
-                                     extern crate old; \
-                                     #[allow(unused_extern_crates)] \
-                                     extern crate new;"))?;
+        stdin.write_fmt(format_args!(
+            "#[allow(unused_extern_crates)] \
+             extern crate old; \
+             #[allow(unused_extern_crates)] \
+             extern crate new;"
+        ))?;
     } else {
         return Err(Error("could not pipe to rustc (wtf?)".to_owned()).into());
     }
@@ -296,12 +304,30 @@ fn main() {
     opts.optflag("V", "version", "print version information and exit");
     opts.optflag("e", "explain", "print detailed error explanations");
     opts.optflag("d", "debug", "print command to debug and exit");
-    opts.optopt("s", "stable-path", "use local path as stable/old crate", "PATH");
-    opts.optopt("c", "current-path", "use local path as current/new crate", "PATH");
-    opts.optopt("S", "stable-pkg", "use a `name:version` string as stable/old crate",
-                "NAME:VERSION");
-    opts.optopt("C", "current-pkg", "use a `name:version` string as current/new crate",
-                "NAME:VERSION");
+    opts.optopt(
+        "s",
+        "stable-path",
+        "use local path as stable/old crate",
+        "PATH",
+    );
+    opts.optopt(
+        "c",
+        "current-path",
+        "use local path as current/new crate",
+        "PATH",
+    );
+    opts.optopt(
+        "S",
+        "stable-pkg",
+        "use a `name:version` string as stable/old crate",
+        "NAME:VERSION",
+    );
+    opts.optopt(
+        "C",
+        "current-pkg",
+        "use a `name:version` string as current/new crate",
+        "NAME:VERSION",
+    );
 
     let config = match Config::default() {
         Ok(cfg) => cfg,
@@ -323,15 +349,17 @@ fn main() {
         return;
     }
 
-    if (matches.opt_present("s") && matches.opt_present("S")) ||
-        matches.opt_count("s") > 1 || matches.opt_count("S") > 1
+    if (matches.opt_present("s") && matches.opt_present("S"))
+        || matches.opt_count("s") > 1
+        || matches.opt_count("S") > 1
     {
         let msg = "at most one of `-s,--stable-path` and `-S,--stable-pkg` allowed";
         err(&config, Error(msg.to_owned()).into());
     }
 
-    if (matches.opt_present("c") && matches.opt_present("C")) ||
-        matches.opt_count("c") > 1 || matches.opt_count("C") > 1
+    if (matches.opt_present("c") && matches.opt_present("C"))
+        || matches.opt_count("c") > 1
+        || matches.opt_count("C") > 1
     {
         let msg = "at most one of `-c,--current-path` and `-C,--current-pkg` allowed";
         err(&config, Error(msg.to_owned()).into());