1 files changed, 117 insertions, 0 deletions
diff --git a/development/tools/cargo-workspace2/src/ops/publish/exec.rs b/development/tools/cargo-workspace2/src/ops/publish/exec.rs
new file mode 100644
index 000000000000..3f2d36863bcf
--- /dev/null
+++ b/development/tools/cargo-workspace2/src/ops/publish/exec.rs
@@ -0,0 +1,117 @@
+//! Publishing executor
+
+use super::{Publish, PublishMod as Mod, PublishType};
+use crate::{
+    models::{CrateId, DepGraph},
+    ops::verify_user,
+};
+use semver::Version;
+use textwrap;
+
+pub(in crate::ops) fn run(p: Publish, set: Vec<CrateId>, g: &mut DepGraph) {
+    let Publish { ref tt, devel } = p;
+
+    let vec = set.into_iter().fold(vec![], |mut vec, id| {
+        let c = g.mut_crate(id);
+        let c_name = c.name().clone();
+        let curr_ver = c.version();
+        let new_ver = bump(&curr_ver, tt);
+        c.publish(new_ver.clone());
+        eprintln!("Bumping `{}`: `{}` ==> `{}`", c.name(), &curr_ver, new_ver);
+        drop(c);
+
+        g.get_dependents(id).into_iter().for_each(|id| {
+            let dep = g.mut_crate(id);
+            dep.change_dependency(&c_name, &new_ver);
+            eprintln!("Changing dependency `{}`: {} = {{ version = `{}`, ... }} ==> {{ version = `{}`, ... }}",
+                      dep.name(),
+                      c_name,
+                      &curr_ver,
+                      new_ver);
+            vec.push(id);
+        });
+
+        vec.push(id);
+        vec
+    });
+
+    // If we make it past this point the user is sure
+    verify_user();
+
+    vec.into_iter().for_each(|(id)| {
+        let c = g.mut_crate(id);
+        c.sync();
+    });
+
+    eprintln!("{}", textwrap::fill("Publish complete. Check that everything is in order, \
+                                    then run `cargo publish` to upload to crates.io!", 80));
+}
+
+/// Bump a version number according to some rules
+fn bump(v: &String, tt: &PublishType) -> String {
+    let mut ver = Version::parse(&v).unwrap();
+    let ver = match tt {
+        PublishType::Fixed(ref ver) => Version::parse(ver).unwrap(),
+        PublishType::Major(_) => {
+            ver.increment_major();
+            ver
+        }
+        PublishType::Minor(_) => {
+            ver.increment_minor();
+            ver
+        }
+        PublishType::Patch(_) => {
+            ver.increment_patch();
+            ver
+        }
+    };
+
+    // If a mod applies, handle it...
+    if let Some(_mod) = tt._mod() {
+        if ver.is_prerelease() {
+            let v = ver.clone().to_string();
+            let num = v.split(".").last().unwrap();
+            let num: usize = num.parse().unwrap();
+            ver.clone()
+                .to_string()
+                .replace(&format!("{}", num), &format!("{}", num + 1))
+                .to_string()
+        } else {
+            format!(
+                "{}-{}",
+                ver.to_string(),
+                match _mod {
+                    Mod::Alpha => "alpha.0",
+                    Mod::Beta => "beta.0",
+                    Mod::Rc => "rc.0",
+                    _ => unreachable!(),
+                }
+            )
+        }
+    } else {
+        ver.to_string()
+    }
+}
+
+macro_rules! assert_bump {
+    ($input:expr, $level_mod:expr, $expect:expr) => {
+        assert_eq!(bump(&$input.to_owned(), $level_mod), $expect.to_string());
+    };
+}
+
+#[cfg(test)]
+use super::{PublishMod::*, PublishType::*};
+
+#[test]
+fn bump_major() {
+    assert_bump!("1.0.0", &Major(None), "2.0.0");
+    assert_bump!("1.5.4", &Major(None), "2.0.0");
+    assert_bump!("1.3.0", &Major(Alpha), "2.0.0-alpha.0");
+}
+
+#[test]
+fn bump_minor() {
+    assert_bump!("1.1.0", &Minor(None), "1.2.0");
+    assert_bump!("1.5.4", &Minor(Beta), "1.6.0-beta.0");
+    assert_bump!("1.5.4-beta.0", &Minor(Beta), "1.6.0-beta.0");
+}