prepare for multi-line parsing and all the bells and whistles

Sebastian Thiel committed 6 years ago

Commit 08f9ec41 parent 6dc57b36 files · +53 −28Browse files

Unified · Split

6 files

README.md +3 −3
git-odb/src/alternate.rs +22 −18
git-odb/src/compound/init.rs +1 −3
git-odb/src/compound/mod.rs +1 −1
git-odb/tests/alternate/mod.rs +21 −3
tasks.md +5 −0

@@ -91,9 +91,9 @@ become available. · 90 unmodified lines
91	* sink	91	* sink
92	* [x] write objects and obtain id	92	* [x] write objects and obtain id
93	* alternates	93	* alternates
94	* [ ] _database that act as link to other known ODB types on disk_	94	* [ ] _database that act as link to other known git ODBs on disk_
95	* [ ] handles cycles	95	* [ ] safe with cycles and recursive configurations
96	* [ ] handles recursive configurations	96	* [ ] multi-line with comments and quotes
97	* multi-odb	97	* multi-odb
98	* [ ] _an ODB for object lookup from multiple lower level ODB at once_	98	* [ ] _an ODB for object lookup from multiple lower level ODB at once_
99	* promisor	99	* promisor

git-odb/src/alternate.rs+22−18

     Cycle(Vec<PathBuf>),
 }
-pub fn resolve(objects_directory: impl Into<PathBuf>) -> Result<Option<compound::Db>, Error> {
+pub fn resolve(objects_directory: impl Into<PathBuf>) -> Result<Vec<compound::Db>, Error> {
-    let mut dir = objects_directory.into();
+    let mut dirs = vec![(0, objects_directory.into())];
-    let mut count = 0;
+    let mut out = Vec::new();
     let mut seen = Vec::new();
-    loop {
+    while let Some((depth, dir)) = dirs.pop() {
         if seen.contains(&dir) {
-            break Err(Error::Cycle(seen));
+            return Err(Error::Cycle(seen));
         }
         seen.push(dir.clone());
-        let content = match fs::read(dir.join("info").join("alternates")) {
+        match fs::read(dir.join("info").join("alternates")) {
-            Ok(d) => d,
+            Ok(content) => {
+                dirs.push((
+                    depth + 1,
+                    content
+                        .as_bstr()
+                        .to_path()
+                        .map(ToOwned::to_owned)
+                        .map_err(|_| Error::PathConversion(content))?,
+                ));
+            }
             Err(err) if err.kind() == io::ErrorKind::NotFound => {
-                break if count == 0 {
+                // Only resolve for repositories with at least one link, otherwise the line below isn't safe to call
-                    Ok(None)
+                if depth != 0 {
-                } else {
+                    // The tail of a chain doesn't have alternates, and thus is the real deal
-                    Ok(Some(compound::Db::at(dir)?))
+                    out.push(compound::Db::at(dir)?);
                 }
             }
-            Err(err) => break Err(err.into()),
+            Err(err) => return Err(err.into()),
         };
-        dir = content
-            .as_bstr()
-            .to_path()
-            .map(ToOwned::to_owned)
-            .map_err(|_| Error::PathConversion(content))?;
-        count += 1;
     }
+    Ok(out)
 }

git-odb/src/compound/init.rs+1−3

         Ok(compound::Db {
             loose: loose::Db::at(loose_objects.clone()),
             packs,
-            alternate: crate::alternate::resolve(loose_objects)
+            alternates: crate::alternate::resolve(loose_objects).map_err(Box::new)?,
-                .map_err(Box::new)?
-                .map(Box::new),
         })
     }
 }

git-odb/src/compound/mod.rs+1−1

@@ -3,7 +3,7 @@ use crate::{loose, pack}; · 2 unmodified lines
3	pub struct Db {	3	pub struct Db {
4	pub loose: loose::Db,	4	pub loose: loose::Db,
5	pub packs: Vec<pack::Bundle>,	5	pub packs: Vec<pack::Bundle>,
6	pub alternate: Option<Box<Db>>,	6	pub alternates: Vec<Db>,
7	}	7	}
8		8
9	pub mod object {	9	pub mod object {

git-odb/tests/alternate/mod.rs+21−3

 use std::{fs, io, path::PathBuf};
 fn alternate(objects_at: impl Into<PathBuf>, objects_to: impl Into<PathBuf>) -> Result<(PathBuf, PathBuf), io::Error> {
+    alternate_with(objects_at, objects_to, None)
+}
+fn alternate_with(
+    objects_at: impl Into<PathBuf>,
+    objects_to: impl Into<PathBuf>,
+    content_before_to: Option<&str>,
+) -> Result<(PathBuf, PathBuf), io::Error> {
     let at = objects_at.into();
     let to = objects_to.into();
     let at_info = at.join("info");
     fs::create_dir_all(&at_info)?;
     fs::create_dir_all(&to)?;
-    fs::write(at_info.join("alternates"), to.to_string_lossy().as_bytes())?;
+    let contents = if let Some(content) = content_before_to {
+        let mut c = vec![b'\n'];
+        c.extend(content.as_bytes());
+        c.extend(to.to_string_lossy().as_bytes());
+        c
+    } else {
+        to.to_string_lossy().as_bytes().to_owned()
+    };
+    fs::write(at_info.join("alternates"), contents)?;
     Ok((at, to))
 }
     let non_alternate = tmp.path().join("actual");
     let (from, to) = alternate(tmp.path().join("a"), non_alternate)?;
-    assert_eq!(alternate::resolve(from).unwrap().unwrap().loose.path, to);
+    let alternates = alternate::resolve(from)?;
+    assert_eq!(alternates.len(), 1);
+    assert_eq!(alternates[0].loose.path, to);
     Ok(())
 }
 #[test]
 fn no_alternate_in_first_objects_dir() -> crate::Result {
     let tmp = tempdir::TempDir::new("alternates")?;
-    assert!(alternate::resolve(tmp.path()).unwrap().is_none());
+    assert!(alternate::resolve(tmp.path())?.is_empty());
     Ok(())
 }

tasks.md+5−0

   * [x] alternate DB (location - it's really must following the chain until a compound DB can be created)
     * [x] circular dependencies test
     * [x] basic test
+    * [ ] are multiple alternates supported, too? YES
+    * [ ] comments
+    * [ ] quotes
+    * [ ] support for relative directories
+    * [ ] alternates lookup
   * [x] loose upgrade: jwalk powered iteration behind a feature flag
   * [ ] full docs
 * **git-config**