feat(cli): ✨ add new flag --message to automatize pipelines

sc.toml

@@ -1,5 +1,9 @@
-# Generated automatically by CLI
-
 [[scopes]]
 name = "core"
 description = "the core of the repo"
+
+[[scopes]]
+name = "tools"
+
+[[scopes]]
+name = "cli"

src/config/cli.rs

@@ -13,9 +13,6 @@ pub struct CliConfig {
  #[clap(long, help = "set custom path to load config.")]
  pub(super) config: Option<PathBuf>,
 
- #[clap(short, long)]
- pub(super) message: Option<String>,
-
  #[clap(flatten)]
  pub(super) sc_config: SimpleCommitsConfig,
 
@@ -43,6 +40,10 @@ pub struct SimpleCommitsConfig {
  #[clap(skip)]
  pub config: PathBuf,
 
+ #[clap(short, long)]
+ #[serde(skip)]
+ pub message: Option<String>,
+
  #[clap(skip)]
  #[serde(flatten)]
  #[merge(strategy = swap_option)]

src/tui/mod.rs

@@ -30,7 +30,6 @@ pub fn init() {
 #[derive(Clone, Default, Debug)]
 pub struct AppData {
  pub commit: CommitBuilder,
- pub action: Action,
 }
 
 #[allow(dead_code)]
@@ -61,10 +60,10 @@ impl Action {
 pub type StepResult = Result<(), Error>;
 
 /// A trait to setup steps along the TUI app.
-#[allow(dead_code)]
+
 pub trait Step {
  fn before_run(
- &self,
+ &mut self,
  _prompt: &mut Promptuity<Stderr>,
  _state: &mut AppData,
  _config: &mut SimpleCommitsConfig,
@@ -73,7 +72,7 @@ pub trait Step {
  }
 
  fn after_run(
- &self,
+ &mut self,
  _prompt: &mut Promptuity<Stderr>,
  _state: &mut AppData,
  _config: &mut SimpleCommitsConfig,
@@ -82,7 +81,7 @@ pub trait Step {
  }
 
  fn run(
- &self,
+ &mut self,
  prompt: &mut Promptuity<Stderr>,
  state: &mut AppData,
  config: &mut SimpleCommitsConfig,
@@ -91,11 +90,11 @@ pub trait Step {
 
 #[macro_export]
 macro_rules! gen_steps {
- ($($module:ident),*) => {
+ ($($struct:ty),*) => {
  {
  let steps: Vec<Box<dyn super::Step>> = vec![
  $(
- Box::new(self::$module::_Step),
+ Box::new(<$struct>::default()),
  )*
  ];
  steps

src/tui/steps/commit.rs

@@ -9,11 +9,11 @@ use crate::{
 };
 
 #[derive(Default)]
-pub struct _Step;
+pub struct Definition;
 
-impl Step for _Step {
+impl Step for Definition {
  fn run(
- &self,
+ &mut self,
  p: &mut Promptuity<Stderr>,
  state: &mut crate::tui::AppData,
  _: &mut SimpleCommitsConfig,

src/tui/steps/emoji.rs

@@ -6,18 +6,32 @@ use crate::tui::widgets::{Autocomplete, AutocompletePriority};
 use crate::tui::{Step, StepResult};
 
 #[derive(Default)]
-pub struct _Step;
+pub struct Emoji {
+ skip: bool,
+}
+
+impl Step for Emoji {
+ fn before_run(
+ &mut self,
+ _: &mut promptuity::Promptuity<std::io::Stderr>,
+ _: &mut crate::tui::AppData,
+ config: &mut SimpleCommitsConfig,
+ ) -> StepResult {
+ self.skip = config.git.as_ref().is_some_and(|cfg| cfg.skip_emojis);
+
+ Ok(())
+ }
 
-impl Step for _Step {
  fn run(
- &self,
+ &mut self,
  p: &mut promptuity::Promptuity<std::io::Stderr>,
  state: &mut crate::tui::AppData,
- config: &mut SimpleCommitsConfig,
+ _: &mut SimpleCommitsConfig,
  ) -> StepResult {
- if config.git.as_ref().is_some_and(|cfg| cfg.skip_emojis) {
+ if self.skip {
  return Ok(());
  }
+
  let emojis_mapped = EMOJIS
  .map(|emoji| {
  SelectOption::new(

src/tui/steps/exec.rs

@@ -11,56 +11,87 @@ use crate::{
 };
 
 #[derive(Default)]
-pub struct _Step;
+pub struct Execute {
+ skip: bool,
+ action: Action,
+ cmd: Vec<String>,
+}
 
-impl Step for _Step {
- fn run(
- &self,
- p: &mut Promptuity<Stderr>,
+impl Step for Execute {
+ fn before_run(
+ &mut self,
+ _: &mut Promptuity<Stderr>,
  state: &mut crate::tui::AppData,
  config: &mut SimpleCommitsConfig,
  ) -> StepResult {
+ self.skip = config
+ .git
+ .as_ref()
+ .map(|cfg| cfg.skip_preview)
+ .unwrap_or(false);
+
  let commit = state.commit.clone().build()?;
- let mut command = vec![
- "git".to_string(),
- "commit".to_string(),
- "-m".to_string(),
- format!("{0}", commit.0),
- ];
- let cmd = command.first().expect("unreachable!").clone();
- if let Some(git) = &config.git {
- command = git
- .commit_template
- .as_ref()
- .map(|msg| {
- msg.iter()
- .map(|m| m.replace("{{message}}", &commit.0.to_string()))
- .collect::<Vec<String>>()
- })
- .unwrap_or(command);
 
- let cmd = command
- .first()
- .expect("The commit template cannot be empty");
- if git.skip_preview {
- state.action = Action::Commit(cmd.clone(), (command[1..]).to_vec());
- state.action.execute_action();
- return Ok(());
+ let command = {
+ let base = ["git", "commit", "-m", &commit.0]
+ .iter()
+ .map(|s| String::from(*s))
+ .collect::<Vec<_>>();
+
+ if let Some(cfg) = &config.git {
+ cfg.commit_template.as_ref().map_or_else(
+ || base,
+ |cfg| {
+ cfg.iter()
+ .map(|msg| msg.replace("{{message}}", &commit.0))
+ .collect::<Vec<_>>()
+ },
+ )
+ } else {
+ base
  }
+ };
+
+ self.cmd = command;
+
+ Ok(())
+ }
+
+ fn run(
+ &mut self,
+ p: &mut Promptuity<Stderr>,
+ state: &mut crate::tui::AppData,
+ _: &mut SimpleCommitsConfig,
+ ) -> StepResult {
+ if self.skip {
+ let (head, tail) = self.cmd.split_first().unwrap();
+ self.action = Action::Commit(head.clone(), tail.to_vec());
+ return Ok(());
  }
 
+ let commit = state.commit.clone().build()?;
+
  let execute =
  p.prompt(Confirm::new("Do you want to execute this command?").with_default(true))?;
  if !execute {
  p.step("Commit preview")?;
  p.log(commit.0)?;
  p.log(BLANK_CHARACTER)?;
  } else {
- state.action = Action::Commit(cmd.clone(), (command[1..]).to_vec());
-
- state.action.execute_action();
+ let (head, tail) = self.cmd.split_first().unwrap();
+ self.action = Action::Commit(head.clone(), tail.to_vec());
  };
 
  Ok(())
  }
+
+ fn after_run(
+ &mut self,
+ _: &mut Promptuity<Stderr>,
+ _: &mut crate::tui::AppData,
+ _config: &mut SimpleCommitsConfig,
+ ) -> StepResult {
+ self.action.execute_action();
+ Ok(())
+ }
 }

src/tui/steps/message.rs

@@ -6,15 +6,33 @@ use crate::{
 };
 
 #[derive(Default)]
-pub struct _Step;
+pub struct Title {
+ skip: bool,
+ title: Option<String>,
+}
+
+impl Step for Title {
+ fn before_run(
+ &mut self,
+ _: &mut promptuity::Promptuity<std::io::Stderr>,
+ _: &mut crate::tui::AppData,
+ config: &mut SimpleCommitsConfig,
+ ) -> StepResult {
+ self.skip = config.message.as_ref().is_some();
+ self.title = config.message.clone();
+ Ok(())
+ }
 
-impl Step for _Step {
  fn run(
- &self,
+ &mut self,
  p: &mut promptuity::Promptuity<std::io::Stderr>,
- state: &mut crate::tui::AppData,
+ _: &mut crate::tui::AppData,
  _: &mut SimpleCommitsConfig,
  ) -> StepResult {
+ if self.skip {
+ return Ok(());
+ }
+
  let msg = p.prompt(
  Input::new("Enter a brief title of the commit").with_validator(|text: &String| {
  valid_length(
@@ -24,7 +42,17 @@ impl Step for _Step {
  )
  }),
  )?;
- state.commit.set_title(Some(msg));
+ self.title = Some(msg);
+ Ok(())
+ }
+
+ fn after_run(
+ &mut self,
+ _: &mut promptuity::Promptuity<std::io::Stderr>,
+ state: &mut crate::tui::AppData,
+ _: &mut SimpleCommitsConfig,
+ ) -> StepResult {
+ state.commit.set_title(self.title.clone());
  Ok(())
  }
 }

src/tui/steps/mod.rs

@@ -18,17 +18,25 @@ pub fn init(
  config: &mut SimpleCommitsConfig,
 ) -> Result<(), Error> {
  let mut state = AppData::default();
- let steps = gen_steps![commit, scopes, emoji, message, exec];
+ let mut steps = gen_steps![
+ commit::Definition,
+ scopes::Scope,
+ emoji::Emoji,
+ message::Title,
+ exec::Execute
+ ];
 
  prompt.with_intro("Simple Commit").begin()?;
 
- for step in steps {
+ for step in steps.iter_mut() {
+ let _before = step.before_run(prompt, &mut state, config);
  let res = step.run(prompt, &mut state, config);
  if let Err(err) = res {
  let msg = format!("❌ Error: {:?}", err);
  error!(target: "tui::steps", "{}", msg.bright_red());
  return Err(Error::Prompt(String::from("Error")));
  }
+ let _after = step.after_run(prompt, &mut state, config);
  info!(target: "tui::steps", "steps: {state:#?}");
  }
 

src/tui/steps/scopes.rs

@@ -10,11 +10,11 @@ use crate::{
 };
 
 #[derive(Default)]
-pub struct _Step;
+pub struct Scope;
 
-impl Step for _Step {
+impl Step for Scope {
  fn run(
- &self,
+ &mut self,
  p: &mut promptuity::Promptuity<std::io::Stderr>,
  state: &mut crate::tui::AppData,
  config: &mut SimpleCommitsConfig,
@@ -38,11 +38,12 @@ impl Step for _Step {
  let scope = (!scope.is_empty()).then_some(scope);
  state.commit.set_scope(scope.clone());
 
+ // FIX: Error on global path
  if let Some(scope) = scope {
  if let Some(scopes) = &mut config.scopes {
  if !scopes.exists(&scope) {
  debug!(target: "steps::scope", "This shit works");
- scopes.add_scope(scope.clone());
+ scopes.add_scope(scope);
  if let Err(err) = config.update() {
  error!(target: "step::scope", "This shit aint work! {}", err);
  }