From de7ad182b3e2a5102ecec26812ea056285c7a9fa Mon Sep 17 00:00:00 2001 From: Tom Alexander Date: Sat, 9 Sep 2023 04:03:53 -0400 Subject: [PATCH] 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 | 12 +- .../foreign_document_test_entrypoint.sh | 2 +- scripts/run_docker_compare.bash | 2 +- src/bin_compare.rs | 122 ++++++++++++++++++ src/main.rs | 83 ------------ 5 files changed, 133 insertions(+), 88 deletions(-) create mode 100644 src/bin_compare.rs diff --git a/Cargo.toml b/Cargo.toml index c529340..9ffb014 100644 --- a/Cargo.toml +++ b/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" diff --git a/docker/organic_test/foreign_document_test_entrypoint.sh b/docker/organic_test/foreign_document_test_entrypoint.sh index b1755d3..6dbea8c 100644 --- a/docker/organic_test/foreign_document_test_entrypoint.sh +++ b/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 diff --git a/scripts/run_docker_compare.bash b/scripts/run_docker_compare.bash index bfd25e1..309cddf 100755 --- a/scripts/run_docker_compare.bash +++ b/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) diff --git a/src/bin_compare.rs b/src/bin_compare.rs new file mode 100644 index 0000000..3c65ebc --- /dev/null +++ b/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> { + main_body() +} + +#[cfg(feature = "tracing")] +fn main() -> Result<(), Box> { + 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> { + 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> { + let mut stdin_contents = String::new(); + std::io::stdin() + .lock() + .read_to_string(&mut stdin_contents)?; + Ok(stdin_contents) +} + +fn run_anonymous_parse>(org_contents: P) -> Result<(), Box> { + 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>(org_path: P) -> Result<(), Box> { + 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(()) +} diff --git a/src/main.rs b/src/main.rs index fc6d4dd..e6e7880 100644 --- a/src/main.rs +++ b/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> { Ok(stdin_contents) } -#[cfg(feature = "compare")] fn run_anonymous_parse>(org_contents: P) -> Result<(), Box> { - 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>(org_contents: P) -> Result<(), Box> { - 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>(org_path: P) -> Result<(), Box> { 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>(org_path: P) -> Result<(), Box> { - 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.")?;