Switch to hierarchical manifest format

Author: casey

Cargo.lock

@@ -29,12 +29,15 @@ serde_json = "1.0.127"
 serde_with = "3.11.0"
 serde_yaml = "0.9.34"
 snafu = "0.8.4"
+strum = { version = "0.27.2", features = ["derive"] }
+usized = "0.0.2"
 walkdir = "2.5.0"
 
 [dev-dependencies]
 assert_cmd = { version = "2.0.16", features = ["color-auto"] }
 assert_fs = { version = "1.1.2", features = ["color-auto"] }
 predicates = "3.1.2"
+pretty_assertions = "1.4.1"
 regex = "1.10.6"
 
 [lints.clippy]

Cargo.toml

@@ -197,9 +197,11 @@ An example manifest for a directory containing the files `README.md` and
       "hash": "5a9a6d96244ec398545fc0c98c2cb7ed52511b025c19e9ad1e3c1ef4ac8575ad",
       "size": 1573
     },
-    "src/main.c": {
-      "hash": "38abf296dc2a90f66f7870fe0ce584af3859668cf5140c7557a76786189dcf0f",
-      "size": 4491
+    "src": {
+      "main.c": {
+        "hash": "38abf296dc2a90f66f7870fe0ce584af3859668cf5140c7557a76786189dcf0f",
+        "size": 4491
+      }
     }
   }
 }

README.md

@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 
-set -euxo pipefail
+set -euo pipefail
 
 which rg
 

bin/forbid

@@ -0,0 +1,45 @@
+use super::*;
+
+#[derive(Clone, Debug, Deserialize, Eq, Ord, PartialEq, PartialOrd, Serialize)]
+#[serde(deny_unknown_fields, rename_all = "kebab-case", transparent)]
+pub(crate) struct Component(String);
+
+impl Component {
+  pub(crate) fn as_bytes(&self) -> &[u8] {
+    self.0.as_bytes()
+  }
+
+  pub(crate) fn as_str(&self) -> &str {
+    &self.0
+  }
+}
+
+impl Borrow<str> for Component {
+  fn borrow(&self) -> &str {
+    self.0.as_str()
+  }
+}
+
+impl FromStr for Component {
+  type Err = PathError;
+
+  fn from_str(s: &str) -> Result<Self, Self::Err> {
+    for character in s.chars() {
+      if SEPARATORS.contains(&character) {
+        return Err(PathError::Separator { character });
+      }
+    }
+
+    if s == ".." || s == "." {
+      return Err(PathError::Component {
+        component: s.into(),
+      });
+    }
+
+    if s.is_empty() {
+      return Err(PathError::Empty);
+    }
+
+    Ok(Self(s.into()))
+  }
+}

src/component.rs

@@ -0,0 +1,21 @@
+use super::*;
+
+#[derive(Clone, Copy, IntoStaticStr)]
+#[strum(serialize_all = "kebab-case")]
+pub(crate) enum Context {
+  Directory,
+  Entry,
+  File,
+}
+
+impl Context {
+  fn name(self) -> &'static str {
+    self.into()
+  }
+}
+
+impl Display for Context {
+  fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+    write!(f, "{}", self.name())
+  }
+}

src/context.rs

@@ -0,0 +1,75 @@
+use super::*;
+
+#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
+#[serde(deny_unknown_fields, rename_all = "kebab-case", transparent)]
+pub struct Directory {
+  pub(crate) entries: BTreeMap<Component, Entry>,
+}
+
+impl Directory {
+  pub(crate) fn create_directory(&mut self, path: &RelativePath) -> Result {
+    let mut current = self;
+    for component in path.components() {
+      current = current.create_directory_entry(component)?;
+    }
+    Ok(())
+  }
+
+  fn create_directory_entry(&mut self, component: Component) -> Result<&mut Directory> {
+    let entry = self
+      .entries
+      .entry(component)
+      .or_insert(Entry::Directory(Directory::new()));
+
+    match entry {
+      Entry::Directory(directory) => Ok(directory),
+      Entry::File(_file) => Err(
+        error::Internal {
+          message: "entry `{component}` already contains file",
+        }
+        .build(),
+      ),
+    }
+  }
+
+  pub(crate) fn create_file(&mut self, path: &RelativePath, file: File) -> Result {
+    let mut components = path.components().peekable();
+
+    let mut current = self;
+    while let Some(component) = components.next() {
+      if components.peek().is_none() {
+        ensure! {
+          current.entries.insert(component, Entry::File(file)).is_none(),
+          error::Internal {
+            message: "entry `{component}` already contains file",
+          }
+        }
+        return Ok(());
+      }
+
+      current = current.create_directory_entry(component)?;
+    }
+
+    Ok(())
+  }
+
+  pub(crate) fn fingerprint(&self) -> Hash {
+    let mut hasher = FieldHasher::new(Context::Directory);
+
+    hasher.array(0, self.entries.len().into_u64());
+
+    for (component, entry) in &self.entries {
+      hasher.element(entry.fingerprint(component));
+    }
+
+    hasher.finalize()
+  }
+
+  pub(crate) fn is_empty(&self) -> bool {
+    self.entries.is_empty()
+  }
+
+  pub(crate) fn new() -> Self {
+    Self::default()
+  }
+}

