eyeling 1.24.24 → 1.24.26

package/lib/parser.js

@@ -465,6 +465,20 @@ class Parser {
     if (this.peek().typ === 'Ident' && (this.peek().value || '') === 'a') {
       this.next();
       pred = internIri(RDF_NS + 'type');
+    } else if (this.peek().typ === 'Ident' && (this.peek().value || '') === 'has') {
+      // N3 syntactic sugar is also valid in predicate-object lists,
+      // including blank node property lists: [ has :p :o ] means _:b :p :o.
+      this.next();
+      pred = this.parseTerm();
+    } else if (this.peek().typ === 'Ident' && (this.peek().value || '') === 'is') {
+      // N3 syntactic sugar: [ is :p of :s ] means :s :p _:b.
+      this.next();
+      pred = this.parseTerm();
+      if (!(this.peek().typ === 'Ident' && (this.peek().value || '') === 'of')) {
+        this.fail(`Expected 'of' after 'is <expr>', got ${this.peek().toString()}`);
+      }
+      this.next();
+      invert = true;
     } else if (this.peek().typ === 'OpPredInvert') {
       this.next();
       pred = this.parseTerm();

package/lib/prelude.js

@@ -24,14 +24,142 @@ const STRING_NS = 'http://www.w3.org/2000/10/swap/string#';
 const SKOLEM_NS = 'https://eyereasoner.github.io/.well-known/genid/';
 const RDF_JSON_DT = RDF_NS + 'JSON';
 
+function parseUriReferenceForResolution(uri) {
+  // RFC 3986 Appendix B-style component parser, with the scheme tightened to
+  // the RFC scheme grammar. Capturing delimiter presence matters: `?` with an
+  // empty query is defined, while no `?` means undefined.
+  const m = /^(([A-Za-z][A-Za-z0-9+.-]*):)?(\/\/([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?$/u.exec(String(uri));
+  if (!m) return null;
+  return {
+    scheme: m[2] !== undefined ? m[2] : undefined,
+    authority: m[4] !== undefined ? m[4] : undefined,
+    path: m[5] || '',
+    query: m[6] !== undefined ? (m[7] || '') : undefined,
+    fragment: m[8] !== undefined ? (m[9] || '') : undefined,
+  };
+}
+
+function recomposeUriReference(parts) {
+  let out = '';
+  if (parts.scheme !== undefined) out += `${parts.scheme}:`;
+  if (parts.authority !== undefined) out += `//${parts.authority}`;
+  out += parts.path || '';
+  if (parts.query !== undefined) out += `?${parts.query}`;
+  if (parts.fragment !== undefined) out += `#${parts.fragment}`;
+  return out;
+}
+
+function removeLastPathSegment(path) {
+  if (!path) return '';
+  const i = path.lastIndexOf('/');
+  if (i < 0) return '';
+  if (i === 0) return '';
+  return path.slice(0, i);
+}
+
+function removeDotSegments(path) {
+  // RFC 3986 section 5.2.4.  This deliberately avoids WHATWG URL parsing so
+  // Eyeling preserves IRI spelling (for example, it does not add a trailing
+  // slash to `http://example.org`) while still normalizing `.` and `..` path
+  // segments as required by section 5.2.2.
+  let input = String(path || '');
+  let output = '';
+
+  while (input.length > 0) {
+    if (input.startsWith('../')) {
+      input = input.slice(3);
+    } else if (input.startsWith('./')) {
+      input = input.slice(2);
+    } else if (input.startsWith('/./')) {
+      input = `/${input.slice(3)}`;
+    } else if (input === '/.') {
+      input = '/';
+    } else if (input.startsWith('/../')) {
+      input = `/${input.slice(4)}`;
+      output = removeLastPathSegment(output);
+    } else if (input === '/..') {
+      input = '/';
+      output = removeLastPathSegment(output);
+    } else if (input === '.' || input === '..') {
+      input = '';
+    } else {
+      let segmentEnd;
+      if (input[0] === '/') {
+        segmentEnd = input.indexOf('/', 1);
+      } else {
+        segmentEnd = input.indexOf('/');
+      }
+
+      if (segmentEnd < 0) {
+        output += input;
+        input = '';
+      } else {
+        output += input.slice(0, segmentEnd);
+        input = input.slice(segmentEnd);
+      }
+    }
+  }
+
+  return output;
+}
+
+function mergePaths(base, refPath) {
+  if (base.authority !== undefined && base.path === '') {
+    return `/${refPath}`;
+  }
+  const i = base.path.lastIndexOf('/');
+  if (i < 0) return refPath;
+  return `${base.path.slice(0, i + 1)}${refPath}`;
+}
+
 function resolveIriRef(ref, base) {
-  if (!base) return ref;
-  if (/^[A-Za-z][A-Za-z0-9+.-]*:/.test(ref)) return ref; // already absolute
-  try {
-    return new URL(ref, base).toString();
-  } catch {
-    return ref;
+  const r = parseUriReferenceForResolution(ref);
+  if (!r) return ref;
+
+  const baseParts = base ? parseUriReferenceForResolution(base) : null;
+
+  // Absolute references do not need a base, but RFC 3986 section 5.2.2 still
+  // applies remove_dot_segments(R.path) when R.scheme is defined.
+  if (r.scheme !== undefined) {
+    return recomposeUriReference({
+      scheme: r.scheme,
+      authority: r.authority,
+      path: removeDotSegments(r.path),
+      query: r.query,
+      fragment: r.fragment,
+    });
   }
+
+  // Without a usable base, preserve relative references as written.
+  if (!baseParts || baseParts.scheme === undefined) return ref;
+
+  const t = {
+    scheme: baseParts.scheme,
+    authority: undefined,
+    path: '',
+    query: undefined,
+    fragment: r.fragment,
+  };
+
+  if (r.authority !== undefined) {
+    t.authority = r.authority;
+    t.path = removeDotSegments(r.path);
+    t.query = r.query;
+  } else if (r.path === '') {
+    t.authority = baseParts.authority;
+    t.path = baseParts.path;
+    t.query = r.query !== undefined ? r.query : baseParts.query;
+  } else {
+    t.authority = baseParts.authority;
+    if (r.path.startsWith('/')) {
+      t.path = removeDotSegments(r.path);
+    } else {
+      t.path = removeDotSegments(mergePaths(baseParts, r.path));
+    }
+    t.query = r.query;
+  }
+
+  return recomposeUriReference(t);
 }
 
 // -----------------------------------------------------------------------------

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eyeling",
-  "version": "1.24.24",
+  "version": "1.24.26",
   "description": "A minimal Notation3 (N3) reasoner in JavaScript.",
   "main": "./index.js",
   "keywords": [

package/test/api.test.js

@@ -1269,6 +1269,38 @@ _:l2 rdf:rest rdf:nil.
   // Newer eyeling.js features
   // -------------------------
 
+  {
+    name: '50b regression: rdf:first/rest with variable subject binds existing N3 list term',
+    opt: { proofComments: false },
+    input: `@prefix : <http://example.org/> .
+
+(1) <http://a.example/p> <http://a.example/o> .
+
+{
+    _:el1 <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> 1 .
+    _:el1 <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> <http://www.w3.org/1999/02/22-rdf-syntax-ns#nil> .
+    _:el1 <http://a.example/p> <http://a.example/o> .
+}
+=>
+{
+    :result :has :success-literal-25.
+}.
+
+{} => {
+    :test :contains :success-literal-25.
+}.
+
+{
+    :result :has :success-literal-25.
+}
+=>
+{
+    :test :is true.
+}.
+`,
+    expect: [/:result\s+:has\s+:success-literal-25\s*\./, /:test\s+:is\s+true\s*\./],
+  },
+
   {
     name: '51 automatic output rendering: prints log:outputString values ordered by key (subject)',
     opt: ['-n'],
@@ -1396,6 +1428,111 @@ res:CITY_Chañaral rdfs:label "Chañaral".
     expect: [/:result\s+:has\s+:success-literal-24\s*\./, /:test\s+:is\s+true\s*\./],
   },
 
+  {
+    name: '52d regression: @base and @prefix remapping resolve relative IRIs incrementally',
+    opt: { proofComments: false },
+    input: `# Reference: https://www.w3.org/TR/turtle/#sec-iri-references
+@base <http://foo/bar/> .
+<a1> <b1> <c1> .
+@base <http://example.org/ns/> .
+<a2> <http://example.org/ns/b2> <c2> .
+@base <foo/> .
+<a3> <b3> <c3> .
+@prefix : <bar#> .
+:a4 :b4 :c4 .
+@prefix : <http://example.org/ns2#> .
+:a5 :b5 :c5 .
+
+{
+    <http://foo/bar/a1> <http://foo/bar/b1> <http://foo/bar/c1> .
+    <http://example.org/ns/a2> <http://example.org/ns/b2> <http://example.org/ns/c2> .
+    <http://example.org/ns/foo/a3> <http://example.org/ns/foo/b3> <http://example.org/ns/foo/c3> .
+    <http://example.org/ns/foo/bar#a4> <http://example.org/ns/foo/bar#b4> <http://example.org/ns/foo/bar#c4> .
+    <http://example.org/ns2#a5> <http://example.org/ns2#b5> <http://example.org/ns2#c5> .
+}
+=>
+{
+    :result :has :success-literal-28.
+}.
+
+{} => {
+    :test :contains :success-literal-28.
+}.
+
+{
+    :result :has :success-literal-28.
+}
+=>
+{
+    :test :is true.
+}.
+`,
+    expect: [/:result\s+:has\s+:success-literal-28\s*\./, /:test\s+:is\s+true\s*\./],
+  },
+
+  {
+    name: '52e regression: is/of works in blank node property lists with list values',
+    opt: { proofComments: false },
+    input: `@prefix : <http://example.org/> .
+@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
+
+:thing :prop (1 2 3).
+
+{
+    (1 2 3) is :prop of :thing.
+    [ is :prop of :thing ].
+}
+=>
+{
+    :result :has :success-literal-29.
+}.
+
+{} => {
+    :test :contains :success-literal-29.
+}.
+
+{
+    :result :has :success-literal-29.
+}
+=>
+{
+    :test :is true.
+}.
+`,
+    expect: [/:result\s+:has\s+:success-literal-29\s*\./, /:test\s+:is\s+true\s*\./],
+  },
+
+  {
+    name: '52f regression: has works with list values in statement predicate position',
+    opt: { proofComments: false },
+    input: `@prefix : <http://example.org/> .
+@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
+
+:thing :prop (1 2 3).
+
+{
+    :thing has :prop (1 2 3).
+}
+=>
+{
+    :result :has :success-literal-30.
+}.
+
+{} => {
+    :test :contains :success-literal-30.
+}.
+
+{
+    :result :has :success-literal-30.
+}
+=>
+{
+    :test :is true.
+}.
+`,
+    expect: [/:result\s+:has\s+:success-literal-30\s*\./, /:test\s+:is\s+true\s*\./],
+  },
+
   {
     name: '53 --stream: prints prefixes used in input (not just derived output) before streaming triples',
     opt: ['--stream', '-n'],