Harper + Mockingbird 0.0.2.

This release includes the following major changes:

  * `derive_more` was removed as a dependency.
  * Collections are now associated with a name.
  * Internal refactor for a new `OwnedEntry`.
  * Updated to minijinja2.
  * Undefined variables now result in errors.
  * Added a `get()` template helper with a default when undefined.
  * Added a real CLI parser.
  * Added a `time!()` macro for wall-clock time measurements.
  * Now exits with status 1 if rendering fails.

CHANGELOG.md

@@ -1,3 +1,7 @@
+# Version 0.0.2 (Apr 4, 2024)
+
+This is the second testing release of Mockingbird. More details to come.
+
 # Version 0.0.1 (Mar 3, 2024)
 
 This is the initial testing release of Mockingbird. More details to come.

lib/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "harper"
-version = "0.0.1"
+version = "0.0.2"
 edition = "2021"
 authors = ["Sergio Benitez <[email protected]>"]
 license = "MIT OR Apache-2.0"
@@ -23,7 +23,6 @@ serde = { version = "1", features = ["rc", "derive"] }
 toml = { version = "0.8", features = ["preserve_order"] }
 memchr = "2"
 either = "1.10"
-derive_more = { version = "=1.0.0-beta.6", features = ["debug", "deref", "from"] }
 grass = { version = "0.13", default-features = false, features = ["random"], optional = true }
 pulldown-cmark = { version = "0.10", default-features = false, features = ["simd", "html"] }
 
@@ -56,11 +55,8 @@ default-features = false
 features = ["html", "default-syntaxes", "regex-onig", "plist-load"]
 
 [dependencies.minijinja]
-# git = "https://github.com/SergioBenitez/minijinja.git"
-# # branch = "value-unification"
-# rev = "517d147"
 package = "unified-minijinja"
-version = "1.0.12"
+version = "=0.0.2"
 default-features = false
 features = ["speedups", "loader", "builtins", "debug", "deserialization", "macros", "multi_template"]
 

lib/src/fstree.rs

@@ -1,24 +1,26 @@
+use std::{fs, fmt};
+use std::ops::Deref;
 use std::sync::Arc;
 use std::path::Path;
 use std::collections::VecDeque;
-use std::{fs, fmt};
 
 use rustc_hash::FxHashMap;
 
 use crate::error::Result;
 
-#[derive(Copy, Clone, PartialEq, Eq, Hash)]
-pub struct EntryId(pub(crate) usize);
-
 #[derive(Debug)]
 pub struct FsTree {
     entries: Vec<Entry>,
     map: FxHashMap<Arc<Path>, EntryId>,
 }
 
-pub struct FsSubTree<'a> {
-    tree: &'a FsTree,
-    root: EntryId
+#[derive(Copy, Clone, PartialEq, Eq, Hash)]
+pub struct EntryId(usize);
+
+#[derive(Clone)]
+pub struct OwnedEntry {
+    pub tree: Arc<FsTree>,
+    pub id: EntryId,
 }
 
 #[derive(Debug)]
@@ -44,10 +46,12 @@ impl FsTree {
         }
     }
 
+    #[inline(always)]
     pub fn build<P: AsRef<Path>>(root: P) -> Result<Self> {
         Self::build_with(root.as_ref(), |_, _| Ok(()))
     }
 
+    #[inline]
     pub fn build_with<P, F>(root: P, mut callback: F) -> Result<Self>
         where P: AsRef<Path>,
               F: FnMut(&Self, EntryId) -> Result<()>,
@@ -91,12 +95,6 @@ impl FsTree {
         EntryId(0)
     }
 
-    #[inline]
-    pub fn subtree(&self, root: EntryId) -> FsSubTree<'_> {
-        assert!(self[root].id == root);
-        FsSubTree { tree: self, root }
-    }
-
     #[inline]
     pub fn get<R, P>(&self, root: R, path: P) -> Option<&Entry>
         where R: Into<Option<EntryId>>, P: AsRef<Path>
@@ -227,22 +225,38 @@ impl FsTree {
     }
 }
 
