build.rs

@@ -71,6 +71,10 @@ fn write_header(test_file: &mut File) {
         test_file,
         r#"
 #[feature(exit_status_error)]
+use organic::compare_document;
+use organic::parser::parse;
+use organic::emacs_parse_anonymous_org_document;
+use organic::sexp;
 
 "#
     )

src/bin_compare.rs

@@ -1,9 +1,18 @@
 #![feature(round_char_boundary)]
 #![feature(exact_size_is_empty)]
 use std::io::Read;
+use std::path::Path;
 
-use organic::compare::run_anonymous_compare;
+use ::organic::parser::parse;
-use organic::compare::run_compare_on_file;
+use organic::compare_document;
+use organic::emacs_parse_anonymous_org_document;
+use organic::emacs_parse_file_org_document;
+use organic::get_emacs_version;
+use organic::get_org_mode_version;
+use organic::parser::parse_with_settings;
+use organic::sexp;
+use organic::GlobalSettings;
+use organic::LocalFileAccessInterface;
 
 #[cfg(feature = "tracing")]
 use crate::init_tracing::init_telemetry;
@@ -34,10 +43,10 @@ fn main_body() -> Result<(), Box<dyn std::error::Error>> {
     let args = std::env::args().skip(1);
     if args.is_empty() {
         let org_contents = read_stdin_to_string()?;
-        run_anonymous_compare(org_contents)
+        run_anonymous_parse(org_contents)
     } else {
         for arg in args {
-            run_compare_on_file(arg)?
+            run_parse_on_file(arg)?
         }
         Ok(())
     }
@@ -50,3 +59,62 @@ fn read_stdin_to_string() -> Result<String, Box<dyn std::error::Error>> {
         .read_to_string(&mut stdin_contents)?;
     Ok(stdin_contents)
 }
+
+fn run_anonymous_parse<P: AsRef<str>>(org_contents: P) -> Result<(), Box<dyn std::error::Error>> {
+    let org_contents = org_contents.as_ref();
+    eprintln!("Using emacs version: {}", get_emacs_version()?.trim());
+    eprintln!("Using org-mode version: {}", get_org_mode_version()?.trim());
+    let rust_parsed = parse(org_contents)?;
+    let org_sexp = emacs_parse_anonymous_org_document(org_contents)?;
+    let (_remaining, parsed_sexp) = sexp(org_sexp.as_str()).map_err(|e| e.to_string())?;
+
+    println!("{}\n\n\n", org_contents);
+    println!("{}", org_sexp);
+    println!("{:#?}", rust_parsed);
+
+    // We do the diffing after printing out both parsed forms in case the diffing panics
+    let diff_result = compare_document(&parsed_sexp, &rust_parsed)?;
+    diff_result.print(org_contents)?;
+
+    if diff_result.is_bad() {
+        Err("Diff results do not match.")?;
+    }
+
+    Ok(())
+}
+
+fn run_parse_on_file<P: AsRef<Path>>(org_path: P) -> Result<(), Box<dyn std::error::Error>> {
+    let org_path = org_path.as_ref();
+    eprintln!("Using emacs version: {}", get_emacs_version()?.trim());
+    eprintln!("Using org-mode version: {}", get_org_mode_version()?.trim());
+    let parent_directory = org_path
+        .parent()
+        .ok_or("Should be contained inside a directory.")?;
+    let org_contents = std::fs::read_to_string(org_path)?;
+    let org_contents = org_contents.as_str();
+    let file_access_interface = LocalFileAccessInterface {
+        working_directory: Some(parent_directory.to_path_buf()),
+    };
+    let global_settings = {
+        let mut global_settings = GlobalSettings::default();
+        global_settings.file_access = &file_access_interface;
+        global_settings
+    };
+    let rust_parsed = parse_with_settings(org_contents, &global_settings)?;
+    let org_sexp = emacs_parse_file_org_document(org_path)?;
+    let (_remaining, parsed_sexp) = sexp(org_sexp.as_str()).map_err(|e| e.to_string())?;
+
+    println!("{}\n\n\n", org_contents);
+    println!("{}", org_sexp);
+    println!("{:#?}", rust_parsed);
+
+    // We do the diffing after printing out both parsed forms in case the diffing panics
+    let diff_result = compare_document(&parsed_sexp, &rust_parsed)?;
+    diff_result.print(org_contents)?;
+
+    if diff_result.is_bad() {
+        Err("Diff results do not match.")?;
+    }
+
+    Ok(())
+}

src/compare/compare.rs

@@ -1,73 +0,0 @@
-use std::path::Path;
-
-use crate::compare::diff::compare_document;
-use crate::compare::parse::emacs_parse_anonymous_org_document;
-use crate::compare::parse::emacs_parse_file_org_document;
-use crate::compare::parse::get_emacs_version;
-use crate::compare::parse::get_org_mode_version;
-use crate::compare::sexp::sexp;
-use crate::parser::parse;
-use crate::parser::parse_with_settings;
-use crate::GlobalSettings;
-use crate::LocalFileAccessInterface;
-
-pub fn run_anonymous_compare<P: AsRef<str>>(
-    org_contents: P,
-) -> Result<(), Box<dyn std::error::Error>> {
-    let org_contents = org_contents.as_ref();
-    eprintln!("Using emacs version: {}", get_emacs_version()?.trim());
-    eprintln!("Using org-mode version: {}", get_org_mode_version()?.trim());
-    let rust_parsed = parse(org_contents)?;
-    let org_sexp = emacs_parse_anonymous_org_document(org_contents)?;
-    let (_remaining, parsed_sexp) = sexp(org_sexp.as_str()).map_err(|e| e.to_string())?;
-
-    println!("{}\n\n\n", org_contents);
-    println!("{}", org_sexp);
-    println!("{:#?}", rust_parsed);
-
-    // We do the diffing after printing out both parsed forms in case the diffing panics
-    let diff_result = compare_document(&parsed_sexp, &rust_parsed)?;
-    diff_result.print(org_contents)?;
-
-    if diff_result.is_bad() {
-        Err("Diff results do not match.")?;
-    }
-
-    Ok(())
-}
-
-pub fn run_compare_on_file<P: AsRef<Path>>(org_path: P) -> Result<(), Box<dyn std::error::Error>> {
-    let org_path = org_path.as_ref();
-    eprintln!("Using emacs version: {}", get_emacs_version()?.trim());
-    eprintln!("Using org-mode version: {}", get_org_mode_version()?.trim());
-    let parent_directory = org_path
-        .parent()
-        .ok_or("Should be contained inside a directory.")?;
-    let org_contents = std::fs::read_to_string(org_path)?;
-    let org_contents = org_contents.as_str();
-    let file_access_interface = LocalFileAccessInterface {
-        working_directory: Some(parent_directory.to_path_buf()),
-    };
-    let global_settings = {
-        let mut global_settings = GlobalSettings::default();
-        global_settings.file_access = &file_access_interface;
-        global_settings
-    };
-    let rust_parsed = parse_with_settings(org_contents, &global_settings)?;
-    let org_sexp = emacs_parse_file_org_document(org_path)?;
-    let (_remaining, parsed_sexp) = sexp(org_sexp.as_str()).map_err(|e| e.to_string())?;
-
-    println!("{}\n\n\n", org_contents);
-    println!("{}", org_sexp);
-    println!("{:#?}", rust_parsed);
-
-    // We do the diffing after printing out both parsed forms in case the diffing panics
-    let diff_result = compare_document(&parsed_sexp, &rust_parsed)?;
-    diff_result.print(org_contents)?;
-
-    if diff_result.is_bad() {
-        Err("Diff results do not match.")?;
-    }
-
-    Ok(())
-}

src/compare/mod.rs

@@ -1,7 +1,10 @@
-mod compare;
 mod diff;
 mod parse;
 mod sexp;
 mod util;
-pub use compare::run_anonymous_compare;
+pub use diff::compare_document;
-pub use compare::run_compare_on_file;
+pub use parse::emacs_parse_anonymous_org_document;
+pub use parse::emacs_parse_file_org_document;
+pub use parse::get_emacs_version;
+pub use parse::get_org_mode_version;
+pub use sexp::sexp;

src/lib.rs

@@ -4,7 +4,19 @@
 // TODO: #![warn(missing_docs)]
 
 #[cfg(feature = "compare")]
-pub mod compare;
+mod compare;
+#[cfg(feature = "compare")]
+pub use compare::compare_document;
+#[cfg(feature = "compare")]
+pub use compare::emacs_parse_anonymous_org_document;
+#[cfg(feature = "compare")]
+pub use compare::emacs_parse_file_org_document;
+#[cfg(feature = "compare")]
+pub use compare::get_emacs_version;
+#[cfg(feature = "compare")]
+pub use compare::get_org_mode_version;
+#[cfg(feature = "compare")]
+pub use compare::sexp;
 
 mod context;
 mod error;

src/parser/document.rs

@@ -28,7 +28,7 @@ use crate::types::Object;
 ///
 /// This is the main entry point for Organic. It will parse the full contents of the input string as an org-mode document.
 #[allow(dead_code)]
-pub fn parse<'s>(input: &'s str) -> Result<Document<'s>, Box<dyn std::error::Error>> {
+pub fn parse<'s>(input: &'s str) -> Result<Document<'s>, String> {
     parse_with_settings(input, &GlobalSettings::default())
 }
 
