tewip-ai 0.42.0 → 0.43.0

package/README.md

@@ -995,6 +995,9 @@ tewip vouch tests/            # or a file, or the whole project
 tewip vouch tests/ --strict   # exits non-zero, for a merge gate
 ```
 
+Reads **JavaScript, TypeScript, Python, Java, Kotlin, Scala, Go, C#, Ruby, PHP and Rust** — and says
+so, rather than clearing a file it cannot read.
+
 Most tests in a pull request are now written by an agent, and the question that decides whether they
 are worth anything goes unasked: **could this test ever fail?** Coverage counts a test that checks
 nothing. CI goes green on it. A reviewer skims something plausible and approves it.

package/dist/cli/help.js

@@ -185,8 +185,9 @@ Usage:
                                     that check nothing, compare a value with itself, leave an
                                     expectation unfinished, swallow their own failure, or never run.
                                     Where the checking is in a helper it cannot follow it says so
-                                    instead of accusing. --strict exits non-zero on a finding, for a
-                                    gate. No model, no cost.
+                                    instead of accusing. Reads JavaScript, TypeScript, Python, Java,
+                                    Kotlin, Scala, Go, C#, Ruby, PHP and Rust. --strict exits
+                                    non-zero on a finding, for a gate. No model, no cost.
   tewip trace [--only "<ticket or title>"] [--out trace.md]
                                     Is this requirement covered, and is it passing right now? Joins
                                     the plans Tewip wrote to the tests that cover them and the runs

package/dist/engine/vouch/assertions.js

@@ -38,10 +38,35 @@ const CHECKS = [
     // Go.
     /\bt\s*\.\s*(Error|Errorf|Fatal|Fatalf|Fail|FailNow)\b/,
     /\b(require|assert)\s*\.\s*[A-Z]\w+\s*\(/,
-    // Ruby, PHP, Rust.
-    /\bexpect\s*\(.*\)\s*\.\s*to\b/,
-    /\b\$this\s*->\s*assert/,
+    // Ruby. The snake_case family is the whole of minitest and most of Rails's own suite, and
+    // `assert_equal "x", y` has no parentheses - so the generic `assert` patterns above, which all
+    // want a `.` or a `(`, matched none of it. Without this, 121 of the 154 real tests in Rails's
+    // activesupport string_ext_test.rb were reported as comparing no value. That is the Phase 8
+    // lesson for the fourth time: a missing entry here does not produce a smaller answer, it
+    // produces a confident wrong one.
+    /\b(assert|refute)_\w+/,
+    /\bassert\s+[^=\n]/,
+    /\bexpect\s*\(.*\)\s*\.\s*(to|not_to|to_not)\b/,
+    // RSpec's block form, which is how every raise_error, change and output matcher is written:
+    // `expect { thing }.to raise_error(...)`. Missing it reported rspec-core's own specs - the
+    // reference implementation - as containing tests that cannot fail.
+    /\bexpect\s*\{[\s\S]*?\}\s*\.\s*(to|not_to|to_not)\b/,
+    /\bis_expected\s*\.\s*to\b/,
+    /\.\s*(must_equal|must_be|wont_equal|wont_be)\b/,
+    // PHP: PHPUnit on the instance or statically, and Pest's expectation chain.
+    //
+    // No `\b` before the `$`. A word boundary needs a word character on one side, `$` is not one,
+    // and the character before it in real code is a space - so `/\b\$this/` matched nothing, ever.
+    // This pattern was on the list from the start and had never once fired: 88 of the 128 real tests
+    // in laravel/framework's SupportStrTest came back as "Tewip would not judge" because the
+    // `assertSame(...)` in them was being read as an unknown helper that might assert.
+    /\$this\s*->\s*assert/,
+    /\b(?:self|static|Assert)\s*::\s*assert/,
+    /\bexpect\s*\(.*\)\s*->\s*\w+/,
+    // Rust. A #[should_panic] test asserts by panicking, so it can fail without an assert in it.
     /\bassert(_eq|_ne|_matches)?!\s*\(/,
+    /\bdebug_assert(_eq|_ne)?!\s*\(/,
+    /#\s*\[\s*should_panic/,
     // Robot Framework and other keyword styles: a line that reads as a check.
     /^\s*Should\s+(Be|Not|Contain|Match)\b/im,
 ];

package/dist/engine/vouch/find-tests.js

@@ -0,0 +1,274 @@
+// Phase 22 and after: finding the tests inside a file, in each language's own shape.
+//
+// Split out of tests-in.ts, which passed this project's 300-line rule when Ruby, PHP and Rust were
+// added. tests-in.ts keeps the questions every language shares - which language is this, does it
+// look like tests at all, which parts of it are text rather than code - and this file holds the
+// four readers: callbacks (JavaScript), indentation (Python), `end` (Ruby), and braces (the rest).
+import { braced, isText, lineAt, textRanges } from './tests-in.js';
+/**
+ * `it('...', async () => { ... })` and its many spellings, including `test.each`, `it.skip` and a
+ * plain `function ()` callback. The body is taken by matching braces from the callback's opening one.
+ */
+function jsTests(text) {
+    const found = [];
+    const ranges = textRanges(text);
+    const declaration = /\b(it|test|specify)\s*(\.\s*(skip|only|todo|failing|concurrent|each|for)\s*(\([^)]*\)|`[^`]*`)?\s*)*\(\s*(['"`])((?:\\.|(?!\5)[^\\])*)\5/g;
+    for (const hit of text.matchAll(declaration)) {
+        const at = hit.index ?? 0;
+        if (isText(ranges, at))
+            continue;
+        const open = text.indexOf('{', at + hit[0].length);
+        if (open === -1)
+            continue;
+        const body = braced(text, open);
+        if (body === null)
+            continue;
+        const signature = text.slice(at + hit[0].length, open);
+        found.push({
+            name: hit[6],
+            line: lineAt(text, at),
+            body,
+            skipped: /\.\s*(skip|todo|failing)\b/.test(hit[0]) || /\bxit\s*\(/.test(hit[0]),
+            callback: /\(\s*([A-Za-z_$][\w$]*)\s*\)\s*(=>)?\s*$/.exec(signature.trim())?.[1] ?? '',
+        });
+    }
+    // `xit(...)` and `xtest(...)`, which the pattern above deliberately does not match.
+    for (const hit of text.matchAll(/\bx(it|test)\s*\(\s*(['"`])((?:\\.|(?!\2)[^\\])*)\2/g)) {
+        const at = hit.index ?? 0;
+        if (isText(ranges, at))
+            continue;
+        const open = text.indexOf('{', at + hit[0].length);
+        const body = open === -1 ? null : braced(text, open);
+        found.push({ name: hit[3], line: lineAt(text, at), body: body ?? '', skipped: true, callback: '' });
+    }
+    return found.sort((a, b) => a.line - b.line);
+}
+/** Python has no braces: a test's body is everything indented further than its `def`. */
+function pythonTests(text) {
+    const lines = text.split(String.fromCharCode(10));
+    const ranges = textRanges(text);
+    const offsets = [];
+    let seen = 0;
+    for (const line of lines) {
+        offsets.push(seen);
+        seen += line.length + 1;
+    }
+    const found = [];
+    for (let i = 0; i < lines.length; i += 1) {
+        const hit = /^(\s*)(?:async\s+)?def\s+(test_\w+|test)\s*\(/.exec(lines[i]);
+        if (!hit)
+            continue;
+        if (isText(ranges, offsets[i] + hit[1].length + 1))
+            continue;
+        const indent = hit[1].length;
+        // Nested in another def? Then it is a helper or, in Click's tests, a CLI command that happens to
+        // be named `test`. Only a module-level def, or a method of a test class, is a test.
+        if (nestedInFunction(lines, i, indent))
+            continue;
+        if (hit[2] === 'test' && indent > 0)
+            continue;
+        // A def whose parameters run over several lines ends at the line that closes them, and the body
+        // starts after that. Without this, the parameter list was read as the body and the real body was
+        // thrown away: psf/requests has several, and each came back as a test that compares no value.
+        let signatureEnds = i;
+        let open = 0;
+        for (let j = i; j < lines.length && j < i + 20; j += 1) {
+            open += (lines[j].match(/\(/g) ?? []).length - (lines[j].match(/\)/g) ?? []).length;
+            signatureEnds = j;
+            if (open <= 0)
+                break;
+        }
+        const body = [];
+        for (let j = signatureEnds + 1; j < lines.length; j += 1) {
+            const line = lines[j];
+            if (line.trim() === '') {
+                body.push(line);
+                continue;
+            }
+            const width = line.length - line.trimStart().length;
+            if (width <= indent)
+                break;
+            body.push(line);
+        }
+        // Decorators sit above the def, so skipping is read upwards.
+        const above = lines.slice(Math.max(0, i - 4), i).join(String.fromCharCode(10));
+        // A conditional skip runs somewhere - `skipif` on Windows registry tests in psf/requests runs
+        // on Windows - so only an unconditional skip means the test never runs. `xfail` runs too.
+        const skipped = /@\s*(pytest\s*\.\s*mark\s*\.\s*skip|unittest\s*\.\s*skip)\b/.test(above) && !/skipif|skipUnless|xfail/.test(above);
+        found.push({ name: hit[2], line: i + 1, body: body.join(String.fromCharCode(10)), skipped, callback: '' });
+    }
+    return found;
+}
+/** Is the def on line `i` nested inside another def, rather than inside a class or at the top? */
+function nestedInFunction(lines, i, indent) {
+    for (let j = i - 1; j >= 0; j -= 1) {
+        const line = lines[j];
+        if (line.trim() === '')
+            continue;
+        const width = line.length - line.trimStart().length;
+        if (width >= indent)
+            continue;
+        return /^\s*(async\s+)?def\s/.test(line);
+    }
+    return false;
+}
+/**
+ * Ruby, in both of the two shapes that cover nearly all of it: minitest's `def test_name ... end`
+ * and RSpec's `it "name" do ... end`. Rails's own activesupport tests are the first; rspec-core's
+ * own specs are the second.
+ *
+ * The body runs to the `end` that lines up with the opener's indentation. Counting `do`, `def`,
+ * `if`, `case` and the rest against `end` would be the thorough way and is a poor trade: Ruby has
+ * one-line `if` modifiers, `end` inside strings, and heredocs, so a counter gets it wrong on real
+ * code in ways that are hard to see. Matching the indentation is right for conventionally
+ * formatted Ruby, which is nearly all Ruby, and when it cannot find the closing `end` the test is
+ * skipped rather than judged on a body that was guessed at.
+ */
+function rubyTests(text) {
+    /** Each accepted test with the line its `end` sits on, so a nested one can be recognised. */
+    const found = [];
+    const lines = text.split(String.fromCharCode(10));
+    const ranges = textRanges(text);
+    const offsets = [];
+    let seen = 0;
+    for (const line of lines) {
+        offsets.push(seen);
+        seen += line.length + 1;
+    }
+    for (let i = 0; i < lines.length; i += 1) {
+        //  def test_foo            minitest
+        //  it "does a thing" do    RSpec
+        //  test "does a thing" do  Rails and minitest's spec syntax
+        //  specify { ... }         is deliberately not here: a one-line specify has no body to read.
+        const hit = /^(\s*)(?:(?:x|f)?(it|test|scenario|example)\s*[("']|def\s+(test_\w+))/.exec(lines[i]);
+        if (!hit)
+            continue;
+        if (isText(ranges, offsets[i] + hit[1].length))
+            continue;
+        const indent = hit[1].length;
+        let close = -1;
+        for (let j = i + 1; j < lines.length; j += 1) {
+            const line = lines[j];
+            if (line.trim() === '')
+                continue;
+            if (/^\s*end\b/.test(line) && line.length - line.trimStart().length === indent) {
+                close = j;
+                break;
+            }
+        }
+        if (close === -1)
+            continue;
+        // An `it` inside another `it` is not a test. rspec-core's own specs define one as a fixture -
+        // `describe_successfully do it "..." do sequence << :example end end` - and the assertion that
+        // matters is in the enclosing test. Python's finder skips nested defs for the same reason.
+        if (found.some((earlier) => i > earlier.line - 1 && i < earlier.endsAt))
+            continue;
+        const body = lines.slice(i + 1, close).join(String.fromCharCode(10));
+        const named = hit[3] ?? /^\s*(?:x|f)?(?:it|test|scenario|example)\s*[("']\s*["']?([^"')]*)/.exec(lines[i])?.[1]?.trim();
+        found.push({
+            endsAt: close,
+            name: (named ?? '').trim() === '' ? 'unnamed' : named,
+            line: i + 1,
+            body,
+            // `xit` turns a test off. A bare `skip` does too - but only at the top level of the body.
+            // rspec-core's own specs pass a block containing `skip "because"` to a helper, as the
+            // fixture whose behaviour the test is checking, and the test around it asserts plenty.
+            // Reading that as "this test never runs" condemned the reference implementation.
+            skipped: /^\s*(?:x(?:it|specify|example)|skip\b)/.test(lines[i]) || skipsAtTopLevel(body),
+            callback: '',
+        });
+    }
+    return found;
+}
+/**
+ * How each language says "this is a test".
+ *
+ * Rust and PHP join the braced finder rather than getting one of their own, because both mark a
+ * test the way the JVM languages do: an attribute or a naming convention, then a braced body. Only
+ * the marker differs.
+ */
+const DECLARES = {
+    // Rust marks a test with an attribute. `#[bench]` is left out for the same reason Go's Benchmark
+    // is: it measures rather than checks, and calling it assertion-free is true and useless.
+    rust: /#\s*\[\s*(?:test|tokio::test|async_std::test|rstest)\s*\]/g,
+    // PHPUnit accepts three markers and real suites use all of them: the testFoo naming convention
+    // (laravel/framework does this), the #[Test] attribute of PHPUnit 10, and the @test docblock.
+    php: /(?:#\s*\[\s*Test[^\]]*\]|\*\s*@test\b|(?:public|protected|private)?\s*function\s+test\w*\s*\()/g,
+};
+/** JUnit, Kotlin, Scala, Go, C#, PHP and Rust: an annotation or a naming convention, then a braced body. */
+function bracedTests(language, text) {
+    const found = [];
+    const ranges = textRanges(text, language);
+    const declaration = DECLARES[language] ??
+        (language === 'go'
+            ? // Only a Test function. A Benchmark asserts nothing by design, an Example is checked against
+                // its own Output comment, and a Fuzz target is not a test - all three were condemned as
+                // "checks nothing" in gorilla/mux before this narrowed.
+                /\bfunc\s+(Test)(\w+)\s*\(\s*\w+\s+\*testing\.[TB]\s*\)\s*\{/g
+            : /(@Test\b[^\n]*|\[\s*(?:Test|Fact|Theory)[^\]]*\]|@(?:ParameterizedTest|RepeatedTest)\b)/g);
+    for (const hit of text.matchAll(declaration)) {
+        const at = hit.index ?? 0;
+        if (isText(ranges, at))
+            continue;
+        // Where the body starts. Go's marker already includes the brace. Rust and PHP put a signature
+        // after the marker, and in PHP the marker may itself *be* the signature, so searching from the
+        // end of the match covers both.
+        const open = language === 'go'
+            ? text.indexOf('{', at)
+            : language === 'rust' || language === 'php'
+                ? text.indexOf('{', at + hit[0].length)
+                : text.indexOf('{', text.indexOf('(', at + hit[0].length));
+        if (open === -1)
+            continue;
+        const body = braced(text, open);
+        if (body === null)
+            continue;
+        const signature = text.slice(at, open);
+        // `void foo() throws IOException` still names foo. Without allowing the throws clause, every
+        // checked-exception test in gson was reported as 'unnamed'.
+        const name = language === 'go'
+            ? hit[1] + hit[2]
+            : language === 'rust'
+                ? // ripgrep generates whole families of tests from a macro, where the name in the source
+                    // is literally `$name`. Reporting that is more honest than inventing one.
+                    /\bfn\s+(\$?\w+)/.exec(text.slice(at, open))?.[1] ?? 'unnamed'
+                : language === 'php'
+                    ? /\bfunction\s+(\w+)/.exec(text.slice(at, open))?.[1] ?? 'unnamed'
+                    : (/([\w]+)\s*\([^)]*\)\s*(throws\s+[\w.,\s]+)?$/.exec(signature.trim())?.[1] ?? 'unnamed');
+        const around = text.slice(Math.max(0, at - 200), open);
+        // An annotation disables a test outright. A `t.Skip()` may be conditional - cobra's
+        // TestDeadcodeElimination skips on Windows and runs everywhere else - so it counts only when it
+        // is unconditional, at the top level of the body.
+        const skipped = /@(Disabled|Ignore)\b|\[\s*Ignore\b/.test(around) || skipsUnconditionally(body);
+        found.push({ name, line: lineAt(text, at), body, skipped, callback: '' });
+    }
+    return found;
+}
+/**
+ * A `t.Skip()` that runs whatever happens: at the top level of the body, not inside an `if`. Go
+ * tests commonly skip on one platform and run on the others, and calling those "never runs" is
+ * wrong.
+ */
+function skipsUnconditionally(body) {
+    let depth = 0;
+    for (const line of body.split(String.fromCharCode(10))) {
+        const text = line.trim();
+        if (depth === 0 && /^\w+\s*\.\s*Skip(Now)?\s*\(/.test(text))
+            return true;
+        depth += (line.match(/\{/g) ?? []).length - (line.match(/\}/g) ?? []).length;
+    }
+    return false;
+}
+/**
+ * A Ruby `skip` that turns this test off, rather than one sitting inside a block the test is
+ * handing to something else. Only a call at the body's own indentation counts: anything deeper is
+ * inside a block, and in rspec-core's specs that block is the fixture under test.
+ */
+function skipsAtTopLevel(body) {
+    const lines = body.split(String.fromCharCode(10)).filter((l) => l.trim() !== '');
+    if (lines.length === 0)
+        return false;
+    const base = Math.min(...lines.map((l) => l.length - l.trimStart().length));
+    return lines.some((l) => l.length - l.trimStart().length === base && /^\s*(?:skip|pending)\b/.test(l));
+}
+export { jsTests, pythonTests, rubyTests, bracedTests };

package/dist/engine/vouch/tests-in.js

@@ -1,3 +1,10 @@
+// Finding the individual tests in a file, and their bodies, without a parser per language.
+//
+// A parser for each of six languages is not the job, and would be the whole job. What is needed is
+// narrower: where each test starts, what text belongs to it, and whether it was marked as skipped.
+// Everything after this reads that text. Where the shape is not recognised, the file is reported as
+// unread rather than judged - a file Tewip cannot see into is not a file full of worthless tests.
+import { bracedTests, jsTests, pythonTests, rubyTests } from './find-tests.js';
 /** Which language this file is, by extension. Unknown extensions are not guessed at. */
 export function languageOf(file) {
     const lower = file.toLowerCase();
@@ -11,12 +18,27 @@ export function languageOf(file) {
         return 'go';
     if (/\.(cs|fs)$/.test(lower))
         return 'csharp';
+    // Phase 36. The assertion vocabulary already knew how these three check things - `expect(x).to`,
+    // `$this->assert`, `assert_eq!` were all on the list - so the only reason a Ruby, PHP or Rust
+    // file was never judged is that it never got this far. Triage has claimed all three for months.
+    if (lower.endsWith('.rb'))
+        return 'ruby';
+    if (lower.endsWith('.php'))
+        return 'php';
+    if (lower.endsWith('.rs'))
+        return 'rust';
     return null;
 }
 /** Does this file look like tests at all? Vouching for a source file is a category error. */
 export function looksLikeTests(file, text) {
     const named = /(^|[\\/])(tests?|spec|specs|__tests__|e2e|it|integration)[\\/]|[._-](test|tests|spec|specs|it)\.[a-z]+$|(^|[\\/])test_[^\\/]+\.py$|_test\.(go|py|rb)$|Tests?\.(java|kt|cs|scala)$/i.test(file);
-    const declares = /\b(it|test|describe|Scenario)\s*\(|^\s*def\s+test_|@Test\b|\[(Test|Fact|Theory)\]|\bfunc\s+Test[A-Z]/m.test(text);
+    const declares = /\b(it|test|describe|Scenario)\s*\(|^\s*def\s+test_|@Test\b|\[(Test|Fact|Theory)\]|\bfunc\s+Test[A-Z]/m.test(text) ||
+        // Ruby, PHP and Rust, added in Phase 36. PHPUnit names a test `testSomething`, so the `test\s*\(`
+        // above never matched it, and Rust marks one with an attribute no pattern here knew. Both came
+        // back as "0 test(s) read in 0 file(s)", which reads like a clean answer and is not one.
+        /#\s*\[\s*(?:test|tokio::test|rstest)\s*\]/.test(text) ||
+        /\bfunction\s+test\w*\s*\(|#\s*\[\s*Test\b|\*\s*@test\b/.test(text) ||
+        /^\s*(?:RSpec\.)?(?:describe|context)\s+|^\s*(?:x|f)?it\s+["'].*\bdo\b/m.test(text);
     return named || declares;
 }
 /**
@@ -26,7 +48,9 @@ export function looksLikeTests(file, text) {
  * a checker ends up telling somebody that a string in their fixture checks nothing. Found by
  * pointing this at Tewip's own test suite, where it produced 27 confident false accusations.
  */
-export function textRanges(text) {
+/** A Rust char literal: `'a'`, `'\n'`, `'\''`. Anything else beginning with a quote is a lifetime. */
+const RUST_CHAR = new RegExp(`^'(?:${String.raw `\\`}.|[^'${String.raw `\\`}])'`);
+export function textRanges(text, language) {
     const ranges = [];
     const TRIPLES = ['"'.repeat(3), "'".repeat(3)];
     for (let i = 0; i < text.length; i += 1) {
@@ -47,6 +71,14 @@ export function textRanges(text) {
             ranges.push([i, end]);
             i = end;
         }
+        else if (ch === "'" && language === 'rust' && !RUST_CHAR.test(text.slice(i, i + 4))) {
+            // A lone quote in Rust is a lifetime - `&'a str`, `Cow<'_, str>` - and not the start of
+            // anything. Treating it as a quote made the detector swallow the rest of the file, so all
+            // six of ripgrep's #[test] attributes were discarded as being inside a string and the file
+            // was reported as having no tests at all. A char literal is still text, so it is matched
+            // first: a char closes within three characters and a lifetime never closes.
+            continue;
+        }
         else if (ch === '"' || ch === "'" || ch === '`') {
             // A Python docstring runs to the next triple quote, not to the next single one.
             const triple = TRIPLES.find((t) => text.startsWith(t, i));
@@ -58,171 +90,18 @@ export function textRanges(text) {
     return ranges;
 }
 /** Is this offset inside text rather than code? */
-const isText = (ranges, at) => ranges.some(([from, to]) => at > from && at < to);
+export const isText = (ranges, at) => ranges.some(([from, to]) => at > from && at < to);
 export function testsIn(language, text) {
     if (language === 'python')
         return pythonTests(text);
     if (language === 'js')
         return jsTests(text);
+    if (language === 'ruby')
+        return rubyTests(text);
     return bracedTests(language, text);
 }
 /** The line number of an offset, 1-based. */
-const lineAt = (text, index) => text.slice(0, index).split(String.fromCharCode(10)).length;
-/**
- * `it('...', async () => { ... })` and its many spellings, including `test.each`, `it.skip` and a
- * plain `function ()` callback. The body is taken by matching braces from the callback's opening one.
- */
-function jsTests(text) {
-    const found = [];
-    const ranges = textRanges(text);
-    const declaration = /\b(it|test|specify)\s*(\.\s*(skip|only|todo|failing|concurrent|each|for)\s*(\([^)]*\)|`[^`]*`)?\s*)*\(\s*(['"`])((?:\\.|(?!\5)[^\\])*)\5/g;
-    for (const hit of text.matchAll(declaration)) {
-        const at = hit.index ?? 0;
-        if (isText(ranges, at))
-            continue;
-        const open = text.indexOf('{', at + hit[0].length);
-        if (open === -1)
-            continue;
-        const body = braced(text, open);
-        if (body === null)
-            continue;
-        const signature = text.slice(at + hit[0].length, open);
-        found.push({
-            name: hit[6],
-            line: lineAt(text, at),
-            body,
-            skipped: /\.\s*(skip|todo|failing)\b/.test(hit[0]) || /\bxit\s*\(/.test(hit[0]),
-            callback: /\(\s*([A-Za-z_$][\w$]*)\s*\)\s*(=>)?\s*$/.exec(signature.trim())?.[1] ?? '',
-        });
-    }
-    // `xit(...)` and `xtest(...)`, which the pattern above deliberately does not match.
-    for (const hit of text.matchAll(/\bx(it|test)\s*\(\s*(['"`])((?:\\.|(?!\2)[^\\])*)\2/g)) {
-        const at = hit.index ?? 0;
-        if (isText(ranges, at))
-            continue;
-        const open = text.indexOf('{', at + hit[0].length);
-        const body = open === -1 ? null : braced(text, open);
-        found.push({ name: hit[3], line: lineAt(text, at), body: body ?? '', skipped: true, callback: '' });
-    }
-    return found.sort((a, b) => a.line - b.line);
-}
-/** Python has no braces: a test's body is everything indented further than its `def`. */
-function pythonTests(text) {
-    const lines = text.split(String.fromCharCode(10));
-    const ranges = textRanges(text);
-    const offsets = [];
-    let seen = 0;
-    for (const line of lines) {
-        offsets.push(seen);
-        seen += line.length + 1;
-    }
-    const found = [];
-    for (let i = 0; i < lines.length; i += 1) {
-        const hit = /^(\s*)(?:async\s+)?def\s+(test_\w+|test)\s*\(/.exec(lines[i]);
-        if (!hit)
-            continue;
-        if (isText(ranges, offsets[i] + hit[1].length + 1))
-            continue;
-        const indent = hit[1].length;
-        // Nested in another def? Then it is a helper or, in Click's tests, a CLI command that happens to
-        // be named `test`. Only a module-level def, or a method of a test class, is a test.
-        if (nestedInFunction(lines, i, indent))
-            continue;
-        if (hit[2] === 'test' && indent > 0)
-            continue;
-        // A def whose parameters run over several lines ends at the line that closes them, and the body
-        // starts after that. Without this, the parameter list was read as the body and the real body was
-        // thrown away: psf/requests has several, and each came back as a test that compares no value.
-        let signatureEnds = i;
-        let open = 0;
-        for (let j = i; j < lines.length && j < i + 20; j += 1) {
-            open += (lines[j].match(/\(/g) ?? []).length - (lines[j].match(/\)/g) ?? []).length;
-            signatureEnds = j;
-            if (open <= 0)
-                break;
-        }
-        const body = [];
-        for (let j = signatureEnds + 1; j < lines.length; j += 1) {
-            const line = lines[j];
-            if (line.trim() === '') {
-                body.push(line);
-                continue;
-            }
-            const width = line.length - line.trimStart().length;
-            if (width <= indent)
-                break;
-            body.push(line);
-        }
-        // Decorators sit above the def, so skipping is read upwards.
-        const above = lines.slice(Math.max(0, i - 4), i).join(String.fromCharCode(10));
-        // A conditional skip runs somewhere - `skipif` on Windows registry tests in psf/requests runs
-        // on Windows - so only an unconditional skip means the test never runs. `xfail` runs too.
-        const skipped = /@\s*(pytest\s*\.\s*mark\s*\.\s*skip|unittest\s*\.\s*skip)\b/.test(above) && !/skipif|skipUnless|xfail/.test(above);
-        found.push({ name: hit[2], line: i + 1, body: body.join(String.fromCharCode(10)), skipped, callback: '' });
-    }
-    return found;
-}
-/** Is the def on line `i` nested inside another def, rather than inside a class or at the top? */
-function nestedInFunction(lines, i, indent) {
-    for (let j = i - 1; j >= 0; j -= 1) {
-        const line = lines[j];
-        if (line.trim() === '')
-            continue;
-        const width = line.length - line.trimStart().length;
-        if (width >= indent)
-            continue;
-        return /^\s*(async\s+)?def\s/.test(line);
-    }
-    return false;
-}
-/** JUnit, Kotlin, Scala, Go and C#: an annotation or a naming convention, then a braced body. */
-function bracedTests(language, text) {
-    const found = [];
-    const ranges = textRanges(text);
-    const declaration = language === 'go'
-        ? // Only a Test function. A Benchmark asserts nothing by design, an Example is checked against
-            // its own Output comment, and a Fuzz target is not a test - all three were condemned as
-            // "checks nothing" in gorilla/mux before this narrowed.
-            /\bfunc\s+(Test)(\w+)\s*\(\s*\w+\s+\*testing\.[TB]\s*\)\s*\{/g
-        : /(@Test\b[^\n]*|\[\s*(?:Test|Fact|Theory)[^\]]*\]|@(?:ParameterizedTest|RepeatedTest)\b)/g;
-    for (const hit of text.matchAll(declaration)) {
-        const at = hit.index ?? 0;
-        if (isText(ranges, at))
-            continue;
-        const open = language === 'go' ? text.indexOf('{', at) : text.indexOf('{', text.indexOf('(', at + hit[0].length));
-        if (open === -1)
-            continue;
-        const body = braced(text, open);
-        if (body === null)
-            continue;
-        const signature = text.slice(at, open);
-        // `void foo() throws IOException` still names foo. Without allowing the throws clause, every
-        // checked-exception test in gson was reported as 'unnamed'.
-        const name = language === 'go' ? hit[1] + hit[2] : /([\w]+)\s*\([^)]*\)\s*(throws\s+[\w.,\s]+)?$/.exec(signature.trim())?.[1] ?? 'unnamed';
-        const around = text.slice(Math.max(0, at - 200), open);
-        // An annotation disables a test outright. A `t.Skip()` may be conditional - cobra's
-        // TestDeadcodeElimination skips on Windows and runs everywhere else - so it counts only when it
-        // is unconditional, at the top level of the body.
-        const skipped = /@(Disabled|Ignore)\b|\[\s*Ignore\b/.test(around) || skipsUnconditionally(body);
-        found.push({ name, line: lineAt(text, at), body, skipped, callback: '' });
-    }
-    return found;
-}
-/**
- * A `t.Skip()` that runs whatever happens: at the top level of the body, not inside an `if`. Go
- * tests commonly skip on one platform and run on the others, and calling those "never runs" is
- * wrong.
- */
-function skipsUnconditionally(body) {
-    let depth = 0;
-    for (const line of body.split(String.fromCharCode(10))) {
-        const text = line.trim();
-        if (depth === 0 && /^\w+\s*\.\s*Skip(Now)?\s*\(/.test(text))
-            return true;
-        depth += (line.match(/\{/g) ?? []).length - (line.match(/\}/g) ?? []).length;
-    }
-    return false;
-}
+export const lineAt = (text, index) => text.slice(0, index).split(String.fromCharCode(10)).length;
 /**
  * The text between the brace at `open` and the one that closes it, skipping over strings, template
  * literals, comments and regular expressions - all of which can hold a brace that closes nothing.

package/dist/engine/vouch/vouch-command.js

@@ -34,7 +34,10 @@ export function testFiles(root, paths) {
             }
             if (stat.isDirectory())
                 walk(full, depth + 1);
-            else if (/\.(js|jsx|mjs|cjs|ts|tsx|mts|cts|py|java|kt|kts|scala|groovy|go|cs|fs)$/i.test(entry))
+            // rb, php and rs added in Phase 36. They were missing here as well as in languageOf, so even
+            // a file named outright came back "0 test(s) read in 0 file(s)" - which reads like a clean
+            // answer and is not one.
+            else if (/\.(js|jsx|mjs|cjs|ts|tsx|mts|cts|py|java|kt|kts|scala|groovy|go|cs|fs|rb|php|rs)$/i.test(entry))
                 found.push(full);
         }
     };

package/dist/engine/vouch/vouch.js

@@ -95,6 +95,17 @@ function judge(file, test, helpers) {
     const unknown = called.find((name) => /^(check|verify|ensure|validate|assert|expect|should|confirm)/i.test(name));
     if (unknown)
         return { ...at, verdict: 'cannot-tell', evidence: `${unknown}(…)`, why: `${unknown}() may assert, and it is not in this file, so Tewip will not call this either way` };
+    // A body whose whole content is one call to something defined in another file. The check is very
+    // likely inside it, and Tewip cannot follow it there, so "it compares no value" would be a
+    // confident wrong answer. Rails's own `test_constantize` is exactly this: one line calling
+    // `run_constantize_tests_on`, which lives in a shared helper and asserts plenty.
+    const statements = body
+        .split(String.fromCharCode(10))
+        .map((l) => l.trim())
+        .filter((l) => l !== '' && !l.startsWith('#') && !l.startsWith('//'));
+    if (statements.length === 1 && /^[A-Za-z_][\w.:]*\s*[({]/.test(statements[0])) {
+        return { ...at, verdict: 'cannot-tell', evidence: statements[0].slice(0, 80), why: 'its whole body is one call to something defined elsewhere, which may assert; Tewip will not call this either way' };
+    }
     if (unfinished.length > 0)
         return { ...at, verdict: 'unfinished-expectation', evidence: unfinished[0], why: MEANS['unfinished-expectation'] };
     if (tautology.length > 0)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tewip-ai",
-  "version": "0.42.0",
+  "version": "0.43.0",
   "mcpName": "io.github.hmamut39/tewip",
   "description": "Tewip finds why each failing test failed - real bug, flaky test, environment, test data or changed selector - for any stack, from the command line, CI, or your editor.",
   "keywords": [