refactor: group git operations

Author: codcod

src/git/clone.rs

@@ -0,0 +1,74 @@
+//! Git clone and repository removal operations
+//!
+//! This module handles the core repository lifecycle operations:
+//! cloning repositories from remote URLs and removing local repository
+//! directories when they're no longer needed.
+//!
+//! ## Functions
+//!
+//! - [`clone_repository`]: Clone a repository from its remote URL
+//! - [`remove_repository`]: Remove a cloned repository directory
+//!
+//! Both functions work with the [`Repository`] configuration type and
+//! provide detailed logging throughout the operation.
+
+use crate::config::Repository;
+use anyhow::{Context, Result};
+use std::path::Path;
+use std::process::Command;
+
+use super::common::Logger;
+
+/// Clone a repository from its URL to the target directory
+pub fn clone_repository(repo: &Repository) -> Result<()> {
+    let logger = Logger;
+    let target_dir = repo.get_target_dir();
+
+    // Check if directory already exists
+    if Path::new(&target_dir).exists() {
+        logger.warn(repo, "Repository directory already exists, skipping");
+        return Ok(());
+    }
+
+    let mut args = vec!["clone"];
+
+    // Add branch flag if a branch is specified
+    if let Some(branch) = &repo.branch {
+        args.extend_from_slice(&["-b", branch]);
+        logger.info(
+            repo,
+            &format!("Cloning branch '{}' from {}", branch, repo.url),
+        );
+    } else {
+        logger.info(repo, &format!("Cloning default branch from {}", repo.url));
+    }
+
+    // Add repository URL and target directory
+    args.push(&repo.url);
+    args.push(&target_dir);
+
+    let output = Command::new("git")
+        .args(&args)
+        .output()
+        .context("Failed to execute git clone command")?;
+
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        anyhow::bail!("Failed to clone repository: {}", stderr);
+    }
+
+    logger.success(repo, "Successfully cloned");
+    Ok(())
+}
+
+/// Remove a cloned repository directory
+pub fn remove_repository(repo: &Repository) -> Result<()> {
+    let target_dir = repo.get_target_dir();
+
+    if Path::new(&target_dir).exists() {
+        std::fs::remove_dir_all(&target_dir).context("Failed to remove repository directory")?;
+        Ok(())
+    } else {
+        anyhow::bail!("Repository directory does not exist: {}", target_dir);
+    }
+}

src/git/common.rs

@@ -0,0 +1,47 @@
+//! Common git utilities and shared helpers
+//!
+//! This module contains utilities that are shared across different git workflows,
+//! such as logging and error handling helpers.
+
+use crate::config::Repository;
+use colored::*;
+
+/// Logger for git operations with consistent formatting
+///
+/// Provides standardized logging methods for git operations, ensuring
+/// consistent output formatting across all git workflows. Each log
+/// message is prefixed with the repository name in cyan/bold for
+/// easy identification.
+///
+/// ## Example
+///
+/// ```rust,no_run
+/// use repos::git::Logger;
+/// use repos::config::Repository;
+///
+/// let logger = Logger::default();
+/// let repo = Repository::new("my-repo".to_string(), "https://github.com/user/repo.git".to_string());
+/// logger.info(&repo, "Starting operation");
+/// logger.success(&repo, "Operation completed");
+/// ```
+#[derive(Default)]
+pub struct Logger;
+
+impl Logger {
+    pub fn info(&self, repo: &Repository, msg: &str) {
+        println!("{} | {}", repo.name.cyan().bold(), msg);
+    }
+
+    pub fn success(&self, repo: &Repository, msg: &str) {
+        println!("{} | {}", repo.name.cyan().bold(), msg.green());
+    }
+
+    pub fn warn(&self, repo: &Repository, msg: &str) {
+        println!("{} | {}", repo.name.cyan().bold(), msg.yellow());
+    }
+
+    #[allow(dead_code)]
+    pub fn error(&self, repo: &Repository, msg: &str) {
+        eprintln!("{} | {}", repo.name.cyan().bold(), msg.red());
+    }
+}

src/git/mod.rs

@@ -0,0 +1,39 @@
+//! Git operations using system git commands for maximum compatibility
+//!
+//! This module is organized into sub-modules for different git workflows:
+//!
+//! ## Sub-modules
+//!
+//! - [`clone`]: Repository cloning and removal operations
+//!   - `clone_repository()` - Clone a repository from URL
+//!   - `remove_repository()` - Remove a cloned repository directory
+//!
+//! - [`pull_request`]: Git operations specific to pull request workflows
+//!   - `has_changes()` - Check for uncommitted changes
+//!   - `create_and_checkout_branch()` - Create and switch to new branch
+//!   - `add_all_changes()` - Stage all changes
+//!   - `commit_changes()` - Commit staged changes
+//!   - `push_branch()` - Push branch to remote
+//!   - `get_default_branch()` - Get repository's default branch
+//!
+//! - [`common`]: Shared utilities and helpers
+//!   - `Logger` - Consistent logging for git operations
+//!
+//! ## Benefits of this organization
+//!
+//! - **Scalability**: Easy to add new git features without making single files unwieldy
+//! - **Readability**: Developers can quickly find code for specific git workflows
+//! - **Maintainability**: Clear separation of concerns between different git operations
+//! - **Backward compatibility**: All functions are re-exported at the module level
+
+pub mod clone;
+pub mod common;
+pub mod pull_request;
+
+// Re-export all public functions to maintain backward compatibility
+pub use clone::{clone_repository, remove_repository};
+pub use common::Logger;
+pub use pull_request::{
+    add_all_changes, commit_changes, create_and_checkout_branch, get_default_branch, has_changes,
+    push_branch,
+};

