add support for git branch/commit hash/tags when specifying remote configuration/dotfile repo

src/apply.rs

···
 use crate::{
     command::{run_command, run_command_without_local_path},
     config::SshConfig,
+    git::extract_version,
 };
 
 #[derive(Debug)]
···
         repo.to_string()
     };
 
+    let (repo, version) = extract_version(&repo);
+
     let home = dirs::home_dir().ok_or_else(|| Error::msg("Failed to get home directory"))?;
 
     if !Path::new(&home.join(".dotfiles")).exists() {
         run_command("bash", &["-c", &format!("git clone {} ~/.dotfiles", repo)])
             .context("Failed to clone dotfiles repository")?;
     } else {
+        run_command("bash", &["-c", "git -C ~/.dotfiles pull"])
+            .context("Failed to update dotfiles repository")?;
+    }
+
+    if let Some(version) = version {
+        run_command("bash", &["-c", "git -C ~/.dotfiles fetch --all"])?;
+        run_command(
+            "bash",
+            &["-c", &format!("git -C ~/.dotfiles checkout {}", version)],
+        )
+        .context("Failed to checkout dotfiles version")?;
         run_command("bash", &["-c", "git -C ~/.dotfiles pull"])
             .context("Failed to update dotfiles repository")?;
     }

src/cmd/setup.rs

···
 
 use anyhow::{Context, Error};
 use owo_colors::OwoColorize;
