Skip to main content

git2db/
remote.rs

1//! Remote management for tracked repositories
2//!
3//! Provides git-native remote operations similar to `git remote`
4
5use crate::errors::{Git2DBError, Git2DBResult};
6use crate::registry::{Git2DB, RemoteConfig, RepoId};
7use crate::repo_accessor::RepositoryAccessor;
8use git2::Repository;
9
10/// Manager for repository remotes
11///
12/// Provides operations similar to `git remote` commands.
13///
14/// # Examples
15///
16/// ```rust,no_run
17/// # async fn example(registry: &git2db::Git2DB, repo_id: &git2db::RepoId) -> Result<(), Box<dyn std::error::Error>> {
18/// let repo = registry.repo(repo_id)?;
19/// let remote_mgr = repo.remote();
20///
21/// // Add remotes
22/// remote_mgr.add("origin", "https://github.com/user/repo.git").await?;
23/// remote_mgr.add("p2p", "gittorrent://peer/repo").await?;
24/// remote_mgr.add("backup", "https://backup.com/repo.git").await?;
25///
26/// // List remotes
27/// for remote in remote_mgr.list().await? {
28///     println!("{}: {}", remote.name, remote.url);
29/// }
30///
31/// // Change URL
32/// remote_mgr.set_url("origin", "https://github.com/newuser/repo.git").await?;
33///
34/// // Remove remote
35/// remote_mgr.remove("backup").await?;
36/// # Ok(())
37/// # }
38/// ```
39pub struct RemoteManager<'a> {
40    registry: &'a Git2DB,
41    repo_id: RepoId,
42}
43
44impl<'a> RepositoryAccessor for RemoteManager<'a> {
45    fn registry(&self) -> &Git2DB {
46        self.registry
47    }
48
49    fn repo_id(&self) -> &RepoId {
50        &self.repo_id
51    }
52}
53
54impl<'a> RemoteManager<'a> {
55    /// Create a new remote manager
56    pub(crate) fn new(registry: &'a Git2DB, repo_id: RepoId) -> Self {
57        Self { registry, repo_id }
58    }
59
60    /// Add a new remote
61    ///
62    /// Similar to `git remote add <name> <url>`
63    pub async fn add(&self, name: &str, url: &str) -> Git2DBResult<()> {
64        let path = self.repo_path()?;
65        let name = name.to_owned();
66        let url = url.to_owned();
67
68        tokio::task::spawn_blocking(move || -> Git2DBResult<()> {
69            let repo = Repository::open(&path).map_err(|e| {
70                Git2DBError::repository(&path, format!("Failed to open repository: {e}"))
71            })?;
72
73            // Check if remote already exists
74            if repo.find_remote(&name).is_ok() {
75                return Err(Git2DBError::configuration(format!(
76                    "Remote '{name}' already exists"
77                )));
78            }
79
80            // Add remote to git config
81            repo.remote(&name, &url).map_err(|e| {
82                Git2DBError::configuration(format!("Failed to add remote '{name}': {e}"))
83            })?;
84
85            Ok(())
86        })
87        .await
88        .map_err(|e| Git2DBError::internal(format!("Task join error: {e}")))??;
89
90        // Update registry metadata
91        self.update_metadata_remotes().await?;
92
93        Ok(())
94    }
95
96    /// Remove a remote
97    ///
98    /// Similar to `git remote remove <name>`
99    pub async fn remove(&self, name: &str) -> Git2DBResult<()> {
100        let path = self.repo_path()?;
101        let name = name.to_owned();
102
103        tokio::task::spawn_blocking(move || -> Git2DBResult<()> {
104            let repo = Repository::open(&path).map_err(|e| {
105                Git2DBError::repository(&path, format!("Failed to open repository: {e}"))
106            })?;
107
108            // Check if remote exists
109            repo.find_remote(&name)
110                .map_err(|_| Git2DBError::configuration(format!("Remote '{name}' not found")))?;
111
112            // Remove from git config
113            repo.remote_delete(&name).map_err(|e| {
114                Git2DBError::configuration(format!("Failed to remove remote '{name}': {e}"))
115            })?;
116
117            Ok(())
118        })
119        .await
120        .map_err(|e| Git2DBError::internal(format!("Task join error: {e}")))??;
121
122        // Update registry metadata
123        self.update_metadata_remotes().await?;
124
125        Ok(())
126    }
127
128    /// Change a remote's URL
129    ///
130    /// Similar to `git remote set-url <name> <url>`
131    pub async fn set_url(&self, name: &str, url: &str) -> Git2DBResult<()> {
132        let path = self.repo_path()?;
133        let name = name.to_owned();
134        let url = url.to_owned();
135
136        tokio::task::spawn_blocking(move || -> Git2DBResult<()> {
137            let repo = Repository::open(&path).map_err(|e| {
138                Git2DBError::repository(&path, format!("Failed to open repository: {e}"))
139            })?;
140
141            // Verify remote exists
142            repo.find_remote(&name)
143                .map_err(|_| Git2DBError::configuration(format!("Remote '{name}' not found")))?;
144
145            // Update URL
146            repo.remote_set_url(&name, &url).map_err(|e| {
147                Git2DBError::configuration(format!("Failed to set URL for remote '{name}': {e}"))
148            })?;
149
150            Ok(())
151        })
152        .await
153        .map_err(|e| Git2DBError::internal(format!("Task join error: {e}")))??;
154
155        // Update registry metadata
156        self.update_metadata_remotes().await?;
157
158        Ok(())
159    }
160
161    /// Rename a remote
162    ///
163    /// Similar to `git remote rename <old> <new>`
164    pub async fn rename(&self, old_name: &str, new_name: &str) -> Git2DBResult<()> {
165        let path = self.repo_path()?;
166        let old_name = old_name.to_owned();
167        let new_name = new_name.to_owned();
168
169        tokio::task::spawn_blocking(move || -> Git2DBResult<()> {
170            let repo = Repository::open(&path).map_err(|e| {
171                Git2DBError::repository(&path, format!("Failed to open repository: {e}"))
172            })?;
173
174            // Verify old remote exists
175            repo.find_remote(&old_name).map_err(|_| {
176                Git2DBError::configuration(format!("Remote '{old_name}' not found"))
177            })?;
178
179            // Check new name doesn't exist
180            if repo.find_remote(&new_name).is_ok() {
181                return Err(Git2DBError::configuration(format!(
182                    "Remote '{new_name}' already exists"
183                )));
184            }
185
186            // Rename remote
187            repo.remote_rename(&old_name, &new_name).map_err(|e| {
188                Git2DBError::configuration(format!(
189                    "Failed to rename remote '{old_name}' to '{new_name}': {e}"
190                ))
191            })?;
192
193            Ok(())
194        })
195        .await
196        .map_err(|e| Git2DBError::internal(format!("Task join error: {e}")))??;
197
198        // Update registry metadata
199        self.update_metadata_remotes().await?;
200
201        Ok(())
202    }
203
204    /// List all remotes
205    ///
206    /// Similar to `git remote -v`
207    pub async fn list(&self) -> Git2DBResult<Vec<Remote>> {
208        let path = self.repo_path()?;
209
210        tokio::task::spawn_blocking(move || -> Git2DBResult<Vec<Remote>> {
211            let repo = Repository::open(&path).map_err(|e| {
212                Git2DBError::repository(&path, format!("Failed to open repository: {e}"))
213            })?;
214
215            let remote_names = repo
216                .remotes()
217                .map_err(|e| Git2DBError::internal(format!("Failed to list remotes: {e}")))?;
218
219            let mut remotes = Vec::new();
220
221            for name in remote_names.iter().flatten() {
222                if let Ok(remote) = repo.find_remote(name) {
223                    let url = remote.url().unwrap_or("").to_owned();
224                    let fetch_refspec = remote
225                        .fetch_refspecs()
226                        .map_err(|_| Git2DBError::internal("Failed to get fetch refspecs"))?;
227
228                    let fetch_refs: Vec<String> = fetch_refspec
229                        .iter()
230                        .flatten()
231                        .map(std::borrow::ToOwned::to_owned)
232                        .collect();
233
234                    remotes.push(Remote {
235                        name: name.to_owned(),
236                        url,
237                        fetch_refs,
238                        push_url: remote.pushurl().map(std::borrow::ToOwned::to_owned),
239                    });
240                }
241            }
242
243            Ok(remotes)
244        })
245        .await
246        .map_err(|e| Git2DBError::internal(format!("Task join error: {e}")))?
247    }
248
249    /// Get default remote (usually "origin")
250    pub async fn default(&self) -> Git2DBResult<Option<Remote>> {
251        let remotes = self.list().await?;
252
253        // Look for "origin" first
254        if let Some(origin) = remotes.iter().find(|r| r.name == "origin") {
255            return Ok(Some(origin.clone()));
256        }
257
258        // Return first remote if any
259        Ok(remotes.into_iter().next())
260    }
261
262    /// Update registry metadata with current remotes
263    async fn update_metadata_remotes(&self) -> Git2DBResult<()> {
264        // Get current remotes from git
265        let remotes = self.list().await?;
266
267        // Convert to RemoteConfig
268        let _configs: Vec<RemoteConfig> = remotes
269            .into_iter()
270            .map(|r| RemoteConfig {
271                name: r.name,
272                url: r.url,
273                fetch_refs: r.fetch_refs,
274            })
275            .collect();
276
277        // Update in registry metadata
278        // Note: This requires &mut self, which we don't have
279        // For now, remotes are persisted in .git/config
280        // Metadata sync will happen on next registry save
281        // TODO: Implement proper metadata update mechanism (use _configs)
282
283        Ok(())
284    }
285}
286
287/// Remote information
288#[derive(Debug, Clone)]
289pub struct Remote {
290    pub name: String,
291    pub url: String,
292    pub fetch_refs: Vec<String>,
293    pub push_url: Option<String>,
294}
295
296impl Remote {
297    /// Check if this is the default remote (origin)
298    pub fn is_default(&self) -> bool {
299        self.name == "origin"
300    }
301
302    /// Get display URL (prefer push URL if set)
303    pub fn display_url(&self) -> &str {
304        self.push_url.as_deref().unwrap_or(&self.url)
305    }
306}