eyeling 1.5.12 → 1.5.14

package/examples/string-builtins-tests.n3

@@ -0,0 +1,210 @@
+# ---------------------
+# string builtins tests
+# ---------------------
+
+@prefix :       <https://eyereasoner.github.io/ns#> .
+@prefix string: <http://www.w3.org/2000/10/swap/string#> .
+@prefix log:    <http://www.w3.org/2000/10/swap/log#> .
+@prefix list:   <http://www.w3.org/2000/10/swap/list#> .
+@prefix math:   <http://www.w3.org/2000/10/swap/math#> .
+@prefix xsd:    <http://www.w3.org/2001/XMLSchema#> .
+
+# Each rule checks one builtin and, if it behaves as specified,
+# derives a single marker triple:
+#   :ok_string_<name>_1 a :Pass .
+
+# ----------------------------------------------------------------------
+# 4.6.1 string:concatenation
+# ----------------------------------------------------------------------
+
+{
+    ("hello" " " "world!") string:concatenation "hello world!" .
+}
+=>
+{
+    :ok_string_concatenation_1 a :Pass .
+} .
+
+# ----------------------------------------------------------------------
+# 4.6.2 string:contains
+# ----------------------------------------------------------------------
+
+{
+    "hello world!" string:contains "llo worl" .
+}
+=>
+{
+    :ok_string_contains_1 a :Pass .
+} .
+
+# ----------------------------------------------------------------------
+# 4.6.3 string:containsIgnoringCase
+# ----------------------------------------------------------------------
+
+{
+    "hello world!" string:containsIgnoringCase "lLO woRl" .
+}
+=>
+{
+    :ok_string_containsIgnoringCase_1 a :Pass .
+} .
+
+# ----------------------------------------------------------------------
+# 4.6.4 string:endsWith
+# ----------------------------------------------------------------------
+
+{
+    "hello world!" string:endsWith "orld!" .
+}
+=>
+{
+    :ok_string_endsWith_1 a :Pass .
+} .
+
+# ----------------------------------------------------------------------
+# 4.6.5 string:equalIgnoringCase
+# ----------------------------------------------------------------------
+
+{
+    "hello world!" string:equalIgnoringCase "hELLo wORld!" .
+}
+=>
+{
+    :ok_string_equalIgnoringCase_1 a :Pass .
+} .
+
+# ----------------------------------------------------------------------
+# 4.6.6 string:format
+# (eyeling implementation: only %s and %% are required / used here)
+# ----------------------------------------------------------------------
+
+{
+    ("%s://%s/%s" "https" "w3c.github.io" "N3/spec/") 
+        string:format "https://w3c.github.io/N3/spec/" .
+}
+=>
+{
+    :ok_string_format_1 a :Pass .
+} .
+
+# ----------------------------------------------------------------------
+# 4.6.7 string:greaterThan
+# ----------------------------------------------------------------------
+
+{
+    "Penguin" string:greaterThan "Cat" .
+}
+=>
+{
+    :ok_string_greaterThan_1 a :Pass .
+} .
+
+# ----------------------------------------------------------------------
+# 4.6.8 string:lessThan
+# ----------------------------------------------------------------------
+
+{
+    "Cat" string:lessThan "Penguin" .
+}
+=>
+{
+    :ok_string_lessThan_1 a :Pass .
+} .
+
+# ----------------------------------------------------------------------
+# 4.6.9 string:matches
+# ----------------------------------------------------------------------
+
+{
+    "hello world!" string:matches ".*(l)+o wo.*" .
+}
+=>
+{
+    :ok_string_matches_1 a :Pass .
+} .
+
+# ----------------------------------------------------------------------
+# 4.6.10 string:notEqualIgnoringCase
+# ----------------------------------------------------------------------
+
+{
+    "hello world!" string:notEqualIgnoringCase "hELLo dunia!" .
+}
+=>
+{
+    :ok_string_notEqualIgnoringCase_1 a :Pass .
+} .
+
+# ----------------------------------------------------------------------
+# 4.6.11 string:notGreaterThan
+# ----------------------------------------------------------------------
+
+{
+    "Cat" string:notGreaterThan "Penguin" .
+}
+=>
+{
+    :ok_string_notGreaterThan_1 a :Pass .
+} .
+
+# ----------------------------------------------------------------------
+# 4.6.12 string:notLessThan
+# ----------------------------------------------------------------------
+
+{
+    "Penguin" string:notLessThan "Cat" .
+}
+=>
+{
+    :ok_string_notLessThan_1 a :Pass .
+} .
+
+# ----------------------------------------------------------------------
+# 4.6.13 string:notMatches
+# ----------------------------------------------------------------------
+
+{
+    "hello world!" string:notMatches ".*(l)+o dunia.*" .
+}
+=>
+{
+    :ok_string_notMatches_1 a :Pass .
+} .
+
+# ----------------------------------------------------------------------
+# 4.6.14 string:replace
+# ----------------------------------------------------------------------
+
+{
+    ("fofof bar" "of" "baz") string:replace "fbazbaz bar" .
+}
+=>
+{
+    :ok_string_replace_1 a :Pass .
+} .
+
+# ----------------------------------------------------------------------
+# 4.6.15 string:scrape
+# (extracts the first capturing group)
+# ----------------------------------------------------------------------
+
+{
+    ("id=abc&x=123&y=zzz" "x=([0-9]+)") string:scrape "123" .
+}
+=>
+{
+    :ok_string_scrape_1 a :Pass .
+} .
+
+# ----------------------------------------------------------------------
+# 4.6.16 string:startsWith
+# ----------------------------------------------------------------------
+
+{
+    "hello world!" string:startsWith "hello" .
+}
+=>
+{
+    :ok_string_startsWith_1 a :Pass .
+} .
+

