feat: commit_changes flag for .publish. Default value is true

Author: Barsik-sus

module/move/willbe/src/action/publish.rs

@@ -121,6 +121,7 @@ mod private
     patterns : Vec< String >,
     channel : channel::Channel,
     exclude_dev_dependencies : bool,
+    commit_changes : bool,
     dry : bool,
     temp : bool
   )
@@ -236,6 +237,7 @@ mod private
     .workspace_dir( CrateDir::try_from( workspace_root_dir ).unwrap() )
     .option_base_temp_dir( dir.clone() )
     .exclude_dev_dependencies( exclude_dev_dependencies )
+    .commit_changes( commit_changes )
     .dry( dry )
     .roots( roots )
     .packages( queue )

module/move/willbe/src/command/mod.rs

@@ -30,6 +30,11 @@ mod private
         .kind( Type::Bool )
         .optional( true )
         .end()
+      .property( "commit_changes" )
+        .hint( "Indicates whether changes should be committed. Default is `true`." )
+        .kind( Type::Bool )
+        .optional( true )
+        .end()
       .property( "dry" )
         .hint( "Enables 'dry run'. Does not publish, only simulates. Default is `true`." )
         .kind( Type::Bool )

module/move/willbe/src/command/publish.rs

@@ -18,6 +18,8 @@ mod private
     #[ former( default = true ) ]
     exclude_dev_dependencies : bool,
     #[ former( default = true ) ]
+    commit_changes : bool,
+    #[ former( default = true ) ]
     dry : bool,
     #[ former( default = true ) ]
     temp : bool,
@@ -55,10 +57,11 @@ mod private
     {
       channel,
       exclude_dev_dependencies,
+      commit_changes,
       dry,
       temp
     } = o.props.try_into()?;
-    let plan = action::publish_plan( patterns, channel, exclude_dev_dependencies, dry, temp )
+    let plan = action::publish_plan( patterns, channel, exclude_dev_dependencies, commit_changes, dry, temp )
     .context( "Failed to plan the publication process" )?;
 
     let mut formatted_plan = String::new();
@@ -116,6 +119,8 @@ mod private
       this = if let Some( v ) = value
       .get_owned( "exclude_dev_dependencies" ) { this.exclude_dev_dependencies::< bool >( v ) } else { this };
       this = if let Some( v ) = value
+      .get_owned( "commit_changes" ) { this.commit_changes::< bool >( v ) } else { this };
+      this = if let Some( v ) = value
       .get_owned( "dry" ) { this.dry::< bool >( v ) } else { this };
       this = if let Some( v ) = value
       .get_owned( "temp" ) { this.temp::< bool >( v ) } else { this };

module/move/willbe/src/entity/publish.rs

@@ -26,7 +26,7 @@ mod private
     /// Options for bumping the package version.
     pub bump : version::BumpOptions,
     /// Git options related to the package.
-    pub git_options : entity::git::GitOptions,
+    pub git_options : Option< entity::git::GitOptions >,
     /// Options for publishing the package using Cargo.
     pub publish : cargo::PublishOptions,
     /// Indicates whether the process should be dry-run (no actual publishing).
@@ -44,6 +44,8 @@ mod private
     base_temp_dir : Option< path::PathBuf >,
     exclude_dev_dependencies : bool,
     #[ former( default = true ) ]
+    commit_changes : bool,
+    #[ former( default = true ) ]
     dry : bool,
   }
 
@@ -75,13 +77,16 @@ mod private
         dependencies : dependencies.clone(),
         dry : self.dry,
       };
