dotme 0.1.3

A dotfiles manager written in Rust.
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
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178

use anyhow::{Context, Result};
use std::path::Path;
use tokio::process::Command;

/// Clone a git repository to the specified path
pub async fn clone(url: &str, target: &Path) -> Result<()> {
    log::info!("Cloning git repository: {}", url);
    log::debug!("Target path: {}", target.display());

    // Check if target already exists
    if target.exists() {
        log::warn!("Target directory already exists: {}", target.display());
        return Ok(());
    }

    // Create parent directory if needed
    if let Some(parent) = target.parent() {
        tokio::fs::create_dir_all(parent)
            .await
            .context("Failed to create parent directory")?;
    }

    // Clone the repository
    let output = Command::new("git")
        .arg("clone")
        .arg(url)
        .arg(target)
        .output()
        .await
        .context("Failed to execute git clone command")?;

    if !output.status.success() {
        let stderr = String::from_utf8_lossy(&output.stderr);
        anyhow::bail!("Git clone failed: {}", stderr);
    }

    log::info!("✓ Repository cloned successfully");

    // Check for .gitmodules file and initialize submodules if present
    let gitmodules_path = target.join(".gitmodules");
    if gitmodules_path.exists() {
        log::info!("Found .gitmodules file, initializing submodules...");
        init_submodules(target).await?;
    }

    Ok(())
}

/// Initialize and update git submodules
async fn init_submodules(repo_path: &Path) -> Result<()> {
    log::debug!("Initializing submodules in: {}", repo_path.display());

    // Initialize submodules
    let init_output = Command::new("git")
        .arg("submodule")
        .arg("init")
        .current_dir(repo_path)
        .output()
        .await
        .context("Failed to execute git submodule init")?;

    if !init_output.status.success() {
        let stderr = String::from_utf8_lossy(&init_output.stderr);
        anyhow::bail!("Git submodule init failed: {}", stderr);
    }

    // Update submodules
    let update_output = Command::new("git")
        .arg("submodule")
        .arg("update")
        .arg("--recursive")
        .current_dir(repo_path)
        .output()
        .await
        .context("Failed to execute git submodule update")?;

    if !update_output.status.success() {
        let stderr = String::from_utf8_lossy(&update_output.stderr);
        anyhow::bail!("Git submodule update failed: {}", stderr);
    }

    log::info!("✓ Submodules initialized and updated");

    Ok(())
}

/// Pull latest changes from a git repository
pub async fn pull(repo_path: &Path) -> Result<()> {
    log::info!("Pulling latest changes: {}", repo_path.display());

    if !repo_path.exists() {
        anyhow::bail!("Repository does not exist: {}", repo_path.display());
    }

    // Pull changes
    let output = Command::new("git")
        .arg("pull")
        .current_dir(repo_path)
        .output()
        .await
        .context("Failed to execute git pull")?;

    if !output.status.success() {
        let stderr = String::from_utf8_lossy(&output.stderr);
        anyhow::bail!("Git pull failed: {}", stderr);
    }

    log::info!("✓ Repository updated successfully");

    // Update submodules if .gitmodules exists
    let gitmodules_path = repo_path.join(".gitmodules");
    if gitmodules_path.exists() {
        log::info!("Updating submodules...");
        update_submodules(repo_path).await?;
    }

    Ok(())
}

/// Update git submodules
async fn update_submodules(repo_path: &Path) -> Result<()> {
    let output = Command::new("git")
        .arg("submodule")
        .arg("update")
        .arg("--recursive")
        .arg("--remote")
        .current_dir(repo_path)
        .output()
        .await
        .context("Failed to execute git submodule update")?;

    if !output.status.success() {
        let stderr = String::from_utf8_lossy(&output.stderr);
        anyhow::bail!("Git submodule update failed: {}", stderr);
    }

    log::info!("✓ Submodules updated");

    Ok(())
}

/// Check if git is available on the system
pub async fn check_git_available() -> Result<()> {
    let output = Command::new("git")
        .arg("--version")
        .output()
        .await
        .context("Failed to check git version. Is git installed?")?;

    if !output.status.success() {
        anyhow::bail!("Git command failed. Please ensure git is installed.");
    }

    let version = String::from_utf8_lossy(&output.stdout);
    log::debug!("Git version: {}", version.trim());

    Ok(())
}

/// Get the current status of a git repository
#[allow(dead_code)]
pub async fn status(repo_path: &Path) -> Result<String> {
    let output = Command::new("git")
        .arg("status")
        .arg("--short")
        .current_dir(repo_path)
        .output()
        .await
        .context("Failed to execute git status")?;

    if !output.status.success() {
        let stderr = String::from_utf8_lossy(&output.stderr);
        anyhow::bail!("Git status failed: {}", stderr);
    }

    let status = String::from_utf8_lossy(&output.stdout).to_string();
    Ok(status)
}