package/examples/test

@@ -0,0 +1,154 @@
+#!/bin/bash
+set -euo pipefail
+
+RED="\e[31m"
+GREEN="\e[32m"
+YELLOW="\e[33m"
+NORMAL="\e[0;39m"
+
+OK=0
+DIFF=0
+
+pad() {
+  # pad "text" width
+  local s="$1" w="$2"
+  printf "%-${w}s" "$s"
+}
+
+now_ms() {
+  echo $(( $(date +%s%N) / 1000000 ))
+}
+
+in_git_worktree() {
+  command -v git >/dev/null 2>&1 && git rev-parse --is-inside-work-tree >/dev/null 2>&1
+}
+
+# Expectation logic:
+# 1) If the .n3 contains a comment like:  # expect-exit: 2  -> use that
+# 2) Else, if it contains "=> false" -> expect exit 2
+# 3) Else -> expect exit 0
+expected_exit_code() {
+  local file="$1"
+  local line
+  if line=$(grep -Em1 '^[[:space:]]*#[: ]*expect-exit:[[:space:]]*[0-9]+' "$file" 2>/dev/null); then
+    if [[ "$line" =~ ([0-9]+) ]]; then
+      echo "${BASH_REMATCH[1]}"
+      return
+    fi
+  fi
+  if grep -Eq '=>[[:space:]]*false\b' "$file"; then
+    echo 2
+  else
+    echo 0
+  fi
+}
+
+echo -e "${YELLOW}-------------------------------------------------${NORMAL}"
+echo -e "${YELLOW}running eyeling examples${NORMAL}"
+echo -e "${YELLOW}using $(../eyeling.js -v) and node $(node --version)${NORMAL}"
+echo -e "${YELLOW}-------------------------------------------------${NORMAL}"
+echo ""
+
+IN_GIT=0
+if in_git_worktree; then IN_GIT=1; fi
+
+# In maintainer mode we write expected outputs (tracked) to output/
+if [[ $IN_GIT -eq 1 ]]; then
+  mkdir -p output
+fi
+
+begin="$(now_ms)"
+
+for file in *.n3; do
+  printf "%s" "$(pad "$file" 36)"
+  start="$(now_ms)"
+
+  expected_rc="$(expected_exit_code "$file")"
+
+  # Decide where we write generated output
+  tmp=""
+  generated=""
+  expected="output/${file}"
+
+  if [[ $IN_GIT -eq 1 ]]; then
+    generated="$expected"            # overwrite expected output in working tree
+  else
+    # npm-installed / no .git: never modify output/ in node_modules
+    if [[ ! -f "$expected" ]]; then
+      end="$(now_ms)"
+      ms=$((end-start))
+      echo -en "${YELLOW}$(pad "${ms} ms" 10)${NORMAL} "
+      echo -e "${RED}MISSING expected ${expected}${NORMAL}"
+      ((++DIFF))
+      continue
+    fi
+    tmp="$(mktemp)"
+    generated="$tmp"
+  fi
+
+  # Run eyeling, capture exit code without breaking the loop
+  rc=0
+  if ../eyeling.js "$file" > "$generated"; then
+    rc=0
+  else
+    rc=$?
+  fi
+
+  end="$(now_ms)"
+  ms=$((end-start))
+  echo -en "${YELLOW}$(pad "${ms} ms" 10)${NORMAL} "
+
+  # Compare output
+  diff_ok=0
+  if [[ $IN_GIT -eq 1 ]]; then
+    if git diff --quiet -- "$expected"; then diff_ok=1; fi
+  else
+    if command -v git >/dev/null 2>&1; then
+      if git diff --no-index --quiet -- "$expected" "$generated" >/dev/null 2>&1; then diff_ok=1; fi
+    else
+      if diff -u "$expected" "$generated" >/dev/null 2>&1; then diff_ok=1; fi
+    fi
+  fi
+
+  # Decide pass/fail
+  if [[ $diff_ok -eq 1 && $rc -eq $expected_rc ]]; then
+    if [[ $rc -eq 0 ]]; then
+      echo -e "${GREEN}OK${NORMAL}"
+    else
+      echo -e "${GREEN}OK${NORMAL} (exit ${rc})"
+    fi
+    ((++OK))
+  else
+    if [[ $rc -ne $expected_rc ]]; then
+      echo -e "${RED}DIFF${NORMAL} (exit ${rc}, expected ${expected_rc})"
+    else
+      echo -e "${RED}DIFF${NORMAL}"
+    fi
+    ((++DIFF))
+
+    # In npm mode, show a git-style diff when available (nice UX)
+    if [[ $IN_GIT -eq 0 ]]; then
+      if command -v git >/dev/null 2>&1; then
+        git diff --no-index -- "$expected" "$generated" || true
+      else
+        diff -u "$expected" "$generated" || true
+      fi
+    fi
+  fi
+
+  # cleanup tmp file
+  if [[ -n "$tmp" ]]; then rm -f "$tmp"; fi
+done
+
+end="$(now_ms)"
+total=$((end-begin))
+
+echo ""
+echo -e "${YELLOW}${total} ms${NORMAL} ${GREEN}${OK} OK${NORMAL} ${RED}${DIFF} DIFF${NORMAL}"
+
+if [[ ${DIFF} -eq 0 ]]; then
+  exit 0
+else
+  exit 2
+fi
+

