Make parse and compare their own binaries.

This ensures that both code paths are capable of being parsed by rust-analyzer simultaneously and I think it will be less confusing to newcomers.

Cargo.toml

@@ -21,9 +21,15 @@ name = "organic"
 path = "src/lib.rs"
 
 [[bin]]
-# This bin exists for development purposes only. The real target of this crate is the library.
-name = "parse"
-path = "src/main.rs"
+  # This bin exists for development purposes only. The real target of this crate is the library.
+  name = "parse"
+  path = "src/main.rs"
+
+[[bin]]
+  # This bin exists for development purposes only. The real target of this crate is the library.
+  name = "compare"
+  path = "src/bin_compare.rs"
+  required-features = ["compare"]
 
 [dependencies]
 nom = "7.1.1"

docker/organic_test/foreign_document_test_entrypoint.sh

@@ -23,7 +23,7 @@ function main {
     if [ "${CARGO_TARGET_DIR:-}" = "" ]; then
         CARGO_TARGET_DIR=$(realpath target/)
     fi
-    PARSE="${CARGO_TARGET_DIR}/release-lto/parse"
+    PARSE="${CARGO_TARGET_DIR}/release-lto/compare"
 
     local all_status=0
     set +e

scripts/run_docker_compare.bash

@@ -38,7 +38,7 @@ function launch_container {
 
     if [ "$SHELL" != "YES" ]; then
         local features_joined=$(IFS=","; echo "${features[*]}")
-        additional_args+=(cargo run --no-default-features --features "$features_joined")
+        additional_args+=(cargo run --bin compare --no-default-features --features "$features_joined")
         additional_flags+=(--read-only)
     else
         additional_args+=(/bin/sh)

src/bin_compare.rs

@@ -0,0 +1,122 @@
+#![feature(round_char_boundary)]
+#![feature(exact_size_is_empty)]
+use std::io::Read;
+use std::path::Path;
+
+use ::organic::parser::parse;
+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::parser::sexp::sexp_with_padding;
+use organic::GlobalSettings;
+use organic::LocalFileAccessInterface;
+
+#[cfg(feature = "tracing")]
+use crate::init_tracing::init_telemetry;
+#[cfg(feature = "tracing")]
+use crate::init_tracing::shutdown_telemetry;
+#[cfg(feature = "tracing")]
+mod init_tracing;
+
+#[cfg(not(feature = "tracing"))]
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    main_body()
+}
+
+#[cfg(feature = "tracing")]
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let rt = tokio::runtime::Runtime::new()?;
+    let result = rt.block_on(async {
+        init_telemetry()?;
+        let main_body_result = main_body();
+        shutdown_telemetry()?;
+        main_body_result
+    });
+    result
+}
+
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
+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_parse(org_contents)
+    } else {
+        for arg in args {
+            run_parse_on_file(arg)?
+        }
+        Ok(())
+    }
+}
+
+fn read_stdin_to_string() -> Result<String, Box<dyn std::error::Error>> {
+    let mut stdin_contents = String::new();
+    std::io::stdin()
+        .lock()
+        .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_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.")?;
+    }
+
+    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_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.")?;
+    }
+
+    Ok(())
+}

src/main.rs

@@ -4,19 +4,7 @@ use std::io::Read;
 use std::path::Path;
 
 use ::organic::parser::parse;
-#[cfg(feature = "compare")]
-use organic::compare_document;
-#[cfg(feature = "compare")]
-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")]
-use organic::get_org_mode_version;
 use organic::parser::parse_with_settings;
-#[cfg(feature = "compare")]
-use organic::parser::sexp::sexp_with_padding;
 use organic::GlobalSettings;
 use organic::LocalFileAccessInterface;
 
@@ -66,85 +54,14 @@ fn read_stdin_to_string() -> Result<String, Box<dyn std::error::Error>> {
     Ok(stdin_contents)
 }
 
-#[cfg(feature = "compare")]
 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_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.")?;
-    }
-
-    Ok(())
-}
-
-#[cfg(not(feature = "compare"))]
-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."
-    );
     let rust_parsed = parse(org_contents.as_ref())?;
     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());
-    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_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.")?;
-    }
-
-    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."
-    );
     let parent_directory = org_path
         .parent()
         .ok_or("Should be contained inside a directory.")?;