-use url::Url;
 
 use crate::{
-    command::run_command, config::Configuration, consts::CONFIG_FILE, diff::compare_configurations,
+    command::run_command,
+    config::Configuration,
+    consts::CONFIG_FILE,
+    diff::compare_configurations,
+    git::{extract_repo_name, extract_version},
 };
 
 pub fn setup(dry_run: bool, no_confirm: bool, config_path: &str) -> Result<(), Error> {
     let mut cfg = Configuration::default();
 
     let repo_url = parse_config_path(config_path)?;
+    let (repo_url, version) = match repo_url.starts_with("https://") {
+        true => extract_version(&repo_url),
+        false => (repo_url, None),
+    };
 
-    let toml_config = match clone_repo(&repo_url) {
+    let toml_config = match clone_repo(&repo_url, version) {
         Ok(toml_config) => toml_config,
         Err(err) => {
             if !repo_url.starts_with("https://") {
···
 fn parse_config_path(config_path: &str) -> Result<String, Error> {
     if config_path.starts_with("github:") {
         let repo = &config_path["github:".len()..];
-        return Ok(format!("https://github.com/{}.git", repo));
+        return Ok(format!("https://github.com/{}", repo));
     }
 
     if config_path.starts_with("tangled:") {
···
     Ok(config_path.to_string())
 }
 
-fn clone_repo(repo_url: &str) -> Result<String, Error> {
+fn clone_repo(repo_url: &str, version: Option<String>) -> Result<String, Error> {
     if !repo_url.starts_with("https://") {
         return Err(anyhow::anyhow!(
             "Unsupported repository URL. Only HTTPS URLs are supported."
···
             run_command("git", &["-C", dest.to_str().unwrap(), "pull"])?;
         }
         false => {
-            run_command(
-                "git",
-                &["clone", "--depth", "1", repo_url, dest.to_str().unwrap()],
-            )?;
+            run_command("git", &["clone", repo_url, dest.to_str().unwrap()])?;
         }
     }
 
+    if version.is_some() {
+        run_command("git", &["-C", dest.to_str().unwrap(), "fetch", "--all"])?;
+        run_command(
+            "git",
+            &[
+                "-C",
+                dest.to_str().unwrap(),
+                "checkout",
+                version.as_ref().unwrap(),
+            ],
+        )?;
+    }
+
     if !dest.join("oh-my-droid.toml").exists() {
         return Err(anyhow::anyhow!(
             "The repository does not contain an oh-my-droid.toml configuration file."
···
     Ok(dest.join("oh-my-droid.toml").to_str().unwrap().to_string())
 }
 
-fn extract_repo_name(url: &str) -> Option<String> {
-    let parsed = Url::parse(url).ok()?;
-    let mut segments = parsed.path_segments()?;
-    let username = segments.next()?;
-    let mut repo = segments.next()?;
-
-    if let Some(stripped) = repo.strip_suffix(".git") {
-        repo = stripped;
-    }
-
-    Some(format!("{}-{}", username, repo))
-}
-
 #[cfg(test)]
 mod tests {
+    use crate::git::extract_version;
+
     use super::*;
 
     #[test]
-    fn test_extract_repo_name() {
-        let url = "https://github.com/tsirysndr/pkgs.git";
-        let expected = Some("tsirysndr-pkgs".into());
-        let result = extract_repo_name(url);
+    fn test_parse_config_path_github() {
+        let path = "github:tsirysndr/pkgs";
+        let expected = Some("https://github.com/tsirysndr/pkgs".into());
+        let result = parse_config_path(path).ok();
         assert_eq!(result, expected);
     }
 
     #[test]
-    fn test_extract_repo_name_no_git() {
-        let url = "https://github.com/tsirysndr/pkgs";
-        let expected = Some("tsirysndr-pkgs".into());
-        let result = extract_repo_name(url);
+    fn test_parse_config_path_tangled() {
+        let path = "tangled:@tsirysandratraina/pkgs";
+        let expected = Some("https://tangled.sh/@tsirysandratraina/pkgs".into());
+        let result = parse_config_path(path).ok();
+        assert_eq!(result, expected);
+    }
+
+    #[test]
+    fn test_parse_config_path_git_url() {
+        let path = "https://github.com/tsirysndr/pkgs@main";
+        let expected = Some("https://github.com/tsirysndr/pkgs@main".into());
+        let result = parse_config_path(path).ok();
         assert_eq!(result, expected);
     }
 
     #[test]
-    fn test_extract_repo_name_invalid_url() {
-        let url = "invalid-url";
-        let expected = None;
-        let result = extract_repo_name(url);
+    fn test_extract_version() {
+        let url = "https://tangled.sh/@tsirysandratraina/pkgs@main";
+        let expected = (
+            "https://tangled.sh/@tsirysandratraina/pkgs".into(),
+            Some("main".into()),
+        );
+        let result = extract_version(url);
+        assert_eq!(result, expected);
+    }
+
+    #[test]
+    fn test_extract_version_2() {
+        let url = "https://tangled.sh/@tsirysandratraina/pkgs";
+        let expected = ("https://tangled.sh/@tsirysandratraina/pkgs".into(), None);
+        let result = extract_version(url);
         assert_eq!(result, expected);
     }
 
     #[test]
-    fn test_parse_config_path_github() {
-        let path = "github:tsirysndr/pkgs";
-        let expected = Some("https://github.com/tsirysndr/pkgs.git".into());
-        let result = parse_config_path(path).ok();
+    fn test_extract_version_3() {
+        let url = "https://github.com/tsirysndr/pkgs";
+        let expected = ("https://github.com/tsirysndr/pkgs".into(), None);
+        let result = extract_version(url);
         assert_eq!(result, expected);
     }
 
     #[test]
-    fn test_parse_config_path_tangled() {
-        let path = "tangled:@tsirysandratraina/pkgs";
-        let expected = Some("https://tangled.sh/@tsirysandratraina/pkgs".into());
-        let result = parse_config_path(path).ok();
+    fn test_extract_version_4() {
+        let url = "https://github.com/tsirysndr/pkgs@main";
+        let expected = (
+            "https://github.com/tsirysndr/pkgs".into(),
+            Some("main".into()),
+        );
+        let result = extract_version(url);
         assert_eq!(result, expected);
     }
 
     #[test]
-    fn test_parse_config_path_git_url() {
-        let path = "https://github.com/tsirysndr/pkgs.git";
-        let expected = Some("https://github.com/tsirysndr/pkgs.git".into());
+    fn test_parse_config_path_github_with_branch() {
+        let path = "github:tsirysndr/pkgs@main";
+        let expected = Some("https://github.com/tsirysndr/pkgs@main".into());
         let result = parse_config_path(path).ok();
         assert_eq!(result, expected);
     }

src/git.rs

···
+use url::Url;
+
+pub fn extract_repo_name(url: &str) -> Option<String> {
+    let parsed = Url::parse(url).ok()?;
+    let mut segments = parsed.path_segments()?;
+    let username = segments.next()?;
+    let mut repo = segments.next()?;
+
+    if let Some(stripped) = repo.strip_suffix(".git") {
+        repo = stripped;
+    }
+
+    Some(format!("{}-{}", username, repo))
+}
+
+pub fn extract_version(url: &str) -> (String, Option<String>) {
+    let repo_name = url.replace("https://tangled.sh/", "").replace("@", "");
+    match url.rfind('@') {
+        Some(idx) => {
+            let (repo, version) = url.split_at(idx);
+            let version = &version[1..];
+            match version == repo_name {
+                true => (url.to_string(), None),
+                false => (repo.to_string(), Some(version.to_string())),
+            }
+        }
+        None => (url.to_string(), None),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+
+    use super::*;
+
+    #[test]
+    fn test_extract_repo_name() {
+        let url = "https://github.com/tsirysndr/pkgs.git";
+        let expected = Some("tsirysndr-pkgs".into());
+        let result = extract_repo_name(url);
+        assert_eq!(result, expected);
+    }
+
+    #[test]
+    fn test_extract_repo_name_no_git() {
+        let url = "https://github.com/tsirysndr/pkgs";
+        let expected = Some("tsirysndr-pkgs".into());
+        let result = extract_repo_name(url);
+        assert_eq!(result, expected);
+    }
+
+    #[test]
+    fn test_extract_repo_name_invalid_url() {
+        let url = "invalid-url";
+        let expected = None;
+        let result = extract_repo_name(url);
+        assert_eq!(result, expected);
+    }
+}

src/main.rs

···
 use anyhow::Error;
-use clap::{Command, arg};
+use clap::{arg, Command};
 use owo_colors::OwoColorize;
 
 use crate::{
···
 pub mod config;
 pub mod consts;
 pub mod diff;
+pub mod git;
 
 fn cli() -> Command {
     let banner = format!(