feat(proc): add ProcReferences

Add a struct to handle intermediately rendered output. The intention is something similar to the haskell citeproc server json. Signed-off-by: Bruce D'Arcus <bdarcus@gmail.com>
bdarcus · Nov 21, 2023 · d502610 · d502610
1 parent f59c675
commit d502610
Show file tree

Hide file tree

Showing 2 changed files with 52 additions and 8 deletions.
diff --git a/cli/src/main.rs b/cli/src/main.rs
@@ -3,7 +3,7 @@ use csln::bibliography::HasFile;
 use csln::bibliography::InputBibliography as Bibliography;
 use csln::citation::Citation;
 use csln::style::Style;
-use processor::{refs_to_string, Processor};
+use processor::Processor;
 
 #[derive(Parser, Default, Debug)]
 #[clap(author = "Bruce D'Arcus", version, about = "A CLI for CSLN")]
@@ -27,6 +27,6 @@ fn main() {
     let locale = csln::style::locale::Locale::from_file(&opts.locale);
     let processor: Processor = Processor::new(style, bibliography, citations, locale);
     let rendered_refs = processor.process_references();
-    println!("{}", refs_to_string(rendered_refs));
-    //println!("{}", serde_json::to_string_pretty(&rendered_refs).unwrap());
+    //println!("{}", refs_to_string(rendered_refs));
+    println!("{}", serde_json::to_string_pretty(&rendered_refs).unwrap());
 }
diff --git a/processor/src/lib.rs b/processor/src/lib.rs
@@ -6,7 +6,7 @@ SPDX-FileCopyrightText: © 2023 Bruce D'Arcus
 use csln::bibliography::reference::InputReference;
 use csln::bibliography::reference::{EdtfString, RefID};
 use csln::bibliography::InputBibliography as Bibliography;
-use csln::citation::Citation;
+use csln::citation::{Citation, CitationItem};
 use csln::style::locale::Locale;
 use csln::style::options::{Config, MonthFormat, SortKey, SubstituteKey};
 use csln::style::template::{
@@ -619,24 +619,68 @@ impl ComponentValues for TemplateDate {
 //     assert_eq!(rendered_date, "2020");
 // }
 
+/// The intermediate representation of renderered citations and bibliography..
+#[derive(Debug, Deserialize, Serialize, Clone, JsonSchema)]
+pub struct ProcReferences {
+    pub bibliography: Vec<ProcTemplate>,
+    pub citations: Option<Vec<ProcTemplate>>,
+}
+
 impl Processor {
     /// Render references to AST.
     #[inline]
-    pub fn process_references(&self) -> Vec<ProcTemplate> {
+    pub fn process_references(&self) -> ProcReferences {
         let sorted_references = self.sort_references(self.get_references());
-        sorted_references
+        let bibliography = sorted_references
             .par_iter()
             .map(|reference| self.process_reference(reference))
+            .collect();
+        ProcReferences { bibliography, citations: None }
+    }
+
+    fn process_citations(
+        &self,
+        citations: &[Citation],
+    ) -> Vec<Vec<ProcTemplateComponent>> {
+        citations
+            .iter()
+            .map(|citation| vec![self.process_citation(citation)])
             .collect()
     }
 
+    fn process_citation(&self, citation: &Citation) -> Vec<ProcTemplateComponent> {
+        let style = self.style.clone();
+        // map the citation items to a vector of ProcTemplateComponents
+        let proc_template: Vec<Vec<Vec<ProcTemplateComponent>>> = citation
+            .citation_items
+            .iter()
+            .filter_map(|citation_item| self.process_citation_item(citation_item, style))
+            .collect();
+        proc_template
+    }
+
+    fn process_citation_item(
+        &self,
+        citation_item: &CitationItem,
+        style: Style,
+    ) -> Option<Vec<ProcTemplateComponent>> {
+        let citation_style = self.style.citation.clone();
+        let reference = self.get_reference(&citation_item.ref_id)?;
+        let template = citation_style?.template.as_slice();
+        let proc_template = self.process_template(&reference, template);
+        Some(proc_template)
+    }
+
     /// Render a reference to AST.
     fn process_reference(
         &self,
-        reference: &InputReference,
+        reference: &Option<InputReference>,
     ) -> Vec<ProcTemplateComponent> {
         let bibliography_style = self.style.bibliography.clone();
-        self.process_template(reference, bibliography_style.unwrap().template.as_slice())
+        self.process_template(
+            reference.as_ref().unwrap(),
+            bibliography_style.unwrap().template.as_slice(),
+        )
     }
 
     fn get_render_options(&self, style: Style, locale: Locale) -> RenderOptions {