Add target.

src/context/mod.rs

@@ -6,6 +6,7 @@ mod heading;
 mod object;
 mod plain_text;
 mod section;
+mod target;
 
 pub(crate) use blog_post_page::RenderBlogPostPage;
 pub(crate) use document_element::RenderDocumentElement;

src/context/object.rs

@@ -7,11 +7,13 @@ use crate::error::CustomError;
 use crate::intermediate::IObject;
 
 use super::plain_text::RenderPlainText;
+use super::target::RenderTarget;
 
 #[derive(Debug, Serialize)]
 #[serde(untagged)]
 pub(crate) enum RenderObject {
     PlainText(RenderPlainText),
+    Target(RenderTarget),
 }
 
 impl RenderObject {
@@ -28,6 +30,12 @@ impl RenderObject {
                 output_file,
                 inner,
             )?)),
+            IObject::Target(inner) => Ok(RenderObject::Target(RenderTarget::new(
+                config,
+                output_directory,
+                output_file,
+                inner,
+            )?)),
         }
     }
 }

src/context/target.rs

@@ -0,0 +1,27 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::ITarget;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "target")]
+pub(crate) struct RenderTarget {
+    id: String,
+}
+
+impl RenderTarget {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        target: &ITarget,
+    ) -> Result<RenderTarget, CustomError> {
+        Ok(RenderTarget {
+            id: target.id.clone(),
+        })
+    }
+}

src/intermediate/definition.rs

@@ -5,15 +5,14 @@ use tokio::task::JoinHandle;
 use walkdir::WalkDir;
 
 use crate::error::CustomError;
+use crate::intermediate::registry::Registry;
 
 use super::BlogPostPage;