-      let git_options = entity::git::GitOptions
+      let git_options = if self.commit_changes
       {
-        git_root : workspace_root,
-        items : dependencies.iter().chain([ &crate_dir ]).map( | d | d.clone().absolute_path().join( "Cargo.toml" ) ).collect(),
-        message : format!( "{}-v{}", self.package.name().unwrap(), new_version ),
-        dry : self.dry,
-      };
+        Some( entity::git::GitOptions
+        {
+          git_root : workspace_root,
+          items : dependencies.iter().chain([ &crate_dir ]).map( | d | d.clone().absolute_path().join( "Cargo.toml" ) ).collect(),
+          message : format!( "{}-v{}", self.package.name().unwrap(), new_version ),
+          dry : self.dry,
+        })
+      } else { None };
       let publish = cargo::PublishOptions
       {
         path : crate_dir.clone().absolute_path().inner(),
@@ -126,7 +131,11 @@ mod private
 
     /// Setting this option to true will temporarily remove development dependencies before executing the command, then restore them afterward.
     #[ allow( dead_code ) ] // former related
-    pub( crate ) exclude_dev_dependencies : bool,
+    pub exclude_dev_dependencies : bool,
+
+    /// Indicates whether changes should be committed.
+    #[ former( default = true ) ]
+    pub commit_changes : bool,
 
     /// `dry` - A boolean value indicating whether to do a dry run. If set to `true`, the application performs
     /// a simulated run without making any actual changes. If set to `false`, the operations are actually executed.
@@ -257,6 +266,10 @@ mod private
       {
         plan = plan.exclude_dev_dependencies( *exclude_dev_dependencies )
       }
+      if let Some( commit_changes ) = &self.storage.commit_changes
+      {
+        plan = plan.commit_changes( *commit_changes )
+      }
       let plan = plan
       .channel( channel )
       .package( package )
@@ -373,45 +386,55 @@ mod private
     } = instruction;
     pack.dry = dry;
     bump.dry = dry;
-    git_options.dry = dry;
+    git_options.as_mut().map( | d | d.dry = dry );
     publish.dry = dry;
 
     report.get_info = Some( cargo::pack( pack ).err_with_report( &report )? );
     // aaa : redundant field? // aaa : removed
     let bump_report = version::bump( bump ).err_with_report( &report )?;
     report.bump = Some( bump_report.clone() );
-    let git_root = git_options.git_root.clone();
-    let git = match entity::git::perform_git_commit( git_options )
+
+    let git_root = git_options.as_ref().map( | g | g.git_root.clone() );
+    if let Some( git_options ) = git_options
     {
-      Ok( git ) => git,
-      Err( e ) =>
+      let git = match entity::git::perform_git_commit( git_options )
       {
-        version::revert( &bump_report )
-        .map_err( | le | format_err!( "Base error:\n{}\nRevert error:\n{}", e.to_string().replace( '\n', "\n\t" ), le.to_string().replace( '\n', "\n\t" ) ) )
-        .err_with_report( &report )?;
-        return Err(( report, e ));
-      }
-    };
-    report.add = git.add;
-    report.commit = git.commit;
+        Ok( git ) => git,
+        Err( e ) =>
+        {
+          version::revert( &bump_report )
+          .map_err( | le | format_err!( "Base error:\n{}\nRevert error:\n{}", e.to_string().replace( '\n', "\n\t" ), le.to_string().replace( '\n', "\n\t" ) ) )
+          .err_with_report( &report )?;
+          return Err(( report, e ));
+        }
+      };
+      report.add = git.add;
+      report.commit = git.commit;
+    }
     report.publish = match cargo::publish( publish )
     {
       Ok( publish ) => Some( publish ),
       Err( e ) =>
       {
-        tool::git::reset( git_root.as_ref(), true, 1, false )
-        .map_err
-        (
-          | le |
-          format_err!( "Base error:\n{}\nRevert error:\n{}", e.to_string().replace( '\n', "\n\t" ), le.to_string().replace( '\n', "\n\t" ) )
-        )
-        .err_with_report( &report )?;
+        if let Some( git_root ) = git_root.as_ref()
+        {
+          tool::git::reset( git_root.as_ref(), true, 1, false )
+          .map_err
+          (
+            | le |
+            format_err!( "Base error:\n{}\nRevert error:\n{}", e.to_string().replace( '\n', "\n\t" ), le.to_string().replace( '\n', "\n\t" ) )
+          )
+          .err_with_report( &report )?;
+        }
         return Err(( report, e ));
       }
     };
 
-    let res = tool::git::push( &git_root, dry ).err_with_report( &report )?;
-    report.push = Some( res );
+    if let Some( git_root ) = git_root.as_ref()
+    {
+      let res = tool::git::push( &git_root, dry ).err_with_report( &report )?;
+      report.push = Some( res );
+    }
 
     Ok( report )
   }