Add a build for regular non-blog-post pages from org source.

src/command/build/render.rs

@@ -13,9 +13,11 @@ use crate::context::RenderBlogPostPageInput;
 use crate::context::RenderBlogStream;
 use crate::context::RenderBlogStreamInput;
 use crate::context::RenderContext;
+use crate::context::RenderPage;
 use crate::error::CustomError;
 use crate::intermediate::get_web_path;
 use crate::intermediate::BlogPost;
+use crate::intermediate::IPage;
 use crate::render::DusterRenderer;
 use crate::render::RendererIntegration;
 
@@ -27,6 +29,7 @@ pub(crate) struct SiteRenderer {
     output_directory: PathBuf,
     blog_posts: Vec<BlogPost>,
     stylesheets: Vec<Stylesheet>,
+    pages: Vec<IPage>,
 }
 
 impl SiteRenderer {
@@ -34,11 +37,13 @@ impl SiteRenderer {
         output_directory: P,
         blog_posts: Vec<BlogPost>,
         stylesheets: Vec<Stylesheet>,
+        pages: Vec<IPage>,
     ) -> SiteRenderer {
         SiteRenderer {
             output_directory: output_directory.into(),
             blog_posts,
             stylesheets,
+            pages,
         }
     }
 
@@ -73,6 +78,29 @@ impl SiteRenderer {
         Ok(renderer_integration)
     }
 
+    pub(crate) async fn render_pages(&self, config: &Config) -> Result<(), CustomError> {
+        let renderer_integration = self.init_renderer_integration()?;
+
+        for page in &self.pages {
+            let output_path = self.output_directory.join(page.get_output_path());
+            let render_context = RenderContext::new(
+                config,
+                self.output_directory.as_path(),
+                output_path.as_path(),
+                None,
+            )?;
+            let render_context = RenderPage::new(render_context, page)?;
+            let rendered_output = renderer_integration.render(render_context)?;
+            let parent_directory = output_path
+                .parent()
+                .ok_or("Output file should have a containing directory.")?;
+            tokio::fs::create_dir_all(parent_directory).await?;
+            tokio::fs::write(output_path, rendered_output).await?;
+        }
+
+        Ok(())
+    }
+
     pub(crate) async fn render_blog_posts(&self, config: &Config) -> Result<(), CustomError> {
         let renderer_integration = self.init_renderer_integration()?;
 

src/command/build/runner.rs

@@ -1,12 +1,19 @@
 use std::ffi::OsStr;
 use std::path::PathBuf;
+use std::sync::Arc;
+use std::sync::Mutex;
 
 use super::stylesheet::Stylesheet;
 use crate::cli::parameters::BuildArgs;
 use crate::command::build::render::SiteRenderer;
 use crate::config::Config;
 use crate::error::CustomError;
+use crate::intermediate::get_org_files;
 use crate::intermediate::BlogPost;
+use crate::intermediate::IPage;
+use crate::intermediate::IntermediateContext;
+use crate::intermediate::PageInput;
+use crate::intermediate::Registry;
 use include_dir::include_dir;
 use include_dir::Dir;
 
@@ -17,13 +24,16 @@ pub(crate) async fn build_site(args: BuildArgs) -> Result<(), CustomError> {
     let config = Config::load_from_file(args.config).await?;
     let blog_posts = load_blog_posts(&config).await?;
     let stylesheets = load_stylesheets().await?;
+    let pages = load_pages(&config).await?;
     let renderer = SiteRenderer::new(
         get_output_directory(&config).await?,
         blog_posts,
         stylesheets,
+        pages,
     );
     renderer.render_blog_posts(&config).await?;
     renderer.render_blog_stream(&config).await?;
+    renderer.render_pages(&config).await?;
     renderer.render_stylesheets().await?;
     renderer.copy_static_files(&config).await?;
 
@@ -74,6 +84,62 @@ async fn load_blog_posts(config: &Config) -> Result<Vec<BlogPost>, CustomError>
     Ok(blog_posts)
 }
 
+async fn load_pages(config: &Config) -> Result<Vec<IPage>, CustomError> {
+    let pages_source = config
+        .get_root_directory()
+        .join(config.get_relative_path_to_pages());
+    if !pages_source.exists() {
+        return Ok(Vec::new());
+    }
+    let page_files = get_org_files(&pages_source)?;
+    let org_files = {
+        let mut ret = Vec::new();
+        for page in page_files {
+            ret.push(page.await??);
+        }
+        ret
+    };
+    let parsed_org_files = {
+        let mut ret = Vec::new();
+        for (path, contents) in org_files.iter() {
+            let parsed = organic::parser::parse_file(contents.as_str(), Some(path))
+                .map_err(|_| CustomError::Static("Failed to parse org-mode document."))?;
+            ret.push((path, contents, parsed));
+        }
+        ret
+    };
+
+    let pages = {
+        let mut ret = Vec::new();
+        for (real_path, _contents, parsed_document) in parsed_org_files.iter() {
+            let mut registry = Registry::new();
+
+            // Assign IDs to the targets
+            organic::types::AstNode::from(parsed_document)
+                .iter_all_ast_nodes()
+                .for_each(|node| {
+                    if let organic::types::AstNode::Target(target) = node {
+                        registry.get_target(target.value);
+                    }
+                });
+
+            let registry = Arc::new(Mutex::new(registry));
+            let intermediate_context = IntermediateContext::new(registry)?;
+            let relative_to_pages_dir_path = real_path.strip_prefix(&pages_source)?;
+            ret.push(
+                IPage::new(
+                    intermediate_context,
+                    PageInput::new(relative_to_pages_dir_path, parsed_document),
+                )
+                .await?,
+            );
+        }
+        ret
+    };
+
+    Ok(pages)
+}
+
 async fn load_stylesheets() -> Result<Vec<Stylesheet>, CustomError> {
     let sources: Vec<_> = DEFAULT_STYLESHEETS
         .files()