package/examples/turing.n3

@@ -0,0 +1,93 @@
+# --------------
+# Turing Machine
+# --------------
+#
+# Turing completeness test case.
+# See http://en.wikipedia.org/wiki/Prolog#Turing_completeness
+
+@prefix list: <http://www.w3.org/2000/10/swap/list#>.
+@prefix log: <http://www.w3.org/2000/10/swap/log#>.
+@prefix : <http://example.org/#>.
+
+# interpreter for Turing machine
+{() :compute ?OutTape} <= {
+    ?Machine :start ?I.
+    (?I () "#" ()) :find ?OutTape.
+}.
+
+{?List :compute ?OutTape} <= {
+    ?List list:firstRest (?Head ?Tail).
+    ?Machine :start ?I.
+    (?I () ?Head ?Tail) :find ?OutTape.
+}.
+
+{(?State ?Left ?Cell ?Right) :find ?OutTape} <= {
+    (?State ?Cell ?Write ?Move) :tape ?Next.
+    (?Move ?Left ?Write ?Right ?A ?B ?C) :move true.
+    (?Next ?A ?B ?C) :continue ?OutTape.
+}.
+
+{(:halt ?Left ?Cell ?Right) :continue ?OutTape} <= {
+    ?Left :reverse ?R.
+    ?List list:firstRest (?Cell ?Right).
+    (?R ?List) list:append ?OutTape.
+}.
+
+{(?State ?Left ?Cell ?Right) :continue ?OutTape} <= {
+    (?State ?Left ?Cell ?Right) :find ?OutTape.
+}.
+
+{(:left () ?Cell ?Right () "#" ?L) :move true} <= {
+    ?L list:firstRest (?Cell ?Right).
+}.
+
+{(:left ?List ?Cell ?Right ?Tail ?Head ?L) :move true} <= {
+    ?List list:firstRest (?Head ?Tail).
+    ?L list:firstRest (?Cell ?Right).
+}.
+
+{(:stop ?Left ?Cell ?Right ?Left ?Cell ?Right) :move true} <= true.
+
+{(:right ?Left ?Cell () ?L "#" ()) :move true} <= {
+    ?L list:firstRest (?Cell ?Left).
+}.
+
+{(:right ?Left ?Cell ?List ?L ?Head ?Tail) :move true} <= {
+    ?List list:firstRest (?Head ?Tail).
+    ?L list:firstRest (?Cell ?Left).
+}.
+
+{() :reverse ()} <= true.
+
+{?List :reverse ?Reverse} <= {
+    ?List list:firstRest (?Head ?Tail).
+    ?Tail :reverse ?R.
+    (?R (?Head)) list:append ?Reverse.
+}.
+
+# a Turing machine to add 1 to a binary number
+:add1 :start 0.
+
+(0 0 0 :right) :tape 0.
+(0 1 1 :right) :tape 0.
+(0 "#" "#" :left) :tape 1.
+(1 0 1 :stop) :tape :halt.
+(1 1 0 :left) :tape 1.
+(1 "#" 1 :stop) :tape :halt.
+
+@prefix : <http://example.org/#>.
+
+# query
+{
+    (1 0 1 0 0 1) :compute ?A1.
+    (1 0 1 1 1 1) :compute ?A2.
+    (1 1 1 1 1 1) :compute ?A3.
+    () :compute ?A4.
+} => {
+    :test :is {
+        (1 0 1 0 0 1) :compute ?A1.
+        (1 0 1 1 1 1) :compute ?A2.
+        (1 1 1 1 1 1) :compute ?A3.
+        () :compute ?A4.
+    }.
+}.

