tree-sitter-familymarkup 1.8.3

package/LICENSE

@@ -0,0 +1,22 @@
+BSD 4-Clause License
+
+Copyright (c) 2024, Sergii Kliuchnyk
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+3. All advertising materials mentioning features or use of this software must display the following acknowledgement: This product includes software developed by Sergii Kliuchnyk.
+4. Neither the name of Sergii Kliuchnyk nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/README.md

@@ -0,0 +1,3 @@
+# tree-sitter-familymarkup
+
+[![Go Reference](https://pkg.go.dev/badge/github.com/redexp/tree-sitter-familymarkup.svg)](https://pkg.go.dev/github.com/redexp/tree-sitter-familymarkup)

package/binding.gyp

@@ -0,0 +1,30 @@
+{
+  "targets": [
+    {
+      "target_name": "tree_sitter_familymarkup_binding",
+      "dependencies": [
+        "<!(node -p \"require('node-addon-api').targets\"):node_addon_api_except",
+      ],
+      "include_dirs": [
+        "src",
+      ],
+      "sources": [
+        "bindings/node/binding.cc",
+        "src/parser.c",
+        # NOTE: if your language has an external scanner, add it here.
+      ],
+      "conditions": [
+        ["OS!='win'", {
+          "cflags_c": [
+            "-std=c11",
+          ],
+        }, { # OS == "win"
+          "cflags_c": [
+            "/std:c11",
+            "/utf-8",
+          ],
+        }],
+      ],
+    }
+  ]
+}

package/bindings/node/binding.cc

@@ -0,0 +1,20 @@
+#include <napi.h>
+
+typedef struct TSLanguage TSLanguage;
+
+extern "C" TSLanguage *tree_sitter_familymarkup();
+
+// "tree-sitter", "language" hashed with BLAKE2
+const napi_type_tag LANGUAGE_TYPE_TAG = {
+  0x8AF2E5212AD58ABF, 0xD5006CAD83ABBA16
+};
+
+Napi::Object Init(Napi::Env env, Napi::Object exports) {
+    exports["name"] = Napi::String::New(env, "familymarkup");
+    auto language = Napi::External<TSLanguage>::New(env, tree_sitter_familymarkup());
+    language.TypeTag(&LANGUAGE_TYPE_TAG);
+    exports["language"] = language;
+    return exports;
+}
+
+NODE_API_MODULE(tree_sitter_familymarkup_binding, Init)

package/bindings/node/binding_test.js

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+
+const assert = require("node:assert");
+const { test } = require("node:test");
+
+test("can load grammar", () => {
+  const parser = new (require("tree-sitter"))();
+  assert.doesNotThrow(() => parser.setLanguage(require(".")));
+});

package/bindings/node/index.d.ts

@@ -0,0 +1,28 @@
+type BaseNode = {
+  type: string;
+  named: boolean;
+};
+
+type ChildNode = {
+  multiple: boolean;
+  required: boolean;
+  types: BaseNode[];
+};
+
+type NodeInfo =
+  | (BaseNode & {
+      subtypes: BaseNode[];
+    })
+  | (BaseNode & {
+      fields: { [name: string]: ChildNode };
+      children: ChildNode[];
+    });
+
+type Language = {
+  name: string;
+  language: unknown;
+  nodeTypeInfo: NodeInfo[];
+};
+
+declare const language: Language;
+export = language;

package/bindings/node/index.js

@@ -0,0 +1,7 @@
+const root = require("path").join(__dirname, "..", "..");
+
+module.exports = require("node-gyp-build")(root);
+
+try {
+  module.exports.nodeTypeInfo = require("../../src/node-types.json");
+} catch (_) {}

package/grammar.js

@@ -0,0 +1,97 @@
+module.exports = grammar({
+	name: 'familymarkup',
+
+  conflicts: $ => [
+    [$.family],
+    [$.relations],
+    [$.relation],
+    [$.targets],
+  ],
+
+  extras: _ => [' ', '\t'],
+
+	rules: {
+		root: $ => seq(
+      optional(choice($._nl, $._multi_newline)),
+      repeatWith($.family, $._multi_newline),
+      optional(choice($._nl, $._multi_newline)),
+    ),
+
+    _multi_newline: _ => /\r?\n[\r\n\s]*\r?\n/,
+    _nl: _ => /\r?\n/,
+
+		family: $ => seq(
+      field('name', $.family_name),
+      optional(seq(
+        $._nl,
+        repeatWith($.comment, $._nl)
+      )),
+      optional(seq(
+        $._multi_newline,
+        $.relations
+      ))
+    ),
+
+    relations: $ => repeatWith($.relation, $._multi_newline),
+
+    relation: $ => seq(
+      field('sources', $.sources),
+      field('arrow', $._arrows),
+      field('label', optional($.words)),
+      optional($._nl),
+      field('targets', optional($.targets)),
+    ),
+
+    sources: $ => repeatWith(
+      choice($.name_ref, $.name, $.unknown),
+      field('delimiter', choice('+', ',', $._words))
+    ),
+    targets: $ => repeatWith(
+      choice($.name_ref, $.name_def, $.num_unknown, $.unknown, $.comment),
+      field('delimiter', choice(',', $._nl, $._words))
+    ),
+
+    name_ref: $ => seq(alias($.name, $.surname), $.name),
+
+    family_name: $ => seq(
+      field('name', $.name),
+      field('aliases', optional($.name_aliases)),
+    ),
+
+    name_def: $ => seq(
+      field('number', optional($.num)),
+      field('surname', optional($.new_surname)),
+      field('name', $.name),
+      field('aliases', optional($.name_aliases)),
+    ),
+
+    num: _ => /\d+[.)]?/,
+
+    new_surname: $ => seq(
+      '(', $.name, ')'
+    ),
+
+    name_aliases: $ => seq(
+      '(', optional(repeatWith($.name, ',')), ')'
+    ),
+
+    comment: _ => seq(choice('*', '/', '#'), optional(/[^\n]+/)),
+
+    name: _ => /\p{Lu}[\p{L}\-\d'"]*/u,
+    
+    unknown: _ => choice('?', /\p{L}[\p{L}\-\d'" ]*\?/u),
+    num_unknown: $ => seq($.num, $.unknown),
+
+    words: _ => /\p{Ll}([\p{Ll}'"\s]*[\p{Ll}'"])?/u,
+    _words: $ => alias($.words, '_words'),
+
+    _arrows: _ => choice('=', '<->', '->', '<-', '-'),
+  },
+});
+
+function repeatWith(rule, sep) {
+  return seq(
+    rule,
+    optional(repeat(seq(sep, rule)))
+  );
+}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "tree-sitter-familymarkup",
+  "description": "Tree sitter for FamilyMarkup",
+  "version": "1.8.3",
+  "main": "bindings/node",
+  "types": "bindings/node",
+  "scripts": {
+    "install": "node-gyp-build",
+    "gb": "tree-sitter generate && tree-sitter build && rm -rf bindings/go",
+    "prestart": "tree-sitter build --wasm",
+    "start": "tree-sitter playground",
+    "test": "tree-sitter test"
+  },
+  "keywords": [
+    "tree-sitter",
+    "familymarkup"
+  ],
+  "files": [
+    "grammar.js",
+    "binding.gyp",
+    "prebuilds/**",
+    "bindings/node/*",
+    "queries/*",
+    "src/**"
+  ],
+  "author": "Sergii Kliuchnyk",
+  "license": "BSD 4-Clause",
+  "devDependencies": {
+    "prebuildify": "^6.0.0",
+    "tree-sitter-cli": "^0.24.4"
+  },
+  "dependencies": {
+    "node-addon-api": "^8.2.2",
+    "node-gyp-build": "^4.8.0"
+  },
+  "peerDependencies": {
+    "tree-sitter": "^0.21.0"
+  },
+  "peerDependenciesMeta": {
+    "tree_sitter": {
+      "optional": true
+    }
+  }
+}

package/queries/highlights.scm

@@ -0,0 +1,67 @@
+(family_name
+  (name) @class.declaration.family_name
+)
+
+(family_name
+  (name_aliases
+    (name) @class.declaration.family_name.alias
+  )
+)
+
+(name_ref
+  (surname) @class.family_name.ref
+)
+
+(name_ref
+  (name) @property.static.name.ref
+)
+
+(name_def 
+  (name) @property.declaration.static.name.def
+)
+
+(name_def 
+  (name_aliases (name) @property.declaration.static.name.def.alias)
+)
+
+(sources
+  (name) @property.static.name.ref
+)
+
+(targets
+  (name_def
+    .
+    (name) @property.static.name.ref
+    .
+  )
+)
+
+(relation
+  arrow: "="
+  (targets
+    (name_def
+      .
+      (name) @property.declaration.static.name.def
+      .
+    )
+  )
+)
+
+(new_surname
+  (name) @class.family_name.ref
+)
+
+(unknown) @string.unknown
+
+(comment) @comment
+
+(num) @number.targets
+
+(sources delimiter: _ @punctuation.delimiter.sources)
+(targets delimiter: _ @punctuation.delimiter.targets)
+
+"+" @operator.sources.join
+
+(relation arrow: _ @operator.arrow)
+
+(relation label: _ @string.label)

package/queries/locals.scm

@@ -0,0 +1,9 @@
+(targets) @local.scope
+
+(sources
+  (name_ref (name) @local.reference)
+)
+
+(targets
+  (name_def (name) @local.definition)
+)

package/src/binding.go

@@ -0,0 +1,13 @@
+package src
+
+// #cgo CFLAGS: -std=c11 -fPIC
+// #include "./tree_sitter/parser.h"
+//TSLanguage *tree_sitter_familymarkup();
+import "C"
+
+import "unsafe"
+
+// Get the tree-sitter Language for this grammar.
+func Language() unsafe.Pointer {
+	return unsafe.Pointer(C.tree_sitter_familymarkup())
+}