Add proper testing and syntax highlighting, interactivity

Author: bbqsrc

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "divvun-runtime"
-version = "0.2.2"
+version = "0.2.3"
 edition = "2024"
 repository = "https://github.com/divvun/divvun-runtime"
 license = "MIT OR Apache-2.0"
@@ -132,7 +132,7 @@ mod-jq = ["jaq-core", "jaq-std", "jaq-json"]
 ffi = []
 
 [workspace]
-members = [".", "cli", "xml-conv", "macros"]
+members = [".", "cli", "xml-conv", "macros", "crates/syntax-highlight"]
 
 [package.metadata.binstall]
 pkg-url = "{ repo }/releases/download/v{ version }/{ name }-{ target }-v{ version }{ archive-suffix }"

Cargo.toml

@@ -0,0 +1,15 @@
+{
+  "name": "@divvun/runtime",
+  "version": "0.0.1",
+  "description": "Divvun Runtime bindings for Deno",
+  "type": "module",
+  "license": "MIT OR Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/divvun/divvun-runtime"
+  },
+  "exports": {
+    ".": "./mod.ts",
+    "./test": "./test/mod.ts"
+  }
+}

bindings/deno/deno.jsonc

@@ -1,19 +1,17 @@
 import { Bundle } from "../mod.ts";
-export * from "jsr:@std/assert";
+export * from "jsr:@std/assert@1";
 
 let bundle: Bundle;
 
