Serve archive contents

.editorconfig

@@ -0,0 +1,9 @@
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+indent_size = 2
+indent_style = space
+insert_final_newline = true
+trim_trailing_whitespace = true

justfile

@@ -105,17 +105,3 @@ verify-release: tmp
     --dir tmp \
     $VERSION
   cargo run verify tmp --key 3c977ea3a31cd37f0b540f02f33eab158f2ed7449f42b05613c921181aa95b79
-
-render: tmp
-  #!/usr/bin/env bash
-  set -euxo pipefail
-  VERSION=`bin/version`
-  gh release download \
-    --repo casey/filepack \
-    --pattern '*' \
-    --dir tmp \
-    $VERSION
-  rm tmp/filepack.json
-  cargo run create tmp --sign --metadata metadata.yaml
-  cargo run render tmp > tmp/index.html
-  open tmp/index.html

src/error.rs

@@ -3,11 +3,6 @@ use super::*;
 #[derive(Debug, Snafu)]
 #[snafu(context(suffix(false)), visibility(pub(crate)))]
 pub(crate) enum Error {
-  #[snafu(display("failed to load archive at `{path}`"))]
-  ArchiveLoad {
-    path: DisplayPath,
-    source: ArchiveError,
-  },
   #[snafu(display("failed to get current directory"))]
   CurrentDir { source: io::Error },
   #[snafu(display("failed to get local data directory"))]
@@ -56,13 +51,6 @@ pub(crate) enum Error {
   },
   #[snafu(display("fingerprint mismatch"))]
   FingerprintMismatch { backtrace: Option<Backtrace> },
-  #[snafu(display("file `{path}` hash {actual} does not match manifest hash {expected}"))]
-  HashMismatch {
-    actual: Hash,
-    backtrace: Option<Backtrace>,
-    expected: Hash,
-    path: DisplayPath,
-  },
   #[snafu(display("public key `{public_key}` doesn't match private key `{private_key}`"))]
   KeyMismatch {
     backtrace: Option<Backtrace>,
@@ -174,13 +162,6 @@ pub(crate) enum Error {
     backtrace: Option<Backtrace>,
     key: PublicKey,
   },
-  #[snafu(display("file `{path}` size {actual} does not match manifest size {expected}"))]
-  SizeMismatch {
-    actual: u64,
-    backtrace: Option<Backtrace>,
-    expected: u64,
-    path: DisplayPath,
-  },
   #[snafu(display("I/O error reading standard input"))]
   StandardInputIo {
     backtrace: Option<Backtrace>,

src/hash.rs

@@ -10,6 +10,7 @@ impl Hash {
     self.0.as_bytes()
   }
 
+  #[cfg(test)]
   pub(crate) fn bytes(input: &[u8]) -> Self {
     Self(blake3::hash(input))
   }

src/main.rs

@@ -1,33 +1,32 @@
 use {
   self::{
-    archive::Archive, archive_error::ArchiveError, arguments::Arguments, bytes::Bytes,
-    display_path::DisplayPath, display_secret::DisplaySecret, entry::Entry, error::Error,
-    hash::Hash, into_u64::IntoU64, lint::Lint, lint_group::LintGroup, list::List,
+    arguments::Arguments, bytes::Bytes, display_path::DisplayPath, display_secret::DisplaySecret,
+    entry::Entry, error::Error, hash::Hash, lint::Lint, lint_group::LintGroup, list::List,
     manifest::Manifest, metadata::Metadata, options::Options, owo_colorize_ext::OwoColorizeExt,
-    page::Page, private_key::PrivateKey, public_key::PublicKey, relative_path::RelativePath,
+    package::Package, private_key::PrivateKey, public_key::PublicKey, relative_path::RelativePath,
     signature::Signature, signature_error::SignatureError, style::Style, subcommand::Subcommand,
     template::Template, utf8_path_ext::Utf8PathExt,
   },
   blake3::Hasher,
   boilerplate::Boilerplate,
   camino::{Utf8Component, Utf8Path, Utf8PathBuf},
   clap::{Parser, ValueEnum},
-  html_escaper::Escape,
+  html_escaper::{Escape, Trusted},
   indicatif::{ProgressBar, ProgressStyle},
   lexiclean::Lexiclean,
   owo_colors::Styled,
   serde::{Deserialize, Deserializer, Serialize, Serializer},
   serde_with::{DeserializeFromStr, SerializeDisplay},
-  snafu::{ensure, ErrorCompat, IntoError, OptionExt, ResultExt, Snafu},
+  snafu::{ensure, ErrorCompat, OptionExt, ResultExt, Snafu},
   std::{
     array::TryFromSliceError,
     backtrace::{Backtrace, BacktraceStatus},
     cmp::Ordering,
-    collections::{BTreeMap, HashMap, HashSet},
+    collections::{BTreeMap, HashMap},
     env,
     fmt::{self, Display, Formatter},
-    fs::{self, File},
-    io::{self, BufReader, BufWriter, IsTerminal, Read, Write},
+    fs::File,
+    io::{self, IsTerminal},
     path::{Path, PathBuf},
     process,
     str::{self, FromStr},
@@ -38,27 +37,42 @@ use {
 };
 
 #[cfg(test)]
-use assert_fs::{
-  fixture::{FileWriteBin, PathChild},
-  TempDir,
+use {
+  assert_fs::{
+    fixture::{FileWriteStr, PathChild, PathCreateDir},
+    TempDir,
+  },
+  std::ffi::OsString,
 };
 
 #[cfg(test)]
-macro_rules! assert_matches {
-  ($expression:expr, $( $pattern:pat_param )|+ $( if $guard:expr )? $(,)?) => {
-    match $expression {
-      $( $pattern )|+ $( if $guard )? => {}
-      left => panic!(
-        "assertion failed: (left ~= right)\n  left: `{:?}`\n right: `{}`",
-        left,
-        stringify!($($pattern)|+ $(if $guard)?)
-      ),
+macro_rules! command {
+  ( $($argument:expr),* $(,)?) => {
+    {
+      #![allow(clippy::vec_init_then_push)]
+
+      let mut arguments = Vec::<OsString>::new();
+
+      arguments.push("filepack".into());
+
+      arguments.push("--quiet".into());
+
+      $(
+        arguments.push($argument.into());
+      )*
+
+      let arguments = match Arguments::try_parse_from(arguments) {
+        Ok(arguments) => arguments,
+        Err(error) => {
+          panic!("{error}");
+        }
+      };
+
+      arguments.run().unwrap();
     }
-  }
+  };
 }
 
-mod archive;
-mod archive_error;
 mod arguments;
 mod bytes;
 mod display_path;
@@ -67,15 +81,14 @@ mod entry;
 mod error;
 mod filesystem;
 mod hash;
-mod into_u64;
 mod lint;
 mod lint_group;
 mod list;
 mod manifest;
 mod metadata;
 mod options;
 mod owo_colorize_ext;
-mod page;
+mod package;
 mod private_key;
 mod progress_bar;
 mod public_key;

src/manifest.rs

@@ -1,6 +1,6 @@
 use super::*;
 
-#[derive(Debug, Deserialize, PartialEq, Serialize)]
+#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
 #[serde(deny_unknown_fields, rename_all = "kebab-case")]
 pub(crate) struct Manifest {
   #[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
@@ -25,7 +25,7 @@ impl Manifest {
     hasher.finalize().into()
   }
 
-  pub(crate) fn load(path: Option<&Utf8Path>) -> Result<(Utf8PathBuf, String, Self)> {
+  pub(crate) fn load(path: Option<&Utf8Path>) -> Result<(Utf8PathBuf, Self)> {
     let path = if let Some(path) = path {
       if filesystem::metadata(path)?.is_dir() {
         path.join(Manifest::FILENAME)
@@ -42,7 +42,7 @@ impl Manifest {
     let manifest =
       serde_json::from_str(&json).context(error::DeserializeManifest { path: &path })?;
 
-    Ok((path, json, manifest))
+    Ok((path, manifest))
   }
 
   pub(crate) fn store(&self, path: &Utf8Path) -> Result<()> {

src/metadata.rs

@@ -1,6 +1,6 @@
 use super::*;
 
-#[derive(Debug, Deserialize, Serialize)]
+#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
 #[serde(rename_all = "kebab-case")]
 pub(crate) struct Metadata {
   pub(crate) title: String,
@@ -9,11 +9,6 @@ pub(crate) struct Metadata {
 impl Metadata {
   pub(crate) const FILENAME: &'static str = "metadata.json";
 
-  pub(crate) fn load(path: &Utf8Path) -> Result<Self> {
-    serde_json::from_str(&filesystem::read_to_string(path)?)
-      .context(error::DeserializeMetadata { path })
-  }
-
   pub(crate) fn store(&self, path: &Utf8Path) -> Result<()> {
     filesystem::write(path, format!("{}\n", serde_json::to_string(self).unwrap()))
   }