Fix build by making the registry guarded by an ArcMutex.

src/intermediate/definition.rs

@@ -1,5 +1,7 @@
 use std::path::Path;
 use std::path::PathBuf;
+use std::sync::Arc;
+use std::sync::Mutex;
 
 use tokio::task::JoinHandle;
 use walkdir::WalkDir;
@@ -58,13 +60,10 @@ impl BlogPost {
                             _ => {}
                         });
 
+                    let registry = Arc::new(Mutex::new(registry));
                     let relative_to_post_dir_path = real_path.strip_prefix(post_dir)?;
                     ret.push(
-                        BlogPostPage::new(
+                        BlogPostPage::new(relative_to_post_dir_path, registry, parsed_document)
-                            relative_to_post_dir_path,
-                            &mut registry,
-                            parsed_document,
-                        )
                             .await?,
                     );
                 }

src/intermediate/footnote_definition.rs

@@ -1,7 +1,9 @@
 use super::macros::intermediate;
+use super::registry::register_footnote_definition;
 use super::registry::Registry;
 use super::IAstNode;
 use crate::error::CustomError;
+use crate::intermediate::RefRegistry;
 
 #[derive(Debug, Clone)]
 pub(crate) struct IFootnoteDefinition {}
@@ -12,9 +14,7 @@ intermediate!(
     original,
     registry,
     {
-        registry
+        register_footnote_definition(registry, original.label, &original.children).await?;
-            .register_footnote_definition(original.label, &original.children)
-            .await?;
         Ok(IFootnoteDefinition {})
     }
 );
