Root Objects (#22)

Breaking change

Move return type of objects from HashMap<String, Vec<Object>> to HashMap<String, ObjectEntry> where ObjectEntry is an enum of Object(Object) or List(Vec<Object>)

Then, when reading files, allow either defining object/foo/*.toml or object/foo.toml. In the latter case, objects.foo will be an object itself rather than an array, and there will only ever be one of them.

If both are defined, the build will fail.

.github/workflows/rust-ci.yml

@@ -49,7 +49,7 @@ jobs:
       - name: cargo test build
         run: cargo build --tests --release
       - name: cargo test binary
-        run: cargo test --release --features=binary -- --test-threads=1
+        run: ./test-bin.sh
 
   # msrv-check:
   #   name: Minimum Stable Rust Version Check

src/lib.rs

@@ -36,7 +36,7 @@ mod file_system_stdlib;
 #[cfg(feature = "binary")]
 mod server;
 use file_system_mutex::FileSystemMutex;
-use object::Object;
+use object::{Object, ObjectEntry};
 use semver::{Version, VersionReq};
 
 // Re-exports
@@ -202,13 +202,13 @@ impl<F: FileSystemAPI> Archival<F> {
         Ok(())
     }
 
-    pub fn get_objects(&self) -> Result<HashMap<String, Vec<Object>>, Box<dyn Error>> {
+    pub fn get_objects(&self) -> Result<HashMap<String, ObjectEntry>, Box<dyn Error>> {
         self.fs_mutex.with_fs(|fs| self.site.get_objects(fs))
     }
     pub fn get_objects_sorted(
         &self,
         sort: impl Fn(&Object, &Object) -> Ordering,
-    ) -> Result<HashMap<String, Vec<Object>>, Box<dyn Error>> {
+    ) -> Result<HashMap<String, ObjectEntry>, Box<dyn Error>> {
         self.fs_mutex
             .with_fs(|fs| self.site.get_objects_sorted(fs, sort))
     }
@@ -315,9 +315,15 @@ mod lib {
         let zip = include_bytes!("../tests/fixtures/archival-website.zip");
         unpack_zip(zip.to_vec(), &mut fs)?;
         let archival = Archival::new(fs)?;
-        assert_eq!(archival.site.object_definitions.len(), 2);
+        assert_eq!(archival.site.object_definitions.len(), 3);
         assert!(archival.site.object_definitions.contains_key("section"));
         assert!(archival.site.object_definitions.contains_key("post"));
+        assert!(archival.site.object_definitions.contains_key("site"));
+        let objects = archival.get_objects()?;
+        let section_objs = objects.get("section").unwrap();
+        assert!(matches!(section_objs, ObjectEntry::List(_)));
+        let site_obj = objects.get("site").unwrap();
+        assert!(matches!(site_obj, ObjectEntry::Object(_)));
         archival.build()?;
         let dist_files = archival.dist_files();
         println!("dist_files: \n{}", dist_files.join("\n"));

src/main.rs

@@ -1,18 +1,25 @@
-#[cfg(feature = "binary")]
-use archival::binary;
-use tracing_subscriber::{fmt, prelude::*, EnvFilter};
-
 fn main() {
-    tracing_subscriber::registry()
-        .with(fmt::layer())
-        .with(EnvFilter::from_default_env())
-        .init();
     #[cfg(feature = "binary")]
-    match binary::binary(std::env::args()) {
-        Ok(c) => std::process::exit(c.code()),
-        Err(e) => {
-            eprintln!("Error: {e}");
-            std::process::exit(1);
+    binary::main();
+    #[cfg(not(feature = "binary"))]
+    println!("archival was built without the binary feature.")
+}
+
+#[cfg(feature = "binary")]
+mod binary {
+    use archival::binary;
+    use tracing_subscriber::{fmt, prelude::*, EnvFilter};
+    pub fn main() {
+        tracing_subscriber::registry()
+            .with(fmt::layer())
+            .with(EnvFilter::from_default_env())
+            .init();
+        match binary::binary(std::env::args()) {
+            Ok(c) => std::process::exit(c.code()),
+            Err(e) => {
+                eprintln!("Error: {e}");
+                std::process::exit(1);
+            }
         }
     }
 }

src/manifest.rs

@@ -1,4 +1,3 @@
-use clap::ValueEnum;
 use serde::{Deserialize, Serialize};
 use std::{
     error::Error,
@@ -39,7 +38,8 @@ pub struct Manifest {
     pub cdn_url: String,
 }
 
-#[derive(Clone, Debug, ValueEnum)]
+#[derive(Clone, Debug)]
+#[cfg_attr(feature = "binary", derive(clap::ValueEnum))]
 pub enum ManifestField {
     ArchivalVersion,
     SiteUrl,

src/object.rs → src/object/mod.rs

@@ -12,6 +12,8 @@ use serde::{Deserialize, Serialize};
 use std::{collections::HashMap, error::Error, fmt::Debug, path::Path};
 use toml::Table;
 use tracing::warn;
+mod object_entry;
+pub use object_entry::ObjectEntry;
 
 #[derive(Debug, ObjectView, ValueView, Deserialize, Serialize, Clone)]
 #[cfg_attr(feature = "typescript", derive(typescript_type_def::TypeDef))]

src/object/object_entry.rs

@@ -0,0 +1,99 @@
+use crate::object::Object;
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[cfg_attr(feature = "typescript", derive(typescript_type_def::TypeDef))]
+pub enum ObjectEntry {
+    List(Vec<Object>),
+    Object(Object),
+}
+
+impl ObjectEntry {
+    pub fn from_vec(vec: Vec<Object>) -> Self {
+        Self::List(vec)
+    }
+    pub fn from_object(object: Object) -> Self {
+        Self::Object(object)
+    }
+}
+
+pub struct ObjectEntryIterator<'a> {
+    entry: &'a ObjectEntry,
+    index: usize,
+}
+
+impl<'a> Iterator for ObjectEntryIterator<'a> {
+    type Item = &'a Object;
+    fn next(&mut self) -> Option<Self::Item> {
+        match self.entry {
+            ObjectEntry::List(l) => {
+                let o = l.get(self.index);
+                self.index += 1;
+                o
+            }
+            ObjectEntry::Object(o) => {
+                if self.index == 0 {
+                    self.index = usize::MAX;
+                    Some(o)
+                } else {
+                    None
+                }
+            }
+        }
+    }
+}
+
+impl<'a> ObjectEntry {
+    pub fn iter_mut(&'a mut self) -> ObjectEntryMutIterator<'a> {
+        self.into_iter()
+    }
+}
+
+impl<'a> IntoIterator for &'a ObjectEntry {
+    type Item = &'a Object;
+    type IntoIter = ObjectEntryIterator<'a>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        ObjectEntryIterator {
+            entry: self,
+            index: 0,
+        }
+    }
+}
+
+impl<'a> IntoIterator for &'a mut ObjectEntry {
+    type Item = &'a mut Object;
+    type IntoIter = ObjectEntryMutIterator<'a>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        ObjectEntryMutIterator {
+            entry: self,
+            index: 0,
+        }
+    }
+}
+pub struct ObjectEntryMutIterator<'a> {
+    entry: &'a mut ObjectEntry,
+    index: usize,
+}
+
+impl<'a> Iterator for ObjectEntryMutIterator<'a> {
+    type Item = &'a mut Object;
+    fn next(&mut self) -> Option<Self::Item> {
+        match self.entry {
+            ObjectEntry::List(l) => {
+                let o = l.get_mut(self.index);
+                self.index += 1;
+                unsafe { std::mem::transmute(o) }
+            }
+            ObjectEntry::Object(o) => {
+                if self.index == 0 {
+                    self.index = usize::MAX;
+                    unsafe { std::mem::transmute(o) }
+                } else {
+                    None
+                }
+            }
+        }
+    }
+}

src/page.rs

@@ -1,5 +1,9 @@
-use crate::{object::Object, object_definition::ObjectDefinition};
+use crate::{
+    object::{Object, ObjectEntry},
+    object_definition::ObjectDefinition,
+};
 use liquid::ValueView;
+use liquid_core::Value;
 use regex::Regex;
 use std::{collections::HashMap, error::Error, fmt};
 
@@ -113,12 +117,15 @@ impl<'a> Page<'a> {
     pub fn render(
         &self,
         parser: &liquid::Parser,
-        objects_map: &HashMap<String, Vec<Object>>,
+        objects_map: &HashMap<String, ObjectEntry>,
     ) -> Result<String, Box<dyn Error>> {
         tracing::debug!("rendering {}", self.name);
-        let mut objects: HashMap<String, Vec<liquid::model::Value>> = HashMap::new();
-        for (name, objs) in objects_map {
-            let values = objs.iter().map(|o| o.liquid_object()).collect();
+        let mut objects: HashMap<String, liquid::model::Value> = HashMap::new();
+        for (name, obj_entry) in objects_map {
+            let values = match obj_entry {
+                ObjectEntry::List(l) => Value::array(l.iter().map(|o| o.liquid_object())),
+                ObjectEntry::Object(o) => o.liquid_object(),
+            };
             objects.insert(name.to_string(), values);
         }
         let globals = liquid::object!({ "objects": objects, "page": self.name });
@@ -162,7 +169,7 @@ mod tests {
 
     use super::*;
 
-    fn get_objects_map() -> HashMap<String, Vec<Object>> {
+    fn get_objects_map() -> HashMap<String, ObjectEntry> {
         let tour_dates_objects = vec![HashMap::from([
             (
                 "date".to_string(),
@@ -217,8 +224,8 @@ mod tests {
         };
 
         HashMap::from([
-            ("artist".to_string(), vec![artist]),
-            ("c".to_string(), vec![c]),
+            ("artist".to_string(), ObjectEntry::from_vec(vec![artist])),
+            ("c".to_string(), ObjectEntry::from_vec(vec![c])),
         ])
     }
 
@@ -321,7 +328,7 @@ mod tests {
     fn template_page() -> Result<(), Box<dyn Error>> {
         let liquid_parser = liquid_parser::get(None, None, &MemoryFileSystem::default())?;
         let objects_map = get_objects_map();
-        let object = objects_map["artist"].first().unwrap();
+        let object = objects_map["artist"].into_iter().next().unwrap();
         let artist_def = artist_definition();
         let page = Page::new_with_template(
             "tormenta-rey".to_string(),