@gram-data/tree-sitter-gram 0.1.11 → 0.2.1

package/grammar.js

@@ -1,208 +1,394 @@
 module.exports = grammar({
-  name: 'gram',
+  name: "gram",
 
-  rules: {
+  extras: ($) => [
+    /\s/,
+    $.comment,
+  ],
 
-    gram: $ => seq(
-      field('root', optional($.record)), 
-      repeat($.pattern)
-    ),
-
-    pattern: $ => commaSep1($.pattern_element),
-
-    pattern_element: $ => seq(
-      field("annotations", optional(repeat($.annotation))), 
-      field("element", choice(
-        $.subject,
-        $._path,
-        $._reference
-      ))
-    ),
-
-    // ABKNOTE -- consider the naming of the two parts of a subject
-    // attributes & association
-    // information & association
-    subject: $ => seq("[", field("attributes", optional($._attributes)), field("association", optional($._association)),"]"),
-
-    annotation: $ => seq(
-      "@",
-      field('key', $.symbol),
-      "(",
-      field('value', $._value),
-      ")"
-    ),
-    
-    _path: $ => choice(
-      $.relationship,
-      $.node
-    ),
-
-    node: $ => seq(token("("), field("attributes", optional($._attributes)), token(")")),
-
-    relationship: $ => seq(field("left", $.node), field("value", $._relationship_value), field("right", $._path)),
-    
-    _association: $ => seq(
-      token("|"),
-      $.pattern
-    ),
-
-    _reference: $ => $._value,
-
-    _attributes: $ => choice(
-      choice(field("identifier", $._value), field("labels", $.labels), field("record", $.record)), 
-      seq(field("identifier", $._value), field("labels", $.labels)),
-      seq(field("identifier", $._value), field("record", $.record)),
-      seq(field("labels", $.labels), field("record", $.record)),
-      seq(field("identifier", $._value), field("labels", $.labels), field("record", $.record))
-    ),
-
-    _value: $ => choice(
-      prec.right(2, $.range),
-      prec.right(1, $._numeric_literal),
-      $.symbol,
-      $._string_literal,
-      $.math_symbol,
-      $.greek,
-      $.pictograph
-    ),
-
-    _binder: $ => token(/::?/),
-
-    labels: $ => repeat1($.label),
-
-    label: $ => seq($._binder, field("symbol", $.symbol)),
-
-    record: $ => seq("{", commaSep($.property), "}"),
-
-    _key: $ => choice(
-      $.symbol,
-      $._string_literal
-    ),
-
-    property: $ => seq(
-      field('key', $._key),
-      $._binder,
-      field('value', $._value)
-    ),
-
-    symbol: $ => token(/[a-zA-Z_][0-9a-zA-Z_.\-@]*/),
-
-
-    greek: $ => token(/[\u03B1-\u03C9\u0391-\u03A9]/),
-    math_symbol: $ => token(/\p{Other_Math}/),
-    pictograph: $ => token(/[\u2650-\u26FF]/),
-
-    range: $ => choice(
-      seq(field("lower", $._numeric_literal), "..", field("upper", $._numeric_literal)),
-      seq(field("lower", $._numeric_literal), "..."),
-      seq("...", field("upper", $._numeric_literal))
-    ),
-
-    _numeric_literal: $ => choice(
-      $.integer,
-      $.decimal,
-      $.hexadecimal,
-      $.octal,
-      $.measurement
-    ),
-
-    integer: $ => {
-      const integer = /-?(0|[1-9]\d*)/;      
+  rules: {
+    gram: ($) => seq(field("root", optional($.record)), repeat($.pattern)),
+
+    pattern: ($) =>
+      seq(
+        field("annotations", optional($.annotations)),
+        field("elements", commaSep1($._pattern_element)),
+      ),
+    _pattern_element: ($) => choice($.subject, $._path),
+
+    subject: ($) =>
+      seq(
+        "[",
+        field("attributes", optional($._attributes)),
+        field("pattern", optional(seq("|", $.sub_pattern))),
+        "]",
+      ),
+
+    sub_pattern: ($) => commaSep1($._sub_pattern_element),
+
+    _sub_pattern_element: ($) => choice($.subject, $._path, $.reference),
+
+    annotations: ($) => repeat1($.annotation),
+
+    annotation: ($) =>
+      seq("@", field("key", $.symbol), "(", field("value", $._value), ")"),
+
+    _path: ($) => choice($.relationship, $.node),
+
+    node: ($) =>
+      seq(
+        "(",
+        field("annotations", optional($.annotations)),
+        field("attributes", optional($._attributes)),
+        ")",
+      ),
+
+    relationship: ($) =>
+      seq(
+        field("left", $.node),
+        field("kind", $._relationship_kind),
+        field("right", $._path),
+      ),
+
+    reference: ($) => field("identifier", $._identifier),
+
+    _identifier: ($) => choice($.symbol, $.string_literal, $.integer),
+
+    _attributes: ($) =>
+      choice(
+        choice(
+          field("identifier", $._identifier),
+          field("labels", $.labels),
+          field("record", $.record),
+        ),
+        seq(field("identifier", $._identifier), field("labels", $.labels)),
+        seq(field("identifier", $._identifier), field("record", $.record)),
+        seq(field("labels", $.labels), field("record", $.record)),
+        seq(
+          field("identifier", $._identifier),
+          field("labels", $.labels),
+          field("record", $.record),
+        ),
+      ),
+
+    _value: ($) =>
+      choice(
+        prec.right(2, $.range),
+        prec.right(1, $._numeric_literal),
+        prec(3, $.boolean_literal),
+        prec(2, $.tagged_string),
+        prec(1, $.symbol),
+        $.string_literal,
+        $.array,
+        $.map,
+      ),
+
+    _scalar_value: ($) =>
+      choice(
+        prec.right(2, $.range),
+        prec.right(1, $._numeric_literal),
+        prec(3, $.boolean_literal),
+        prec(2, $.tagged_string),
+        prec(1, $.symbol),
+        $.string_literal,
+      ),
+
+    array: ($) => seq("[", commaSep1($._scalar_value), "]"),
+
+    labels: ($) => repeat1($._label),
+
+    _label: ($) => seq(choice(":", "::"), $.symbol),
+
+    record: ($) => seq("{", commaSep($.property), "}"),
+
+    property: ($) =>
+      seq(
+        field("key", $._identifier),
+        choice(":", "::"),
+        field("value", $._value),
+      ),
+
+    map: ($) => seq("{", commaSep($.mapping), "}"),
+
+    mapping: ($) =>
+      seq(field("key", $._identifier), ":", field("value", $._scalar_value)),
+
+    symbol: ($) => token(/[a-zA-Z_][0-9a-zA-Z_.\-@]*/),
+
+    range: ($) =>
+      choice(
+        seq(
+          field("lower", $._numeric_literal),
+          "..",
+          field("upper", $._numeric_literal),
+        ),
+        seq(field("lower", $._numeric_literal), "..."),
+        seq("...", field("upper", $._numeric_literal)),
+      ),
+
+    boolean_literal: ($) => choice("true", "false"),
+
+    _numeric_literal: ($) =>
+      choice($.integer, $.decimal, $.hexadecimal, $.octal, $.measurement),
+
+    integer: ($) => {
+      const integer = /-?(0|[1-9]\d*)/;
       return token(integer);
     },
 
-    decimal: $ => {
-      const decimal = /-?(0|[1-9]\d*)\.\d+/;      
+    decimal: ($) => {
+      const decimal = /-?(0|[1-9]\d*)\.\d+/;
       return token(decimal);
     },
 
-    hexadecimal: $ => {
-      const hexadecimal = /0x[0-9a-fA-F]+/;      
+    hexadecimal: ($) => {
+      const hexadecimal = /0x[0-9a-fA-F]+/;
       return token(hexadecimal);
     },
 
-    octal: $ => {
-      const octal = /0[0-7]+/;      
+    octal: ($) => {
+      const octal = /0[0-7]+/;
       return token(octal);
     },
 
-    measurement: $ => {
+    measurement: ($) => {
       // /-?(?:[0-9]|[1-9][0-9]+)(?:\.[0-9]+)?[a-zA-Z]+\b(?!@)/
-      const measurement = /-?(0|[1-9]\d*)([a-zA-Z]+)/;      
+      const measurement = /-?(0|[1-9]\d*)([a-zA-Z]+)/;
       return token(measurement);
     },
 
-    _string_literal: $ => choice(
-      $.single_quoted_string,
-      $.double_quoted_string,
-      $.backticked_string,
-      $.tagged_string,
-      $.fenced_string
-    ),
-
-    single_quoted_string: $ => {
-      const quoted = /'(\\['bfnrt/\\]|[^'\n])*'/;      
-      return token(quoted);
-    },
-
-    double_quoted_string: $ => {
-      const quoted = /"(\\["bfnrt/\\]|[^"\n])*"/;      
-      return token(quoted);
-    },
-
-    backticked_string: $ => {
-      const quoted = /`(\\[`bfnrt/\\]|[^`\n])*`/;      
-      return token(quoted);
-    },
-
-    tagged_string: $ => {
-      const tagged = /[a-zA-Z@][0-9a-zA-Z_.@]*`[^`\n]*`/;      
-      return token(tagged);
-    },
-
-    fenced_string: $ => {
-      const fenced = /```(\\[`bfnrt/\\]|[^`])*```/;      
-      return token(fenced);
-    },
-
-    _relationship_value: $ => choice(
-      alias($.single_undirected, $.undirected),
-      alias($.double_undirected, $.undirected),
-      alias($.squiggle_undirected, $.undirected),
-      alias($.single_bidirectional, $.bidirectional),
-      alias($.double_bidirectional, $.bidirectional),
-      alias($.squiggle_bidirectional, $.bidirectional),
-      alias($.single_left, $.left),
-      alias($.double_left, $.left),
-      alias($.squiggle_left, $.left),
-      alias($.single_right, $.right),
-      alias($.double_right, $.right),
-      alias($.squiggle_right, $.right)
-    ),
-    
-    // undirected: $ => alias(choice(
-    //   $.single_undirected,
-    //   $.double_undirected,
-    //   $.squiggle_undirected
-    // ), $.undirected),
-
-    single_undirected: $ => seq("-", optional(seq("[", $._attributes, "]")), "-"),
-    single_bidirectional: $ => seq("<-", optional(seq("[", $._attributes, "]")), "->"),
-    single_right: $ => seq("-", optional(seq("[", $._attributes, "]")), "->"),
-    single_left: $ => seq("<-", optional(seq("[", $._attributes, "]")), "-"),
-
-    double_undirected: $ => seq("=", optional(seq("[", $._attributes, "]")), "="),
-    double_bidirectional: $ => seq("<=", optional(seq("[", $._attributes, "]")), "=>"),
-    double_right: $ => seq("=", optional(seq("[", $._attributes, "]")), "=>"),
-    double_left: $ => seq("<=", optional(seq("[", $._attributes, "]")), "="),
-
-    squiggle_undirected: $ => seq("~", optional(seq("[", $._attributes, "]")), "~"),
-    squiggle_bidirectional: $ => seq("<~", optional(seq("[", $._attributes, "]")), "~>"),
-    squiggle_right: $ => seq("~", optional(seq("[", $._attributes, "]")), "~>"),
-    squiggle_left: $ => seq("<~", optional(seq("[", $._attributes, "]")), "~"),
-  }
+    string_literal: ($) =>
+      choice(
+        $._single_quoted_string,
+        $._double_quoted_string,
+        $._backticked_string,
+        $._fenced_string,
+      ),
+
+    _single_quoted_string: ($) =>
+      delimit_string(alias($._single_quoted_text, $.string_content), "'"),
+
+    _single_quoted_text: ($) => token.immediate(/(\\['bfnrt/\\]|[^'\\\n])*/),
+
+    _double_quoted_string: ($) =>
+      delimit_string(alias($._double_quoted_text, $.string_content), '"'),
+
+    _double_quoted_text: ($) => token.immediate(/(\\["bfnrt/\\]|[^"\\\n])*/),
+
+    _backticked_string: ($) =>
+      delimit_string(alias($._backticked_text, $.string_content), "`"),
+
+    _backticked_text: ($) => token.immediate(/(\\[`bfnrt/\\]|[^`\\\n])*/),
+
+    _fenced_string: ($) => seq("```", $._fenced_string_body),
+
+    _fenced_string_body: ($) =>
+      seq(
+        "\n",
+        field(
+          "content",
+          optional(alias($._fenced_string_content, $.string_content)),
+        ),
+        "```",
+      ),
+
+    _fenced_string_content: ($) => token.immediate(/([^`]|`[^`]|``[^`])+/),
+
+    tagged_string: ($) =>
+      choice(
+        seq(
+          field("tag", $.symbol),
+          "`",
+          field("content", alias($._backticked_text, $.string_content)),
+          "`",
+        ),
+        seq(
+          "```",
+          field("tag", $.symbol),
+          "\n",
+          field(
+            "content",
+            optional(alias($._fenced_string_content, $.string_content)),
+          ),
+          "```",
+        ),
+      ),
+
+    _relationship_kind: ($) =>
+      choice(
+        $.undirected_arrow,
+        $.left_arrow,
+        $.right_arrow,
+        $.bidirectional_arrow,
+      ),
+
+    undirected_arrow: ($) =>
+      choice(
+        seq(
+          "-",
+          optional(
+            seq(
+              "[",
+              field("annotations", optional($.annotations)),
+              field("attributes", optional($._attributes)),
+              "]",
+            ),
+          ),
+          "-",
+        ),
+        seq(
+          "=",
+          optional(
+            seq(
+              "[",
+              field("annotations", optional($.annotations)),
+              field("attributes", optional($._attributes)),
+              "]",
+            ),
+          ),
+          "=",
+        ),
+        seq(
+          "~",
+          optional(
+            seq(
+              "[",
+              field("annotations", optional($.annotations)),
+              field("attributes", optional($._attributes)),
+              "]",
+            ),
+          ),
+          "~",
+        ),
+      ),
+
+    right_arrow: ($) =>
+      choice(
+        seq(
+          "-",
+          optional(
+            seq(
+              "[",
+              field("annotations", optional($.annotations)),
+              field("attributes", optional($._attributes)),
+              "]",
+            ),
+          ),
+          "->",
+        ),
+        seq(
+          "=",
+          optional(
+            seq(
+              "[",
+              field("annotations", optional($.annotations)),
+              field("attributes", optional($._attributes)),
+              "]",
+            ),
+          ),
+          "=>",
+        ),
+        seq(
+          "~",
+          optional(
+            seq(
+              "[",
+              field("annotations", optional($.annotations)),
+              field("attributes", optional($._attributes)),
+              "]",
+            ),
+          ),
+          "~>",
+        ),
+      ),
+
+    left_arrow: ($) =>
+      choice(
+        seq(
+          "<-",
+          optional(
+            seq(
+              "[",
+              field("annotations", optional($.annotations)),
+              field("attributes", optional($._attributes)),
+              "]",
+            ),
+          ),
+          "-",
+        ),
+        seq(
+          "<=",
+          optional(
+            seq(
+              "[",
+              field("annotations", optional($.annotations)),
+              field("attributes", optional($._attributes)),
+              "]",
+            ),
+          ),
+          "=",
+        ),
+        seq(
+          "<~",
+          optional(
+            seq(
+              "[",
+              field("annotations", optional($.annotations)),
+              field("attributes", optional($._attributes)),
+              "]",
+            ),
+          ),
+          "~",
+        ),
+      ),
+
+    bidirectional_arrow: ($) =>
+      choice(
+        seq(
+          "<-",
+          optional(
+            seq(
+              "[",
+              field("annotations", optional($.annotations)),
+              field("attributes", optional($._attributes)),
+              "]",
+            ),
+          ),
+          "->",
+        ),
+        seq(
+          "<=",
+          optional(
+            seq(
+              "[",
+              field("annotations", optional($.annotations)),
+              field("attributes", optional($._attributes)),
+              "]",
+            ),
+          ),
+          "=>",
+        ),
+        seq(
+          "<~",
+          optional(
+            seq(
+              "[",
+              field("annotations", optional($.annotations)),
+              field("attributes", optional($._attributes)),
+              "]",
+            ),
+          ),
+          "~>",
+        ),
+      ),
+
+    comment: ($) => token(seq("//", /.*/)),
+  },
 });
 
+function delimit_string(rule, delimiter) {
+  return seq(delimiter, field("content", rule), delimiter);
+}
 /**
  * Creates a rule to match one or more of the rules separated by a comma
  *
@@ -212,7 +398,7 @@ module.exports = grammar({
  *
  */
 function commaSep1(rule) {
-  return seq(rule, repeat(seq(',', rule)));
+  return seq(rule, repeat(seq(",", rule)));
 }
 
 /**
@@ -227,7 +413,6 @@ function commaSep(rule) {
   return optional(commaSep1(rule));
 }
 
-
 /**
  * Creates a rule to match one or more of the rules separated by a colon
  *
@@ -237,10 +422,9 @@ function commaSep(rule) {
  *
  */
 function colonSep1(rule) {
-  return seq(rule, repeat(seq(':', rule)));
+  return seq(rule, repeat(seq(":", rule)));
 }
 
-
 /**
  * Creates a rule to match one or more of the rules separated by another rule
  *
@@ -251,4 +435,4 @@ function colonSep1(rule) {
  */
 function ruleSep1(rule, separator) {
   return seq(rule, repeat(seq(separator, rule)));
-}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gram-data/tree-sitter-gram",
-  "version": "0.1.11",
+  "version": "0.2.1",
   "description": "subject-oriented notation for structured data",
   "homepage": "https://gram-data.github.io",
   "repository": {
@@ -13,13 +13,18 @@
     "install": "node-gyp-build",
     "prestart": "tree-sitter build --wasm",
     "start": "tree-sitter playground",
-    "test": "node --test bindings/node/*_test.js"
+    "test": "node --test bindings/node/*_test.js",
+    "zed:dev": "ZED_REPO_MODE=dev bash scripts/prepare-zed-extension.sh",
+    "zed:publish": "ZED_REPO_MODE=pub bash scripts/prepare-zed-extension.sh"
   },
   "keywords": [
     "tree-sitter",
     "parser",
     "gram",
-    "json"
+    "json",
+    "zed",
+    "editor",
+    "syntax-highlighting"
   ],
   "files": [
     "grammar.js",
@@ -27,7 +32,8 @@
     "prebuilds/**",
     "bindings/node/*",
     "queries/*",
-    "src/**"
+    "src/**",
+    "editors/**"
   ],
   "author": "",
   "license": "ISC",