@shd101wyy/yo 0.1.27 → 0.1.28

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shd101wyy/yo",
   "displayName": "Yo",
-  "version": "0.1.27",
+  "version": "0.1.28",
   "main": "./out/cjs/index.cjs",
   "module": "./out/esm/index.mjs",
   "types": "./out/types/src/index.d.ts",

package/scripts/probe-parser-parity.ts

@@ -0,0 +1,61 @@
+// Probe: for each .yo file in tests/ and yo-self/, parse via TS and check
+// if yo-self's parser via `yo-self compile --emit-c --skip-c-compiler` also
+// succeeds (or fails for the same reason).
+//
+// We don't actually compile — we just lex+parse+evaluate enough to detect
+// parser errors. But yo-self's `compile` subcommand runs the full pipeline
+// which includes evaluation. So we use a lighter probe: try compiling
+// from a tiny stub `main.yo` that imports each file.
+//
+// Simpler: just use the TS parser. If any file fails to TS-parse, log it.
+// Then optionally compare with yo-self by running yo-self-bin and seeing
+// if it also fails.
+import Parser from "../src/parser";
+import * as fs from "fs";
+import * as path from "path";
+
+function walk(dir: string, files: string[] = []): string[] {
+  if (!fs.existsSync(dir)) return files;
+  const stat = fs.statSync(dir);
+  if (stat.isFile() && dir.endsWith(".yo")) {
+    files.push(dir);
+    return files;
+  }
+  if (stat.isDirectory()) {
+    for (const entry of fs.readdirSync(dir)) {
+      if ([".git", "node_modules", "out", "yo-out"].includes(entry)) continue;
+      walk(path.join(dir, entry), files);
+    }
+  }
+  return files;
+}
+
+const files = [
+  ...walk("tests"),
+  ...walk("yo-self"),
+];
+
+console.log(`Found ${files.length} .yo files\n`);
+let tsOk = 0, tsFail = 0;
+const tsFailures: { file: string; err: string }[] = [];
+
+for (const f of files) {
+  const src = fs.readFileSync(f, "utf-8");
+  try {
+    const p = new Parser({ inputString: src, modulePath: f });
+    p.getProgram();
+    tsOk++;
+  } catch (e) {
+    tsFail++;
+    tsFailures.push({ file: f, err: String(e).split("\n")[0].slice(0, 120) });
+  }
+}
+
+console.log(`TS parser: ${tsOk} OK, ${tsFail} fail`);
+if (tsFailures.length > 0 && tsFailures.length < 30) {
+  console.log("\nTS failures:");
+  for (const f of tsFailures.slice(0, 20)) {
+    console.log(`  ${f.file}`);
+    console.log(`    ${f.err}`);
+  }
+}

package/scripts/probe-yo-self-parser.sh

@@ -0,0 +1,33 @@
+#!/bin/bash
+# Run yo-self-bin fmt on every .yo file, count fail/success.
+BIN=/tmp/yo-self-fmt-bin
+OK=0; FAIL=0; FAILS=()
+
+while IFS= read -r f; do
+  # Copy to a temp so original isn't modified.
+  tmp="/tmp/yo_parse_probe_$$.yo"
+  cp "$f" "$tmp"
+  if "$BIN" fmt --check "$tmp" >/dev/null 2>&1 ; then
+    OK=$((OK+1))
+  else
+    # --check may exit 1 for "would format" — that's OK. Check stderr.
+    out=$("$BIN" fmt --check "$tmp" 2>&1)
+    rc=$?
+    if [ "$rc" = "0" ] || [ "$rc" = "1" ]; then
+      OK=$((OK+1))
+    else
+      FAIL=$((FAIL+1))
+      FAILS+=("$f: $out")
+    fi
+  fi
+  rm -f "$tmp"
+done < <(find tests yo-self -name "*.yo" 2>/dev/null)
+
+echo "OK: $OK   FAIL: $FAIL"
+if [ "$FAIL" -gt 0 ]; then
+  echo
+  echo "Failures (first 10):"
+  for f in "${FAILS[@]:0:10}"; do
+    echo "  - $f"
+  done
+fi

package/scripts/validate-yo-self-fmt.ts

