tree-sitter-validatetest 0.1.0

package/README.md

@@ -0,0 +1,83 @@
+# tree-sitter-validatetest
+
+GStreamer ValidateTest grammar for [tree-sitter](https://tree-sitter.github.io/).
+
+This grammar parses [`.validatetest` files](https://gstreamer.freedesktop.org/documentation/gst-devtools/gst-validate-test-file.html) used for testing GStreamer pipelines. These files are executed by `gst-validate-1.0`, `ges-launch-1.0`, or any GStreamer tool that supports the validate test format.
+
+## Features
+
+- Full support for GstStructure serialization format
+- Comments (`# ...`)
+- Variables (`$(variable_name)`)
+- Expressions (`expr(...)`)
+- Type casts (`(type)value`)
+- Property paths (`element.pad::property`)
+- Arrays with nested structures (`[...]`)
+- GstValueArray (`<...>`)
+- Value blocks (`{...}`)
+
+## Installation
+
+### Neovim (with nvim-treesitter)
+
+Add the following to your neovim configuration (e.g., `lua/plugins/validatetest.lua` for LazyVim):
+
+```lua
+-- Register the filetype
+vim.filetype.add({
+  extension = {
+    validatetest = "validatetest",
+  },
+})
+
+-- Register custom parser with nvim-treesitter
+vim.api.nvim_create_autocmd("User", {
+  pattern = "TSUpdate",
+  callback = function()
+    require("nvim-treesitter.parsers").validatetest = {
+      install_info = {
+        url = "https://github.com/thiblahute/tree-sitter-validatetest",
+        files = { "src/parser.c" },
+        branch = "main",
+      },
+    }
+  end,
+})
+
+return {}
+```
+
+Then restart neovim and run `:TSInstall validatetest`.
+
+### Rust
+
+```toml
+[dependencies]
+tree-sitter-validatetest = "0.1"
+```
+
+### Node.js
+
+```bash
+npm install tree-sitter-validatetest
+```
+
+## Development
+
+```bash
+# Install dependencies
+npm install
+
+# Generate the parser
+npx tree-sitter generate
+
+# Run tests
+npx tree-sitter test
+
+# Parse a file
+npx tree-sitter parse path/to/file.validatetest
+```
+
+## License
+
+MIT

package/binding.gyp

@@ -0,0 +1,27 @@
+{
+  "targets": [
+    {
+      "target_name": "tree_sitter_validatetest_binding",
+      "dependencies": [
+        "<!(node -p \"require('node-addon-api').targets\"):node_addon_api_except",
+      ],
+      "include_dirs": [
+        "src",
+      ],
+      "sources": [
+        "bindings/node/binding.cc",
+        "src/parser.c",
+      ],
+      "conditions": [
+        ["OS!='win'", {
+          "cflags_c": ["-std=c11"],
+          "cflags_cc": ["-std=c++17"]
+        }]
+      ],
+      "xcode_settings": {
+        "CLANG_CXX_LANGUAGE_STANDARD": "c++17",
+        "GCC_C_LANGUAGE_STANDARD": "c11"
+      }
+    }
+  ]
+}

package/bindings/node/binding.cc

@@ -0,0 +1,20 @@
+#include <napi.h>
+
+typedef struct TSLanguage TSLanguage;
+
+extern "C" TSLanguage *tree_sitter_validatetest();
+
+// "tree-sitter", "currentABIVersion" heuristic
+static Napi::Number CurrentABIVersion(const Napi::CallbackInfo& info) {
+  return Napi::Number::New(info.Env(), NAPI_VERSION);
+}
+
+Napi::Object Init(Napi::Env env, Napi::Object exports) {
+  exports["name"] = Napi::String::New(env, "validatetest");
+  auto language = Napi::External<TSLanguage>::New(env, tree_sitter_validatetest());
+  exports["language"] = language;
+  exports["currentABIVersion"] = Napi::Function::New(env, CurrentABIVersion);
+  return exports;
+}
+
+NODE_API_MODULE(tree_sitter_validatetest_binding, Init)

package/bindings/node/index.js

@@ -0,0 +1,11 @@
+const root = require("path").join(__dirname, "..", "..");
+
+module.exports =
+  typeof process.versions.bun === "string"
+    // Support `bun build --compile` by being statically analyzable enough to find the .node file at build-time
+    ? require(`../../prebuilds/${process.platform}-${process.arch}/tree-sitter-validatetest.node`)
+    : require("node-gyp-build")(root);
+
+try {
+  module.exports.nodeTypeInfo = require("../../src/node-types.json");
+} catch (_) {}

package/grammar.js

@@ -0,0 +1,259 @@
+/**
+ * @file GStreamer ValidateTest grammar for tree-sitter
+ * @author Thibault Saunier
+ * @license MIT
+ *
+ * Grammar for .validatetest files used by gst-validate-1.0, ges-launch-1.0, etc.
+ * Based on GstStructure serialization format with additional constructs
+ * for variables, expressions, and comments.
+ */
+
+/// <reference types="tree-sitter-cli/dsl" />
+// @ts-check
+
+module.exports = grammar({
+  name: "validatetest",
+
+  extras: ($) => [/\s/, $.line_continuation, $.comment],
+
+  conflicts: ($) => [
+    [$.array_structure],
+    [$.structure],
+    [$.structure, $.field_value],
+    [$.structure_name, $.array_value],
+    [$.structure_name, $.value],
+    [$.field_list],
+  ],
+
+  rules: {
+    // A file is a sequence of structures (comments handled by extras)
+    source_file: ($) => repeat($.structure),
+
+    // Comments start with # and go to end of line
+    comment: ($) => seq("#", /.*/),
+
+    // Line continuation with backslash
+    line_continuation: ($) => seq("\\", /\r?\n/),
+
+    // A structure is: name, field=value, field=value, ...
+    // Can end with semicolon, newline, or EOF
+    structure: ($) =>
+      seq($.structure_name, optional(seq(",", $.field_list)), optional(";")),
+
+    // Structure name (action type) - can be identifier or variable
+    structure_name: ($) => choice($.identifier, $.variable),
+
+    // Comma-separated list of fields (allows trailing comma)
+    field_list: ($) => seq(sep1($.field, ","), optional(",")),
+
+    // A field is: name = value
+    field: ($) =>
+      seq(field("name", $.field_name), "=", field("value", $.field_value)),
+
+    // Field name can be a simple identifier or a property path
+    field_name: ($) => choice($.property_path, $.identifier),
+
+    // Property path: element.pad::property or element::property or element::parent::parent::property
+    property_path: ($) =>
+      seq(
+        $.identifier,
+        optional(seq(".", $.identifier)),
+        repeat1(seq("::", $.identifier)),
+      ),
+
+    // Field value
+    field_value: ($) =>
+      choice(
+        $.typed_value,
+        $.value,
+        $.array,
+        $.angle_bracket_array,
+        $.nested_structure_block,
+      ),
+
+    // Typed value: (type)value or (type)[array] or (type)<array>
+    typed_value: ($) =>
+      seq("(", field("type", $.type_name), ")", field("value", choice($.value, $.array, $.angle_bracket_array))),
+
+    // Type name for casts
+    type_name: ($) => /[a-zA-Z_][a-zA-Z0-9_]*/,
+
+    // A value can be many things
+    // Order matters: more specific patterns first, unquoted_string last as fallback
+    value: ($) =>
+      choice(
+        $.string,
+        $.hex_number,
+        $.fraction,
+        $.number,
+        $.boolean,
+        $.variable,
+        $.expression,
+        prec(2, $.flags),
+        prec(2, $.namespaced_identifier),
+        $.cli_argument,
+        $.unquoted_string,
+      ),
+
+    // CLI arguments like -t, --videosink, +test-clip (used in args blocks)
+    cli_argument: ($) => /[-+][a-zA-Z][-a-zA-Z0-9_]*|--[a-zA-Z][-a-zA-Z0-9_]*/,
+
+    // Double-quoted string with escapes
+    // Expression and variable are matched first, then raw text
+    string: ($) =>
+      seq(
+        '"',
+        optional($.string_inner),
+        '"',
+      ),
+
+    // Inner content of a string (used for injections)
+    string_inner: ($) =>
+      repeat1(
+        choice(
+          $.escape_sequence,
+          $.expression,
+          $.variable,
+          $.string_content,
+          "$",  // Lone $ that's not part of $(...)
+        ),
+      ),
+
+    // String content that's not a special sequence
+    // Excludes: " (end), \ (escape), $ (variable start), e (expr start)
+    string_content: ($) => /[^"\\$e]+|e/,
+
+    // Escape sequences
+    escape_sequence: ($) => /\\./,
+
+    // Variable: $(name) or $(name.subfield)
+    variable: ($) => seq("$(", /[a-zA-Z_][a-zA-Z0-9_]*(\.[a-zA-Z0-9_]+)*/, ")"),
+
+    // Expression: expr(...)
+    // Handle nested parentheses by matching balanced content
+    expression: ($) => token(seq(
+      "expr(",
+      repeat(choice(
+        /[^()]+/,                    // Non-paren characters
+        seq("(", /[^()]*/, ")"),     // One level of nested parens
+      )),
+      ")"
+    )),
+
+    // Integer or float
+    number: ($) => {
+      const integer = /[+-]?[0-9]+/;
+      const float = /[+-]?[0-9]+\.[0-9]*/;
+      return choice(float, integer);
+    },
+
+    // Fraction: num/denom (e.g., 30/1 for framerate)
+    fraction: ($) => /[0-9]+\/[0-9]+/,
+
+    // Hexadecimal number
+    hex_number: ($) => /0x[0-9a-fA-F]+/,
+
+    // Boolean (true/false, yes/no, t/f - case insensitive)
+    // Note: 1/0 are parsed as numbers unless explicitly cast with (bool)
+    boolean: ($) => token(choice(
+      /[tT][rR][uU][eE]/,
+      /[fF][aA][lL][sS][eE]/,
+      /[yY][eE][sS]/,
+      /[nN][oO]/,
+      /[tT]/,
+      /[fF]/,
+    )),
+
+    // Flags: flag1+flag2+flag3
+    // Use token to match the whole flags expression as a single token
+    flags: ($) => token(seq(
+      /[a-zA-Z_][a-zA-Z0-9_-]*/,
+      repeat1(seq("+", /[a-zA-Z_][a-zA-Z0-9_-]*/))
+    )),
+
+    // Namespaced identifier: namespace::name
+    // Use token to match the whole namespaced identifier as a single token
+    namespaced_identifier: ($) => token(seq(
+      /[a-zA-Z_][a-zA-Z0-9_-]*/,
+      "::",
+      /[a-zA-Z_][a-zA-Z0-9_-]*/
+    )),
+
+    // Unquoted string (bare identifier or value)
+    // Using alias to make this distinct from identifier at parse level
+    unquoted_string: ($) => alias(/[a-zA-Z_][a-zA-Z0-9_\-.:/]*/, "unquoted_string"),
+
+    // Basic identifier (allows / for caps media types like video/x-raw)
+    identifier: ($) => /[a-zA-Z_][a-zA-Z0-9_\-/]*/,
+
+    // Array: [ item, item, ... ] or [ structure, structure, ... ]
+    // Allows trailing commas
+    // Uses repeat instead of sep1 because array_structure contains internal commas
+    array: ($) =>
+      seq(
+        "[",
+        repeat($.array_element),
+        "]",
+      ),
+
+    // Array element: either a structure with fields or a simple value
+    // Uses array_value instead of field_value to avoid ambiguity with bare identifiers
+    array_element: ($) =>
+      choice(
+        seq($.array_structure, optional(",")),
+        seq($.array_value, optional(",")),
+      ),
+
+    // Value types allowed directly in arrays (excludes bare identifiers to avoid ambiguity)
+    array_value: ($) =>
+      choice(
+        $.typed_value,
+        $.string,
+        $.hex_number,
+        $.fraction,
+        $.number,
+        $.boolean,
+        $.variable,
+        $.expression,
+        $.flags,
+        $.namespaced_identifier,
+        $.array,
+        $.angle_bracket_array,
+        $.nested_structure_block,
+      ),
+
+    // GstValueArray: < item, item, ... > (angle bracket array, allows trailing comma)
+    angle_bracket_array: ($) =>
+      seq(
+        "<",
+        optional(seq(sep1($.field_value, ","), optional(","))),
+        ">",
+      ),
+
+    // Structure inside an array (without the trailing semicolon rules)
+    // Fields are optional - [video/x-raw] is a valid structure with no fields
+    array_structure: ($) =>
+      seq($.structure_name, optional(seq(",", $.field_list))),
+
+    // Nested structure block: { structure, structure, ... } or { "string", "string", ... }
+    // Note: strings, arrays, and other values are captured via field_value
+    // Allows trailing commas (comments are handled automatically via extras)
+    nested_structure_block: ($) =>
+      seq(
+        "{",
+        repeat(seq(choice($.structure, $.field_value), optional(","))),
+        "}",
+      ),
+  },
+});
+
+/**
+ * Creates a rule to match one or more of the rule separated by the separator.
+ *
+ * @param {Rule} rule
+ * @param {Rule} sep
+ * @returns {SeqRule}
+ */
+function sep1(rule, sep) {
+  return seq(rule, repeat(seq(sep, rule)));
+}

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "tree-sitter-validatetest",
+  "version": "0.1.0",
+  "description": "GStreamer ValidateTest grammar for tree-sitter",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/thiblahute/tree-sitter-validatetest"
+  },
+  "license": "MIT",
+  "author": "Thibault Saunier",
+  "main": "bindings/node",
+  "types": "bindings/node",
+  "keywords": [
+    "gstreamer",
+    "validate",
+    "validatetest",
+    "tree-sitter",
+    "parser"
+  ],
+  "files": [
+    "grammar.js",
+    "binding.gyp",
+    "prebuilds/**",
+    "bindings/node/*",
+    "queries/*",
+    "src/**",
+    "*.wasm"
+  ],
+  "dependencies": {
+    "node-addon-api": "^8.3.0",
+    "node-gyp-build": "^4.8.4"
+  },
+  "devDependencies": {
+    "tree-sitter-cli": "^0.24.0",
+    "prebuildify": "^6.0.1"
+  },
+  "peerDependencies": {
+    "tree-sitter": "^0.21.1"
+  },
+  "peerDependenciesMeta": {
+    "tree-sitter": {
+      "optional": true
+    }
+  },
+  "scripts": {
+    "build": "tree-sitter generate && node-gyp build",
+    "build-wasm": "tree-sitter build --wasm",
+    "install": "node-gyp-build",
+    "prestart": "tree-sitter build --wasm",
+    "start": "tree-sitter playground",
+    "test": "tree-sitter test",
+    "prebuildify": "prebuildify --napi --strip"
+  },
+  "tree-sitter": [
+    {
+      "scope": "source.validatetest",
+      "injection-regex": "^validatetest$",
+      "file-types": [
+        "validatetest"
+      ],
+      "highlights": "queries/highlights.scm",
+      "injections": "queries/injections.scm"
+    }
+  ]
+}

package/queries/highlights.scm

@@ -0,0 +1,85 @@
+; Highlights for GStreamer ValidateTest files
+
+; Comments
+(comment) @comment
+
+; Structure/action names (function calls - actions are "called" with field arguments)
+(structure_name
+  (identifier) @function.call)
+
+(array_structure
+  (structure_name
+    (identifier) @function.call))
+
+; Field names (parameters to the action call)
+(field_name
+  (identifier) @parameter)
+
+(field_name
+  (property_path
+    (identifier) @parameter))
+
+; Type names in casts
+(typed_value
+  (type_name) @type)
+
+; Strings (quoted)
+(string) @string
+
+; Unquoted string values (use same as quoted strings)
+(unquoted_string) @string
+
+; Escape sequences within strings
+(escape_sequence) @string.escape
+
+; Numbers
+(number) @number
+(hex_number) @number
+(fraction) @number
+
+; Booleans
+(boolean) @boolean
+
+; Numbers inside (bool) or (boolean) typed values should be highlighted as booleans
+((typed_value
+  type: (type_name) @_type
+  value: (value (number) @boolean))
+ (#eq? @_type "bool"))
+
+((typed_value
+  type: (type_name) @_type
+  value: (value (number) @boolean))
+ (#eq? @_type "boolean"))
+
+; Variables like $(foo)
+(variable) @variable
+
+; Expressions like expr(...)
+(expression) @function.call
+
+; Flags (like flush+accurate)
+(flags) @constant
+
+; Namespaced identifiers (like scenario::execution-error)
+(namespaced_identifier) @module
+
+; CLI arguments (like -t, --videosink)
+(cli_argument) @attribute
+
+; Operators and punctuation
+"=" @operator
+"::" @punctuation.delimiter
+
+; Brackets and braces
+"[" @punctuation.bracket
+"]" @punctuation.bracket
+"{" @punctuation.bracket
+"}" @punctuation.bracket
+"(" @punctuation.bracket
+")" @punctuation.bracket
+"<" @punctuation.bracket
+">" @punctuation.bracket
+
+; Separators
+"," @punctuation.delimiter
+";" @punctuation.delimiter

package/queries/injections.scm

@@ -0,0 +1,62 @@
+; Injections for GStreamer ValidateTest files
+; Re-parse embedded GstStructure syntax within strings
+
+; Strings in 'configs' field contain GstStructure syntax
+((field
+  name: (field_name (identifier) @_field_name)
+  value: (field_value
+    (nested_structure_block
+      (field_value (value (string (string_inner) @injection.content))))))
+ (#eq? @_field_name "configs")
+ (#set! injection.language "validatetest")
+ (#set! injection.include-children))
+
+; Strings in 'expected-issues' field contain GstStructure syntax
+((field
+  name: (field_name (identifier) @_field_name)
+  value: (field_value
+    (nested_structure_block
+      (field_value (value (string (string_inner) @injection.content))))))
+ (#eq? @_field_name "expected-issues")
+ (#set! injection.language "validatetest")
+ (#set! injection.include-children))
+
+; Typed GstCaps values contain GstStructure/caps syntax
+((typed_value
+  type: (type_name) @_type
+  value: (value (string (string_inner) @injection.content)))
+ (#eq? @_type "GstCaps")
+ (#set! injection.language "validatetest")
+ (#set! injection.include-children))
+
+; Typed caps values (lowercase alias) contain GstStructure/caps syntax
+((typed_value
+  type: (type_name) @_type
+  value: (value (string (string_inner) @injection.content)))
+ (#eq? @_type "caps")
+ (#set! injection.language "validatetest")
+ (#set! injection.include-children))
+
+; Typed GstStructure values contain GstStructure syntax
+((typed_value
+  type: (type_name) @_type
+  value: (value (string (string_inner) @injection.content)))
+ (#eq? @_type "GstStructure")
+ (#set! injection.language "validatetest")
+ (#set! injection.include-children))
+
+; Typed structure values (lowercase alias) contain GstStructure syntax
+((typed_value
+  type: (type_name) @_type
+  value: (value (string (string_inner) @injection.content)))
+ (#eq? @_type "structure")
+ (#set! injection.language "validatetest")
+ (#set! injection.include-children))
+
+; Field named 'caps' with string value contains caps syntax
+((field
+  name: (field_name (identifier) @_field_name)
+  value: (field_value (value (string (string_inner) @injection.content))))
+ (#eq? @_field_name "caps")
+ (#set! injection.language "validatetest")
+ (#set! injection.include-children))