Fixes #25 Add unique tranform paths to commit

Cargo.toml

@@ -15,6 +15,7 @@ clap = { version = "4.3.23", features = ["derive", "string"] }
 clap_complete_command = "0.5.1"
 git2 = "0.17.2"
 git2-ext = "0.6.0"
+itertools = "0.11.0"
 lenient_semver = "0.4.2"
 mockall_double = "0.3.0"
 parse-git-url = "0.5.1"

src/project.rs

@@ -113,15 +113,15 @@ impl Project {
             branches.create_branch(repo, &project_strings.branch_name)?;
             branches.checkout_branch(repo, &project_strings.branch_name)?;
         }
-        // Create commit if enabled in configuration
-        if repo_config.enable_commit {
-            if !self.config.transforms.is_empty() {
-                println!("🤖 applying transforms");
-                self.transformer.transform(&self.config.transforms, version_update)?;
-            }
+        // Create commit if enabled in configuration and we have transforms
+        let transforms = &self.config.transforms;
+        if repo_config.enable_commit && !transforms.is_empty() {
+            println!("🤖 applying transforms");
+            let paths = self.transformer.transform(transforms, version_update)?;
+            let path_refs: Vec<&str> = paths.iter().map(|p| p.as_str()).collect();
             println!("✍️  committing changes");
             let commits = GitCommits::with_default_branch(&repo_config.default_branch);
-            commits.commit(repo, vec![], &project_strings.commit_message)?;
+            commits.commit(repo, path_refs, &project_strings.commit_message)?;
         }
         // Create tag if enabled in configuration
         if repo_config.enable_tag {

src/repo/commit.rs

@@ -51,6 +51,10 @@ impl GitCommits {
         paths.iter().for_each(|path| {
             index.add_path(path.as_ref()).expect("failed to add path")
         });
+        // Write the index itself.
+        index.write()?;
+        // Write the tree from the index, then find it's OID. The OID can then be used to create a
+        // commit.
         let oid = index.write_tree()?;
         repository.find_tree(oid)
     }

src/transform/file_transform.rs

@@ -28,7 +28,7 @@ impl<'a> FileTransformer<'a> {
         }
     }
 
-    pub fn transform(&self, version_update: &VersionUpdate) -> Result<(), SheepError> {
+    pub fn transform(&self, version_update: &VersionUpdate) -> Result<String, SheepError> {
         let relative_path = &self.config.path;
         let path = self.full_path(relative_path);
         let file_text = self.file_reader.read_to_string(&path)?;
@@ -38,11 +38,13 @@ impl<'a> FileTransformer<'a> {
             1,
         );
         self.file_writer.write_string_to_file(&path, &transformed)?;
-        Ok(())
+        Ok(relative_path.clone())
     }
 
     fn full_path(&self, relative_path: &str) -> PathBuf {
-        [self.project_path, &Path::new(relative_path)].iter().collect()
+        [self.project_path, &Path::new(relative_path)]
+            .iter()
+            .collect()
     }
 
     fn find_string(&self, version_update: &VersionUpdate) -> String {
@@ -71,7 +73,7 @@ mod test {
     use crate::transform::file_transform::FileTransformer;
     use crate::version::update::VersionUpdate;
     use semver::Version;
-    use std::path::{PathBuf};
+    use std::path::PathBuf;
 
     const PATH: &str = "path";
     const PROJECT_PATH: &str = "project";
@@ -88,9 +90,10 @@ mod test {
         };
         let project_path = project_path();
         let file_transformer = FileTransformer::new(&config, &reader, &writer, &project_path);
-        file_transformer
+        let path = file_transformer
             .transform(&version_update())
             .expect("transform failed");
+        assert_eq!(PATH, path)
     }
 
     #[test]
@@ -104,9 +107,10 @@ mod test {
         };
         let project_path = project_path();
         let file_transformer = FileTransformer::new(&config, &reader, &writer, &project_path);
-        file_transformer
+        let path = file_transformer
             .transform(&version_update())
             .expect("transform failed");
+        assert_eq!(PATH, path)
     }
 
     #[test]
@@ -120,9 +124,10 @@ mod test {
         };
         let project_path = project_path();
         let file_transformer = FileTransformer::new(&config, &reader, &writer, &project_path);
-        file_transformer
+        let path = file_transformer
             .transform(&version_update())
             .expect("transform failed");
+        assert_eq!(PATH, path)
     }
 
     #[test]
@@ -136,9 +141,10 @@ mod test {
         };
         let project_path = project_path();
         let file_transformer = FileTransformer::new(&config, &reader, &writer, &project_path);
-        file_transformer
+        let path = file_transformer
             .transform(&version_update())
             .expect("transform failed");
+        assert_eq!(PATH, path)
     }
 
     fn project_path() -> PathBuf {

src/transform/project_transform.rs

@@ -38,13 +38,20 @@ impl ProjectTransformer {
         &self,
         configs: &Vec<TransformConfig>,
         version_update: &VersionUpdate,
-    ) -> Result<(), SheepError> {
-        configs
+    ) -> Result<Vec<String>, SheepError> {
+        let transformers: Vec<FileTransformer> = configs
             .iter()
             .map(|c| {
                 FileTransformer::new(c, &self.file_reader, &self.file_writer, &self.project_path)
             })
-            .try_for_each(|t| t.transform(version_update))
+            .collect();
+
+        let mut paths: Vec<String> = Vec::new();
+        for transformer in transformers {
+            let path = transformer.transform(version_update)?;
+            paths.push(path)
+        }
+        Ok(paths)
     }
 }
 
@@ -82,9 +89,13 @@ mod test {
         let writer = mock_writer("first_2.0.0".to_string(), "second_2.0.0".to_string());
         let project_transformer =
             ProjectTransformer::for_tests(reader, writer, PathBuf::from(PROJECT_PATH));
-        project_transformer
+        let paths = project_transformer
             .transform(&configs(), &version_update())
-            .expect("transform fails")
+            .expect("transform fails");
+        assert_eq!(
+            paths,
+            vec![PATH_1.to_string(), PATH_2.to_string()]
+        )
     }
 
     fn failed_reader() -> MockFileReader {
@@ -108,10 +119,14 @@ mod test {
     fn mock_writer(first_expected: String, second_expected: String) -> MockFileWriter {
         let mut mock = MockFileWriter::default();
         mock.expect_write_string_to_file()
-            .withf_st(move |p, t| p.as_ref().to_str().unwrap() == FULL_PATH_1 && t == first_expected)
+            .withf_st(move |p, t| {
+                p.as_ref().to_str().unwrap() == FULL_PATH_1 && t == first_expected
+            })
             .return_once(|_, _| Ok(()));
         mock.expect_write_string_to_file()
-            .withf_st(move |p, t| p.as_ref().to_str().unwrap() == FULL_PATH_2 && t == second_expected)
+            .withf_st(move |p, t| {
+                p.as_ref().to_str().unwrap() == FULL_PATH_2 && t == second_expected
+            })
             .return_once(|_, _| Ok(()));
         mock
     }