@matdata/yasqe 4.6.1

package/grammar/util/gen_ll1.pl

@@ -0,0 +1,37 @@
+:-dynamic fo/2.
+:-dynamic fi/2.
+:-dynamic cf/2.
+:-dynamic change/0.
+:-dynamic m/3.
+:-dynamic tm/1.
+:-dynamic '==>'/2.
+:-dynamic '=>'/2.
+:-op(550,xfy,===>).  % Rewrite rules on EBNF expressions
+:-op(500,xfy,==>).   % EBNF grammar productions
+:-op(500,xfy,=>).    % BNF grammar productions
+:-op(490,xfy,or).
+:-op(480,fy,*).
+:-op(470,xfy,\).
+
+
+:-reconsult('rewrite.pl').
+:-reconsult('ll1.pl').
+:-reconsult('prune').
+:-reconsult('output_to_javascript.pl').
+
+go:-
+	ebnf_to_bnf,
+	prune_for_top_symbol,
+	ll1_tables,
+	ll1_check,
+	output_file(Out),
+	write('Writing to '),write(Out),nl,
+	tell(Out),
+	output_table_js,
+	output_keywords_js,
+	output_punct_js,
+	js_vars(Vars),
+	output_vars_js(Vars),
+  write('}'),
+	told.
+	

package/grammar/util/gen_sparql11.pl

@@ -0,0 +1,11 @@
+
+top_symbol(sparql11).
+output_file('_tokenizer-table.js').
+
+js_vars([
+  startSymbol='"sparql11"',
+  acceptEmpty=true
+]).
+
+:-reconsult(gen_ll1).
+:-reconsult('../sparql11-grammar.pl').

package/grammar/util/ll1.pl

