refactor(core): TUI steps to use pipeline pattern.

Author: romancitodev

Cargo.lock

@@ -2,24 +2,23 @@
 name = "simple-commit"
 description = "A little CLI written in rust to improve your dirty commits into conventional ones. "
 repository = "https://github.com/romancitodev/simple-commits"
-authors = ["romancitodev"]
 version = "1.0.2"
 edition = "2021"
 license = "MIT"
 
-[[bin]]
-name = "sc"
-path = "src/main.rs"
-
 [package.metadata.wix]
 upgrade-guid = "C20E12CB-E616-45DF-8B01-11541D65C6CE"
 path-guid = "E4D36954-1F3E-4535-A0BA-B439FA323671"
 license = false
 eula = false
 
+[[bin]]
+name = "sc"
+path = "src/main.rs"
+
 [dependencies]
 thiserror = "1"
-cliclack = "0.3.4"
+cliclack = "0.3.7"
 clap = { version = "4.5.3", features = ["derive"] }
 clap_derive = { version = "4.0.0-rc.1" }
 colored = "2.1.0"

Cargo.toml

@@ -14,7 +14,7 @@ pub struct CliConfig {
     pub(super) config: Option<PathBuf>,
 
     #[clap(flatten)]
-    pub(super) sc_config: SimpleCommitsConfig,
+    pub(super) sc_config: AppConfig,
 
     #[command(subcommand)]
     pub(super) mode: Option<Command>,
@@ -34,7 +34,7 @@ pub enum InitOptions {
 
 /// File settings for customizing the bin.
 #[derive(Debug, Default, Serialize, Deserialize, Parser, Merge)]
-pub struct SimpleCommitsConfig {
+pub struct AppConfig {
     #[merge(skip)]
     #[serde(skip)]
     #[clap(skip)]
@@ -54,7 +54,7 @@ pub struct SimpleCommitsConfig {
     pub git: Option<GitConfig>,
 }
 
-impl SimpleCommitsConfig {
+impl AppConfig {
     pub fn update(&self) -> std::io::Result<()> {
         let updated = toml::to_string_pretty(&self).unwrap();
         fs::write(&self.config, updated)?;

src/config/cli.rs

@@ -1,6 +1,6 @@
 use crate::tui::structs::Scope;
 
-use super::cli::{InitOptions, SimpleCommitsConfig};
+use super::cli::{AppConfig, InitOptions};
 use directories::BaseDirs;
 use merge2::Merge;
 use std::{env::current_dir, path::PathBuf};
@@ -36,11 +36,11 @@ pub fn create_config(option: InitOptions) -> PathBuf {
 /// (Global, Local)
 type ConfigPaths = (PathBuf, Option<PathBuf>);
 
-pub fn load_config(path: Option<PathBuf>, config: &mut SimpleCommitsConfig) -> ConfigPaths {
+pub fn load_config(path: Option<PathBuf>, config: &mut AppConfig) -> ConfigPaths {
     let global_path = path.unwrap_or(create_config(InitOptions::Global));
 
     if let Ok(content) = std::fs::read_to_string(&global_path) {
-        let mut global_config: SimpleCommitsConfig = toml::from_str(&content).unwrap();
+        let mut global_config: AppConfig = toml::from_str(&content).unwrap();
         config.config.clone_from(&global_path);
         config.scopes = Some(Scope::default());
         config.merge(&mut global_config);
@@ -50,7 +50,7 @@ pub fn load_config(path: Option<PathBuf>, config: &mut SimpleCommitsConfig) -> C
 
     if let Ok(local_path_ok) = &local_path {
         if let Ok(content) = std::fs::read_to_string(local_path_ok) {
-            let mut local_config: SimpleCommitsConfig = toml::from_str(&content).unwrap();
+            let mut local_config: AppConfig = toml::from_str(&content).unwrap();
             config.config.clone_from(local_path_ok);
             config.scopes = Some(Scope::default());
             config.merge(&mut local_config);

src/config/helpers.rs

@@ -6,9 +6,9 @@ pub mod cli;
 pub mod git;
 pub mod helpers;
 
-pub fn get_config() -> (cli::SimpleCommitsConfig, Option<Command>) {
+pub fn get_config() -> (cli::AppConfig, Option<Command>) {
     let mut args = cli::CliConfig::parse();
-    let mut config = cli::SimpleCommitsConfig::default();
+    let mut config = cli::AppConfig::default();
 
     if let Some(Command::Init(option)) = args.mode {
         let path = helpers::create_config(option);

src/config/mod.rs

@@ -1,6 +1,7 @@
 mod config;
 pub mod errors;
 mod gen;
+mod reimpl;
 mod tui;
 
 pub fn main() {

src/main.rs

@@ -0,0 +1,94 @@
+//! Pipeline pattern for composing commit creation steps.
+//!
+//! This module provides a functional, composable approach to building commits
+//! through a series of steps. Each step receives mutable access to the pipeline
+//! and can modify the state and configuration as needed.
+//!
+//! # Example
+//!
+//! ```rust,ignore
+//! Pipeline::new(config)
+//!     .then(|pipeline| {
+//!         // Step 1: Do something with pipeline.state and pipeline.config
+//!         Ok(())
+//!     })?
+//!     .then(|pipeline| {
+//!         // Step 2: Next operation
+//!         Ok(())
+//!     })?;
+//! ```
+//!
+//! The pipeline pattern provides:
+//! - **Explicit data flow**: State and config are passed through each step
+//! - **Error propagation**: Each step returns `Result<(), AppError>`
+//! - **Composability**: Steps can be chained with `.then()`
+//! - **Type safety**: The compiler ensures proper error handling
+
+use crate::{config::cli::AppConfig, errors::AppError, tui::AppData};
+
+/// The pipeline that carries state and configuration through commit creation steps.
+///
+/// Each step in the pipeline receives mutable access to this struct and can:
+/// - Read and modify the application state (`state`)
+/// - Read and modify the configuration (`config`)
+/// - Return an error to halt the pipeline
+pub struct Pipeline {
+    /// The application state, primarily containing the commit being built.
+    pub state: AppData,
+    /// The application configuration, including user preferences and settings.
+    pub config: AppConfig,
+}
+
+impl Pipeline {
+    /// Creates a new pipeline with the given configuration.
+    ///
+    /// The state is initialized to its default value.
+    pub fn new(config: AppConfig) -> Self {
+        Self {
+            state: AppData::default(),
+            config,
+        }
+    }
+}
+
+impl Pipeline {
+    /// Chains a step onto the pipeline.
+    ///
+    /// The provided closure receives mutable access to the pipeline and can modify
+    /// both the state and configuration. If the closure returns an error, the pipeline
+    /// stops and the error is propagated.
+    ///
+    /// # Arguments
+    /// * `run` - A closure that performs the step's logic
+    ///
+    /// # Returns
+    /// * `Ok(Pipeline)` - The pipeline to continue chaining
+    /// * `Err(AppError)` - If the step encountered an error
+    ///
+    /// # Example
+    ///
+    /// ```rust,ignore
+    /// pipeline.then(|p| {
+    ///     p.state.commit.set_title(Some("feat: add feature".to_string()));
+    ///     Ok(())
+    /// })?
+    /// ```
+    pub fn then<F>(mut self, run: F) -> Result<Pipeline, AppError>
+    where
+        F: FnOnce(&mut Self) -> Result<(), AppError>,
+    {
+        run(&mut self)?;
+        Ok(self)
+    }
+
+    pub fn if_then<F, D>(mut self, cond: D, run: F) -> Result<Pipeline, AppError>
+    where
+        D: FnOnce(&mut Self) -> Result<bool, AppError>,
+        F: FnOnce(&mut Self) -> Result<(), AppError>,
+    {
+        if cond(&mut self)? {
+            run(&mut self)?;
+        }
+        Ok(self)
+    }
+}

src/reimpl.rs

@@ -1,13 +1,11 @@
-use crate::config::cli::SimpleCommitsConfig;
+use crate::config::cli::AppConfig;
 use cliclack::{
     intro,
     log::{info, step},
     outro,
 };
 
-pub fn init(
-    SimpleCommitsConfig { config, .. }: &mut SimpleCommitsConfig,
-) -> Result<(), std::io::Error> {
+pub fn init(AppConfig { config, .. }: AppConfig) -> Result<(), std::io::Error> {
     intro("Simple Commit")?;
 
     step("Setting up configuration files")?;

src/tui/config_prompt/mod.rs

@@ -1,5 +1,3 @@
-pub const BLANK_CHARACTER: &str = "";
-
 pub fn valid_length(text: &str, min: usize, msg: &str) -> Result<(), String> {
     if text.len() > min {
         Ok(())

src/tui/helpers.rs

@@ -1,7 +1,4 @@
-use crate::{
-    config::{cli::SimpleCommitsConfig, get_config},
-    errors::AppError,
-};
+use crate::config::get_config;
 
 pub mod config_prompt;
 pub mod helpers;
@@ -11,13 +8,13 @@ pub mod widgets;
 
 /// initialize the configuration and setup the steps
 pub fn init() {
-    let (mut config, command) = get_config();
+    let (config, command) = get_config();
     match command {
         Some(_) => {
-            _ = config_prompt::init(&mut config);
+            _ = config_prompt::init(config);
         }
         None => {
-            _ = steps::init(&mut config);
+            _ = steps::init(config);
         }
     }
 }
@@ -27,65 +24,16 @@ pub struct AppData {
     pub commit: CommitBuilder,
 }
 
-#[allow(dead_code)]
-#[derive(Clone, Debug, Default)]
-pub enum Action {
-    #[default]
-    None,
-    DryRun(String),
-    Commit(String, Vec<String>),
-}
-
-impl Action {
-    /// Returns the action to be executed of this [`Action`].
-    pub fn execute_action(&self) {
-        match self {
-            Self::DryRun(msg) => println!("{msg}"),
-            Self::Commit(cmd, args) => {
-                let _ = std::process::Command::new(cmd)
-                    .args(&args[..])
-                    .spawn()
-                    .expect("The child failed for some reason")
-                    .wait();
-            }
-            Self::None => {}
-        }
-    }
-}
-
-pub type StepResult = Result<(), AppError>;
-
-/// A trait to setup steps along the TUI app.
-pub trait Step {
-    fn before_run(
-        &mut self,
-        _state: &mut AppData,
-        _config: &mut SimpleCommitsConfig,
-    ) -> StepResult {
-        Ok(())
-    }
-
-    fn after_run(&mut self, _state: &mut AppData, _config: &mut SimpleCommitsConfig) -> StepResult {
-        Ok(())
-    }
-
-    fn run(&mut self, state: &mut AppData, config: &mut SimpleCommitsConfig) -> StepResult;
-}
-
-#[macro_export]
-macro_rules! gen_steps {
-    ($($struct:ty),*) => {
-        {
-            let steps: Vec<Box<dyn super::Step>> = vec![
-                $(
-                    Box::new(<$struct>::default()),
-                )*
-            ];
-            steps
-        }
-    };
-}
-
+/// Builder for constructing a conventional commit message.
+///
+/// This builder follows the Conventional Commits specification and supports:
+/// - Commit type (feat, fix, docs, etc.)
+/// - Optional scope
+/// - Optional emoji
+/// - Title/subject line
+/// - Optional body/description
+/// - Optional footer notes
+/// - Breaking change markers and messages
 #[derive(Debug, Default, Clone)]
 pub struct CommitBuilder {
     r#type: Option<String>,
@@ -98,11 +46,15 @@ pub struct CommitBuilder {
     breaking_change_message: Option<String>, // This will filled if is_breaking_change is true
 }
 
-pub struct Commit(String);
+/// The final commit message ready to be executed.
+pub struct Commit(pub String);
 
+/// Errors that can occur when building a commit message.
 #[derive(Debug)]
 pub enum BuildError {
+    /// The commit type (feat, fix, etc.) is required but was not provided.
     TypeRequired,
+    /// The commit title/subject is required but was not provided.
     TitleRequired,
 }