feat(git): short_tags option for vX.Y.Z git tags (#191)

* feat(git): short_tags option for vX.Y.Z git tags
enables composer-compatible releases for php projects

* polish and tests

* fix reviews

* oops

Author: goulvenclech

.sampo/changesets/cranky-lord-erika.md

@@ -0,0 +1,7 @@
+---
+cargo/sampo: minor
+cargo/sampo-core: minor
+cargo/sampo-github-action: minor
+---
+
+Added `git.short_tags` configuration option to create short version tags (`vX.Y.Z`) for a single package. In PHP (Packagist) projects, this enables Composer-compatible releases, with the limitation of not supporting monorepos with multiple publishable PHP packages.

crates/sampo-core/src/adapters/packagist.rs

@@ -21,6 +21,10 @@ const PACKAGIST_RATE_LIMIT: Duration = Duration::from_millis(200);
 static PACKAGIST_LAST_CALL: OnceLock<Mutex<Option<Instant>>> = OnceLock::new();
 
 /// Stateless adapter for Packagist/Composer packages.
+///
+/// Packagist auto-updates from VCS tags, but Composer only recognizes `vX.Y.Z` format.
+/// Use `git.short_tags` config for compatibility (see README). Monorepos with multiple
+/// Packagist packages are not supported due to this tag format constraint.
 pub(super) struct PackagistAdapter;
 
 impl PackagistAdapter {

crates/sampo-core/src/config.rs

@@ -1,5 +1,6 @@
 use crate::errors::SampoError;
 use rustc_hash::FxHashSet;
+use semver::Version;
 use std::collections::BTreeSet;
 use std::path::Path;
 
@@ -23,6 +24,8 @@ pub struct Config {
     pub ignore: Vec<String>,
     pub git_default_branch: Option<String>,
     pub git_release_branches: Vec<String>,
+    /// Package using short tag format (`v{version}`) for Packagist compatibility.
+    pub git_short_tags: Option<String>,
 }
 
 impl Default for Config {
@@ -42,6 +45,7 @@ impl Default for Config {
             ignore: Vec::new(),
             git_default_branch: None,
             git_release_branches: Vec::new(),
+            git_short_tags: None,
         }
     }
 }
@@ -270,7 +274,7 @@ impl Config {
             }
         }
 
-        let (git_default_branch, git_release_branches) = value
+        let (git_default_branch, git_release_branches, git_short_tags) = value
             .get("git")
             .and_then(|v| v.as_table())
             .map(|git_table| {
@@ -294,9 +298,16 @@ impl Config {
                     })
                     .unwrap_or_default();
 
-                (default_branch, release_branches)
+                let short_tags = git_table
+                    .get("short_tags")
+                    .and_then(|v| v.as_str())
+                    .map(|s| s.trim())
+                    .filter(|s| !s.is_empty())
+                    .map(|s| s.to_string());
+
+                (default_branch, release_branches, short_tags)
             })
-            .unwrap_or((None, Vec::new()));
+            .unwrap_or((None, Vec::new(), None));
 
         Ok(Self {
             version,
@@ -313,6 +324,7 @@ impl Config {
             ignore,
             git_default_branch,
             git_release_branches,
+            git_short_tags,
         })
     }
 
@@ -334,6 +346,50 @@ impl Config {
     pub fn is_release_branch(&self, branch: &str) -> bool {
         self.release_branches().contains(branch)
     }
+
+    /// Returns true if the given package should use short tag format (`v{version}`).
+    pub fn uses_short_tags(&self, package_name: &str) -> bool {
+        self.git_short_tags
+            .as_ref()
+            .is_some_and(|name| name == package_name)
+    }
+
+    /// Builds a git tag name for the given package and version.
+    pub fn build_tag_name(&self, package_name: &str, version: &str) -> String {
+        if self.uses_short_tags(package_name) {
+            format!("v{}", version)
+        } else {
+            format!("{}-v{}", package_name, version)
+        }
+    }
+
+    /// Parses a tag and returns (package_name, version).
+    pub fn parse_tag(&self, tag: &str) -> Option<(String, String)> {
+        if let Some(short_pkg) = self
+            .git_short_tags
+            .as_ref()
+            .filter(|_| tag.starts_with('v'))
+        {
+            let version_str = tag.trim_start_matches('v');
+            if Version::parse(version_str).is_ok() {
+                return Some((short_pkg.clone(), version_str.to_string()));
+            }
+        }
+
+        // Iterate over all "-v" positions to handle prereleases containing "-v" (e.g., "pkg-v1.2.3-v1").
+        for (idx, _) in tag.match_indices("-v") {
+            let name = &tag[..idx];
+            let version = &tag[idx + 2..];
+            if name.is_empty() || version.is_empty() {
+                continue;
+            }
+            if Version::parse(version).is_ok() {
+                return Some((name.to_string(), version.to_string()));
+            }
+        }
+
+        None
+    }
 }
 
 #[cfg(test)]
@@ -356,6 +412,7 @@ mod tests {
         assert_eq!(config.default_branch(), "main");
         assert!(config.is_release_branch("main"));
         assert_eq!(config.git_release_branches, Vec::<String>::new());
+        assert!(config.git_short_tags.is_none());
     }
 
     #[test]
@@ -660,4 +717,163 @@ mod tests {
             vec![vec!["pkg-c".to_string(), "pkg-d".to_string()]]
         );
     }