-impl FsSubTree<'_> {
-    pub fn get<P: AsRef<Path>>(&self, path: P) -> Option<&Entry> {
-        self.tree.get(self.root, path.as_ref())
+impl OwnedEntry {
+    pub fn new(tree: Arc<FsTree>, id: EntryId) -> Self {
+        OwnedEntry { tree, id  }
     }
 
-    #[inline]
-    pub fn get_file_id<P: AsRef<Path>>(&self, path: P) -> Option<EntryId> {
-        self.tree.get_file_id(self.root, path.as_ref())
+    pub fn entry(&self) -> &Entry {
+        &self.tree[self.id]
     }
+}
 
-    #[inline]
-    pub fn get_id<P: AsRef<Path>>(&self, path: P) -> Option<EntryId> {
-        self.tree.get_id(self.root, path.as_ref())
+impl Deref for OwnedEntry {
+    type Target = Entry;
+
+    fn deref(&self) -> &Self::Target {
+        self.entry()
+    }
+}
+
+impl fmt::Debug for OwnedEntry {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.entry().fmt(f)
+    }
+}
+
+impl PartialEq for OwnedEntry {
+    fn eq(&self, other: &Self) -> bool {
+        self.id == other.id
     }
 }
 
+impl Eq for OwnedEntry { }
+
 impl Entry {
     /// File name without the extension.
     pub fn file_stem(&self) -> &str {

lib/src/markdown/alias.rs

@@ -19,10 +19,10 @@ impl<'a> Alias<'a> {
 }
 
 impl crate::markdown::Plugin for Alias<'_> {
-    fn remap<'a, I>(&'a mut self, events: I) -> Box<dyn Iterator<Item = Event<'a>> + 'a>
+    fn remap<'a, I>(&'a mut self, events: I) -> impl Iterator<Item = Event<'a>> + 'a
         where I: Iterator<Item = Event<'a>> + 'a
     {
-        Box::new(AliasIterator { inner: events, map: self.map })
+        AliasIterator { inner: events, map: self.map }
     }
 }
 

lib/src/markdown/auto_heading.rs

@@ -54,14 +54,14 @@ impl<'a, I: Iterator<Item = Event<'a>>> Iterator for HeadingIterator<'a, I> {
 }
 
 impl Plugin for AutoHeading {
-    fn remap<'a, I>(&'a mut self, events: I) -> Box<dyn Iterator<Item = Event<'a>> + 'a>
+    fn remap<'a, I>(&'a mut self, events: I) -> impl Iterator<Item = Event<'a>> + 'a
         where I: Iterator<Item = Event<'a>> + 'a
     {
-        Box::new(HeadingIterator {
+        HeadingIterator {
             seen: FxHashMap::default(),
             inner: events,
             stack: VecDeque::with_capacity(4),
-        })
+        }
     }
 }
 
@@ -92,12 +92,12 @@ impl<'a, I: Iterator<Item = Event<'a>>> Iterator for AnchorIterator<'a, I> {
 }
 
 impl Plugin for HeadingAnchor {
-    fn remap<'a, I>(&'a mut self, events: I) -> Box<dyn Iterator<Item = Event<'a>> + 'a>
+    fn remap<'a, I>(&'a mut self, events: I) -> impl Iterator<Item = Event<'a>> + 'a
         where I: Iterator<Item = Event<'a>> + 'a
     {
-        Box::new(AnchorIterator {
+        AnchorIterator {
             inner: events,
             pending: None,
-        })
+        }
     }
 }

lib/src/markdown/code_filter.rs

@@ -40,15 +40,15 @@ impl CodeTrim<()> {
 }
 
 impl<F: CodeFilter> Plugin for CodeTrim<F> {
-    fn remap<'a, I>(&'a mut self, i: I) -> Box<dyn Iterator<Item = Event<'a>> + 'a>
+    fn remap<'a, I>(&'a mut self, i: I) -> impl Iterator<Item = Event<'a>> + 'a
         where I: Iterator<Item = Event<'a>> + 'a
     {
-        Box::new(Iter {
+        Iter {
             trimmer: &mut self.trimmer,
             inner: i,
             line_num: None,
             stack: VecDeque::new(),
-        })
+        }
     }
 }
 

lib/src/markdown/highlight.rs

