1 files changed, 132 insertions, 0 deletions
diff --git a/development/tools/cargo-workspace2/src/ops/publish/mod.rs b/development/tools/cargo-workspace2/src/ops/publish/mod.rs
new file mode 100644
index 000000000000..6022496af273
--- /dev/null
+++ b/development/tools/cargo-workspace2/src/ops/publish/mod.rs
@@ -0,0 +1,132 @@
+//! Publishing operation handling
+
+mod exec;
+pub(super) use exec::run;
+
+use super::RenderHelp;
+
+/// Publish a single crate to crates.io
+///
+/// This command does the following things
+///
+/// 0. Determine if the git tree has modifications, `cargo publish`
+///    will refuse to work otherwise.
+/// 1. Find the crate in question
+/// 2. Bump the version number according to the user input
+/// 3. Find all dependent crates in the workspace with a version bound
+/// 4. Update the version bound to the new version
+pub struct Publish {
+    /// The version type to publish
+    pub tt: PublishType,
+    /// Whether to set a new devel version after publish
+    pub devel: bool,
+}
+
+impl RenderHelp for Publish {
+    fn render_help(code: i32) -> ! {
+        eprintln!("Publish the selected set of crates");
+        eprintln!("Usage: cargo ws2 <...> publish [=]<level> [OPTIONS]");
+        eprintln!("");
+        eprintln!("When prepending `=` to the level, bump crates in sync\n");
+        eprintln!("Available levels:\n");
+        eprintln!(" - major: Bump major version (1.0.0 -> 2.0.0)");
+        eprintln!(" - minor: Bump minor version (0.5.0 -> 0.6.0)");
+        eprintln!(" - patch: Bump patch version (0.5.0 -> 0.5.1)");
+        eprintln!("");
+        eprintln!("Available options:\n");
+        eprintln!(" - alpha: Create a new alpha (append `-alpha.X`)");
+        eprintln!(" - beta: Create a new beta (append `-beta.X`)");
+        eprintln!(" - rc: Create a new rc (append `-rc.X`)");
+        eprintln!(" - devel: Tag next version as -devel");
+        std::process::exit(code)
+    }
+}
+
+/// The level to which to update
+///
+/// New versions are based on the previous version, and are always
+/// computed on the fly.
+///
+/// It's recommended you use the [`versions`](./versions/index.html)
+/// builder functions.
+pub enum PublishType {
+    /// A fixed version to set the set to
+    Fixed(String),
+    /// A major bump (e.g. 1.0 -> 2.0)
+    Major(PublishMod),
+    /// A minor bump (e.g. 0.1 -> 0.2)
+    Minor(PublishMod),
+    /// A patch bump (e.g. 1.5.0 -> 1.5.1)
+    Patch(PublishMod),
+}
+
+impl PublishType {
+    pub(crate) fn _mod(&self) -> Option<&PublishMod> {
+        match self {
+            Self::Major(ref m) => Some(m),
+            Self::Minor(ref m) => Some(m),
+            Self::Patch(ref m) => Some(m),
+            Self::Fixed(_) => None,
+        }
+        .and_then(|_mod| match _mod {
+            PublishMod::None => None,
+            other => Some(other),
+        })
+    }
+}
+
+/// Version string modifier
+///
+/// It's recommended you use the [`versions`](./versions/index.html)
+/// builder functions.
+pub enum PublishMod {
+    /// No version modification
+    None,
+    /// Append `-alpha$X` where `$X` is a continuously increasing number
+    Alpha,
+    /// Append `-beta$X` where `$X` is a continuously increasing number
+    Beta,
+    /// Append `-rc$X` where `$X` is a continuously increasing number
+    Rc,
+}
+
+/// Version bump management
+pub mod versions {
+    use super::{PublishMod, PublishType};
+
+    /// Create a major publish
+    pub fn major(_mod: PublishMod) -> PublishType {
+        PublishType::Major(_mod)
+    }
+
+    /// Create a minor publish
+    pub fn minor(_mod: PublishMod) -> PublishType {
+        PublishType::Minor(_mod)
+    }
+
+    /// Create a patch publish
+    pub fn patch(_mod: PublishMod) -> PublishType {
+        PublishType::Patch(_mod)
+    }
+
+    /// Create a none modifier
+    pub fn mod_none() -> PublishMod {
+        PublishMod::None
+    }
+
+    /// Create an alpha modifier
+    pub fn mod_alpha() -> PublishMod {
+        PublishMod::Alpha
+    }
+
+    /// Create a beta modifier
+    pub fn mod_beta() -> PublishMod {
+        PublishMod::Beta
+    }
+
+    /// Create an rc modifier
+    pub fn mod_rc() -> PublishMod {
+        PublishMod::Rc
+    }
+}
+