monarch-rs 0.1.0

Advanced Git Management Suite for handling multiple repositories concurrently
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

// src/operations/clone.rs
use crate::types::{OperationResult, RepositoryOperation};
use anyhow::{Context, Result};
use std::path::{Path, PathBuf};
use tracing::{debug, info};

pub struct CloneOperation {
    target_dir: PathBuf,
    reverse: bool,
}

impl CloneOperation {
    pub fn new(target_dir: PathBuf, reverse: bool) -> Self {
        Self { target_dir, reverse }
    }
}

impl RepositoryOperation for CloneOperation {
    fn name(&self) -> &'static str {
        "Clone"
    }

    fn description(&self) -> &'static str {
        "Clone repositories from source to target directory"
    }

    fn execute<'a>(&'a self, repo_path: &'a Path) -> 
        std::pin::Pin<Box<dyn std::future::Future<Output = Result<OperationResult>> + Send + 'a>> {
        Box::pin(async move {
            // Get repository name
            let repo_name = repo_path
                .file_name()
                .ok_or_else(|| anyhow::anyhow!("Invalid repository path"))?
                .to_string_lossy()
                .to_string();

            // Determine target path
            let target_path = self.target_dir.join(&repo_name);

            // Skip if target already exists
            if target_path.exists() {
                debug!("Target already exists: {}", target_path.display());
                return Ok(OperationResult::Skipped(format!(
                    "Target already exists: {}",
                    target_path.display()
                )));
            }

            // Create target directory if it doesn't exist
            if !self.target_dir.exists() {
                tokio::fs::create_dir_all(&self.target_dir)
                    .await
                    .context("Failed to create target directory")?;
            }

            // Run git clone command
            let git_url = format!("file://{}", repo_path.display());
            let mut cmd = tokio::process::Command::new("git");
            cmd.arg("clone").arg(git_url).arg(&target_path);

            debug!("Running: {:?}", cmd);
            
            let status = cmd
                .status()
                .await
                .context("Failed to execute git clone command")?;

            if status.success() {
                Ok(OperationResult::Success(format!(
                    "Cloned {} to {}",
                    repo_name,
                    target_path.display()
                )))
            } else {
                Ok(OperationResult::Failure(format!(
                    "Failed to clone {} to {}",
                    repo_name,
                    target_path.display()
                )))
            }
        })
    }
}