eyeprolog 1.2.11 → 1.2.12

package/README.md

@@ -79,6 +79,11 @@ member_test ?- member(X, [prolog, logic]).
 ;  X = logic.
 ```
 
+A label may contain several comma-separated metadata fields. When a query has
+multiple indented answer descriptions, each description is checked and counted
+independently, so one failed expectation does not prevent the later ones from
+running.
+
 ## Strict ISO/IEC 13211-1 core
 
 For portability and conformance work, run the Part 1 core with Technical

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.2.11",
+  "version": "1.2.12",
   "description": "EyeProlog turns facts and rules into answers and proofs.",
   "type": "module",
   "main": "./index.js",

package/src/parser.js

@@ -795,12 +795,28 @@ class Parser {
         continue;
       }
       let head = this.parseTerm(3);
-      // Both a quad label and a TS 13211-3 semicontext may contain an
-      // unparenthesized comma before their priority-1200 operator.  Assemble
-      // that left operand before deciding whether the marker is ?- or -->.
+      // Both a quad label and a TS 13211-3 semicontext may contain one or more
+      // unparenthesized commas before their priority-1200 operator.  Parse the
+      // complete comma sequence here instead of stopping after one separator;
+      // portable quad labels commonly carry several metadata fields, e.g.
+      // `9, "case", passes ?- Goal.`.  Build the standard right-associative
+      // comma term so this is the same label as `(9, "case", passes)`.
       if (this.token.type === TOK.COMMA) {
-        this.advance();
-        head = compound(',', [head, this.parseTerm(3)]);
+        const items = [head];
+        let extraCommaLine = null;
+        while (this.token.type === TOK.COMMA) {
+          if (items.length >= 2 && extraCommaLine == null) extraCommaLine = this.token.line;
+          this.advance();
+          items.push(this.parseTerm(3));
+        }
+        // Historically the program grammar admitted exactly one comma in a
+        // DCG semicontext.  Keep that boundary: the broader comma sequence is
+        // specifically the quad-label extension, not a new DCG syntax.
+        if (extraCommaLine != null && this.operatorTokenName() !== '?-') {
+          throw new Error(`parse line ${extraCommaLine}: expected ., got ,`);
+        }
+        head = items.pop();
+        while (items.length > 0) head = compound(',', [items.pop(), head]);
       }
       if (this.operatorTokenName() === '?-') {
         if (this.strictIso) {

package/src/quads.js

@@ -33,9 +33,14 @@ export function runQuads(source, options = {}) {
   const results = [];
   const lines = [];
   for (const quad of quads) {
-    const result = checkQuad(program, quad, options);
-    results.push(result);
-    if (!result.ok) lines.push(formatFailure(program, quad, result));
+    // Every indented answer description is an independent portable quad test.
+    // Re-run the query for each description so a failed expectation does not
+    // prevent later expectations for the same query from being checked.
+    for (const description of quad.answers) {
+      const result = checkQuadDescription(program, quad, description, options);
+      results.push(result);
+      if (!result.ok) lines.push(formatFailure(program, quad, result, description));
+    }
   }
   const passed = results.filter((result) => result.ok).length;
   const failed = results.length - passed;
@@ -43,15 +48,11 @@ export function runQuads(source, options = {}) {
   return { stdout: lines.join(''), total: results.length, passed, failed, results };
 }
 
-function checkQuad(program, quad, options) {
+function checkQuadDescription(program, quad, description, options) {
   if (quad.id != null && !termIsGround(quad.id, new Env())) {
     return { ok: false, kind: 'bad_identifier', expected: quad.id };
   }
-  for (const description of quad.answers) {
-    const checked = checkDescription(program, quad, description, options);
-    if (!checked.ok) return checked;
-  }
-  return { ok: true };
+  return checkDescription(program, quad, description, options);
 }
 
 function checkDescription(program, quad, description, options) {
@@ -398,14 +399,14 @@ function splitOperator(term, name) {
   return [term];
 }
 
-function formatFailure(program, quad, result) {
+function formatFailure(program, quad, result, description = quad.answers[0]) {
   const source = quad.source ?? { filename: '<input>', line: 1 };
   const label = quad.id == null ? '' : `${formatQuadTerm(program, quad.id)}, `;
   const reason = result.kind === 'malformed' ? 'MALFORMED'
     : result.kind === 'bad_identifier' ? 'BAD_ID'
       : result.kind === 'unsupported' ? 'UNSUPPORTED'
         : 'FAILED';
-  const expected = result.expected ?? quad.answers[0];
+  const expected = result.expected ?? description;
   return `quads: ${reason} ${label}${source.filename}:${source.line}\n` +
     `   ?- ${formatQuadTerm(program, quad.query)}.\n` +
     `   expected: ${formatQuadTerm(program, expected)}.\n`;

package/test/run-regression.mjs

@@ -258,6 +258,46 @@ why(
         assertEqual(strict.clauses.length, 1, 'strict functional ?-/2 remains an ordinary term');
       },
     },
+    {
+      name: 'quad labels accept multiple metadata fields and each answer description is independent',
+      run: () => {
+        const source = `9, "✳54·43", passes
+` +
+          `?- X is 1+1.
+` +
+          `   X = 3, unexpected. % almost
+` +
+          `   X = 1, unexpected. % too low
+` +
+          `   X = 2.0, unexpected.
+` +
+          `% and after checking PM:
+` +
+          `   X = 2.
+`;
+        const program = Program.parseSources([{ text: source, filename: 'issue-21.pl' }]);
+        assertEqual(program.quads.length, 1, 'query group count');
+        assertEqual(program.quads[0].answers.length, 4, 'answer-description count');
+        assertEqual(program.quads[0].id.name, ',', 'outer label comma');
+        assertEqual(program.quads[0].id.args[1].name, ',', 'right-associated label comma');
+        const result = publicApi.runQuads(program);
+        assertEqual(result.total, 4, 'answer-description total');
+        assertEqual(result.passed, 4, 'answer-description passed');
+        assertEqual(result.failed, 0, 'answer-description failed');
+        assertEqual(result.stdout, 'quads: 4 run, 4 passed, 0 failed.\n', 'issue #21 report');
+
+        const continuing = publicApi.runQuads(
+          `case ?- X is 1+1.
+   X = 3.
+   X = 2.
+`,
+        );
+        assertEqual(continuing.total, 2, 'later descriptions still run after failure');
+        assertEqual(continuing.passed, 1, 'later passing description counted');
+        assertEqual(continuing.failed, 1, 'failed description counted');
+        assertIncludes(continuing.stdout, 'quads: 2 run, 1 passed, 1 failed.', 'continuation summary');
+      },
+    },
     {
       name: 'runQuads checks portable answer descriptions',
       run: () => {
@@ -275,10 +315,10 @@ why(
           `?- X = 1.\n   X = 2, unexpected.\n   X = 1.\n\n` +
           `?- catch(throw(ball), E, true).\n   E = ball | error(system_error, ...).\n`;
         const result = publicApi.runQuads(Program.parseSources([{ text: source, filename: 'quads.pl' }]));
-        assertEqual(result.total, 12, 'quad total');
-        assertEqual(result.passed, 12, 'quad passed');
-        assertEqual(result.failed, 0, 'quad failed');
-        assertEqual(result.stdout, 'quads: 12 run, 12 passed, 0 failed.\n', 'quad report');
+        assertEqual(result.total, 13, 'answer-description total');
+        assertEqual(result.passed, 13, 'answer-description passed');
+        assertEqual(result.failed, 0, 'answer-description failed');
+        assertEqual(result.stdout, 'quads: 13 run, 13 passed, 0 failed.\n', 'quad report');
       },
     },
     {
@@ -288,10 +328,10 @@ why(
           `   throw(g(_X)).\n` +
           `   throw(g(X)), unexpected.\n`;
         const result = publicApi.runQuads(Program.parseSources([{ text: source, filename: 'throw-copy-quad.pl' }]));
-        assertEqual(result.total, 1, 'quad total');
-        assertEqual(result.passed, 1, 'quad passed');
-        assertEqual(result.failed, 0, 'quad failed');
-        assertEqual(result.stdout, 'quads: 1 run, 1 passed, 0 failed.\n', 'quad report');
+        assertEqual(result.total, 2, 'answer-description total');
+        assertEqual(result.passed, 2, 'answer-description passed');
+        assertEqual(result.failed, 0, 'answer-description failed');
+        assertEqual(result.stdout, 'quads: 2 run, 2 passed, 0 failed.\n', 'quad report');
 
         const forbiddenFresh = publicApi.runQuads(
           `?- throw(g(X)).\n   throw(g(_X)), unexpected.\n`,
@@ -396,9 +436,9 @@ c4 ?- call((!;1)).
           text: source,
           filename,
         }]));
-        assertEqual(result.total, 73, 'quad total');
-        assertEqual(result.passed, 73, 'quad passed');
-        assertEqual(result.stdout, 'quads: 73 run, 73 passed, 0 failed.\n', 'quad report');
+        assertEqual(result.total, 77, 'answer-description total');
+        assertEqual(result.passed, 77, 'answer-description passed');
+        assertEqual(result.stdout, 'quads: 77 run, 77 passed, 0 failed.\n', 'quad report');
       },
     },
     {

package/the-art-of-eyeprolog.md

@@ -6408,8 +6408,10 @@ descriptions; variables introduced only by a description are fresh. For example,
 a query `throw(g(X))` is described by `throw(g(_X))`, while
 `throw(g(X)), unexpected` verifies that ISO `throw/1` did not retain the query
 variable in the renamed exception term. `...` and `ad_infinitum` accept further answers. Multiple
-indented descriptions after one query must all hold. `inputs/1` supplies and
-checks consumed characters; `outputs/1` checks emitted characters. `sto` marks
+indented descriptions after one query are independent checks: each re-runs the
+query, each is counted in the `quads:` summary, and a failing description does
+not suppress later descriptions for that query. `inputs/1` supplies and checks
+consumed characters; `outputs/1` checks emitted characters. `sto` marks
 an answer description that this finite-tree implementation skips. `loops` is
 checked with a deterministic solver-depth budget. The advanced stream
 annotations `peeks/1` and `waits`, and the unordered `other_answer_sequence`
@@ -6428,10 +6430,12 @@ console.log(report.passed, report.failed, report.stdout);
 The syntax follows the “queries using answer descriptions” convention used by
 Trealla and the ISO Prolog working examples. Because answer descriptions are
 layout-sensitive, indent every description while keeping ordinary clause heads
-and the next quad query at the left margin. A comma may be part of a quad label,
-including across layout before `?-`. Canonical functional notation is
-semantically equivalent: `?-(Label, Query).` followed by the same indented
-answer descriptions creates the same labelled quad as `Label ?- Query.`.
+and the next quad query at the left margin. A quad label may contain any number
+of comma-separated metadata fields, including across layout before `?-`; for
+example `9, "case", passes ?- Goal.` is one labelled query. Canonical
+functional notation is semantically equivalent: `?-(Label, Query).` followed by
+the same indented answer descriptions creates the same labelled quad as
+`Label ?- Query.`.
 
 Statistics are comparative evidence, not a score in isolation. Preserve the
 program, input, runtime version, selected query, answers, and counters together.