@kurrawongai/codemirror-lang-turtle12 0.2.1 → 0.4.0

package/src/index.ts

@@ -14,10 +14,13 @@ import { parser as rawParser } from './turtle.grammar';
 import { turtleHighlighting } from './highlight';
 import { turtleCompletionSource } from './complete';
 import type { CompletionOptions } from './complete';
+import { parseErrorLinter } from './lint';
 
 export type { CompletionOptions, PrefixMap, PrefixSource } from './complete';
 export { documentPrefixes, knownPrefixes, turtleCompletionSource } from './complete';
 export { turtleHighlighting } from './highlight';
+export { parseErrorLinter, parseErrors } from './lint';
+export type { ParseError } from './lint';
 
 /** The unconfigured grammar, for callers that want their own `top` or props. */
 export const parser: LRParser = rawParser;
@@ -46,7 +49,20 @@ const statementFold = (node: SyntaxNode, state: EditorState) => {
 };
 
 /**
- * Highlighting, folding and indentation, shared by all four dialects.
+ * Fold an RDF Patch transaction from the end of its `TX .` row to the start of
+ * its `TC .` or `TA .` row, so both rows stay visible.
+ */
+const transactionFold = (node: SyntaxNode, state: EditorState) => {
+  const begin = node.getChild('TxBegin');
+  const end = node.getChild('TxCommit') ?? node.getChild('TxAbort');
+  if (!begin || !end) return null;
+  const from = state.doc.lineAt(begin.to).to;
+  const to = state.doc.lineAt(end.from).from - 1;
+  return to > from ? { from, to } : null;
+};
+
+/**
+ * Highlighting, folding and indentation, shared by all five dialects.
  *
  * Exported so a consumer can re-configure the parser with props of their own —
  * extra `styleTags`, say, to tag the three RDF 1.2 constructs' regions apart
@@ -64,6 +80,7 @@ export const turtleProps = [
     ReifiedTriple: delimitedIndent({ closing: '>>' }),
   }),
   foldNodeProp.add({
+    Transaction: transactionFold,
     BlankNodePropertyList: foldInside,
     Collection: foldInside,
     WrappedGraph: foldInside,
@@ -78,9 +95,17 @@ const languageData = {
   indentOnInput: /^\s*[\]})]$/,
 };
 
+const LANGUAGE_NAMES: Record<string, string> = {
+  TurtleDoc: 'turtle',
+  TrigDoc: 'trig',
+  NTriplesDoc: 'ntriples',
+  NQuadsDoc: 'nquads',
+  RdfPatchDoc: 'rdfpatch',
+};
+
 function define(top: string) {
   return LRLanguage.define({
-    name: top === 'TurtleDoc' ? 'turtle' : top === 'TrigDoc' ? 'trig' : top === 'NTriplesDoc' ? 'ntriples' : 'nquads',
+    name: LANGUAGE_NAMES[top],
     parser: rawParser.configure({ top, props: turtleProps }),
     languageData,
   });
@@ -90,10 +115,12 @@ export const turtleLanguage = define('TurtleDoc');
 export const trigLanguage = define('TrigDoc');
 export const ntriplesLanguage = define('NTriplesDoc');
 export const nquadsLanguage = define('NQuadsDoc');
+export const rdfPatchLanguage = define('RdfPatchDoc');
 
 function support(language: LRLanguage, options: CompletionOptions, dialect: 'turtle' | 'trig') {
   return new LanguageSupport(language, [
     language.data.of({ autocomplete: turtleCompletionSource(options, dialect) }),
+    parseErrorLinter(),
   ]);
 }
 
@@ -115,10 +142,21 @@ export function trig(options: CompletionOptions = {}): LanguageSupport {
  * an editor that colours it as valid is lying about the file it will write.
  */
 export function ntriples(): LanguageSupport {
-  return new LanguageSupport(ntriplesLanguage);
+  return new LanguageSupport(ntriplesLanguage, parseErrorLinter());
 }
 
 /** RDF 1.2 N-Quads. */
 export function nquads(): LanguageSupport {
-  return new LanguageSupport(nquadsLanguage);
+  return new LanguageSupport(nquadsLanguage, parseErrorLinter());
+}
+
+/**
+ * RDF Patch (https://afs.github.io/rdf-delta/rdf-patch.html).
+ *
+ * Rows take N-Quads terms. `A` and `PA` rows are tagged `inserted`, and `D` and
+ * `PD` rows `deleted`, so a style can show a patch as a diff. A transaction
+ * folds between its `TX .` and `TC .` rows.
+ */
+export function rdfPatch(): LanguageSupport {
+  return new LanguageSupport(rdfPatchLanguage, parseErrorLinter());
 }

package/src/lint.ts

@@ -0,0 +1,53 @@
+import { ensureSyntaxTree } from '@codemirror/language';
+import { linter } from '@codemirror/lint';
+import type { EditorState, Extension } from '@codemirror/state';
+
+export interface ParseError {
+  from: number;
+  to: number;
+  message: string;
+}
+
+/**
+ * How long to spend completing the parse before reporting errors. A partial
+ * tree ends in error nodes that are not in the document, so nothing is
+ * reported until the parse reaches the end.
+ */
+const PARSE_TIMEOUT_MS = 1000;
+
+/** Whitespace and `#` comments: what may separate error nodes in one run. */
+const GAP = /^(?:\s|#.*)*$/;
+
+/**
+ * Every parse error in the document.
+ *
+ * The parser recovers by skipping one token at a time, so `this is a test`
+ * produces four error nodes. Nodes separated only by whitespace or comments are
+ * merged into one error.
+ */
+export function parseErrors(state: EditorState): ParseError[] {
+  const tree = ensureSyntaxTree(state, state.doc.length, PARSE_TIMEOUT_MS);
+  if (!tree) return [];
+  const runs: { from: number; to: number }[] = [];
+  tree.iterate({
+    enter: (node) => {
+      if (!node.type.isError) return;
+      const last = runs[runs.length - 1];
+      if (last && (node.from <= last.to || GAP.test(state.sliceDoc(last.to, node.from))))
+        last.to = Math.max(last.to, node.to);
+      else runs.push({ from: node.from, to: node.to });
+    },
+  });
+  return runs.map(({ from, to }) => ({ from, to, message: errorMessage(state.sliceDoc(from, to)) }));
+}
+
+function errorMessage(text: string): string {
+  const shown = text.replace(/\s+/g, ' ').trim();
+  if (!shown) return 'Syntax error.';
+  return `Unexpected “${shown.length > 32 ? `${shown.slice(0, 32)}…` : shown}”.`;
+}
+
+/** Underline every parse error. Included in `turtle()`, `trig()`, `ntriples()`, `nquads()` and `rdfPatch()`. */
+export function parseErrorLinter(): Extension {
+  return linter((view) => parseErrors(view.state).map((error) => ({ ...error, severity: 'error' })));
+}