Handle org-mode documents passed as args.

We were running into issues where the documents grew too large for being passed as a string to emacs, and we need to handle #+setupfile so we need to start handling org-mode documents as files and not just as anonymous streams of text.

The anonymous stream of text handling will remain because the automated tests use it.

src/main.rs

@@ -1,11 +1,15 @@
 #![feature(round_char_boundary)]
+#![feature(exact_size_is_empty)]
 use std::io::Read;
+use std::path::Path;
 
 use ::organic::parser::document;
 #[cfg(feature = "compare")]
 use organic::compare_document;
 #[cfg(feature = "compare")]
-use organic::emacs_parse_org_document;
+use organic::emacs_parse_anonymous_org_document;
+#[cfg(feature = "compare")]
+use organic::emacs_parse_file_org_document;
 #[cfg(feature = "compare")]
 use organic::get_emacs_version;
 #[cfg(feature = "compare")]
@@ -39,8 +43,16 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 
 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn main_body() -> Result<(), Box<dyn std::error::Error>> {
-    let org_contents = read_stdin_to_string()?;
-    run_compare(org_contents)
+    let args = std::env::args();
+    if args.is_empty() {
+        let org_contents = read_stdin_to_string()?;
+        run_anonymous_parse(org_contents)
+    } else {
+        for arg in args.skip(1) {
+            run_parse_on_file(arg)?
+        }
+        Ok(())
+    }
 }
 
 fn read_stdin_to_string() -> Result<String, Box<dyn std::error::Error>> {
@@ -52,14 +64,12 @@ fn read_stdin_to_string() -> Result<String, Box<dyn std::error::Error>> {
 }
 
 #[cfg(feature = "compare")]
-fn run_compare<P: AsRef<str>>(org_contents: P) -> Result<(), Box<dyn std::error::Error>> {
-    let emacs_version = get_emacs_version()?;
-    let org_mode_version = get_org_mode_version()?;
+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: {}", emacs_version.trim());
-    eprintln!("Using org-mode version: {}", org_mode_version.trim());
+    eprintln!("Using emacs version: {}", get_emacs_version()?.trim());
+    eprintln!("Using org-mode version: {}", get_org_mode_version()?.trim());
     let (remaining, rust_parsed) = document(org_contents).map_err(|e| e.to_string())?;
-    let org_sexp = emacs_parse_org_document(org_contents)?;
+    let org_sexp = emacs_parse_anonymous_org_document(org_contents)?;
     let (_remaining, parsed_sexp) =
         sexp_with_padding(org_sexp.as_str()).map_err(|e| e.to_string())?;
 
@@ -82,7 +92,7 @@ fn run_compare<P: AsRef<str>>(org_contents: P) -> Result<(), Box<dyn std::error:
 }
 
 #[cfg(not(feature = "compare"))]
-fn run_compare<P: AsRef<str>>(org_contents: P) -> Result<(), Box<dyn std::error::Error>> {
+fn run_anonymous_parse<P: AsRef<str>>(org_contents: P) -> Result<(), Box<dyn std::error::Error>> {
     eprintln!(
         "This program was built with compare disabled. Only parsing with organic, not comparing."
     );
@@ -90,3 +100,48 @@ fn run_compare<P: AsRef<str>>(org_contents: P) -> Result<(), Box<dyn std::error:
     println!("{:#?}", rust_parsed);
     Ok(())
 }
+
+#[cfg(feature = "compare")]
+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());
+    // TODO: This should take into account the original file path when parsing in Organic, not just in emacs.
+    let org_contents = std::fs::read_to_string(org_path)?;
+    let org_contents = org_contents.as_str();
+    let (remaining, rust_parsed) = document(org_contents).map_err(|e| e.to_string())?;
+    let org_sexp = emacs_parse_file_org_document(org_path)?;
+    let (_remaining, parsed_sexp) =
+        sexp_with_padding(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.")?;
+    }
+    if remaining != "" {
+        Err(format!("There was unparsed text remaining: {}", remaining))?;
+    }
+
+    Ok(())
+}
+
+#[cfg(not(feature = "compare"))]
+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!(
+        "This program was built with compare disabled. Only parsing with organic, not comparing."
+    );
+    // TODO: This should take into account the original file path when parsing
+    let org_contents = std::fs::read_to_string(org_path)?;
+    let org_contents = org_contents.as_str();
+    let (_remaining, rust_parsed) = document(org_contents).map_err(|e| e.to_string())?;
+    println!("{:#?}", rust_parsed);
+    Ok(())
+}