feat(chumbucket) - walker from & bundle version

Author: rumblefrog

chumbucket/src/accessors/git.rs

@@ -8,7 +8,7 @@ use walker::{DiffList, Walker};
 pub struct Git<'g>(DiffList<'g>);
 
 impl<'g> Git<'g> {
-    pub fn from_walker(from: Option<&str>, walker: &'g mut Walker) -> Result<Self> {
+    pub fn from_walker(from: Option<i64>, walker: &'g mut Walker) -> Result<Self> {
         Ok(Self(walker.walk(from)?))
     }
 }

chumbucket/src/main.rs

@@ -66,30 +66,35 @@ async fn main() -> Result<()> {
 
     let manifest: Manifest = toml::from_slice(&fs_content)?;
     let mut bundle: Option<Bundle> = None;
+    let mut from_time: Option<i64> = None;
 
     if matches.is_present("bundle") {
         let bundle_str = std::fs::read(matches.value_of("bundle").unwrap())?;
 
-        bundle = Some(serde_json::from_slice(&bundle_str)?);
+        let parsed_bundle: Bundle = serde_json::from_slice(&bundle_str)?;
+
+        if let Some(version) = &parsed_bundle.version {
+            from_time = Some(version.time);
+        }
+
+        bundle = Some(parsed_bundle);
     }
 
     match manifest.source.r#type {
-        // SourceType::Git => {
-
-        // },
-        _ => {
+        SourceType::Git => {
             let mut walker = Walker::from_remote(
                 &manifest.source.repository.clone().unwrap(),
                 &manifest.meta.name,
                 manifest.source.patterns.clone().unwrap(),
             )?;
 
-            let git = accessors::Git::from_walker(None, &mut walker)?;
+            let git = accessors::Git::from_walker(from_time, &mut walker)?;
 
             let b = iterate_chronicles(git, manifest, bundle).await?;
 
             write_to_disk(fs_out, b)?;
         }
+        _ => (),
     };
 
     Ok(())
@@ -105,12 +110,12 @@ where
         version: None,
     });
 
-    for chronicle in i {
+    let mut iter = i.peekable();
+
+    while let Some(chronicle) = iter.next() {
         let version = chronicle.version;
 
         for (file_name, v) in chronicle.files {
-            println!("processing {} @ {}", file_name, version.clone().unwrap().hash);
-
             let alternator_strand = match alternator::consume(file_name.clone(), v).await {
                 Ok(o) => o,
                 // If it errors, we'll continue
@@ -195,6 +200,12 @@ where
                 }
             }
         }
+
+        // If this is the last iteration of chronicles
+        // Set the bundle's version to the last commit processed
+        if iter.peek().is_none() {
+            bundle.version = version.clone();
+        }
     }
 
     Ok(bundle)

libalternator/src/lib.rs

@@ -255,8 +255,6 @@ impl DPStrand {
 
         let section: String = from_utf8(snippet).unwrap().to_owned();
 
-        println!("{}", section);
-
         doc.docs = Some(Comment::parse(section));
     }
 }

libschema/src/manifest.rs

@@ -11,6 +11,7 @@ pub struct Manifest {
 }
 
 #[derive(Deserialize)]
+#[serde(rename_all = "lowercase")]
 pub enum SourceType {
     /// Git SSH URL schema
     /// Repository field must be populated

libwalker/src/lib.rs

@@ -58,15 +58,12 @@ impl Walker {
         })
     }
 
-    pub fn walk(&mut self, from: Option<&str>) -> Result<DiffList> {
+    pub fn walk(&mut self, from: Option<i64>) -> Result<DiffList> {
         let mut revwalk = self.repo.revwalk()?;
 
         revwalk.set_sorting(Sort::TIME | Sort::REVERSE)?;
 
-        match from {
-            Some(v) => revwalk.push(Oid::from_str(v)?)?,
-            None => revwalk.push_head()?,
-        }
+        revwalk.push_head()?;
 
         let mut spec_diffs = Vec::new();
 
@@ -75,6 +72,14 @@ impl Walker {
 
             let commit = self.repo.find_commit(oid)?;
 
+            // If a from time is specified
+            // Any commit that's older than this time is skipped
+            if let Some(from_time) = from {
+                if commit.time().seconds() < from_time {
+                    continue;
+                }
+            }
+
             let c_tree = commit.tree()?;
 
             let parent_count = commit.parent_count();