feat: move print to main file (#1)

Author: filipstefansson

README.md

@@ -1,5 +1,7 @@
 # cargo-semver
 
+[![codecov](https://codecov.io/gh/filipstefansson/cargo-semver/branch/master/graph/badge.svg?token=HSAldVxPvX)](https://codecov.io/gh/filipstefansson/cargo-semver)
+
 **cargo-semver** is a cargo subcommand to help you update the version in your `Cargo.toml` file.
 
 - Update the version with `cargo semver major|minor|patch|pre`

src/main.rs

@@ -5,6 +5,7 @@ use seahorse::{App, Command, Context, Flag, FlagType};
 use std::env;
 use version::{Bump, Version};
 
+#[cfg(not(tarpaulin_include))]
 fn main() {
     let args: Vec<String> = env::args().collect();
 
@@ -24,7 +25,7 @@ fn main() {
             Command::new("set")
                 .description("Set the version in Cargo.toml")
                 .usage("cargo-semver set [VERSION]")
-                .action(set_version_action)
+                .action(set_action)
                 .flag(config_file_flag.clone()),
         )
         .command(
@@ -70,52 +71,149 @@ fn default_action(c: &Context) {
     println!("{}", version.version);
 }
 
-/// Set the version in `Config.toml` to the `VALUE` input
-/// in `cargo-semver set [VERSION]`.
-fn set_version_action(c: &Context) {
+fn set_version(c: &Context, version_arg: &str) -> String {
     let mut version = Version::new(c);
 
-    // the new version argument
-    let version_arg = c.args.join(" ");
-
-    let new_version = match version_arg.as_str() {
+    let new_version = match version_arg {
         v => match semver::Version::parse(&v) {
             Ok(v) => v,
             Err(err) => panic!("{}", err),
         },
     };
 
-    version.set(new_version);
+    let new_version = version.set(new_version);
+    println!("{}", new_version);
+    new_version
 }
 
-fn bump_version(c: &Context, bump: Bump) {
+fn bump_version(c: &Context, bump: Bump) -> String {
     let mut version = Version::new(c);
 
     let pre_flag = match c.string_flag("pre") {
         Ok(flag) => Some(flag),
         _ => None,
     };
 
-    version.bump(bump, pre_flag)
+    let new_version = version.bump(bump, pre_flag);
+    println!("{}", new_version);
+    new_version
+}
+
+/// Set the version in `Config.toml` to the `VALUE` input
+/// in `cargo-semver set [VERSION]`.
+fn set_action(c: &Context) {
+    // the new version argument
+    let version_arg = c.args.join(" ");
+
+    set_version(c, &version_arg);
 }
 
 /// Increments the patch version number.
 fn patch_action(c: &Context) {
-    bump_version(c, Bump::Patch)
+    bump_version(c, Bump::Patch);
 }
 
 /// Increments the minor version number.
 fn minor_action(c: &Context) {
-    bump_version(c, Bump::Minor)
+    bump_version(c, Bump::Minor);
 }
 
 /// Increments the major version number.
 fn major_action(c: &Context) {
-    bump_version(c, Bump::Major)
+    bump_version(c, Bump::Major);
 }
 
 /// Increments the pre-release version number.
 fn pre_action(c: &Context) {
     let value = c.args.join(" ");
     bump_version(c, Bump::Pre(value));
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use predicates::prelude::*;
+    use seahorse::{Context, Flag, FlagType};
+    use std::{fs, io::Write};
+    use tempfile::NamedTempFile;
+
+    fn setup_test_context(
+        file: &mut NamedTempFile,
+        version: &str,
+        extra_args: &mut Vec<String>,
+    ) -> Context {
+        let file_has_content = file.as_file().metadata().unwrap().len() > 0;
+        if !file_has_content {
+            writeln!(
+                file,
+                "[package]\nversion = \"{}\"\n\n[dependencies]\nversion = \"{}\"",
+                version, version,
+            )
+            .unwrap();
+        }
+
+        let config_path = file.path().to_str().unwrap().to_string();
+        let config_flag = Flag::new("config", FlagType::String);
+        let pre_flag = Flag::new("pre", FlagType::String);
+
+        let mut args = vec!["--config".to_string(), config_path];
+        args.append(extra_args);
+
+        Context::new(args, Some(vec![config_flag, pre_flag]), "".to_string())
+    }
+
+    fn get_file_path(file: &mut NamedTempFile) -> String {
+        file.path().to_str().unwrap().to_string()
+    }
+
+    #[test]
+    fn test_bump_version() {
+        let mut file = NamedTempFile::new().unwrap();
+        let context = setup_test_context(&mut file, "1.0.0", &mut vec![]);
+        let path = get_file_path(&mut file);
+
+        major_action(&context);
+        let contains = predicate::str::contains("2.0.0");
+        assert_eq!(true, contains.eval(&fs::read_to_string(&path).unwrap()));
+
+        minor_action(&context);
+        let contains = predicate::str::contains("2.1.0");
+        assert_eq!(true, contains.eval(&fs::read_to_string(&path).unwrap()));
+
+        patch_action(&context);
+        let contains = predicate::str::contains("2.1.1");
+        assert_eq!(true, contains.eval(&fs::read_to_string(&path).unwrap()));
+
+        let new_context = setup_test_context(&mut file, "0", &mut vec!["alpha".to_string()]);
+        pre_action(&new_context);
+        let contains = predicate::str::contains("2.1.1-alpha.1");
+        assert_eq!(true, contains.eval(&fs::read_to_string(&path).unwrap()));
+
+        pre_action(&new_context);
+        let contains = predicate::str::contains("2.1.1-alpha.2");
+        assert_eq!(true, contains.eval(&fs::read_to_string(&path).unwrap()));
+
+        let new_context = setup_test_context(&mut file, "0", &mut vec!["beta".to_string()]);
+        pre_action(&new_context);
+        let contains = predicate::str::contains("2.1.1-beta.1");
+        assert_eq!(true, contains.eval(&fs::read_to_string(&path).unwrap()));
+
+        let new_context = setup_test_context(
+            &mut file,
+            "0",
+            &mut vec!["--pre".to_string(), "beta".to_string()],
+        );
+        major_action(&new_context);
+        let contains = predicate::str::contains("3.0.0-beta.1");
+        assert_eq!(true, contains.eval(&fs::read_to_string(&path).unwrap()));
+
+        major_action(&context);
+        let contains = predicate::str::contains("4.0.0");
+        assert_eq!(true, contains.eval(&fs::read_to_string(&path).unwrap()));
+
+        let new_context = setup_test_context(&mut file, "0", &mut vec!["1.5.0".to_string()]);
+        set_action(&new_context);
+        let contains = predicate::str::contains("1.5.0");
+        assert_eq!(true, contains.eval(&fs::read_to_string(&path).unwrap()));
+    }
+}

src/version.rs

@@ -63,13 +63,13 @@ impl Version {
         panic!("failed to find version in Config.toml")
     }
 
-    pub fn set(&mut self, version: semver::Version) {
+    pub fn set(&mut self, version: semver::Version) -> String {
         self.version = version;
 
-        self.update_config_version();
+        self.update_config_version()
     }
 
-    pub fn bump(&mut self, bump: Bump, pre_flag: Option<String>) {
+    pub fn bump(&mut self, bump: Bump, pre_flag: Option<String>) -> String {
         match bump {
             Bump::Major => &self.version.increment_major(),
             Bump::Minor => &self.version.increment_minor(),
@@ -81,10 +81,10 @@ impl Version {
             self.version.pre = vec![Identifier::AlphaNumeric(pre_flag), Identifier::Numeric(1)];
         }
 
-        self.update_config_version();
+        self.update_config_version()
     }
 
-    fn update_config_version(&self) {
+    fn update_config_version(&self) -> String {
         // validate version
         let string_version = &self.version.to_string();
         if let Err(err) = semver::Version::parse(string_version) {
@@ -105,7 +105,7 @@ impl Version {
             .output()
             .expect("failed to run `cargo check` to update Cargo.lock");
 
-        println!("{}", &self.version);
+        self.version.to_string()
     }
 
     fn increment_pre(&mut self, pre_version: String) {
@@ -139,89 +139,3 @@ impl Version {
         }
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use seahorse::{Context, Flag, FlagType};
-    use std::io::Write;
-    use tempfile::NamedTempFile;
-
-    fn setup_test_context(file: &mut NamedTempFile, version: &str) -> Context {
-        writeln!(
-            file,
-            "[package]\nversion = \"{}\"\n\n[dependencies]\nversion = \"{}\"",
-            version, version,
-        )
-        .unwrap();
-        let config_path = file.path().to_str().unwrap().to_string();
-
-        let config_flag = Flag::new("config", FlagType::String);
-
-        Context::new(
-            vec!["--config".to_string(), config_path],
-            Some(vec![config_flag]),
-            "".to_string(),
-        )
-    }
-
-    #[test]
-    fn test_create_version() {
-        let mut file = NamedTempFile::new().unwrap();
-        let context = setup_test_context(&mut file, "1.0.0");
-
-        let version = Version::new(&context);
-
-        assert_eq!(version.version.to_string(), "1.0.0");
-        assert_eq!(version.line, "version = \"1.0.0\"");
-        assert_eq!(
-            version.config_path,
-            file.path().to_str().unwrap().to_string()
-        );
-    }
-
-    #[test]
-    fn test_set_version() {
-        let mut file = NamedTempFile::new().unwrap();
-        let context = setup_test_context(&mut file, "1.0.0");
-
-        let mut version = Version::new(&context);
-        assert_eq!(version.version.to_string(), "1.0.0");
-
-        version.set(semver::Version::parse("2.0.0").unwrap());
-        assert_eq!(version.version.to_string(), "2.0.0");
-    }
-
-    #[test]
-    fn test_bump_version() {
-        let mut file = NamedTempFile::new().unwrap();
-        let context = setup_test_context(&mut file, "1.0.0");
-
-        let mut version = Version::new(&context);
-        assert_eq!(version.version.to_string(), "1.0.0");
-
-        version.bump(Bump::Major, None);
-        assert_eq!(version.version.to_string(), "2.0.0");
-
-        version.bump(Bump::Minor, None);
-        assert_eq!(version.version.to_string(), "2.1.0");
-
-        version.bump(Bump::Patch, None);
-        assert_eq!(version.version.to_string(), "2.1.1");
-
-        version.bump(Bump::Pre("alpha".to_string()), None);
-        assert_eq!(version.version.to_string(), "2.1.1-alpha.1");
-
-        version.bump(Bump::Pre("alpha".to_string()), None);
-        assert_eq!(version.version.to_string(), "2.1.1-alpha.2");
-
-        version.bump(Bump::Pre("beta".to_string()), None);
-        assert_eq!(version.version.to_string(), "2.1.1-beta.1");
-
-        version.bump(Bump::Major, Some("beta".to_string()));
-        assert_eq!(version.version.to_string(), "3.0.0-beta.1");
-
-        version.bump(Bump::Major, None);
-        assert_eq!(version.version.to_string(), "4.0.0");
-    }
-}