src/git.rs src/git/pull_request.rssrc/git.rs renamed to src/git/pull_request.rs

@@ -1,85 +1,25 @@
-//! Git operations using system git commands for maximum compatibility
+//! Git operations for pull request workflows
+//!
+//! This module contains git operations that are commonly used in pull request
+//! workflows, including checking for changes, creating branches, staging and
+//! committing changes, and pushing branches to remotes.
+//!
+//! ## Typical PR Workflow
+//!
+//! 1. [`has_changes`] - Check if repository has uncommitted changes
+//! 2. [`create_and_checkout_branch`] - Create and switch to a new branch
+//! 3. [`add_all_changes`] - Stage all changes for commit
+//! 4. [`commit_changes`] - Commit the staged changes with a message
+//! 5. [`push_branch`] - Push the branch to the remote repository
+//!
+//! ## Additional Utilities
+//!
+//! - [`get_default_branch`] - Determine the repository's default branch
 
-use crate::config::Repository;
 use anyhow::{Context, Result};
-use colored::*;
-use std::path::Path;
 use std::process::Command;
 
-#[derive(Default)]
-pub struct Logger;
-
-impl Logger {
-    pub fn info(&self, repo: &Repository, msg: &str) {
-        println!("{} | {}", repo.name.cyan().bold(), msg);
-    }
-
-    pub fn success(&self, repo: &Repository, msg: &str) {
-        println!("{} | {}", repo.name.cyan().bold(), msg.green());
-    }
-
-    pub fn warn(&self, repo: &Repository, msg: &str) {
-        println!("{} | {}", repo.name.cyan().bold(), msg.yellow());
-    }
-
-    #[allow(dead_code)]
-    pub fn error(&self, repo: &Repository, msg: &str) {
-        eprintln!("{} | {}", repo.name.cyan().bold(), msg.red());
-    }
-}
-
-pub fn clone_repository(repo: &Repository) -> Result<()> {
-    let logger = Logger;
-    let target_dir = repo.get_target_dir();
-
-    // Check if directory already exists
-    if Path::new(&target_dir).exists() {
-        logger.warn(repo, "Repository directory already exists, skipping");
-        return Ok(());
-    }
-
-    let mut args = vec!["clone"];
-
-    // Add branch flag if a branch is specified
-    if let Some(branch) = &repo.branch {
-        args.extend_from_slice(&["-b", branch]);
-        logger.info(
-            repo,
-            &format!("Cloning branch '{}' from {}", branch, repo.url),
-        );
-    } else {
-        logger.info(repo, &format!("Cloning default branch from {}", repo.url));
-    }
-
-    // Add repository URL and target directory
-    args.push(&repo.url);
-    args.push(&target_dir);
-
-    let output = Command::new("git")
-        .args(&args)
-        .output()
-        .context("Failed to execute git clone command")?;
-
-    if !output.status.success() {
-        let stderr = String::from_utf8_lossy(&output.stderr);
-        anyhow::bail!("Failed to clone repository: {}", stderr);
-    }
-
-    logger.success(repo, "Successfully cloned");
-    Ok(())
-}
-
-pub fn remove_repository(repo: &Repository) -> Result<()> {
-    let target_dir = repo.get_target_dir();
-
-    if Path::new(&target_dir).exists() {
-        std::fs::remove_dir_all(&target_dir).context("Failed to remove repository directory")?;
-        Ok(())
-    } else {
-        anyhow::bail!("Repository directory does not exist: {}", target_dir);
-    }
-}
-
+/// Check if a repository has uncommitted changes
 pub fn has_changes(repo_path: &str) -> Result<bool> {
     // Check if there are any uncommitted changes using git status
     let output = Command::new("git")
@@ -100,6 +40,7 @@ pub fn has_changes(repo_path: &str) -> Result<bool> {
     Ok(!output.stdout.is_empty())
 }
 
+/// Create and checkout a new branch
 pub fn create_and_checkout_branch(repo_path: &str, branch_name: &str) -> Result<()> {
     // Create and checkout a new branch using git checkout -b
     let output = Command::new("git")
@@ -121,6 +62,7 @@ pub fn create_and_checkout_branch(repo_path: &str, branch_name: &str) -> Result<
     Ok(())
 }
 
+/// Add all changes to the staging area
 pub fn add_all_changes(repo_path: &str) -> Result<()> {
     // Add all changes using git add .
     let output = Command::new("git")
@@ -140,6 +82,7 @@ pub fn add_all_changes(repo_path: &str) -> Result<()> {
     Ok(())
 }
 
+/// Commit staged changes with a message
 pub fn commit_changes(repo_path: &str, message: &str) -> Result<()> {
     // Commit changes using git commit
     let output = Command::new("git")
@@ -160,6 +103,7 @@ pub fn commit_changes(repo_path: &str, message: &str) -> Result<()> {
     Ok(())
 }
 
+/// Push a branch to remote and set upstream
 pub fn push_branch(repo_path: &str, branch_name: &str) -> Result<()> {
     // Push branch using git push
     let output = Command::new("git")
@@ -181,6 +125,7 @@ pub fn push_branch(repo_path: &str, branch_name: &str) -> Result<()> {
     Ok(())
 }
 
+/// Get the default branch of a repository
 pub fn get_default_branch(repo_path: &str) -> Result<String> {
     // Try to get the default branch using git symbolic-ref
     let output = Command::new("git")