@@ -31,10 +31,10 @@ impl SyntaxHighlight {
 }
 
 impl Plugin for SyntaxHighlight {
-    fn remap<'a, I>(&'a mut self, events: I) -> Box<dyn Iterator<Item = Event<'a>> + 'a>
+    fn remap<'a, I>(&'a mut self, events: I) -> impl Iterator<Item = Event<'a>> + 'a
         where I: Iterator<Item = Event<'a>> + 'a
     {
-        Box::new(Highlighter { generator: None, lines: 0, inner: events })
+        Highlighter { generator: None, lines: 0, inner: events }
     }
 }
 

lib/src/markdown/parts.rs

@@ -55,7 +55,7 @@ impl<O: Sink> Plugin for Parts<O> {
     // secion. This causes the HTML renderer to emit the string so far. We then
     // reuse the same iterator in the renderer again until it signals it cannot
     // be reused. We finally return one string containing all of the HTML.
-    fn remap<'a, I>(&'a mut self, events: I) -> Box<dyn Iterator<Item = Event<'a>> + 'a>
+    fn remap<'a, I>(&'a mut self, events: I) -> impl Iterator<Item = Event<'a>> + 'a
         where I: Iterator<Item = Event<'a>> + 'a
     {
         let mut sections = SectionIterator {
@@ -84,7 +84,7 @@ impl<O: Sink> Plugin for Parts<O> {
             _ => self.sections.join("").into(),
         };
 
-        Box::new(Some(Event::Html(complete_html)).into_iter())
+        Some(Event::Html(complete_html)).into_iter()
     }
 
     fn finalize(&mut self) -> Result<()> {

lib/src/markdown/plugin.rs

@@ -10,14 +10,11 @@ pub trait Plugin {
         Ok(Cow::Borrowed(input))
     }
 
-    // FIXME: To get rid of this box, we need (ideally) `-> impl Trait` in trait
-    // methods, or generic associated types. Edit: We now have GATs! But they're
-    // incredibly annoying to use because of the required bounds everywhere.
     #[inline(always)]
-    fn remap<'a, I>(&'a mut self, events: I) -> Box<dyn Iterator<Item = Event<'a>> + 'a>
+    fn remap<'a, I>(&'a mut self, events: I) -> impl Iterator<Item = Event<'a>> + 'a
         where I: Iterator<Item = Event<'a>> + 'a
     {
-        Box::new(events)
+        events
     }
 
     #[inline(always)]

lib/src/markdown/render.rs

@@ -17,17 +17,16 @@ impl<O: Sink> Renderer<O> {
 }
 
 impl<O: Sink> Plugin for Renderer<O> {
-    fn remap<'a, I>(&'a mut self, events: I) -> Box<dyn Iterator<Item = Event<'a>> + 'a>
+    fn remap<'a, I>(&'a mut self, events: I) -> impl Iterator<Item = Event<'a>> + 'a
         where I: Iterator<Item = Event<'a>>
     {
         let mut html_output = String::new();
         html::push_html(&mut html_output, events);
         self.rendered = html_output;
-        Box::new(std::iter::empty())
+        std::iter::empty()
     }
 
     fn finalize(&mut self) -> Result<()> {
-        let string = std::mem::replace(&mut self.rendered, String::new());
-        self.output.write(string)
+        self.output.write(std::mem::take(&mut self.rendered))
     }
 }

lib/src/markdown/snippet.rs