+
+    #[test]
+    fn reads_short_tags() {
+        let temp = tempfile::tempdir().unwrap();
+        fs::create_dir_all(temp.path().join(".sampo")).unwrap();
+        fs::write(
+            temp.path().join(".sampo/config.toml"),
+            "[git]\nshort_tags = \"my-package\"\n",
+        )
+        .unwrap();
+
+        let config = Config::load(temp.path()).unwrap();
+        assert_eq!(config.git_short_tags.as_deref(), Some("my-package"));
+    }
+
+    #[test]
+    fn defaults_short_tags_to_none() {
+        let temp = tempfile::tempdir().unwrap();
+        let config = Config::load(temp.path()).unwrap();
+        assert!(config.git_short_tags.is_none());
+    }
+
+    #[test]
+    fn uses_short_tags_returns_true_for_matching_package() {
+        let temp = tempfile::tempdir().unwrap();
+        fs::create_dir_all(temp.path().join(".sampo")).unwrap();
+        fs::write(
+            temp.path().join(".sampo/config.toml"),
+            "[git]\nshort_tags = \"my-package\"\n",
+        )
+        .unwrap();
+
+        let config = Config::load(temp.path()).unwrap();
+        assert!(config.uses_short_tags("my-package"));
+        assert!(!config.uses_short_tags("other-package"));
+    }
+
+    #[test]
+    fn build_tag_name_uses_short_format_for_configured_package() {
+        let temp = tempfile::tempdir().unwrap();
+        fs::create_dir_all(temp.path().join(".sampo")).unwrap();
+        fs::write(
+            temp.path().join(".sampo/config.toml"),
+            "[git]\nshort_tags = \"my-package\"\n",
+        )
+        .unwrap();
+
+        let config = Config::load(temp.path()).unwrap();
+        assert_eq!(config.build_tag_name("my-package", "1.2.3"), "v1.2.3");
+        assert_eq!(
+            config.build_tag_name("other-package", "1.2.3"),
+            "other-package-v1.2.3"
+        );
+    }
+
+    #[test]
+    fn parse_tag_handles_short_format() {
+        let temp = tempfile::tempdir().unwrap();
+        fs::create_dir_all(temp.path().join(".sampo")).unwrap();
+        fs::write(
+            temp.path().join(".sampo/config.toml"),
+            "[git]\nshort_tags = \"my-package\"\n",
+        )
+        .unwrap();
+
+        let config = Config::load(temp.path()).unwrap();
+        assert_eq!(
+            config.parse_tag("v1.2.3"),
+            Some(("my-package".to_string(), "1.2.3".to_string()))
+        );
+        assert_eq!(
+            config.parse_tag("v1.2.3-alpha.1"),
+            Some(("my-package".to_string(), "1.2.3-alpha.1".to_string()))
+        );
+        // Standard format still works
+        assert_eq!(
+            config.parse_tag("other-package-v1.2.3"),
+            Some(("other-package".to_string(), "1.2.3".to_string()))
+        );
+    }
+
+    #[test]
+    fn parse_tag_short_format_with_v_in_prerelease() {
+        let temp = tempfile::tempdir().unwrap();
+        fs::create_dir_all(temp.path().join(".sampo")).unwrap();
+        fs::write(
+            temp.path().join(".sampo/config.toml"),
+            "[git]\nshort_tags = \"my-package\"\n",
+        )
+        .unwrap();
+
+        let config = Config::load(temp.path()).unwrap();
+
+        // Prerelease containing -v (the bug case)
+        assert_eq!(
+            config.parse_tag("v1.2.3-v1"),
+            Some(("my-package".to_string(), "1.2.3-v1".to_string()))
+        );
+        assert_eq!(
+            config.parse_tag("v1.0.0-preview1"),
+            Some(("my-package".to_string(), "1.0.0-preview1".to_string()))
+        );
+        assert_eq!(
+            config.parse_tag("v2.0.0-v2-beta"),
+            Some(("my-package".to_string(), "2.0.0-v2-beta".to_string()))
+        );
+        assert_eq!(
+            config.parse_tag("v1.2.3+build.123"),
+            Some(("my-package".to_string(), "1.2.3+build.123".to_string()))
+        );
+        assert_eq!(
+            config.parse_tag("v1.2.3-alpha.1+build.456"),
+            Some((
+                "my-package".to_string(),
+                "1.2.3-alpha.1+build.456".to_string()
+            ))
+        );
+    }
+
+    #[test]
+    fn parse_tag_rejects_invalid_short_tags() {
+        let temp = tempfile::tempdir().unwrap();
+        fs::create_dir_all(temp.path().join(".sampo")).unwrap();
+        fs::write(
+            temp.path().join(".sampo/config.toml"),
+            "[git]\nshort_tags = \"my-package\"\n",
+        )
+        .unwrap();
+
+        let config = Config::load(temp.path()).unwrap();
+
+        assert_eq!(config.parse_tag("v1.2"), None);
+        assert_eq!(config.parse_tag("vfoo"), None);
+        assert_eq!(config.parse_tag("v01.2.3"), None);
+        assert_eq!(config.parse_tag("v"), None);
+    }
+
+    #[test]
+    fn parse_tag_without_short_tags_config() {
+        let temp = tempfile::tempdir().unwrap();
+        let config = Config::load(temp.path()).unwrap();
+
+        assert_eq!(config.parse_tag("v1.2.3"), None);
+        assert_eq!(
+            config.parse_tag("my-package-v1.2.3"),
+            Some(("my-package".to_string(), "1.2.3".to_string()))
+        );
+        assert_eq!(
+            config.parse_tag("my-package-v1.2.3-alpha.1"),
+            Some(("my-package".to_string(), "1.2.3-alpha.1".to_string()))
+        );
+        // -v in prerelease requires semver validation to parse correctly
+        assert_eq!(
+            config.parse_tag("my-package-v1.2.3-v1"),
+            Some(("my-package".to_string(), "1.2.3-v1".to_string()))
+        );
+        assert_eq!(config.parse_tag("my-package-vfoo"), None);
+        assert_eq!(config.parse_tag("my-package-v1.2"), None);
+    }
 }