@@ -26,8 +26,8 @@ pub(crate) struct IRealFootnoteDefinition {
 }
 
 impl IRealFootnoteDefinition {
-    pub(crate) async fn new<'reg, 'orig, 'parse>(
+    pub(crate) async fn new<'orig, 'parse>(
-        registry: &'reg mut Registry<'orig, 'parse>,
+        registry: RefRegistry<'orig, 'parse>,
         footnote_id: usize,
         contents: Vec<IAstNode>,
     ) -> Result<IRealFootnoteDefinition, CustomError> {

src/intermediate/footnote_reference.rs

@@ -1,4 +1,5 @@
 use super::macros::intermediate;
+use super::registry::get_footnote_reference_id;
 use super::registry::Registry;
 use crate::error::CustomError;
 
@@ -9,9 +10,8 @@ pub(crate) struct IFootnoteReference {
 }
 
 intermediate!(IFootnoteReference, FootnoteReference, original, registry, {
-    let footnote_id = registry
+    let footnote_id =
-        .get_footnote_reference_id(original.label, &original.definition)
+        get_footnote_reference_id(registry, original.label, &original.definition).await?;
-        .await?;
     Ok(IFootnoteReference {
         footnote_id,
         duplicate_offset: 0, // TODO

src/intermediate/heading.rs

@@ -15,14 +15,14 @@ intermediate!(IHeading, Heading, original, registry, {
     let title = {
         let mut ret = Vec::new();
         for obj in original.title.iter() {
-            ret.push(IObject::new(registry, obj).await?);
+            ret.push(IObject::new(registry.clone(), obj).await?);
         }
         ret
     };
     let children = {
         let mut ret = Vec::new();
         for obj in original.children.iter() {
-            ret.push(IDocumentElement::new(registry, obj).await?);
+            ret.push(IDocumentElement::new(registry.clone(), obj).await?);
         }
         ret
     };

src/intermediate/macros.rs

@@ -8,7 +8,7 @@ macro_rules! inoop {
 
         impl $istruct {
             pub(crate) async fn new<'reg, 'orig, 'parse>(
-                registry: &'reg mut Registry<'orig, 'parse>,
+                registry: crate::intermediate::RefRegistry<'orig, 'parse>,
                 original: &'orig organic::types::$pstruct<'parse>,
             ) -> Result<$istruct, CustomError> {
                 Ok($istruct {})
@@ -25,8 +25,8 @@ pub(crate) use inoop;
 macro_rules! intermediate {
     ($istruct:ident, $pstruct:ident, $original:ident, $registry:ident, $fnbody:tt) => {
         impl $istruct {
-            pub(crate) async fn new<'reg, 'orig, 'parse>(
+            pub(crate) async fn new<'orig, 'parse>(
-                registry: &'reg mut Registry<'orig, 'parse>,
+                registry: crate::intermediate::RefRegistry<'orig, 'parse>,
                 original: &'orig organic::types::$pstruct<'parse>,
             ) -> Result<$istruct, CustomError> {
                 let $original = original;
@@ -45,10 +45,10 @@ pub(crate) use intermediate;
 macro_rules! iselector {
     ($istruct:ident, $pstruct:ident, $original:ident, $registry:ident, $fnbody:tt) => {
         impl $istruct {
-            pub(crate) fn new<'reg: 'orig, 'orig, 'parse, 'inp: 'reg + 'orig>(
+            pub(crate) fn new<'orig, 'parse>(
-                registry: &'reg mut Registry<'orig, 'parse>,
+                registry: crate::intermediate::RefRegistry<'orig, 'parse>,
                 original: &'orig organic::types::$pstruct<'parse>,
-            ) -> BoxFuture<'inp, Result<$istruct, CustomError>> {
+            ) -> BoxFuture<'orig, Result<$istruct, CustomError>> {
                 let $registry = registry;
                 let $original = original;
                 async move { $fnbody }.boxed()
@@ -64,7 +64,7 @@ macro_rules! iitem {
         match $original {
 $(
             $penum(inner) => Ok($ienum(
-                $istruct::new($registry, inner).await?,
+                $istruct::new($registry.clone(), inner).await?,
             )),
 )*
             }

src/intermediate/mod.rs

@@ -124,3 +124,6 @@ pub(crate) use timestamp::ITimestamp;
 pub(crate) use underline::IUnderline;
 pub(crate) use verbatim::IVerbatim;
 pub(crate) use verse_block::IVerseBlock;
+
+pub(crate) type RefRegistry<'orig, 'parse> =
+    std::sync::Arc<std::sync::Mutex<registry::Registry<'orig, 'parse>>>;

src/intermediate/page.rs

@@ -7,6 +7,7 @@ use super::registry::Registry;
 use super::IDocumentElement;
 use super::IHeading;
 use super::ISection;
+use super::RefRegistry;
 
 #[derive(Debug)]
 pub(crate) struct BlogPostPage {
@@ -24,30 +25,34 @@ impl BlogPostPage {
     // TODO: Move path into the registry so I can give this a standard interface like the others.
     pub(crate) async fn new<'a, 'b, 'parse, P: Into<PathBuf>>(
         path: P,
-        registry: &'a mut Registry<'b, 'parse>,
+        registry: RefRegistry<'b, 'parse>,
         document: &'b organic::types::Document<'parse>,
     ) -> Result<BlogPostPage, CustomError> {
         let path = path.into();
         let mut children = Vec::new();
         if let Some(section) = document.zeroth_section.as_ref() {
             children.push(IDocumentElement::Section(
-                ISection::new(registry, section).await?,
+                ISection::new(registry.clone(), section).await?,
             ));
         }
         for heading in document.children.iter() {
             children.push(IDocumentElement::Heading(
-                IHeading::new(registry, heading).await?,
+                IHeading::new(registry.clone(), heading).await?,
             ));
         }
 
         let footnotes = {
-            let footnote_definitions: Vec<_> = registry
+            let footnote_definitions: Vec<_> = {
+                let registry = registry.lock().unwrap();
+                let ret = registry
                     .get_footnote_ids()
                     .map(|(id, def)| (id, def.clone()))
                     .collect();
+                ret
+            };
             let mut ret = Vec::new();
             for (id, def) in footnote_definitions.into_iter() {
-                ret.push(IRealFootnoteDefinition::new(registry, id, def).await?);
+                ret.push(IRealFootnoteDefinition::new(registry.clone(), id, def).await?);
             }
             ret
         };

src/intermediate/paragraph.rs

@@ -12,7 +12,7 @@ intermediate!(IParagraph, Paragraph, original, registry, {
     let children = {
         let mut ret = Vec::new();
         for obj in original.children.iter() {
-            ret.push(IObject::new(registry, obj).await?);
+            ret.push(IObject::new(registry.clone(), obj).await?);
         }
         ret
     };

src/intermediate/plain_list.rs

@@ -13,7 +13,7 @@ intermediate!(IPlainList, PlainList, original, registry, {
     let children = {
         let mut ret = Vec::new();
         for obj in original.children.iter() {
-            ret.push(IPlainListItem::new(registry, obj).await?);
+            ret.push(IPlainListItem::new(registry.clone(), obj).await?);
         }
         ret
     };

src/intermediate/plain_list_item.rs

@@ -14,7 +14,7 @@ intermediate!(IPlainListItem, PlainListItem, original, registry, {
     let tag = {
         let mut ret = Vec::new();
         for obj in original.tag.iter() {
-            ret.push(IObject::new(registry, obj).await?);
+            ret.push(IObject::new(registry.clone(), obj).await?);
         }
         ret
     };
@@ -22,7 +22,7 @@ intermediate!(IPlainListItem, PlainListItem, original, registry, {
     let children = {
         let mut ret = Vec::new();
         for elem in original.children.iter() {
-            ret.push(IElement::new(registry, elem).await?);
+            ret.push(IElement::new(registry.clone(), elem).await?);
         }
         ret
     };

src/intermediate/quote_block.rs

@@ -12,7 +12,7 @@ intermediate!(IQuoteBlock, QuoteBlock, original, registry, {
     let children = {
         let mut ret = Vec::new();
         for obj in original.children.iter() {
-            ret.push(IElement::new(registry, obj).await?);
+            ret.push(IElement::new(registry.clone(), obj).await?);
         }
         ret
     };

src/intermediate/registry.rs

@@ -1,5 +1,7 @@
 use std::collections::HashMap;
 use std::marker::PhantomData;
+use std::sync::Arc;
+use std::sync::Mutex;
 
 // use super::ast_node::IntoIAstNode;
 use crate::error::CustomError;
@@ -7,6 +9,7 @@ use organic::types::Element;
 use organic::types::Object;
 
 use super::ast_node::IAstNode;
+use super::RefRegistry;
 
 type IdCounter = u16;
 
@@ -40,30 +43,38 @@ impl<'orig, 'parse> Registry<'orig, 'parse> {
             .map(|(_label, definition)| definition)
             .enumerate()
     }
+}
 
-    /// Get a 0-indexed ID for a footnote.
+/// Get a 0-indexed ID for a footnote.
-    ///
+///
-    /// This needs to be incremented to be 1-indexed for render.
+/// This needs to be incremented to be 1-indexed for render.
-    pub(crate) async fn get_footnote_reference_id<'reg>(
+pub(crate) async fn get_footnote_reference_id<'orig, 'parse>(
-        &'reg mut self,
+    registry: RefRegistry<'orig, 'parse>,
     label: Option<&'parse str>,
     definition: &'orig Vec<Object<'parse>>,
-    ) -> Result<usize, CustomError> {
+) -> Result<usize, CustomError> {
     if let None = label {
         // If it has no label then it must always get a new ID.
-            let contents = convert_reference_contents(self, definition).await?;
+        let contents = convert_reference_contents(registry.clone(), definition).await?;
-            self.footnote_ids.push((None, contents));
+        let pos = {
-            return Ok(self.footnote_ids.len() - 1);
+            let mut registry = registry.lock().unwrap();
+            registry.footnote_ids.push((None, contents));
+            registry.footnote_ids.len() - 1
+        };
+        return Ok(pos);
     }
 
-        if let Some(existing_id) = self
+    let existing_index = registry
+        .lock()
+        .unwrap()
         .footnote_ids
         .iter()
-            .position(|(id, _definition)| *id == label)
+        .position(|(id, _definition)| *id == label);
-        {
+    if let Some(existing_id) = existing_index {
         if !definition.is_empty() {
-                let contents = convert_reference_contents(self, definition).await?;
+            let contents = convert_reference_contents(registry.clone(), definition).await?;
-                let entry = self
+            let mut registry = registry.lock().unwrap();
+            let entry = registry
                 .footnote_ids
                 .get_mut(existing_id)
                 .expect("If-statement proves this to be Some.");
@@ -71,20 +82,25 @@ impl<'orig, 'parse> Registry<'orig, 'parse> {
         }
         Ok(existing_id)
     } else {
-            let contents = convert_reference_contents(self, definition).await?;
+        let contents = convert_reference_contents(registry.clone(), definition).await?;
-            self.footnote_ids.push((label, contents));
+        let pos = {
-            Ok(self.footnote_ids.len() - 1)
+            let mut registry = registry.lock().unwrap();
-        }
+            registry.footnote_ids.push((label, contents));
+            registry.footnote_ids.len() - 1
+        };
+        Ok(pos)
     }
+}
 
-    /// Update the definition to a footnote but do not mark it as referenced.
+/// Update the definition to a footnote but do not mark it as referenced.
-    pub(crate) async fn register_footnote_definition<'reg>(
+pub(crate) async fn register_footnote_definition<'orig, 'parse>(
-        &'reg mut self,
+    registry: RefRegistry<'orig, 'parse>,
     label: &'parse str,
     definition: &'orig Vec<Element<'parse>>,
-    ) -> Result<(), CustomError> {
+) -> Result<(), CustomError> {
-        let contents = convert_definition_contents(self, definition).await?;
+    let contents = convert_definition_contents(registry.clone(), definition).await?;
-        if let Some((_existing_id, existing_definition)) = self
+    let mut registry = registry.lock().unwrap();
+    if let Some((_existing_id, existing_definition)) = registry
         .footnote_ids
         .iter_mut()
         .find(|(id, _definition)| *id == Some(label))
@@ -92,11 +108,10 @@ impl<'orig, 'parse> Registry<'orig, 'parse> {
         *existing_definition = contents;
     }
     Ok(())
-    }
 }
 
-async fn convert_reference_contents<'reg, 'orig, 'parse>(
+async fn convert_reference_contents<'orig, 'parse>(
-    registry: &'reg mut Registry<'orig, 'parse>,
+    registry: RefRegistry<'orig, 'parse>,
     contents: &'orig Vec<Object<'parse>>,
 ) -> Result<Vec<IAstNode>, CustomError> {
     let contents = {
@@ -111,8 +126,8 @@ async fn convert_reference_contents<'reg, 'orig, 'parse>(
     Ok(contents)
 }
 
-async fn convert_definition_contents<'reg, 'orig, 'parse>(
+async fn convert_definition_contents<'orig, 'parse>(
-    registry: &'reg mut Registry<'orig, 'parse>,
+    registry: RefRegistry<'orig, 'parse>,
     contents: &'orig Vec<Element<'parse>>,
 ) -> Result<Vec<IAstNode>, CustomError> {
     let contents = {

src/intermediate/regular_link.rs

@@ -13,7 +13,7 @@ intermediate!(IRegularLink, RegularLink, original, registry, {
     let children = {
         let mut ret = Vec::new();
         for obj in original.children.iter() {
-            ret.push(IObject::new(registry, obj).await?);
+            ret.push(IObject::new(registry.clone(), obj).await?);
         }
         ret
     };

src/intermediate/section.rs

@@ -12,7 +12,7 @@ intermediate!(ISection, Section, original, registry, {
     let children = {
         let mut ret = Vec::new();
         for elem in original.children.iter() {
-            ret.push(IElement::new(registry, elem).await?);
+            ret.push(IElement::new(registry.clone(), elem).await?);
         }
         ret
     };

src/intermediate/target.rs

@@ -9,6 +9,7 @@ pub(crate) struct ITarget {
 }
 
 intermediate!(ITarget, Target, original, registry, {
+    let mut registry = registry.lock().unwrap();
     let id = registry.get_target(original.value);
     Ok(ITarget {
         id: id.clone(),