@@ -0,0 +1,175 @@
+
+/*
+
+Compute LL1 parse tables.
+
+fi(NT,T) means that T can be the first terminal in NT.  The special
+         token epsilon means that NT may rewrite to nothing
+         (NT is "nullable").
+
+fo(NT,T) means that nonterminal NT can be followed by terminal T.
+         - the final argument is for debugging only, and records
+           the nonterminal from which the follower T was copied.
+
+stephen.cresswell@tso.co.uk
+
+*/
+
+
+ll1_tables:-
+	retractall(cf(_,_)),
+	retractall(nt(_)),
+	retractall(fi(_,_)),
+	retractall(fo(_,_)),
+	retractall(m(_,_,_)),
+	
+	validate_rules,
+	remember1(change),
+	iterate_first,
+	remember1(change),
+	iterate_follow,
+	iterate_matrix.
+
+validate_rules:-
+	NT=>_,
+	\+ (_=>RHS, memberchk(NT,RHS) ),
+	format("Warning: unused non-terminal: ~w~n",[NT]),
+	fail.
+validate_rules:-
+	% (Check the untranslated rules)
+	LHS ==> RHS,
+	\+RHS=[],
+	\+RHS=[_|_],
+	format("Warning: atomic RHS: ~w~n",[LHS=>RHS]),
+	fail.
+validate_rules:-
+	_ => RHS,
+	member(T,RHS),
+	\+ T => _,
+	remember(tm(T)),
+	fail.
+validate_rules:-
+	tm(T),
+	\+declared_terminal(T),
+	format("Warning: undeclared terminal: ~w~n",[T]),
+	fail.
+validate_rules:-
+	declared_terminal(T),
+	\+tm(T),
+	format("Declared terminal not found in grammar: ~w~n",[T]),
+	fail.
+validate_rules.
+
+declared_terminal(T):-
+	tm_keywords(Ts),
+	member(T,Ts).
+declared_terminal(T):-
+	tm_regex(Ts),
+	member(T,Ts).
+declared_terminal(T):-
+	tm_punct(Ts),
+	member(T=_,Ts).
+
+% Repeated until no change
+iterate_first:-
+	change,
+	!,
+	retractall(change),
+	iterate,
+	iterate_first.
+iterate_first.
+
+% All possibilities
+iterate:-
+	first(A,W),
+	remember(fi(A,W)),
+	fail.
+iterate.
+
+assert_terminals:-
+	tm(Tm),
+	assertz(fi(Tm,Tm)),
+	fail.
+assert_terminals.
+        
+
+first(Tm,Tm):-
+	tm(Tm).
+first(Nonterm,F):-
+        Nonterm=>RHS,
+	first_list(RHS,F).
+
+first_list([],epsilon).
+first_list([W|RHS],F):-
+	fi(W,epsilon),
+	first_list(RHS,F).
+first_list([W|_],F):-
+	fi(W,F),
+	F \== epsilon.
+
+
+iterate_follow:-
+	change,
+	!,
+	retractall(change),
+	iterate_f,
+	iterate_follow.
+iterate_follow.
+
+iterate_f:-
+	follow,
+	fail.
+iterate_f.
+
+
+follow:-
+	B => RHS,
+	follow_list(RHS,B).
+
+follow_list([X],B):-
+	!,
+	copy_follow(B,X).
+follow_list([A|RHS],B):-
+	tm(A),!,
+	follow_list(RHS,B).	
+follow_list([A,X2|RHS],B):-
+	first_list([X2|RHS],F),
+	(F=epsilon -> 
+	    copy_follow(B,A)
+        ;
+	    remember(fo(A,F))
+        ),
+	follow_list([X2|RHS],B).	
+
+% Whatever can follow B, can follow A
+%  (applied when A can be final constituent of B)
+copy_follow(B,A):-
+	\+tm(A),
+	remember1(cf(B,A)),
+	fo(B,Fo),
+	remember(fo(A,Fo)),
+	fail.
+copy_follow(_,_).
+
+iterate_matrix:-
+	A => RHS,
+	first_list(RHS,F),
+	F \== epsilon,
+	remember1(m(A,F,A=>RHS)),
+	fail.
+iterate_matrix:-
+	A => RHS,
+	first_list(RHS,epsilon),
+	fo(A,F),
+	remember1(m(A,F,A=>RHS)),
+	fail.
+iterate_matrix.
+
+ll1_check:-
+	m(NT,T,R1),
+	m(NT,T,R2),
+	R1@<R2,
+	format('LL(1) clash - ~w, ~w,~n R1=~w~n R2=~w~n',[NT,T,R1,R2]),
+	fail.
+ll1_check:-
+	write('LL(1) check complete.'),nl.

package/grammar/util/output_to_javascript.pl

@@ -0,0 +1,75 @@
+/* Convert computed LL(1) table into javascript source
+*/
+
+output_table_js:-
+	write('module.exports = {table:'),nl,
+	setof(LHS, RHS^(LHS=>RHS), NTs),
+	form_table(NTs,'{'),
+	nl,write('},').
+
+output_terminals_js:-
+	nl,nl,write('var terminal=['),nl,
+	tm_regex(Ks),
+	member(TM,Ks),
+	format('   { name: "~w", regex:new RegExp("^"+~w) }, ~n',[TM,TM]),
+	fail.
+output_terminals_js:-
+        write('];'),nl,nl.
+output_keywords_js:-
+	tm_keywords(Ps),
+	findall(Reg,member(Reg,Ps),Regs),
+	nl,nl,write('keywords:/^('),
+	output_as_regex_disj(Regs,''),
+	write(')/i ,'),nl.
+output_punct_js:-
+	tm_punct(Ps),
+	findall(Reg,member(_=Reg,Ps),Regs),
+	nl,write('punct:/^('),
+	output_as_regex_disj(Regs,''),
+	write(')/ ,'),nl,nl.
+output_top_symbol_js:-
+	start_symbol(TS),
+	format('startSymbol:"~w";~n',[TS]).
+output_default_query_type_js:-
+	default_query_type(QT),
+	format('defaultQueryType:~w;~n',[QT]).
+output_lex_version_js:-
+	lex_version(LV),
+	format('lexVersion:"~w";~n',[LV]).
+output_accept_empty_js:-
+	accept_empty(AE),
+	format('acceptEmpty:"~w";~n',[AE]).
+
+output_vars_js([]).
+output_vars_js([Var=Val|Pairs]):-
+	format('~w:~w,~n',[Var,Val]),
+	output_vars_js(Pairs).
+
+output_as_regex_disj([],_).
+output_as_regex_disj([T|Ts],Prefix):-
+    format('~w~w',[Prefix,T]),
+    output_as_regex_disj(Ts,'|').
+
+form_table([],_).
+form_table([NT|NTs],Punc):-
+	format('~w~n  "~w" : ',[Punc,NT]),
+	findall(First-RHS,m(NT,First,_=>RHS),Pairs),
+	output_pairs(Pairs,'{'),
+	write('}'),
+	form_table(NTs,', ').
+
+output_pairs([],_).
+output_pairs([First-RHS|Pairs],Punc):-
+	format('~w~n     "~w": ',[Punc,First]),
+	write_list_strings(RHS),
+	output_pairs(Pairs, ', ').
+
+write_list_strings(Xs):-
+	write('['),
+	write_list_strings1(Xs,''),
+	write(']').
+
+write_list_strings1([],_).
+write_list_strings1([X|Xs],Punc):-
+	format('~w"~w"',[Punc,X]),
+	write_list_strings1(Xs,',').