@@ -41,7 +41,7 @@ pub fn parse<'s>(input: &'s str) -> Result<Document<'s>, Box<dyn std::error::Err
 pub fn parse_with_settings<'g, 's>(
     input: &'s str,
     global_settings: &'g GlobalSettings<'g, 's>,
-) -> Result<Document<'s>, Box<dyn std::error::Error>> {
+) -> Result<Document<'s>, String> {
     let initial_context = ContextElement::document_context();
     let initial_context = Context::new(global_settings, List::new(&initial_context));
     let wrapped_input = OrgSource::new(input);
@@ -49,7 +49,7 @@ pub fn parse_with_settings<'g, 's>(
         all_consuming(parser_with_context!(document_org_source)(&initial_context))(wrapped_input)
             .map_err(|err| err.to_string())
             .map(|(_remaining, parsed_document)| parsed_document);
-    Ok(ret?)
+    ret
 }
 
 /// Parse a full org-mode document.

src/types/mod.rs

@@ -64,5 +64,5 @@ pub use object::Target;
 pub use object::Timestamp;
 pub use object::Underline;
 pub use object::Verbatim;
-pub(crate) use source::SetSource;
+pub use source::SetSource;
 pub use source::Source;

src/types/source.rs

@@ -1,6 +1,6 @@
 pub trait Source<'s> {
     fn get_source(&'s self) -> &'s str;
 }
