eyeleng 1.0.5 → 1.0.7

package/src/api.js

@@ -2,6 +2,7 @@
 
 const { parse, parseQuery } = require('./parser.js');
 const { parseRdfSyntax, parseRdfDocument, rdfDocumentToProgram, looksLikeRdfRules } = require('./rdfSyntax.js');
+const { parseRdfMessageLog, looksLikeRdfMessageLog } = require('./rdfMessages.js');
 const { evaluate } = require('./engine.js');
 const { analyze } = require('./analyze.js');
 const { formatTriples, sortTriples, toJSON, formatTrace, formatBindings } = require('./format.js');
@@ -10,6 +11,7 @@ const { resultTriples } = require('./output.js');
 
 function parseInput(source, options = {}) {
   if (typeof source !== 'string') return source;
+  if (looksLikeRdfMessageLog(source, options)) return parseRdfMessageLog(source, options);
   return looksLikeRdfRules(source, options) ? parseRdfSyntax(source, options) : parse(source, options);
 }
 
@@ -106,6 +108,8 @@ module.exports = {
   parseInput,
   parseRdfSyntax,
   parseRdfDocument,
+  parseRdfMessageLog,
+  looksLikeRdfMessageLog,
   rdfDocumentToProgram,
   compile,
   resolveImports,

package/src/cli.js

@@ -52,6 +52,8 @@ function parseArgs(argv) {
     imports: true,
     syntax: 'auto',
     ruleSet: null,
+    rdfMessages: false,
+    includeMessageFacts: false,
   };
   const files = [];
   for (let i = 0; i < argv.length; i += 1) {
@@ -64,6 +66,8 @@ function parseArgs(argv) {
     else if (arg === '--strict') options.strict = true;
     else if (arg === '--deps') options.deps = true;
     else if (arg === '--no-imports') options.imports = false;
+    else if (arg === '--rdf-messages' || arg === '--stream-messages') options.rdfMessages = true;
+    else if (arg === '--include-message-facts') options.includeMessageFacts = true;
     else if (arg === '--syntax') {
       i += 1;
       if (i >= argv.length) throw new Error('--syntax requires srl, rdf, or auto');
@@ -173,6 +177,8 @@ function main(argv = process.argv.slice(2), io = process) {
       importResolver: options.imports ? createFileImportResolver() : null,
       syntax: options.syntax === 'auto' ? undefined : options.syntax,
       ruleSet: options.ruleSet,
+      rdfMessages: options.rdfMessages,
+      includeMessageFacts: options.includeMessageFacts,
     });
     const fatal = hasFatalDiagnostics(compiled.analysis, options.strict);
 

package/src/parser.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const { tokenize, SyntaxErrorWithLocation } = require('./tokenizer.js');
+const { parseN3 } = require('./rdfSyntax.js');
 const { isBuiltinName } = require('./builtins.js');
 const { ruleNeedsRunOnce } = require('./assignments.js');
 const {
@@ -14,6 +15,7 @@ const {
   RDF_REST,
   RDF_NIL,
   RDF_REIFIES,
+  XSD_STRING,
   XSD_BOOLEAN,
   XSD_INTEGER,
   XSD_DECIMAL,
@@ -22,7 +24,7 @@ const {
 
 class Parser {
   constructor(source, options = {}) {
-    this.tokens = Array.isArray(source) ? source : tokenize(source, options.filename);
+    this.tokens = Array.isArray(source) ? source : tokenize(source, options);
     this.pos = 0;
     this.options = options;
     this.baseIRI = options.baseIRI || null;
@@ -52,7 +54,7 @@ class Parser {
         this.parseImports();
       } else if (this.matchWord('DATA')) {
         this.expectValue('{');
-        data.push(...this.parseTriplesBlock({ allowPath: false, context: 'data' }));
+        data.push(...this.parseDataBlockWithRdfSyntax());
       } else if (this.matchWord('RULE')) {
         rules.push(this.parseRule());
       } else if (this.matchWord('IF')) {
@@ -85,6 +87,7 @@ class Parser {
     let name = nameToken.value;
     if (!name.endsWith(':')) throw this.error('Prefix name must end with :', nameToken);
     name = name.slice(0, -1);
+    if (this.strictGrammar() && !isValidPNPrefix(name)) throw this.error(`Invalid prefix name ${nameToken.value}`, nameToken);
     const iriToken = this.expectType('iri');
     this.prefixes[name] = this.resolveIRI(iriToken.value, iriToken);
     if (wasAtPrefix) this.consumeOptionalDot();
@@ -92,6 +95,10 @@ class Parser {
 
   parseVersion() {
     const token = this.expectType('string');
+    if (this.strictGrammar()) {
+      if (token.long) throw this.error('VERSION must use a short string literal', token);
+      if (token.value !== '1.2') throw this.error('VERSION must be the SHACL Rules version label \"1.2\"', token);
+    }
     this.version = token.value;
   }
 
@@ -196,6 +203,98 @@ class Parser {
     return triples;
   }
 
+  parseDataBlockWithRdfSyntax() {
+    const blockSource = this.collectBalancedDataBlockSource();
+    const program = parseN3(blockSource, {
+      profile: 'trig',
+      base: this.baseIRI || '',
+      prefixes: this.prefixes,
+    });
+    return (program.facts || []).map((triple) => this.convertRdfSyntaxTriple(triple));
+  }
+
+  collectBalancedDataBlockSource() {
+    const tokens = [];
+    let depth = 1;
+    while (!this.is('eof')) {
+      const token = this.advance();
+      if (token.value === '{') {
+        depth += 1;
+        tokens.push(token);
+      } else if (token.value === '}') {
+        depth -= 1;
+        if (depth === 0) return this.tokensToRdfSource(tokens);
+        tokens.push(token);
+      } else {
+        tokens.push(token);
+      }
+    }
+    throw this.error('Unterminated DATA block');
+  }
+
+  tokensToRdfSource(tokens) {
+    const parts = [];
+    for (let i = 0; i < tokens.length; i += 1) {
+      const token = tokens[i];
+      if (token.type === 'eof') continue;
+      if ((token.value === '+' || token.value === '-') && tokens[i + 1] && tokens[i + 1].type === 'number') {
+        parts.push(`${token.value}${this.tokenToRdfSource(tokens[i + 1])}`);
+        i += 1;
+      } else {
+        parts.push(this.tokenToRdfSource(token));
+      }
+    }
+    return parts.join(' ');
+  }
+
+  tokenToRdfSource(token) {
+    if (token.type === 'iri') return `<${String(token.value).replace(/>/g, '\\>')}>`;
+    if (token.type === 'string') return JSON.stringify(token.value);
+    if (token.type === 'variable') return `?${token.value}`;
+    if (token.type === 'number') return String(token.value);
+    return String(token.value);
+  }
+
+  convertRdfSyntaxTriple(triple) {
+    const out = {
+      s: this.convertRdfSyntaxTerm(triple.s),
+      p: this.convertRdfSyntaxTerm(triple.p),
+      o: this.convertRdfSyntaxTerm(triple.o),
+    };
+    if (out.s.type === 'var' || out.p.type === 'var' || out.o.type === 'var') {
+      throw this.error('DATA blocks may not contain variables');
+    }
+    if (out.p.type !== 'iri') {
+      throw this.error('DATA predicates must be IRIs');
+    }
+    if (triple.graph) out.graph = this.convertRdfSyntaxTerm(triple.graph);
+    return out;
+  }
+
+  convertRdfSyntaxTerm(term) {
+    if (!term) return null;
+    if (term.type) return term;
+    if (term.kind === 'iri') return iri(term.value);
+    if (term.kind === 'blank') return blankNode(term.value);
+    if (term.kind === 'var') return variable(term.name || term.value);
+    if (term.kind === 'literal') {
+      return literal(
+        coerceLexicalLiteral(term.value, term.datatype),
+        term.datatype === XSD_STRING ? null : (term.datatype || null),
+        term.language || null,
+        term.langDir || null,
+      );
+    }
+    if (term.kind === 'triple') {
+      return tripleTerm(
+        this.convertRdfSyntaxTerm(term.s),
+        this.convertRdfSyntaxTerm(term.p),
+        this.convertRdfSyntaxTerm(term.o),
+      );
+    }
+    throw this.error(`Unsupported RDF term kind ${term.kind || typeof term}`);
+  }
+
   parseTripleStatement(options = {}) {
     const subjectNode = this.parseGraphNode(options);
     const triples = [...subjectNode.triples];
@@ -395,6 +494,7 @@ class Parser {
       } else if (this.matchWord('SET')) {
         clauses.push(this.parseSetClause());
       } else if (this.matchWord('BIND')) {
+        if (this.strictGrammar()) throw this.error('BIND is not part of the SHACL 1.2 Rules grammar; use SET');
         clauses.push(this.parseBindClause());
       } else if (this.matchWord('NOT')) {
         this.expectValue('{');
@@ -502,8 +602,9 @@ class Parser {
     if (colon < 0) throw this.error(`Expected IRI, prefixed name, literal, blank node, or variable; got ${value}`, token);
     const prefix = value.slice(0, colon);
     const local = value.slice(colon + 1);
+    if (this.strictGrammar()) validatePrefixedName(prefix, local, value, token, (message, errToken) => this.error(message, errToken));
     if (!(prefix in this.prefixes)) throw this.error(`Unknown prefix ${prefix}:`, token);
-    return this.prefixes[prefix] + local;
+    return this.prefixes[prefix] + decodePNLocalEscapes(local);
   }
 
   resolveIRI(value, token = null) {
@@ -662,9 +763,76 @@ class Parser {
   peek() { return this.tokens[this.pos]; }
   peekN(n) { return this.tokens[this.pos + n] || this.tokens[this.tokens.length - 1]; }
   previous() { return this.tokens[this.pos - 1]; }
+  strictGrammar() { return !!this.options.strictGrammar; }
   error(message, token = this.peek()) { return new SyntaxErrorWithLocation(message, token); }
 }
 
+
+function isPnCharsBase(ch) {
+  if (!ch) return false;
+  return /[A-Za-z]/.test(ch) || ch.codePointAt(0) >= 0x00C0;
+}
+
+function isPnCharsU(ch) {
+  return isPnCharsBase(ch) || ch === '_';
+}
+
+function isPnChars(ch) {
+  return isPnCharsU(ch) || /[0-9-]/.test(ch) || ch === '\u00B7' || /[\u0300-\u036F\u203F-\u2040]/u.test(ch);
+}
+
+function isValidPNPrefix(prefix) {
+  if (prefix === '') return true;
+  const chars = Array.from(prefix);
+  if (!isPnCharsBase(chars[0])) return false;
+  if (chars.length > 1 && chars.at(-1) === '.') return false;
+  return chars.slice(1).every((ch) => isPnChars(ch) || ch === '.');
+}
+
+function plxLength(text, index) {
+  const ch = text[index];
+  if (ch === '%' && /[0-9A-Fa-f]/.test(text[index + 1] || '') && /[0-9A-Fa-f]/.test(text[index + 2] || '')) return 3;
+  if (ch === '\\' && /[_~.!$&'()*+,;=/?#@%-]/.test(text[index + 1] || '')) return 2;
+  return 0;
+}
+
+function isPNLocalStartAt(text, index) {
+  const ch = text[index];
+  return isPnCharsU(ch) || /[0-9:]/.test(ch || '') || plxLength(text, index) > 0;
+}
+
+function isPNLocalBodyAt(text, index) {
+  const ch = text[index];
+  return isPnChars(ch) || ch === '.' || ch === ':' || plxLength(text, index) > 0;
+}
+
+function isPNLocalEndAt(text, index) {
+  const ch = text[index];
+  return isPnChars(ch) || ch === ':' || plxLength(text, index) > 0;
+}
+
+function validatePNLocal(local) {
+  if (local === '') return true;
+  if (!isPNLocalStartAt(local, 0)) return false;
+  let lastStart = 0;
+  for (let i = 0; i < local.length;) {
+    const len = plxLength(local, i) || 1;
+    if (i > 0 && !isPNLocalBodyAt(local, i)) return false;
+    lastStart = i;
+    i += len;
+  }
+  return isPNLocalEndAt(local, lastStart);
+}
+
+function validatePrefixedName(prefix, local, value, token, makeError) {
+  if (!isValidPNPrefix(prefix)) throw makeError(`Invalid prefixed name ${value}: invalid prefix`, token);
+  if (!validatePNLocal(local)) throw makeError(`Invalid prefixed name ${value}: invalid local name`, token);
+}
+
+function decodePNLocalEscapes(local) {
+  return String(local).replace(/\\([_~.!$&'()*+,;=/?#@%-])/g, '$1');
+}
+
 function numericLiteral(value) {
   if (Number.isInteger(value)) return literal(value, XSD_INTEGER);
   return literal(value, XSD_DECIMAL);