-const sleep = (ms: number) => new Promise((resolve) => setTimeout(() => resolve(null), ms))
-
-export function loadBundle(bundlePath: string) {
+export function loadBundle(bundlePath: string): () => Bundle {
   Deno.test.beforeAll(async () => {
     bundle = await Bundle.fromBundle(bundlePath);
   });
 
   return () => bundle;
 }
 
-export function loadPath(devPath: string) {
+export function loadPath(devPath: string): () => Bundle {
   Deno.test.beforeAll(async () => {
     bundle = await Bundle.fromPath(devPath);
   });
@@ -24,31 +22,3 @@ export function loadPath(devPath: string) {
 export function load(): () => Bundle {
   return loadPath(Deno.cwd());
 }
-
-export async function runGrammar(text: string): Promise<GrammarResponse[]> {
-  if (bundle == null) {
-    bundle = await Bundle.fromPath(Deno.cwd());
-  }
-
-  const pipe = await bundle.create();
-  const res = await pipe.forward(text);
-  return (await res.json()) as unknown as GrammarResponse[];
-}
-
-export type GrammarResponse = {
-  form: string;
-  beg: number;
-  end: number;
-  err: string;
-  msg: [string, string];
-  rep: string[];
-};
-
-type DivvunRuntimeModule = typeof import("../mod.ts");
-
-declare global {
-  interface Window {
-    _DRT?: DivvunRuntimeModule;
-  }
-  var _DRT: DivvunRuntimeModule | undefined;
-}

bindings/deno/test/mod.ts

@@ -14,6 +14,7 @@ ffi = ["divvun-runtime/ffi"]
 
 [dependencies]
 divvun-runtime = { default-features = false, path = ".." }
+syntax-highlight = { path = "../crates/syntax-highlight", features = ["terminal"] }
 clap = { version = "4.5.47", features = ["env", "derive"] }
 fwdansi = "1.1.0"
 termcolor = "1.4.1"

cli/Cargo.toml

@@ -1,5 +1,5 @@
 use std::{
-    io::{IsTerminal, Read},
+    io::{self, IsTerminal, Read},
     sync::{
         atomic::{AtomicBool, Ordering},
         Arc, Mutex,
@@ -25,9 +25,45 @@ use crate::{
 
 use super::utils;
 
-pub fn dump_ast(_shell: &mut Shell, args: DebugDumpAstArgs) -> anyhow::Result<()> {
+fn format_input_highlighted(input: &Input, command: Option<&Command>) -> String {
+    if !syntax_highlight::supports_color() {
+        return format!("{:#}", input);
+    }
+
+    match input {
+        Input::Json(j) => {
+            let json = serde_json::to_string_pretty(j).unwrap();
+            syntax_highlight::highlight_to_terminal(&json, "json")
+        }
+        Input::String(s) => {
+            let syntax = command
+                .and_then(|cmd| cmd.kind.as_deref())
+                .filter(|k| *k == "cg3");
+
+            if let Some("cg3") = syntax {
+                syntax_highlight::highlight_to_terminal(s, "cg3")
+            } else {
+                s.clone()
+            }
+        }
+        _ => format!("{:#}", input),
+    }
+}
+
+fn print_input_highlighted(
+    shell: &mut Shell,
+    input: &Input,
+    command: Option<&Command>,
+) -> anyhow::Result<()> {
+    let formatted = format_input_highlighted(input, command);
+    io::Write::write_all(shell.out(), formatted.as_bytes())?;
+    Ok(())
+}
+
+pub fn dump_ast(shell: &mut Shell, args: DebugDumpAstArgs) -> anyhow::Result<()> {
     let value = crate::deno_rt::dump_ast(&std::fs::read_to_string(args.path)?)?;
-    println!("{}", serde_json::to_string_pretty(&value).unwrap());
+    let json = serde_json::to_string_pretty(&value).unwrap();
+    shell.print_highlighted_stdout(&json, "json")?;
     Ok(())
 }
 
@@ -117,7 +153,12 @@ async fn run_repl(
         let tap_stepping = tap_stepping.clone();
 
         println!("\x1b[41;31m[{}]\x1b[0m {}", key, cmd);
-        println!("\x1b[33m{:#}\x1b[0m", event);
+        match event {
+            InputEvent::Input(input) => {
+                println!("{}", format_input_highlighted(input, Some(cmd)));
+            }
+            _ => println!("{:#}", event),
+        }
 
         // Store the event for the current run
         if let Ok(mut events) = current_events_clone.lock() {
@@ -211,10 +252,9 @@ async fn run_repl(
                     println!();
                 }
                 ":ast" => {
-                    println!(
-                        "{}\n",
-                        serde_json::to_string_pretty(&**bundle.definition()).unwrap()
-                    );
+                    let json = serde_json::to_string_pretty(&**bundle.definition()).unwrap();
+                    shell.print_highlighted_stdout(&json, "json")?;
+                    println!();
                 }
                 ":step" => {
                     let cur = is_stepping
@@ -228,7 +268,9 @@ async fn run_repl(
                     }
                 }
                 ":config" => {
-                    println!("{}\n", serde_json::to_string_pretty(&config).unwrap());
+                    let json = serde_json::to_string_pretty(&config).unwrap();
+                    shell.print_highlighted_stdout(&json, "json")?;
+                    println!();
                 }
                 ":save" => {
                     let filename = chunks.next().unwrap_or("pipeline_debug.md");
@@ -309,10 +351,13 @@ async fn run_repl(
         // };
         let mut stream = pipe.forward(Input::String(line.to_string())).await;
 
+        let output_cmd = bundle.definition().output.resolve(bundle.definition());
+
         while let Some(input) = stream.next().await {
             match input {
                 Ok(input) => {
-                    shell.print(&"<-", Some(&format!("{:#}", input)), Color::Green, false)?;
+                    shell.print(&"<-", None, Color::Green, false)?;
+                    print_input_highlighted(shell, &input, output_cmd)?;
 
                     if let Some(path) = args.output_path.as_deref() {
                         match input {
@@ -519,8 +564,10 @@ pub async fn run(shell: &mut Shell, mut args: RunArgs) -> Result<(), Arc<anyhow:
     if let Some(input) = args.input {
         let mut stream = pipe.forward(Input::String(input)).await;
 
+        let output_cmd = bundle.definition().output.resolve(bundle.definition());
+
         while let Some(Ok(input)) = stream.next().await {
-            println!("{:#}", input);
+            print_input_highlighted(shell, &input, output_cmd)?;
         }
 
         // if let Some(path) = args.output_path.as_deref() {

cli/src/command/run.rs

@@ -57,6 +57,8 @@ pub async fn test(_shell: &mut Shell, args: TestArgs) -> anyhow::Result<()> {
 
     let mut cmd = Command::new("deno");
     cmd.arg("test")
+        .arg("--hide-stacktraces")
+        .arg("--parallel")
         .arg("--allow-ffi")
         .arg("--allow-env")
         .arg("--no-check")