@@ -103,17 +103,17 @@ impl<'a, I: Iterator<Item = Event<'a>>> Iterator for SnippetIterator<'a, I> {
 // IDEA: What if we just take the first k character of the text and render that as markdown?
 
 impl<O: Sink> Plugin for Snippet<O> {
-    fn remap<'a, I>(&'a mut self, events: I) -> Box<dyn Iterator<Item = Event<'a>> + 'a>
+    fn remap<'a, I>(&'a mut self, events: I) -> impl Iterator<Item = Event<'a>> + 'a
         where I: Iterator<Item = Event<'a>> + 'a
     {
-        Box::new(SnippetIterator {
+        SnippetIterator {
             snippet: &mut self.snippet,
             snip_text_len: 0,
             inner: events,
             capture: vec![],
             min_length: self.length,
             done: self.length == 0,
-        })
+        }
     }
 
     fn finalize(&mut self) -> Result<()> {

lib/src/markdown/toc.rs

@@ -52,11 +52,12 @@ impl<O: Sink> TableOfContents<O> {
 }
 
 impl<O: Sink> Plugin for TableOfContents<O> {
-    fn remap<'a, I>(&'a mut self, events: I) -> Box<dyn Iterator<Item = Event<'a>> + 'a>
+    fn remap<'a, I>(&'a mut self, events: I) -> impl Iterator<Item = Event<'a>> + 'a
         where I: Iterator<Item = Event<'a>> + 'a
     {
         self.reset();
-        Box::new(events.inspect(|ev| match ev {
+
+        events.inspect(|ev| match ev {
             Event::Start(Tag::Heading { level, id, .. }) => {
                 self.entry = Some(Entry {
                     title: String::new(),
@@ -75,7 +76,7 @@ impl<O: Sink> Plugin for TableOfContents<O> {
                 }
             }
             _ => {}
-        }))
+        })
     }
 
     fn finalize(&mut self) -> Result<()> {

lib/src/markdown/ts_highlight.rs

@@ -133,7 +133,6 @@ impl<'a, I: Iterator<Item = Event<'a>>> Iterator for Highlighter<I> {
                         .unwrap_or(&*label);
 
                     self.code = String::new();
-                    // self.config = time!(find_ts_highlight_config(lang));
                     self.config = find_ts_highlight_config(lang);
                 }
                 Event::Text(text) if self.config.is_some() => {

lib/src/taxonomy/collection.rs

@@ -2,18 +2,15 @@ use std::sync::Arc;
 
 use rayon::prelude::*;
 use rustc_hash::FxHashMap;
-use derive_more::Debug;
 
-use crate::fstree::{Entry, EntryId, FsTree};
+use crate::fstree::{Entry, EntryId, FsTree, OwnedEntry};
 use crate::value::List;
 use crate::taxonomy::*;
 
 #[derive(Debug)]
 pub struct Collection {
-    #[debug(ignore)]
-    pub tree: Arc<FsTree>,
-    #[debug("{:?}", tree[**root])]
-    pub root: EntryId,
+    pub entry: OwnedEntry,
+    pub name: Arc<str>,
     pub index: Option<Arc<Item>>,
     pub items: Arc<List<Arc<Item>>>,
     pub data: FxHashMap<EntryId, Arc<List<Arc<Item>>>>,
@@ -32,34 +29,34 @@ pub enum Kind {
 }
 
 impl Collection {
-    pub fn new(tree: Arc<FsTree>, root: EntryId) -> Collection {
+    pub fn new(name: Arc<str>, tree: Arc<FsTree>, root: EntryId) -> Collection {
         Collection {
-            tree,
-            root,
+            name,
+            entry: OwnedEntry::new(tree, root),
             index: None,
             items: Default::default(),
             data: Default::default(),
         }
     }
 
-    pub fn root_entry(&self) -> &Entry {
-        &self.tree[self.root]
+    pub fn entry(&self) -> &Entry {
+        &self.entry
     }
 
-    pub fn new_item(&mut self, entry: EntryId) -> Arc<Item> {
-        let item = Arc::new(Item::new(self.tree.clone(), entry));
+    pub fn new_item(&mut self, id: EntryId) -> Arc<Item> {
+        let item = Arc::new(Item::new(self.entry.tree.clone(), id));
         self.items.push(item.clone());
         item
     }
 
     pub fn new_datum(&mut self, parent: EntryId, entry: EntryId) -> Arc<Item> {
-        let datum = Arc::new(Item::new(self.tree.clone(), entry));
+        let datum = Arc::new(Item::new(self.entry.tree.clone(), entry));
         self.data.entry(parent).or_default().push(datum.clone());
         datum
     }
 
     pub fn set_index_item(&mut self, entry: EntryId) -> Arc<Item> {
-        let index = Arc::new(Item::new(self.tree.clone(), entry));
+        let index = Arc::new(Item::new(self.entry.tree.clone(), entry));
         self.index = Some(index.clone());
         index
     }