-use super::IDocumentElement;
 
 #[derive(Debug)]
 pub(crate) struct BlogPost {
     pub(crate) id: String,
     pub(crate) pages: Vec<BlogPostPage>,
-    pub(crate) children: Vec<IDocumentElement>,
 }
 
 impl BlogPost {
@@ -44,12 +43,27 @@ impl BlogPost {
                 ret
             };
 
+            let mut registry = Registry::new();
+
+            // Assign IDs to the targets
+            for (_real_path, _contents, parsed_document) in parsed_org_files.iter() {
+                organic::types::AstNode::from(parsed_document)
+                    .iter_all_ast_nodes()
+                    .for_each(|node| match node {
+                        organic::types::AstNode::Target(target) => {
+                            registry.get_target(target.value);
+                        }
+                        _ => {}
+                    });
+            }
+
             let pages = {
                 let mut ret = Vec::new();
-                for (real_path, _contents, parsed_document) in parsed_org_files {
+                for (real_path, _contents, parsed_document) in parsed_org_files.iter() {
                     let relative_to_post_dir_path = real_path.strip_prefix(post_dir)?;
                     ret.push(BlogPostPage::new(
                         relative_to_post_dir_path,
+                        &mut registry,
                         parsed_document,
                     )?);
                 }
@@ -59,7 +73,6 @@ impl BlogPost {
             Ok(BlogPost {
                 id: post_id.to_string_lossy().into_owned(),
                 pages,
-                children: Vec::new(),
             })
         }
         inner(root_dir.as_ref(), post_dir.as_ref()).await

src/intermediate/heading.rs

@@ -1,5 +1,6 @@
 use crate::error::CustomError;
 
+use super::registry::Registry;
 use super::IObject;
 
 #[derive(Debug)]
@@ -9,11 +10,14 @@ pub(crate) struct IHeading {
 }
 
 impl IHeading {
-    pub(crate) fn new(heading: &organic::types::Heading<'_>) -> Result<IHeading, CustomError> {
+    pub(crate) fn new<'parse>(
+        registry: &mut Registry<'parse>,
+        heading: &organic::types::Heading<'parse>,
+    ) -> Result<IHeading, CustomError> {
         let title = heading
             .title
             .iter()
-            .map(IObject::new)
+            .map(|obj| IObject::new(registry, obj))
             .collect::<Result<Vec<_>, _>>()?;
         Ok(IHeading {
             title,

src/intermediate/mod.rs

@@ -6,7 +6,9 @@ mod heading;
 mod object;
 mod page;
 mod plain_text;
+mod registry;
 mod section;
+mod target;
 mod util;
 pub(crate) use convert::convert_blog_post_page_to_render_context;
 pub(crate) use definition::BlogPost;
@@ -17,3 +19,4 @@ pub(crate) use object::IObject;
 pub(crate) use page::BlogPostPage;
 pub(crate) use plain_text::IPlainText;
 pub(crate) use section::ISection;
+pub(crate) use target::ITarget;

src/intermediate/object.rs

@@ -1,14 +1,20 @@
 use crate::error::CustomError;
 
 use super::plain_text::IPlainText;
+use super::registry::Registry;
+use super::ITarget;
 
 #[derive(Debug)]
 pub(crate) enum IObject {
     PlainText(IPlainText),
+    Target(ITarget),
 }
 
 impl IObject {
-    pub(crate) fn new(obj: &organic::types::Object<'_>) -> Result<IObject, CustomError> {
+    pub(crate) fn new<'parse>(
+        registry: &mut Registry<'parse>,
+        obj: &organic::types::Object<'parse>,
+    ) -> Result<IObject, CustomError> {
         match obj {
             organic::types::Object::Bold(_) => todo!(),
             organic::types::Object::Italic(_) => todo!(),
@@ -17,7 +23,7 @@ impl IObject {
             organic::types::Object::Code(_) => todo!(),
             organic::types::Object::Verbatim(_) => todo!(),
             organic::types::Object::PlainText(plain_text) => {
-                Ok(IObject::PlainText(IPlainText::new(plain_text)?))
+                Ok(IObject::PlainText(IPlainText::new(registry, plain_text)?))
             }
             organic::types::Object::RegularLink(_) => todo!(),
             organic::types::Object::RadioLink(_) => todo!(),
@@ -34,7 +40,9 @@ impl IObject {
             organic::types::Object::InlineBabelCall(_) => todo!(),
             organic::types::Object::InlineSourceBlock(_) => todo!(),
             organic::types::Object::LineBreak(_) => todo!(),
-            organic::types::Object::Target(_) => todo!(),
+            organic::types::Object::Target(target) => {
+                Ok(IObject::Target(ITarget::new(registry, target)?))
+            }
             organic::types::Object::StatisticsCookie(_) => todo!(),
             organic::types::Object::Subscript(_) => todo!(),
             organic::types::Object::Superscript(_) => todo!(),

src/intermediate/page.rs

@@ -2,6 +2,7 @@ use std::path::PathBuf;
 
 use crate::error::CustomError;
 
+use super::registry::Registry;
 use super::IDocumentElement;
 use super::IHeading;
 use super::ISection;
@@ -17,17 +18,18 @@ pub(crate) struct BlogPostPage {
 }
 
 impl BlogPostPage {
-    pub(crate) fn new<P: Into<PathBuf>>(
+    pub(crate) fn new<'parse, P: Into<PathBuf>>(
         path: P,
-        document: organic::types::Document<'_>,
+        registry: &mut Registry<'parse>,
+        document: &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(section)?));
+            children.push(IDocumentElement::Section(ISection::new(registry, section)?));
         }
         for heading in document.children.iter() {
-            children.push(IDocumentElement::Heading(IHeading::new(heading)?));
+            children.push(IDocumentElement::Heading(IHeading::new(registry, heading)?));
         }
 
         Ok(BlogPostPage {

src/intermediate/plain_text.rs

@@ -1,6 +1,8 @@
 use crate::error::CustomError;
 use crate::intermediate::util::coalesce_whitespace;
 
+use super::registry::Registry;
+
 #[derive(Debug)]
 pub(crate) struct IPlainText {
     source: String,
@@ -8,6 +10,7 @@ pub(crate) struct IPlainText {
 
 impl IPlainText {
     pub(crate) fn new(
+        registry: &mut Registry<'_>,
         plain_text: &organic::types::PlainText<'_>,
     ) -> Result<IPlainText, CustomError> {
         Ok(IPlainText {

src/intermediate/registry.rs

@@ -0,0 +1,24 @@
+use std::collections::HashMap;
+
+type IdCounter = u16;
+
+pub(crate) struct Registry<'parse> {
+    id_counter: IdCounter,
+    targets: HashMap<&'parse str, String>,
+}
+
+impl<'parse> Registry<'parse> {
+    pub(crate) fn new() -> Registry<'parse> {
+        Registry {
+            id_counter: 0,
+            targets: HashMap::new(),
+        }
+    }
+
+    pub(crate) fn get_target<'b>(&'b mut self, body: &'parse str) -> &'b String {
+        self.targets.entry(body).or_insert_with(|| {
+            self.id_counter += 1;
+            format!("target_{}", self.id_counter)
+        })
+    }
+}

src/intermediate/section.rs

@@ -1,10 +1,15 @@
 use crate::error::CustomError;
 
+use super::registry::Registry;
+
 #[derive(Debug)]
 pub(crate) struct ISection {}
 
 impl ISection {
-    pub(crate) fn new(section: &organic::types::Section<'_>) -> Result<ISection, CustomError> {
+    pub(crate) fn new(
+        registry: &mut Registry<'_>,
+        section: &organic::types::Section<'_>,
+    ) -> Result<ISection, CustomError> {
         Ok(ISection {})
     }
 }

src/intermediate/target.rs

@@ -0,0 +1,23 @@
+use crate::error::CustomError;
+use crate::intermediate::util::coalesce_whitespace;
+
+use super::registry::Registry;
+
+#[derive(Debug)]
+pub(crate) struct ITarget {
+    pub(crate) id: String,
+    value: String,
+}
+
+impl ITarget {
+    pub(crate) fn new<'parse>(
+        registry: &mut Registry<'parse>,
+        target: &organic::types::Target<'parse>,
+    ) -> Result<ITarget, CustomError> {
+        let id = registry.get_target(target.value);
+        Ok(ITarget {
+            id: id.clone(),
+            value: target.value.to_owned(),
+        })
+    }
+}