entities rework, allow "inline" documentation, merge config with cli

1 files changed, 78 insertions, 68 deletions

diff --git a/src/generator.rs b/src/generator.rs
index 0ab4511..0fa5a94 100644
--- a/src/generator.rs
+++ b/src/generator.rs
@@ -1,16 +1,20 @@
+use crate::config::Config;
 use crate::entities::{
-    Described, Description, EntitiesManager, EntitiesManagerComponents, Entity, Usr,
+    Description, DynEntity, EntitiesManager, EntitiesManagerComponents, Usr,
 };
+use crate::pandoc::into_pandoc;
 
-use anyhow::{Context, Result};
+use anyhow::{ensure, Context, Result};
+use rayon::Scope;
 use thiserror::Error;
-use threadpool::ThreadPool;
 
 use std::collections::HashMap;
+use std::io::Write;
 use std::path::Path;
-use std::sync::{mpsc::channel, Arc};
 
-pub(crate) fn generate(base_dir: &Path, manager: EntitiesManager) -> Result<()> {
+const DEFAULT_CSS: &[u8] = include_bytes!("../res/style.css");
+
+pub(crate) fn generate(base_dir: &Path, manager: EntitiesManager, config: &Config) -> Result<()> {
     let EntitiesManagerComponents {
         toplevel_entities,
         descriptions,
@@ -24,87 +28,78 @@ pub(crate) fn generate(base_dir: &Path, manager: EntitiesManager) -> Result<()>
     std::fs::create_dir_all(&html_output_dir)
         .context("Failed to create the HTML output directory")?;
 
-    let pool = ThreadPool::new(num_cpus::get());
-
-    let descriptions = Arc::new(descriptions);
-
-    let (tx, rx) = channel::<()>();
-
-    for (usr, entity) in toplevel_entities {
-        generate_recursively(
-            usr,
-            entity,
-            pool.clone(),
-            tx.clone(),
-            descriptions.clone(),
-            &md_output_dir,
-            &html_output_dir,
-        );
-    }
+    let mut css_tempfile = tempfile::Builder::new()
+        .prefix("style")
+        .suffix(".css")
+        .tempfile()?;
+    css_tempfile.write_all(DEFAULT_CSS)?;
 
-    drop(tx);
+    let css_path = css_tempfile.path();
+    debug!("Generated temporary file with CSS at: {:?}", css_path);
 
-    // This is not really idiomatic, but iter returns None when every Sender is destroyed, so just
-    // by passing around Senders in generate_recursively, we wait for every job.
-    rx.iter().for_each(drop);
+    rayon::scope(|scope| {
+        for (usr, entity) in &toplevel_entities {
+            generate_recursively(
+                &usr,
+                entity.as_ref(),
+                scope,
+                &descriptions,
+                &md_output_dir,
+                &html_output_dir,
+                css_path,
+            );
+        }
+    });
 
     Ok(())
 }
 
-fn generate_recursively(
-    usr: Usr,
-    entity: Entity,
-    pool: ThreadPool,
-    tx: std::sync::mpsc::Sender<()>,
-    descriptions: Arc<HashMap<Usr, Description>>,
-    md_output_dir: impl AsRef<Path>,
-    html_output_dir: impl AsRef<Path>,
+fn generate_recursively<'a>(
+    usr: &'a Usr,
+    entity: &'a DynEntity,
+    pool: &Scope<'a>,
+    descriptions: &'a HashMap<Usr, Description>,
+    md_output_dir: &'a Path,
+    html_output_dir: &'a Path,
+    css_path: &'a Path,
 ) {
-    let descriptions = descriptions.clone();
-    let md_output_dir = md_output_dir.as_ref().to_owned();
-    let html_output_dir = html_output_dir.as_ref().to_owned();
-
-    let pool2 = pool.clone();
-    pool.execute(move || {
+    pool.spawn(move |pool| {
         trace!("Trying to generate {}", usr.0);
 
-        let entity = Described::<Entity> {
-            entity,
-            description: descriptions.get(&usr).unwrap().clone(),
-        };
-
         let leftovers = generate_single(
             &usr,
             entity,
+            descriptions.get(&usr).unwrap(),
             &descriptions,
             &md_output_dir,
             &html_output_dir,
+            &css_path,
         )
         .unwrap();
 
         for (usr, entity) in leftovers {
-            let pool = pool2.clone();
-            let tx = tx.clone();
             generate_recursively(
                 usr,
                 entity,
                 pool,
-                tx,
-                descriptions.clone(),
-                md_output_dir.clone(),
-                html_output_dir.clone(),
+                descriptions,
+                md_output_dir,
+                html_output_dir,
+                css_path,
             );
         }
     });
 }
 
-fn generate_single(
+fn generate_single<'e>(
     usr: &Usr,
-    entity: Described<Entity>,
+    entity: &'e DynEntity,
+    description: &Description,
     descriptions: &HashMap<Usr, Description>,
     md_output_dir: impl AsRef<Path>,
     html_output_dir: impl AsRef<Path>,
-) -> Result<HashMap<Usr, Entity>> {
+    css_path: impl AsRef<Path>,
+) -> Result<HashMap<&'e Usr, &'e DynEntity>> {
     use std::io::prelude::*;
     use std::process::{Command, Stdio};
 
@@ -132,7 +127,7 @@ fn generate_single(
         .spawn()
         .context("Failed to execute Pandoc command")?;
 
-    let (pandoc_ast, leftovers) = entity.into_pandoc(&descriptions);
+    let (pandoc_ast, leftovers) = into_pandoc(entity, description, descriptions);
 
     if log_enabled!(log::Level::Trace) {
         let json =
@@ -152,17 +147,20 @@ fn generate_single(
         .context("Failed to convert Pandoc AST to JSON")?;
     }
 
+    let command_str = format!("{:?}", pandoc);
+
     let output = pandoc
         .wait_with_output()
         .expect("Pandoc command wasn't running");
 
-    if !output.status.success() {
-        Err(CommandError {
+    ensure!(
+        output.status.success(),
+        CommandError {
+            command: format!("{:?}", command_str),
             status: output.status,
             stderr: String::from_utf8(output.stderr).expect("Pandoc outputted invalid UTF-8"),
-        })
-        .context("Pandoc command failed")?;
-    }
+        }
+    );
 
     let mut command = Command::new("pandoc");
     command
@@ -172,7 +170,11 @@ fn generate_single(
         .args(&[
             "--from=markdown",
             "--to=html",
-            "--css=res/style.css",
+            "--css",
+            css_path
+                .as_ref()
+                .to_str()
+                .context("CSS path is not valid UTF-8")?,
             "--standalone",
             "--self-contained",
             md_output_file
@@ -184,26 +186,34 @@ fn generate_single(
                 .context("Entity name is not valid UTF-8")?,
         ]);
 
-    debug!("Launching command: {:?}", command);
+    let command_str = format!("{:?}", command);
+    debug!("Launching command: {}", command_str);
 
     let output = command
         .output()
         .context("Failed to execute Pandoc command")?;
 
-    if !output.status.success() {
-        Err(CommandError {
+    ensure!(
+        output.status.success(),
+        CommandError {
+            command: command_str,
             status: output.status,
             stderr: String::from_utf8(output.stderr).expect("Pandoc outputted invalid UTF-8"),
-        })
-        .context("Pandoc command failed")?;
-    }
+        }
+    );
 
     Ok(leftovers)
 }
 
 #[derive(Debug, Clone, Error)]
-#[error("Command returned status {:?} and stderr {:?}", status, stderr)]
+#[error(
+    "Command {} returned status {:?} and stderr {:?}",
+    command,
+    status,
+    stderr
+)]
 struct CommandError {
+    command: String,
     status: std::process::ExitStatus,
     stderr: String,
 }