package/examples/uri.n3

@@ -0,0 +1,17 @@
+# ---------------
+# log:uri example
+# ---------------
+
+@prefix :   <http://example.org/> .
+@prefix log: <http://www.w3.org/2000/10/swap/log#> .
+
+{
+  <https://www.w3.org> log:uri ?s .
+  ?r log:uri "https://www.w3.org" .
+}
+=>
+{
+  :uriString :is ?s .
+  :uriResource :is ?r .
+}.
+

package/examples/witch.n3

@@ -0,0 +1,33 @@
+# --------------
+# Burn the witch
+# --------------
+#
+# http://clarkparsia.com/weblog/2007/01/02/burn-the-witch/
+# http://www.netfunny.com/rhf/jokes/90q4/burnher.html
+
+# original http://www.w3.org/2000/10/swap/test/reason/witch.n3
+
+@prefix : <https://eyereasoner.github.io/eye/reasoning/witch#>.
+
+#[1]     BURNS(x) /\ WOMAN(x)         =>    WITCH(x)
+{ ?x a :BURNS. ?x a :WOMAN } => { ?x a :WITCH }.
+
+#[2]    WOMAN(GIRL)
+:GIRL a :WOMAN.
+
+#[3]    \forall x, ISMADEOFWOOD(x)    =>    BURNS(x)
+{ ?x a :ISMADEOFWOOD } => { ?x a :BURNS }.
+
+#[4]    \forall x, FLOATS(x)         =>    ISMADEOFWOOD(x)
+{ ?x a :FLOATS } => { ?x a :ISMADEOFWOOD }.
+
+#[5]    FLOATS(DUCK)
+
+:DUCK a :FLOATS.
+
+#[6]    \forall x,y FLOATS(x) /\ SAMEWEIGHT(x,y) =>    FLOATS(y)
+{ ?x a :FLOATS. ?x :SAMEWEIGHT ?y } => { ?y a :FLOATS }.
+
+# and, by experiment
+# [7]    SAMEWEIGHT(DUCK,GIRL)
+:DUCK :SAMEWEIGHT :GIRL.