@@ -0,0 +1,184 @@
+// One-off validation: extract each test() block from src/tests/formatter.test.ts,
+// run yo-self-bin fmt on the source, compare to the inline expected output.
+//
+// Usage: bun /tmp/validate-yo-self-fmt.ts
+import { spawnSync } from "child_process";
+import * as fs from "fs";
+
+const BIN = "/tmp/yo-self-fmt-bin";
+const TEST_FILE = "src/tests/formatter.test.ts";
+
+const source = fs.readFileSync(TEST_FILE, "utf-8");
+
+// Match each `test("name", () => { ... });` block at the top level.
+// Within: extract `const source = (template-literal);` and the final
+// `expect(formatYoSource(source)).toBe(template-literal);`.
+//
+// Template literals may contain newlines, embedded ${...}, and escaped backticks.
+// We use a state-machine over the source to find balanced backtick-delimited
+// template literals starting at a given position.
+function findTemplateLiteral(
+  s: string,
+  start: number
+): { value: string; end: number } | null {
+  if (s[start] !== "`") return null;
+  let i = start + 1;
+  while (i < s.length) {
+    const c = s[i];
+    if (c === "\\") {
+      i += 2;
+      continue;
+    }
+    if (c === "`") {
+      // Closing backtick.
+      return { value: s.slice(start, i + 1), end: i + 1 };
+    }
+    if (c === "$" && s[i + 1] === "{") {
+      // Skip the ${...} interpolation balanced by curlies.
+      let depth = 1;
+      i += 2;
+      while (i < s.length && depth > 0) {
+        if (s[i] === "{") depth++;
+        else if (s[i] === "}") depth--;
+        i++;
+      }
+      continue;
+    }
+    i++;
+  }
+  return null;
+}
+
+function findStringLiteral(
+  s: string,
+  start: number
+): { value: string; end: number } | null {
+  if (s[start] !== '"' && s[start] !== "'" && s[start] !== "`") return null;
+  if (s[start] === "`") return findTemplateLiteral(s, start);
+  const quote = s[start];
+  let i = start + 1;
+  while (i < s.length) {
+    if (s[i] === "\\") {
+      i += 2;
+      continue;
+    }
+    if (s[i] === quote) return { value: s.slice(start, i + 1), end: i + 1 };
+    i++;
+  }
+  return null;
+}
+
+// Parse all test("name", () => { ... }); blocks.
+//
+// Anchor matching on `test("name", () => {` so we don't mistake
+// `test("name", { … })` substrings that appear inside test source/expected
+// template literals (e.g. test 7's source includes a literal
+// `test("format effect", { … })`). The `() =>` arrow distinguishes a real
+// top-level `test()` call from the inner content.
+type TestCase = { name: string; source: string; expected: string };
+const cases: TestCase[] = [];
+const skipped: { name: string; reason: string }[] = [];
+
+const testStartRe = /test\("([^"]+)",\s*\(\s*\)\s*=>\s*\{/g;
+let m: RegExpExecArray | null;
+while ((m = testStartRe.exec(source)) !== null) {
+  const name = m[1];
+  const p = m.index + m[0].length;
+
+  // Find `const source = `...`;`
+  const srcMarker = "const source = ";
+  const srcIdx = source.indexOf(srcMarker, p);
+  if (srcIdx === -1) {
+    skipped.push({ name, reason: "no `const source = `" });
+    continue;
+  }
+  const srcLitStart = srcIdx + srcMarker.length;
+  const srcLit = findStringLiteral(source, srcLitStart);
+  if (!srcLit) {
+    skipped.push({ name, reason: "source is not a string literal" });
+    continue;
+  }
+
+  // Find the first `.toBe(` after the source declaration. Most tests use
+  // `expect(formatYoSource(source)).toBe(`<literal>`)` but some use the
+  // intermediate `const once = formatYoSource(source); expect(once).toBe(`<literal>`)`
+  // form — both are caught here because the first `.toBe(` carries the
+  // literal. Tests that compare two identifiers (e.g. `expect(twice).toBe(once)`
+  // for idempotency-only checks) have no literal to compare and are skipped.
+  const expMarker = ".toBe(";
+  const expIdx = source.indexOf(expMarker, srcLit.end);
+  if (expIdx === -1) {
+    skipped.push({ name, reason: "no `.toBe(` after source" });
+    continue;
+  }
+  let expLitStart = expIdx + expMarker.length;
+  while (/\s/.test(source[expLitStart])) expLitStart++;
+  const expLit = findStringLiteral(source, expLitStart);
+  if (!expLit) {
+    skipped.push({
+      name,
+      reason:
+        "`.toBe(` argument is not a string literal (idempotency-only test?)",
+    });
+    continue;
+  }
+
+  // eval the literals (template-strings with embedded vars: those aren't used
+  // in our test cases except for backslash-escaped backticks)
+  let srcValue: string, expectedValue: string;
+  try {
+    srcValue = eval(srcLit.value);
+    expectedValue = eval(expLit.value);
+  } catch (e) {
+    skipped.push({ name, reason: `eval failed: ${e}` });
+    continue;
+  }
+  cases.push({ name, source: srcValue, expected: expectedValue });
+}
+
+console.log(
+  `Extracted ${cases.length} test cases; skipped ${skipped.length}.\n`
+);
+if (skipped.length > 0) {
+  console.log("Skipped:");
+  for (const s of skipped) {
+    console.log(`  - ${s.name}: ${s.reason}`);
+  }
+  console.log();
+}
+
+// Run each through yo-self-bin
+let pass = 0,
+  fail = 0;
+const failures: { name: string; expected: string; actual: string }[] = [];
+
+for (const tc of cases) {
+  const tmpPath = `/tmp/yo_fmt_${Date.now()}_${Math.floor(Math.random() * 1e9)}.yo`;
+  fs.writeFileSync(tmpPath, tc.source);
+  spawnSync(BIN, ["fmt", tmpPath], { encoding: "utf-8" });
+  const actual = fs.readFileSync(tmpPath, "utf-8");
+  fs.unlinkSync(tmpPath);
+
+  if (actual === tc.expected) {
+    console.log(`✓ ${tc.name}`);
+    pass++;
+  } else {
+    console.log(`✗ ${tc.name}`);
+    failures.push({ name: tc.name, expected: tc.expected, actual });
+    fail++;
+  }
+}
+
+console.log(`\n${pass} passed, ${fail} failed, ${pass + fail} total\n`);
+
+if (failures.length > 0) {
+  console.log("=== first 5 failures ===\n");
+  for (const f of failures.slice(0, 5)) {
+    console.log(`--- ${f.name} ---`);
+    console.log("expected:");
+    console.log(JSON.stringify(f.expected));
+    console.log("actual:");
+    console.log(JSON.stringify(f.actual));
+    console.log();
+  }
+}