package/grammar/util/prune.pl

@@ -0,0 +1,49 @@
+%
+% Find and remove inaccessible non-terminals
+%
+% The is used because we have SPARQL1.1 query / update
+% grammars together, but it helps (e.g. to keep autocompletion clean) 
+% for the grammars to be separated.  This is done on the basis
+% of reachability from the top symbol.
+%
+% stephen.cresswell@tso.co.uk
+
+prune_for_top_symbol:-
+	top_symbol(Top),
+	reachable_syms(Top,NTs,_Ts),
+        findall(NT,(NT=>_RHS,\+memberchk(NT,NTs)),UnreachableNTs0),
+        sort(UnreachableNTs0,UnreachableNTs),
+        delete_NTs(UnreachableNTs).
+
+delete_NTs([]).
+delete_NTs([NT|NTs]):-
+	format('Removing unreachable nonterminal ~w~n',[NT]),
+	retractall(NT=>_),
+	delete_NTs(NTs).
+
+reachable_syms(Top,NTs,Ts):-
+	NTs=[Top|_],
+	reachable(NTs,NTs,Ts),
+	once(append(NTs,[],NTs)),
+	once(append(Ts,[],Ts)).
+	
+reachable([],_,_):-!.
+reachable([NT|NTs1],NTs0,Ts):-
+	once(findall(A,(NT=>RHS,member(A,RHS)),As)),
+	includes_rhs(As,NTs0,Ts),
+	reachable(NTs1,NTs0,Ts).
+
+includes_rhs([],_,_).
+includes_rhs([A|As],NTs0,Ts):-
+	A=>_,!,
+	% Non-terminal
+	memberchk(A,NTs0),
+	includes_rhs(As,NTs0,Ts).
+includes_rhs([A|As],NTs0,Ts):-
+	memberchk(A,Ts),
+	includes_rhs(As,NTs0,Ts).
+
+write_list([]).
+write_list([H|T]):-
+	write(H),nl,
+	write_list(T).

package/grammar/util/rewrite.pl