package/examples/zebra.n3

@@ -0,0 +1,47 @@
+# ---------------
+# Einstein Riddle
+# ---------------
+#
+# The situation:
+# - There are 5 houses in five different colors.
+# - In each house lives a person with a different nationality.
+# - These five owners drink a certain type of beverage, smoke a certain brand of cigar and keep a certain pet.
+# - No owners have the same pet, smoke the same brand of cigar or drink the same beverage.
+#
+# The question is:
+#  Who owns the fish?
+
+@prefix list: <http://www.w3.org/2000/10/swap/list#>.
+@prefix log: <http://www.w3.org/2000/10/swap/log#>.
+@prefix : <http://eulersharp.sourceforge.net/2005/11swap/zebra#>.
+
+{   ?L log:equalTo ((?A1 :norwegian ?A2 ?A3 ?A4) (:blue ?A5 ?A6 ?A7 ?A8) (?A9 ?A10 ?A11 :milk ?A12) ?A13 ?A14);
+        :pair ((?A15 ?A16 ?A17 ?A18 :blends) (?A19 ?A20 :cats ?A21 ?A22));
+        :pair ((?A23 ?A24 :horse ?A25 ?A26) (?A27 ?A28 ?A29 ?A30 :dunhill));
+        :sublist ((:green ?A31 ?A32 :coffee ?A33) (:white ?A34 ?A35 ?A36 ?A37));
+        :pair ((?A38 ?A39 ?A40 ?A41 :blends) (?A42 ?A43 ?A44 :water ?A45));
+        list:member (:red :brit ?A46 ?A47 ?A48);
+        list:member (?A49 :swede :dogs ?A50 ?A51);
+        list:member (?A52 :dane ?A53 :tea ?A54);
+        list:member (?A55 ?A56 :birds ?A57 :pallmall);
+        list:member (:yellow ?A58 ?A59 ?A60 :dunhill);
+        list:member (?A61 ?A62 ?A63 :beer :bluemasters);
+        list:member (?A64 :german ?A65 ?A66 :prince);
+        list:member (?A67 ?B :fish ?A69 ?A70).
+}
+=>
+{   ?B :eats :fish.
+}.
+
+{?A :pair (?B ?C)} <=
+{   ?A :sublist (?B ?C).
+}.
+
+{?A :pair (?B ?C)} <=
+{   ?A :sublist (?C ?B).
+}.
+
+{?A :sublist ?B} <=
+{   (?C ?D) list:append ?A.
+    (?E ?B) list:append ?C.
+}.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eyeling",
-  "version": "1.5.12",
+  "version": "1.5.14",
   "description": "A minimal Notation3 (N3) reasoner in JavaScript.",
   "main": "./index.js",
   "keywords": [
@@ -20,6 +20,8 @@
   "files": [
     "index.js",
     "eyeling.js",
+    "test",
+    "examples",
     "README.md",
     "LICENSE.md"
   ],
@@ -27,6 +29,9 @@
     "node": ">=18"
   },
   "scripts": {
-    "test": "node test/api.test.js"
+    "test:api": "node test/api.test.js",
+    "test:examples": "bash -lc 'cd examples && ./test'",
+    "test:package": "bash test/package-smoke.sh",
+    "test": "npm run test:api && npm run test:examples"
   }
 }

package/test/api.test.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const { reason } = require('..'); // gebruikt package main: ./index.js
+
+const input = `
+{ <http://example.org/s> <http://example.org/p> <http://example.org/o>. }
+  => { <http://example.org/s> <http://example.org/q> <http://example.org/o>. }.
+
+<http://example.org/s> <http://example.org/p> <http://example.org/o>.
+`;
+
+const out = reason({ proofComments: false }, input);
+
+// Verwacht dat de afgeleide triple aanwezig is (tolerant voor formatting)
+assert.match(
+  out,
+  /<http:\/\/example\.org\/s>\s+<http:\/\/example\.org\/q>\s+<http:\/\/example\.org\/o>\s*\./
+);
+
+console.log('OK: reason() inferred expected triple');
+