Serialize to wasm during wasm compare.

For some unknown reason, this makes rust-analyzer not angry.

src/bin_wasm.rs

@@ -1,9 +1,6 @@
-use wasm::wasm_parse_org;
+use organic::wasm::wasm_parse_org;
 use wasm_bindgen::prelude::wasm_bindgen;
 
-mod error;
-mod wasm;
-
 #[wasm_bindgen]
 pub fn parse_org(org_contents: &str) -> wasm_bindgen::JsValue {
     let rust_parsed = wasm_parse_org(org_contents);

src/bin_wasm_test.rs

@@ -2,7 +2,7 @@
 #![feature(exit_status_error)]
 use std::io::Read;
 
-use organic::wasm::compare::wasm_run_anonymous_compare;
+use organic::wasm_test::wasm_run_anonymous_compare;
 
 #[cfg(feature = "tracing")]
 use crate::init_tracing::init_telemetry;
@@ -36,8 +36,6 @@ async 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()?;
-        // let wasm_result = wasm_parse_org(org_contents.as_str());
-        // println!("{}", serde_json::to_string(&wasm_result)?);
         if wasm_run_anonymous_compare(org_contents).await? {
         } else {
             Err("Diff results do not match.")?;

src/compare/compare.rs

@@ -2,13 +2,13 @@ use std::path::Path;
 
 use crate::compare::diff::compare_document;
 use crate::compare::diff::DiffResult;
-use crate::compare::parse::emacs_parse_anonymous_org_document;
-use crate::compare::parse::emacs_parse_file_org_document;
 use crate::compare::sexp::sexp;
 use crate::context::GlobalSettings;
 use crate::context::LocalFileAccessInterface;
 use crate::parser::parse_file_with_settings;
 use crate::parser::parse_with_settings;
+use crate::util::emacs_parse_anonymous_org_document;
+use crate::util::emacs_parse_file_org_document;
 use crate::util::print_versions;
 
 pub async fn run_anonymous_compare<P: AsRef<str>>(

src/compare/mod.rs

@@ -4,7 +4,6 @@ mod compare_field;
 mod diff;
 mod elisp_fact;
 mod macros;
-mod parse;
 mod sexp;
 mod util;
 pub use compare::run_anonymous_compare;
@@ -13,3 +12,4 @@ pub use compare::run_compare_on_file;
 pub use compare::run_compare_on_file_with_settings;
 pub use compare::silent_anonymous_compare;
 pub use compare::silent_compare_on_file;
+pub use sexp::sexp;

src/compare/parse.rs

@@ -1,145 +0,0 @@
-use std::path::Path;
-
-use tokio::process::Command;
-
-use crate::context::HeadlineLevelFilter;
-use crate::settings::GlobalSettings;
-
-/// Generate elisp to configure org-mode parsing settings
-///
-/// Currently only org-list-allow-alphabetical is supported.
-fn global_settings_elisp(global_settings: &GlobalSettings) -> String {
-    // This string concatenation is wildly inefficient but its only called in tests 🤷.
-    let mut ret = "".to_owned();
-    if global_settings.list_allow_alphabetical {
-        ret += "(setq org-list-allow-alphabetical t)\n"
-    }
-    if global_settings.tab_width != crate::settings::DEFAULT_TAB_WIDTH {
-        ret += format!("(setq-default tab-width {})", global_settings.tab_width).as_str();
-    }
-    if global_settings.odd_levels_only != HeadlineLevelFilter::default() {
-        ret += match global_settings.odd_levels_only {
-            HeadlineLevelFilter::Odd => "(setq org-odd-levels-only t)\n",
-            HeadlineLevelFilter::OddEven => "(setq org-odd-levels-only nil)\n",
-        };
-    }
-    ret
-}
-
-pub(crate) async fn emacs_parse_anonymous_org_document<'g, 's, C>(
-    file_contents: C,
-    global_settings: &GlobalSettings<'g, 's>,
-) -> Result<String, Box<dyn std::error::Error>>
-where
-    C: AsRef<str>,
-{
-    let escaped_file_contents = escape_elisp_string(file_contents);
-    let elisp_script = format!(
-        r#"(progn
-     (erase-buffer)
-     (require 'org)
-     (defun org-table-align () t)
-     (insert "{escaped_file_contents}")
-     {global_settings}
-     (org-mode)
-     (message "%s" (pp-to-string (org-element-parse-buffer)))
-)"#,
-        escaped_file_contents = escaped_file_contents,
-        global_settings = global_settings_elisp(global_settings)
-    );
-    let mut cmd = Command::new("emacs");
-    let cmd = cmd
-        .arg("-q")
-        .arg("--no-site-file")
-        .arg("--no-splash")
-        .arg("--batch")
-        .arg("--eval")
-        .arg(elisp_script);
-    let out = cmd.output().await?;
-    let status = out.status.exit_ok();
-    if status.is_err() {
-        eprintln!(
-            "Emacs errored out: {}\n{}",
-            String::from_utf8(out.stdout)?,
-            String::from_utf8(out.stderr)?
-        );
-        status?;
-        unreachable!();
-    }
-    let org_sexp = out.stderr;
-    Ok(String::from_utf8(org_sexp)?)
-}
-
-pub(crate) async fn emacs_parse_file_org_document<'g, 's, P>(
-    file_path: P,
-    global_settings: &GlobalSettings<'g, 's>,
-) -> Result<String, Box<dyn std::error::Error>>
-where
-    P: AsRef<Path>,
-{
-    let file_path = file_path.as_ref().canonicalize()?;
-    let containing_directory = file_path.parent().ok_or(format!(
-        "Failed to get containing directory for path {}",
-        file_path.display()
-    ))?;
-    let elisp_script = format!(
-        r#"(progn
-     (require 'org)
-     (defun org-table-align () t)
-     (setq vc-handled-backends nil)
-     {global_settings}
-     (find-file-read-only "{file_path}")
-     (org-mode)
-     (message "%s" (pp-to-string (org-element-parse-buffer)))
-)"#,
-        global_settings = global_settings_elisp(global_settings),
-        file_path = file_path
-            .as_os_str()
-            .to_str()
-            .expect("File name should be valid utf-8.")
-    );
-    let mut cmd = Command::new("emacs");
-    let cmd = cmd
-        .current_dir(containing_directory)
-        .arg("-q")
-        .arg("--no-site-file")
-        .arg("--no-splash")
-        .arg("--batch")
-        .arg("--eval")
-        .arg(elisp_script);
-    let out = cmd.output().await?;
-    let status = out.status.exit_ok();
-    if status.is_err() {
-        eprintln!(
-            "Emacs errored out: {}\n{}",
-            String::from_utf8(out.stdout)?,
-            String::from_utf8(out.stderr)?
-        );
-        status?;
-        unreachable!();
-    }
-    let org_sexp = out.stderr;
-    Ok(String::from_utf8(org_sexp)?)
-}
-
-fn escape_elisp_string<C>(file_contents: C) -> String
-where
-    C: AsRef<str>,
-{
-    let source = file_contents.as_ref();
-    let source_len = source.len();
-    // We allocate a string 10% larger than the source to account for escape characters. Without this, we would have more allocations during processing.
-    let mut output = String::with_capacity(source_len + (source_len / 10));
-    for c in source.chars() {
-        match c {
-            '"' | '\\' => {
-                output.push('\\');
-                output.push(c);
-            }
-            _ => {
-                output.push(c);
-            }
-        }
-    }
-    output
-}

src/lib.rs

@@ -12,8 +12,10 @@ extern crate test;
 pub mod compare;
 #[cfg(any(feature = "compare", feature = "wasm_test"))]
 pub mod util;
-#[cfg(feature = "wasm_test")]
+#[cfg(any(feature = "wasm", feature = "wasm_test"))]
 pub mod wasm;
+#[cfg(feature = "wasm_test")]
+pub mod wasm_test;
 
 mod context;
 mod error;

src/util/mod.rs

@@ -1,5 +1,10 @@
+use std::path::Path;
+
 use tokio::process::Command;
 
+use crate::settings::GlobalSettings;
+use crate::settings::HeadlineLevelFilter;
+
 pub async fn print_versions() -> Result<(), Box<dyn std::error::Error>> {
     eprintln!("Using emacs version: {}", get_emacs_version().await?.trim());
     eprintln!(
@@ -45,3 +50,142 @@ pub(crate) async fn get_org_mode_version() -> Result<String, Box<dyn std::error:
     out.status.exit_ok()?;
     Ok(String::from_utf8(out.stderr)?)
 }
+
+pub(crate) async fn emacs_parse_anonymous_org_document<'g, 's, C>(
+    file_contents: C,
+    global_settings: &GlobalSettings<'g, 's>,
+) -> Result<String, Box<dyn std::error::Error>>
+where
+    C: AsRef<str>,
+{
+    let escaped_file_contents = escape_elisp_string(file_contents);
+    let elisp_script = format!(
+        r#"(progn
+     (erase-buffer)
+     (require 'org)
+     (defun org-table-align () t)
+     (insert "{escaped_file_contents}")
+     {global_settings}
+     (org-mode)
+     (message "%s" (pp-to-string (org-element-parse-buffer)))
+)"#,
+        escaped_file_contents = escaped_file_contents,
+        global_settings = global_settings_elisp(global_settings)
+    );
+    let mut cmd = Command::new("emacs");
+    let cmd = cmd
+        .arg("-q")
+        .arg("--no-site-file")
+        .arg("--no-splash")
+        .arg("--batch")
+        .arg("--eval")
+        .arg(elisp_script);
+    let out = cmd.output().await?;
+    let status = out.status.exit_ok();
+    if status.is_err() {
+        eprintln!(
+            "Emacs errored out: {}\n{}",
+            String::from_utf8(out.stdout)?,
+            String::from_utf8(out.stderr)?
+        );
+        status?;
+        unreachable!();
+    }
+    let org_sexp = out.stderr;
+    Ok(String::from_utf8(org_sexp)?)
+}
+
+pub(crate) async fn emacs_parse_file_org_document<'g, 's, P>(
+    file_path: P,
+    global_settings: &GlobalSettings<'g, 's>,
+) -> Result<String, Box<dyn std::error::Error>>
+where
+    P: AsRef<Path>,
+{
+    let file_path = file_path.as_ref().canonicalize()?;
+    let containing_directory = file_path.parent().ok_or(format!(
+        "Failed to get containing directory for path {}",
+        file_path.display()
+    ))?;
+    let elisp_script = format!(
+        r#"(progn
+     (require 'org)
+     (defun org-table-align () t)
+     (setq vc-handled-backends nil)
+     {global_settings}
+     (find-file-read-only "{file_path}")
+     (org-mode)
+     (message "%s" (pp-to-string (org-element-parse-buffer)))
+)"#,
+        global_settings = global_settings_elisp(global_settings),
+        file_path = file_path
+            .as_os_str()
+            .to_str()
+            .expect("File name should be valid utf-8.")
+    );
+    let mut cmd = Command::new("emacs");
+    let cmd = cmd
+        .current_dir(containing_directory)
+        .arg("-q")
+        .arg("--no-site-file")
+        .arg("--no-splash")
+        .arg("--batch")
+        .arg("--eval")
+        .arg(elisp_script);
+    let out = cmd.output().await?;
+    let status = out.status.exit_ok();
+    if status.is_err() {
+        eprintln!(
+            "Emacs errored out: {}\n{}",
+            String::from_utf8(out.stdout)?,
+            String::from_utf8(out.stderr)?
+        );
+        status?;
+        unreachable!();
+    }
+    let org_sexp = out.stderr;
+    Ok(String::from_utf8(org_sexp)?)
+}
+
+fn escape_elisp_string<C>(file_contents: C) -> String
+where
+    C: AsRef<str>,
+{
+    let source = file_contents.as_ref();
+    let source_len = source.len();
+    // We allocate a string 10% larger than the source to account for escape characters. Without this, we would have more allocations during processing.
+    let mut output = String::with_capacity(source_len + (source_len / 10));
+    for c in source.chars() {
+        match c {
+            '"' | '\\' => {
+                output.push('\\');
+                output.push(c);
+            }
+            _ => {
+                output.push(c);
+            }
+        }
+    }
+    output
+}
+
+/// Generate elisp to configure org-mode parsing settings
+///
+/// Currently only org-list-allow-alphabetical is supported.
+fn global_settings_elisp(global_settings: &GlobalSettings) -> String {
+    // This string concatenation is wildly inefficient but its only called in tests 🤷.
+    let mut ret = "".to_owned();
+    if global_settings.list_allow_alphabetical {
+        ret += "(setq org-list-allow-alphabetical t)\n"
+    }
+    if global_settings.tab_width != crate::settings::DEFAULT_TAB_WIDTH {
+        ret += format!("(setq-default tab-width {})", global_settings.tab_width).as_str();
+    }
+    if global_settings.odd_levels_only != HeadlineLevelFilter::default() {
+        ret += match global_settings.odd_levels_only {
+            HeadlineLevelFilter::Odd => "(setq org-odd-levels-only t)\n",
+            HeadlineLevelFilter::OddEven => "(setq org-odd-levels-only nil)\n",
+        };
+    }
+    ret
+}

src/wasm/mod.rs

@@ -9,8 +9,6 @@ mod clock;
 mod code;
 mod comment;
 mod comment_block;
-#[cfg(feature = "wasm_test")]
-pub mod compare;
 mod diary_sexp;
 mod document;
 mod drawer;
@@ -64,7 +62,7 @@ mod underline;
 mod verbatim;
 mod verse_block;
 
-pub(crate) use parse_result::wasm_parse_org;
-pub(crate) use parse_result::ParseResult;
+pub use parse_result::wasm_parse_org;
+pub use parse_result::ParseResult;
 pub(crate) use to_wasm::ToWasm;
 pub(crate) use to_wasm::ToWasmContext;

src/wasm/parse_result.rs

@@ -8,7 +8,7 @@ use crate::settings::GlobalSettings;
 
 #[derive(Debug, Serialize)]
 #[serde(tag = "status", content = "content")]
-pub(crate) enum ParseResult<'s> {
+pub enum ParseResult<'s> {
     #[serde(rename = "success")]
     Success(WasmDocument<'s>),
 
@@ -16,7 +16,7 @@ pub(crate) enum ParseResult<'s> {
     Error(String),
 }
 
-pub(crate) fn wasm_parse_org(org_contents: &str) -> ParseResult<'_> {
+pub fn wasm_parse_org(org_contents: &str) -> ParseResult<'_> {
     let global_settings = GlobalSettings::default();
     let to_wasm_context = ToWasmContext::new(org_contents);
     let rust_parsed = match parse_with_settings(org_contents, &global_settings)

src/wasm_test/runner.rs

@@ -1,6 +1,11 @@
+use crate::compare::sexp;
 use crate::context::GlobalSettings;
 use crate::parser::parse_with_settings;
+use crate::util::emacs_parse_anonymous_org_document;
 use crate::util::print_versions;
+use crate::wasm::ParseResult;
+use crate::wasm::ToWasm;
+use crate::wasm::ToWasmContext;
 
 pub async fn wasm_run_anonymous_compare<P: AsRef<str>>(
     org_contents: P,
@@ -20,13 +25,19 @@ pub async fn wasm_run_anonymous_compare_with_settings<'g, 's, P: AsRef<str>>(
         print_versions().await?;
     }
     let rust_parsed = parse_with_settings(org_contents, global_settings)?;
-    // let org_sexp = emacs_parse_anonymous_org_document(org_contents, global_settings).await?;
-    // let (_remaining, parsed_sexp) = sexp(org_sexp.as_str()).map_err(|e| e.to_string())?;
+    let to_wasm_context = ToWasmContext::new(org_contents);
+    let wasm_parsed = match rust_parsed.to_wasm(to_wasm_context) {
+        Ok(wasm_document) => ParseResult::Success(wasm_document),
+        Err(err) => ParseResult::Error(format!("{:?}", err)),
+    };
+    let org_sexp = emacs_parse_anonymous_org_document(org_contents, global_settings).await?;
+    let (_remaining, parsed_sexp) = sexp(org_sexp.as_str()).map_err(|e| e.to_string())?;
 
     if !silent {
         println!("{}\n\n\n", org_contents);
-        // println!("{}", org_sexp);
+        println!("{}", org_sexp);
         println!("{:#?}", rust_parsed);
+        println!("{}", serde_json::to_string(&wasm_parsed)?);
     }
 
     // We do the diffing after printing out both parsed forms in case the diffing panics