9682cec | plum | pyrossh

git clone https://git.pyrossh.dev/plum

A statically typed, imperative programming language inspired by rust, python

9682cec — Peter John 2026-09-04T15:12:26+05:30

feat(plum-cli): colored test output, actual/expected values on failure

Files changed (4) hide show

README.md +3 -1
examples/testing.plum +1 -1
plum-cli/src/main.rs +14 -6
plum-wasm-codegen/src/lib.rs +53 -2

README.md CHANGED Viewed

@@ -218,11 +218,13 @@ test "add works"
 $ plum test examples/testing.plum
 └─ add works ✘
       add(2, 2) == 5
+            Expected: 5
+            Actual:   4
 0 passed, 1 failed
 ```
-`assert` is a single statement with two behaviors depending on context. Outside a `test` block, a failing `assert` traps immediately, everywhere in the language, the same as it always has (`assert n > 0` above). Inside a `test` block, it's non-fatal instead: a failure is recorded as its own literal condition text, and the rest of the block keeps running, so one `test` can report every failing assertion in it, not just the first. `plum test`'s output is a tree, one `├─`/`└─` line per test with `✔`/`✘`, a failure listing each recorded assert's condition underneath, followed by a `N passed, M failed` summary, with a non-zero exit code if anything failed.
+`assert` is a single statement with two behaviors depending on context. Outside a `test` block, a failing `assert` traps immediately, everywhere in the language, the same as it always has (`assert n > 0` above). Inside a `test` block, it's non-fatal instead: a failure is recorded — the condition's own source text, plus (for a top-level `==`/`!=`/`<`/... comparison) each side's own runtime value via its `.toStr()`, labeled `Expected`/`Actual` (right/left) — and the rest of the block keeps running, so one `test` can report every failing assertion in it, not just the first. `plum test`'s output is a tree, one `├─`/`└─` line per test with `✔`/`✘` (green/red in a real terminal), a failure listing each recorded assert underneath, followed by a `N passed, M failed` summary, with a non-zero exit code if anything failed. The actual/expected values aren't shown when either side is obviously a `Float` literal — string interpolation, which this reuses, doesn't support `Float` yet (see Known gaps) — a computed-`Float`-vs-computed-`Float` comparison with no literal on either side isn't caught by that guard, so it's the one remaining way this feature can't show values (the condition text itself is unaffected either way).
 Full example: [`examples/testing.plum`](examples/testing.plum).

examples/testing.plum CHANGED Viewed

@@ -5,7 +5,7 @@ fun isEven(n: Int) -> Bool =
   n % 2 == 0
 test "add works"
-  assert add(1, 2) == 4
+  assert add(1, 2) == 3
   assert add(2, 2) == 4
 test "isEven works"

plum-cli/src/main.rs CHANGED Viewed

@@ -3,7 +3,7 @@
 #![allow(non_snake_case)]
 use std::fs;
-use std::io::{self, Read};
+use std::io::{self, IsTerminal, Read};
 use std::process;
 use anyhow::{Context, Result};
@@ -577,6 +577,13 @@ fn cmdTest(file: std::path::PathBuf, lib_path: std::path::PathBuf) -> Result<()>
     // corner), "✔"/"✘" for the outcome, and a failure's report indented under
     // a continuation "│" (or blank once past the last test) so it visually
     // nests under its own branch rather than reading like a new top-level line.
+    // Colored green/red like every other test runner's PASS/FAIL — but only
+    // when stdout is a real terminal, so piping `plum test` into a file/CI log
+    // doesn't fill it with raw escape codes.
+    let color = io::stdout().is_terminal();
+    let green = |s: &str| if color { format!("\x1b[32m{s}\x1b[0m") } else { s.to_string() };
+    let red = |s: &str| if color { format!("\x1b[31m{s}\x1b[0m") } else { s.to_string() };
     let mut passed = 0usize;
     let mut failed = 0usize;
     let last = names.len() - 1;
@@ -600,25 +607,26 @@ fn cmdTest(file: std::path::PathBuf, lib_path: std::path::PathBuf) -> Result<()>
             Ok(()) => {
                 let report = readStrResult(&mut store, &results[0])?;
                 if report.is_empty() {
-                    println!("{branch} {name} \u{2714}");
+                    println!("{branch} {name} {}", green("\u{2714}"));
                     passed += 1;
                 } else {
-                    println!("{branch} {name} \u{2718}");
+                    println!("{branch} {name} {}", red("\u{2718}"));
                     for line in report.lines() {
-                        println!("{cont}   {line}");
+                        println!("{cont}   {}", red(line));
                     }
                     failed += 1;
                 }
             }
             Err(trap) => {
-                println!("{branch} {name} \u{2718} PANIC: {trap}");
+                println!("{branch} {name} {} PANIC: {trap}", red("\u{2718}"));
                 failed += 1;
             }
         }
     }
     println!();
-    println!("{passed} passed, {failed} failed");
+    let summary = format!("{passed} passed, {failed} failed");
+    println!("{}", if failed > 0 { red(&summary) } else { green(&summary) });
     if failed > 0 {
         process::exit(1);
     }

plum-wasm-codegen/src/lib.rs CHANGED Viewed

@@ -910,6 +910,58 @@ fn strLit(s: String) -> ast::Expr {
     ast::Expr::String(ast::StringExpr { parts: vec![ast::StringPart::Text(s)] })
 }
+/// True if `expr` is OBVIOUSLY float-valued from its own AST shape alone (a
+/// bare float literal) — no real type inference, just enough to catch the
+/// overwhelmingly common `assert computed() == 1.5` shape. `"{expr}"` string
+/// interpolation doesn't support `Float` yet (see README's Known gaps), so
+/// `assertFailureMessage` skips the actual/expected enhancement whenever
+/// either side looks like one, rather than break compiling a real test that
+/// compares a float against a literal (a computed-float-vs-computed-float
+/// comparison with no literal on either side isn't caught by this — a
+/// narrower residual gap, not a new one: interpolating that value was never
+/// going to work either way).
+fn looksLikeFloat(expr: &ast::Expr) -> bool {
+    match expr {
+        ast::Expr::Float(_) => true,
+        // `-1.5` parses as a unary negation wrapping the literal, not a bare
+        // `Expr::Float` itself.
+        ast::Expr::Unary(u) => looksLikeFloat(&u.operand),
+        _ => false,
+    }
+}
+/// Builds a failing `assert`'s report line: the literal condition text, plus —
+/// when the condition is a top-level comparison (`left OP right`) whose sides
+/// aren't obviously `Float` (see `looksLikeFloat`) — the ACTUAL (left) and
+/// EXPECTED (right) sides' own runtime values underneath, `assert computed()
+/// == literal` being the overwhelmingly common shape a test writes such a
+/// comparison in. Reuses `"{expr}"` string interpolation's own existing
+/// codegen (rather than any special stringification of its own) — so this
+/// shows a value for any type interpolation already supports today, and
+/// fails to compile with that same, ordinary interpolation error for a type
+/// it doesn't (no separate risk introduced beyond what `looksLikeFloat`
+/// already guards against). A non-comparison condition (`assert isEven(4)`)
+/// has no meaningful actual/expected split — a boolean condition is always
+/// false by the time this fires — so it's just the bare text.
+fn assertFailureMessage(c: &ast::Check) -> ast::Expr {
+    let ast::Expr::Compare(cmp) = &c.cond else {
+        return strLit(format!("{}\n", c.text));
+    };
+    if looksLikeFloat(&cmp.left) || looksLikeFloat(&cmp.right) {
+        return strLit(format!("{}\n", c.text));
+    }
+    ast::Expr::String(ast::StringExpr {
+        parts: vec![
+            ast::StringPart::Text(format!("{}\n", c.text)),
+            ast::StringPart::Text("      Expected: ".to_string()),
+            ast::StringPart::Interp(cmp.right.clone()),
+            ast::StringPart::Text("\n      Actual:   ".to_string()),
+            ast::StringPart::Interp(cmp.left.clone()),
+            ast::StringPart::Text("\n".to_string()),
+        ],
+    })
+}
 fn desugarTestsToFns(source: &ast::Source) -> (ast::Source, Vec<(String, String)>) {
     let mut items = Vec::with_capacity(source.items.len());
     let mut extra_exports = Vec::new();
@@ -955,13 +1007,12 @@ fn desugarTestsToFns(source: &ast::Source) -> (ast::Source, Vec<(String, String)
 fn desugarAssertStmt(stmt: &ast::Stmt) -> ast::Stmt {
     match stmt {
         ast::Stmt::Assert(c) => {
-            let message = format!("{}\n", c.text);
             let appendReport = ast::Stmt::Assign(ast::Assign {
                 targets: vec![ast::AssignTarget::Var("__report".to_string())],
                 values: vec![ast::Expr::Binary(Box::new(ast::BinaryExpr {
                     op: ast::BinOp::Add,
                     left: ast::Expr::Var("__report".to_string()),
-                    right: strLit(message),
+                    right: assertFailureMessage(c),
                 }))],
                 declare: false,
             });