src/directory.rs

@@ -1,8 +1,25 @@
 use super::*;
 
-#[derive(Clone, Copy, Debug, Deserialize, PartialEq, Serialize)]
-#[serde(deny_unknown_fields, rename_all = "kebab-case")]
-pub struct Entry {
-  pub hash: Hash,
-  pub size: u64,
+#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
+#[serde(deny_unknown_fields, rename_all = "kebab-case", untagged)]
+pub(crate) enum Entry {
+  Directory(Directory),
+  File(File),
+}
+
+impl Entry {
+  pub(crate) fn fingerprint(&self, component: &Component) -> Hash {
+    let mut hasher = FieldHasher::new(Context::Entry);
+
+    hasher.field(0, component.as_bytes());
+
+    let inner = match self {
+      Self::Directory(directory) => directory.fingerprint(),
+      Self::File(file) => file.fingerprint(),
+    };
+
+    hasher.field(1, inner.as_bytes());
+
+    hasher.finalize()
+  }
 }

src/entry.rs

@@ -25,14 +25,6 @@ pub enum Error {
     path: DisplayPath,
     source: serde_yaml::Error,
   },
-  #[snafu(
-    display(
-      "empty director{} {}",
-      if paths.len() == 1 { "y" } else { "ies" },
-      List::and_ticked(paths),
-    )
-  )]
-  EmptyDirectory { paths: Vec<DisplayPath> },
   #[snafu(display("{count} mismatched file{}", if *count == 1 { "" } else { "s" }))]
   EntryMismatch {
     backtrace: Option<Backtrace>,
@@ -51,6 +43,11 @@ pub enum Error {
   },
   #[snafu(display("fingerprint mismatch"))]
   FingerprintMismatch { backtrace: Option<Backtrace> },
+  #[snafu(display("internal error, this may indicate a bug in filepack: {message}"))]
+  Internal {
+    backtrace: Option<Backtrace>,
+    message: String,
+  },
   #[snafu(display("public key `{public_key}` doesn't match private key `{private_key}`"))]
   KeyMismatch {
     backtrace: Option<Backtrace>,
@@ -90,7 +87,7 @@ pub enum Error {
   #[snafu(display("invalid path `{path}`"))]
   Path {
     path: DisplayPath,
-    source: relative_path::Error,
+    source: PathError,
   },
   #[snafu(display("path not valid unicode: `{}`", path.display()))]
   PathUnicode {

src/error.rs

@@ -0,0 +1,46 @@
+use super::*;
+
+pub(crate) struct FieldHasher {
+  array: Option<NonZeroU64>,
+  hasher: Hasher,
+  next: u8,
+}
+
+impl FieldHasher {
+  pub(crate) fn array(&mut self, tag: u8, len: u64) {
+    self.tag(tag);
+    self.array = NonZeroU64::new(len);
+    self.hasher.update(&len.to_le_bytes());
+  }
+
+  pub(crate) fn element(&mut self, hash: Hash) {
+    self.array = NonZeroU64::new(self.array.unwrap().get() - 1);
+    self.hasher.update(hash.as_bytes());
+  }
+
+  pub(crate) fn field(&mut self, tag: u8, contents: &[u8]) {
+    self.tag(tag);
+    self.hasher.update(&contents.len().into_u64().to_le_bytes());
+    self.hasher.update(contents);
+  }
+
+  pub(crate) fn finalize(self) -> Hash {
+    assert_eq!(self.array, None);
+    self.hasher.finalize().into()
+  }
+
+  pub(crate) fn new(context: Context) -> Self {
+    Self {
+      array: None,
+      hasher: Hasher::new_derive_key(&format!("filepack:{context}")),
+      next: 0,
+    }
+  }
+
+  pub(crate) fn tag(&mut self, tag: u8) {
+    assert_eq!(self.next, tag);
+    assert_eq!(self.array, None);
+    self.next = self.next.checked_add(1).unwrap();
+    self.hasher.update(&[tag]);
+  }
+}