@@ -0,0 +1,104 @@
+
+/*
+  Compile EBNF rules (==>) to BNF rules (=>).
+   - i.e. expanding out *, +, ?, 'or'
+
+stephen.cresswell@tso.co.uk
+*/
+
+
+ebnf_to_bnf:-
+	retractall(_=>_),
+	remember(change),
+	rewrite_until_stable.
+
+rewrite_until_stable:-
+	change,
+	!,
+	retractall(change),
+	rewrite_any,
+	rewrite_until_stable.
+rewrite_until_stable.
+
+rewrite_any:-
+	LHS==>RHS0,
+	rewrite(RHS0,RHS1),
+	remember(LHS=>RHS1),
+	fail.
+rewrite_any.
+
+
+*(A) ===> A_star :-
+	atom(A),
+	format(atom(A_star),"*~w",[A]),
+	remember(A_star=>[]),
+	remember(A_star=>[A,A_star]).
+
++(A) ===> A_plus :-
+	atom(A),
+	format(atom(A_plus),"+~w",[A]),
+	remember(A_plus==>[A,*(A)]). % Assert as EBNF - requires further wrangling
+
+?(A) ===> A_qm :-
+	atom(A),
+	format(atom(A_qm),"?~w",[A]),
+	remember(A_qm=>[]),
+	remember(A_qm=>[A]).
+
++A \ B ===> A_or_B :-
+	format(atom(A_or_B),"(~w or ~w)",[A,B]),
+	remember(A_or_B=>[A]),
+	remember(A_or_B=>[B]).
+
+List ===> ListAtom :-
+	List = [_|_],
+	format(atom(ListAtom),"~w",[List]),
+	remember(ListAtom=>List).
+
+OrExpr ===> ListAtom :-
+	OrExpr =.. [or|Args],
+	format(atom(ListAtom),"or(~w)",[Args]),
+	map_disjuncts(Args,ListAtom).
+
+map_disjuncts([],_).
+map_disjuncts([D|Ds],Head):-
+	remember(Head=>[D]),
+	map_disjuncts(Ds,Head).
+
+% Apply rewrite rules starting from inside outwards
+rewrite([],[]).
+rewrite([T0|Ts0],[T2|Ts1]):-
+	\+(T0 = [_|_]),
+	T0 =.. [F|Args0],
+	!,
+	rewrite(Args0,Args1),
+	T1 =.. [F|Args1],
+	rewrite_if_poss(T1,T2),
+	rewrite(Ts0,Ts1).
+rewrite([T0|Ts0],[T2|Ts1]):-
+	% A raw list (that is a sequence rather than an argument list)
+	T0 = [_|_],
+	rewrite(T0,T1),
+	rewrite_if_poss(T1,T2),
+	rewrite(Ts0,Ts1).
+
+rewrite_if_poss(T0,T1):-
+	T0 ===> T1,
+        !.
+rewrite_if_poss(T,T).
+
+remember(X):-
+	call(X),
+	!.
+remember(X):-
+	%write(X),nl,
+	assertz(change),
+	assertz(X).
+
+% Do avoid duplication, but don't assert change
+remember1(X):-
+	call(X),
+	!.
+remember1(X):-
+	%write(X),nl,
+	assertz(X).

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@matdata/yasqe",
+  "description": "Yet Another SPARQL Query Editor",
+  "version": "4.6.1",
+  "main": "build/yasqe.min.js",
+  "types": "build/ts/src/index.d.ts",
+  "license": "MIT",
+  "author": "Triply <info@triply.cc>",
+  "homepage": "https://github.com/Matdata-eu/Yasgui",
+  "engines": {
+    "node": ">= 8"
+  },
+  "keywords": [
+    "JavaScript",
+    "SPARQL",
+    "Editor",
+    "Semantic Web",
+    "Linked Data"
+  ],
+  "bugs": "https://github.com/Matdata-eu/Yasgui/issues/",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Matdata-eu/Yasgui.git",
+    "directory": "packages/yasqe"
+  },
+  "dependencies": {
+    "@matdata/yasgui-utils": "^4.6.1",
+    "codemirror": "^5.51.0",
+    "lodash-es": "^4.17.15",
+    "query-string": "^6.10.1"
+  },
+  "devDependencies": {
+    "@types/codemirror": "0.0.100",
+    "@types/lodash-es": "^4.17.3",
+    "@types/node": "^22.5.4"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/CodeMirror.ts

@@ -0,0 +1,54 @@
+//Do not want to import this using typescript. Somehow, we get a tangled mess when transpiling to es6 with ts,
+//and applying babel.
+import {
+  Editor as CmEditor,
+  Doc as CmDoc,
+  Token as CmToken,
+  Position as CmPosition,
+  EditorConfiguration as CmEditorConfiguration,
+} from "codemirror";
+
+const _CodeMirror = require("codemirror");
+
+import * as sparql11Mode from "../grammar/tokenizer";
+import { default as prefixFold } from "./prefixFold";
+import { TokenizerState } from "./index";
+
+require("codemirror/addon/fold/foldcode.js");
+require("codemirror/addon/fold/foldgutter.js");
+require("codemirror/addon/fold/xml-fold.js");
+require("codemirror/addon/fold/brace-fold.js");
+require("codemirror/addon/hint/show-hint.js");
+require("codemirror/addon/search/searchcursor.js");
+require("codemirror/addon/search/match-highlighter.js");
+require("codemirror/addon/edit/matchbrackets.js");
+require("codemirror/addon/runmode/runmode.js");
+require("codemirror/lib/codemirror.css");
+require("codemirror/addon/fold/foldgutter.css");
+require("./scss/codemirrorMods.scss");
+
+_CodeMirror.registerHelper("fold", "prefix", prefixFold);
+_CodeMirror.defineMode("sparql11", sparql11Mode.default);
+
+namespace CodeMirror {
+  export type Doc = CmDoc;
+  export type Position = CmPosition;
+  export type EditorConfiguration = CmEditorConfiguration;
+  export interface Token extends CmToken {
+    state: sparql11Mode.State;
+  }
+}
+interface CodeMirror extends Omit<CmEditor, "getOption" | "setOption" | "on" | "off"> {
+  /**
+   * Added some more specific typings for `getOption`
+   * For some functions (called from keyboard combinations like ctrl-enter) we cannot use member props of our object
+   * as these are lost when we are receiving the native CM object as argument
+   * Only way to persistently store these options is by using getOption and setOption
+   */
+  getOption(opt: "queryType"): TokenizerState["queryType"];
+  setOption(opt: "queryType", val: TokenizerState["queryType"]): void;
+
+  foldCode(firstPrefixLine: number, prefix: string, collapse: "fold" | "unfold"): void;
+}
+const CodeMirror: { new (): CodeMirror; signal: (target: any, name: string, ...args: any[]) => void } = _CodeMirror;
+export default CodeMirror;

package/src/autocompleters/classes.ts

@@ -0,0 +1,32 @@
+import * as Autocompleter from "./";
+
+var conf: Autocompleter.CompleterConfig = {
+  onInitialize: function (_yasqe) {
+    // validPosition: yasqe.autocompleters.notifications.show,
+    // invalidPosition: yasqe.autocompleters.notifications.hide
+  },
+  get: function (yasqe, token) {
+    return Autocompleter.fetchFromLov(yasqe, "class", token);
+  },
+  isValidCompletionPosition: function (yasqe) {
+    const token = yasqe.getCompleteToken();
+    if (token.string[0] === "?" || token.string[0] === "$") return false;
+    const cur = yasqe.getDoc().getCursor();
+    const previousToken = yasqe.getPreviousNonWsToken(cur.line, token);
+    if (previousToken.state.lastProperty === "a") return true;
+    if (previousToken.state.lastProperty === "rdf:type") return true;
+    if (previousToken.state.lastProperty === "rdfs:domain") return true;
+    if (previousToken.state.lastProperty === "rdfs:range") return true;
+    return false;
+  },
+  preProcessToken: function (yasqe, token) {
+    return Autocompleter.preprocessIriForCompletion(yasqe, token);
+  },
+  postProcessSuggestion: function (yasqe, token, suggestedString) {
+    return Autocompleter.postprocessIriCompletion(yasqe, token, suggestedString);
+  },
+  bulk: false,
+  name: "class",
+};
+
+export default conf;