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

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()