-pub(crate) trait SetSource<'s> {
+pub trait SetSource<'s> {
     fn set_source(&mut self, source: &'s str);
 }

tests/test_template

@@ -1,7 +1,17 @@
 #[test]
-fn {name}() -> Result<(), Box<dyn std::error::Error>> {{
+fn {name}() {{
-    let org_path = "{path}";
+    let todo_org_path = "{path}";
-    let org_contents = std::fs::read_to_string(org_path).expect("Read org file.");
+    let org_contents = std::fs::read_to_string(todo_org_path).expect("Read org file.");
-    organic::compare::run_anonymous_compare(org_contents.as_str())?;
+    println!("{{}}", org_contents);
-    Ok(())
+    let org_sexp = emacs_parse_anonymous_org_document(org_contents.as_str()).expect("Use emacs to parse org file.");
+    println!("{{}}", org_sexp);
+    let (_remaining, parsed_sexp) = sexp(org_sexp.as_str()).expect("Sexp Parse failure");
+    let rust_parsed = parse(org_contents.as_str()).expect("Org Parse failure");
+    println!("{{:#?}}", rust_parsed);
+    let diff_result =
+        compare_document(&parsed_sexp, &rust_parsed).expect("Compare parsed documents.");
+    diff_result
+        .print(org_contents.as_str())
+        .expect("Print document parse tree diff.");
+    assert!(!diff_result.is_bad());
 }}