cocogitto · ABWassim · May 29, 2024
diff --git a/src/bin/cog/main.rs b/src/bin/cog/main.rs
@@ -227,6 +227,10 @@ enum Command {
         /// Name of the repository used during template generation
         #[arg(long, requires_all = ["owner", "remote"])]
         repository: Option<String>,
+
+        /// Generate the changelog for the specified package
+        #[arg(short, long)]
+        package: Option<String>,
     },
 
     /// Get current version
@@ -581,6 +585,7 @@ fn main() -> Result<()> {
             remote,
             owner,
             repository,
+            package,
         } => {
             let cocogitto = CocoGitto::get()?;
 
@@ -593,15 +598,20 @@ fn main() -> Result<()> {
                 Template::default()
             };
 
-            // TODO: fallback to tag here
-            let pattern = pattern.as_deref().unwrap_or("..");
-            let result = match at {
-                Some(at) => cocogitto.get_changelog_at_tag(&at, template)?,
+            let pattern = at.unwrap_or(pattern.as_deref().unwrap_or("..").to_string());
+
+            let result = match package {
+                Some(package) => {
+                    let changelog =
+                        cocogitto.get_changelog_for_package
10000
(&pattern, &package, true)?;
+                    changelog.into_markdown(template)?
+                }
                 None => {
-                    let changelog = cocogitto.get_changelog(pattern, true)?;
+                    let changelog = cocogitto.get_changelog(&pattern, true)?;
                     changelog.into_markdown(template)?
                 }
             };
+
             println!("{result}");
         }
         Command::Init { path } => {

diff --git a/src/command/changelog.rs b/src/command/changelog.rs
@@ -1,8 +1,5 @@
 use crate::conventional::changelog::release::Release;
-use crate::conventional::changelog::template::Template;
-
 use crate::CocoGitto;
-use anyhow::anyhow;
 use anyhow::Result;
 
 impl CocoGitto {
@@ -14,11 +11,15 @@ impl CocoGitto {
         Release::try_from(commit_range).map_err(Into::into)
     }
 
-    pub fn get_changelog_at_tag(&self, tag: &str, template: Template) -> Result<String> {
-        let changelog = self.get_changelog(tag, false)?;
-
-        changelog
-            .into_markdown(template)
-            .map_err(|err| anyhow!(err))
+    pub fn get_changelog_for_package(
+        &self,
+        pattern: &str,
+        package: &str,
+        _with_child_releases: bool,
+    ) -> Result<Release> {
+        let commit_range = self
+            .repository
+            .get_commit_range_for_package(pattern, package)?;
+        Release::try_from(commit_range).map_err(Into::into)
     }
 }
diff --git a/src/git/rev/cache.rs b/src/git/rev/cache.rs
@@ -6,23 +6,23 @@ use once_cell::sync::{Lazy, OnceCell};
 use std::collections::BTreeMap;
 use std::sync::{Arc, Mutex, MutexGuard};
 
-static REPO_CACHE: Lazy<Arc<Mutex<BTreeMap<String, OidOf>>>> =
+static REPO_CACHE: Lazy<Arc<Mutex<BTreeMap<String, Vec<OidOf>>>>> =
     Lazy::new(|| Arc::new(Mutex::new(BTreeMap::new())));
 
 static FIRST_COMMIT: OnceCell<OidOf> = OnceCell::new();
 
-pub(crate) fn get_cache(repository: &Repository) -> MutexGuard<'_, BTreeMap<String, OidOf>> {
+pub(crate) fn get_cache(repository: &Repository) -> MutexGuard<'_, BTreeMap<String, Vec<OidOf>>> {
     let mut cache = REPO_CACHE.lock().unwrap();
     if cache.is_empty() {
         let head = repository.get_head_commit().expect("HEAD");
         let first = FIRST_COMMIT.get_or_init(|| {
             OidOf::FirstCommit(repository.get_first_commit().expect("first commit"))
         });
 
-        cache.insert(head.id().to_string(), OidOf::Head(head.id()));
+        cache.insert(head.id().to_string(), vec![OidOf::Head(head.id())]);
         cache.insert(
             first.to_string(),
-            FIRST_COMMIT.get().expect("first commit").clone(),
+            vec![FIRST_COMMIT.get().expect("first commit").clone()],
         );
 
         let tag_iter = repository.0.tag_names(None).expect("tags");
@@ -35,15 +35,19 @@ pub(crate) fn get_cache(repository: &Repository) -> MutexGuard<'_, BTreeMap<Stri
         for tag in tag_iter {
             if let Some(target) = tag.target.as_ref() {
                 let target = target.to_string();
-                cache.insert(target, OidOf::Tag(tag.clone()));
+
+                let vec = cache.entry(target).or_insert(Vec::new());
+                vec.push(OidOf::Tag(tag.clone()));
             }
 
             if let Some(oid) = tag.oid.as_ref() {
                 let oid = oid.to_string();
-                cache.insert(oid, OidOf::Tag(tag.clone()));
+                let vec = cache.entry(oid).or_insert(Vec::new());
+                vec.push(OidOf::Tag(tag.clone()));
             }
 
-            cache.insert(tag.to_string(), OidOf::Tag(tag));
+            let vec = cache.entry(tag.to_string()).or_insert(Vec::new());
+            vec.push(OidOf::Tag(tag));
         }
     }
 

diff --git a/src/git/rev/revspec.rs b/src/git/rev/revspec.rs
@@ -63,20 +63,81 @@ impl Repository {
     pub(super) fn resolve_oid_of(&self, from: &str) -> Result<OidOf, Git2Error> {
         let cache = get_cache(self);
 
-        let oid = cache
+        println!("oid to resolve is {}", from);
+
+        let oids = cache
             .iter()
             .find(|(k, _)| k.starts_with(from))
             .map(|(_, v)| v);
 
-        match oid {
+        for o in oids.unwrap_or(&Vec::new()) {
+            print!("oid is {} ", o.to_string());
+            match o {
+                OidOf::FirstCommit(_) => {
+                    print!("type is first FirstCommit ");
+                }
+                &OidOf::Head(_) => {
+                    print!("type is first Head ");
+                }
+                OidOf::Other(_) => {
+                    print!("type is first Other ");
+                }
+                &OidOf::Tag(_) => {
+                    print!("type is first Tag ");
+                }
+            }
+        }
+        println!("");
+
+        match oids {
+            None => {
+                let object = self
+                    .0
+                    .revparse_single(from)
+                    .map_err(|_| Git2Error::UnknownRevision(from.to_string()))?;
+                Ok(OidOf::Other(object.id()))
+            }
            Some(oids) => Ok(oids.first().unwrap().clone()),
+        }
+    }
+
+    pub(super) fn resolve_oid_of_for_package(
+        &self,
+        from: &str,
+        package: &str,
+    ) -> Result<OidOf, Git2Error> {
+        let cache = get_cache(self);
+
+        println!("pattern to look for is {}", from);
+
+        let oids = cache
+            .iter()
+            .find(|(k, _)| k.starts_with(from))
+            .map(|(_, v)| v.clone());
+
+        /*
+        println!("len is {}", &oid.len());
+
+        for o in &oid {
+            print!("oid is {} ", o.to_string());
+        }
+
+        println!("");
+        */
+
+        match oids {
             None => {
                 let object = self
                     .0
                     .revparse_single(from)
                     .map_err(|_| Git2Error::UnknownRevision(from.to_string()))?;
                 Ok(OidOf::Other(object.id()))
             }
-            Some(oid) => Ok(oid.clone()),
+            Some(oids) => Ok(oids
+                .iter()
+                .find(|oid| oid.to_string().starts_with(&package))
+                .unwrap_or(oids.first().unwrap())
+                .clone()),
         }
     }
 }

diff --git a/src/git/rev/revwalk.rs b/src/git/rev/revwalk.rs
@@ -14,7 +14,7 @@ impl Repository {
         pattern: &str,
         package: &str,
     ) -> Result<CommitIter, Git2Error> {
-        let mut commit_range = self.revwalk(pattern)?;
+        let mut commit_range = self.revwalk_for_package(pattern, package)?;
         let mut commits = vec![];
         let package = SETTINGS.packages.get(package).expect("package exists");
         let package_path_filter = PackagePathFilter::from_package(package);
@@ -124,6 +124,9 @@ impl Repository {
             let oid = oid?;
             // TODO: can we avoid allocating strings here ?
             let oid_of = self.resolve_oid_of(&oid.to_string())?;
+
+            println!("resolved oid : {}", oid_of.to_string());
+
             let commit = self.0.find_commit(oid)?;
             commits.push((oid_of, commit));
         }
@@ -142,6 +145,38 @@ impl Repository {
 
         Ok(CommitIter(commits))
     }
+
+    /// Return a commit range from a [`RevspecPattern2`]
+    pub fn revwalk_for_package(&self, spec: &str, package: &str) -> Result<CommitIter, Git2Error> {
+        let spec = self.revspec_from_str(spec)?;
+        let mut revwalk = self.0.revwalk()?;
+        revwalk.push_range(&spec.to_string())?;
+
+        let mut commits: Vec<(OidOf, Commit)> = vec![];
+
+        for oid in revwalk {
+            let oid = oid?;
+            // TODO: can we avoid allocating strings here ?
+            let oid_of = self.resolve_oid_of_for_package(&oid.to_string(), package)?;
+
+            let commit = self.0.find_commit(oid)?;
+            commits.push((oid_of, commit));
+        }
+
+        // TODO: can we avoid allocating strings here ?
+        let first_oid = self.resolve_oid_of_for_package(&spec.from().to_string(), package)?;
+        let include_start = match &first_oid {
+            OidOf::Head(_) | OidOf::FirstCommit(_) => true,
+            OidOf::Tag(_) | OidOf::Other(_) => false,
+        };
+
+        if include_start {
+            let first_commit = self.0.find_commit(*spec.from())?;
+            commits.push((first_oid, first_commit));
+        }
+
+        Ok(CommitIter(commits))
+    }
 }
 
 #[cfg(test)]

diff --git a/src/git/tag.rs b/src/git/tag.rs
@@ -145,6 +145,7 @@ impl Repository {
 
         Ok(repo_cache
             .values()
+            .flatten()
             .filter_map(|oid| match oid {
                 OidOf::Tag(tag) if tag_filter(tag) => Some(tag),
                 _ => None,

diff --git a/tests/cog_tests/changelog.rs b/tests/cog_tests/changelog.rs
@@ -563,6 +563,72 @@ fn ensure_omit_from_changelog_is_honored() -> Result<()> {
     Ok(())
 }
 
+#[sealed_test]
+fn get_changelog_for_package() -> Result<()> {
+    init_monorepo(&mut Settings::default())?;
+
+    let settings = formatdoc!(
+        "
+        [packages.one]
+        path = \"one\"
+        changelog_path = \"one/CHANGELOG.md\"
+
+        [packages.two]
+        path = \"two\"
+        changelog_path = \"two/CHANGELOG.md\"
+        "
+    );
+
+    Command::
BAA9
cargo_bin("cog")?
+        .arg("bump")
+        .arg("--auto")
+        .assert()
+        .success();
+
+    run_cmd!(
+        echo $settings > cog.toml;
+        git add .;
+        git commit -m "chore: update cog";
+        echo "one feature" > one/one_feature;
+        git add .;
+        git commit -m "feat: one feature";
+        mkdir two;
+        echo "two feature" > two/two_feature;
+        git add .;
+        git commit -m "feat: two feature";
+    )?;
+
+    Command::cargo_bin("cog")?
+        .arg("bump")
+        .arg("--auto")
+        .assert()
+        .success();
+
+    let changelog = Command::cargo_bin("cog")?
+        .arg("changelog")
+        .arg("-p")
+        .arg("one")
+        // Assert
+        .assert()
+        .success();
+
+    let tags = Command::new("git")
+        .arg("--no-pager")
+        .arg("tag")
+        .assert()
+        .success();
+
+    let tags = tags.get_output();
+    let tags = String::from_utf8_lossy(&tags.stdout);
+    println!("\n\n\n{}", tags.as_ref());
+
+    let changelog = changelog.get_output();
+    let changelog = String::from_utf8_lossy(&changelog.stdout);
+    println!("\n\n\n{}", changelog.as_ref());
+
+    assert_tag_exists("one-0.2.0")?;
+    Ok(())
+}
 //TODO
 /*// see: https://github.com/cocogitto/cocogitto/issues/359
 #[sealed_test]