ruby_tree_sitter 1.2.0-x86_64-linux → 1.4.0-x86_64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cfbfdfc0c297585fe24e04c4b9822ff404baa795182b7a7b144f56a3941db672
-  data.tar.gz: 010faa21be194e40cdf7f5f00986c16ee5d51d64f377097bfb307a4245ba61b6
+  metadata.gz: 701e16d45de25378b1f6e0b3e21b8c589cadb9f2f4e8af420a130d55637cd984
+  data.tar.gz: b1899ead2950b9ab9806076a0708c084221d3a8b59bbeb6a0e6848b57cbecf93
 SHA512:
-  metadata.gz: b98898e1a8b801de3599e6daebd2adaa27b2ea729a46ebe730095d31e053dfb84c48a83712364a09fd58bac236f1b499f16ced6dcf4640902d0d4c12ac4ac7be
-  data.tar.gz: 4dd45cf49030a553819febb05cc8a0755ed549c413d44ea1c88836d4e2fad3c55138db3a3079776f2e14a828c38fd7d7b11664366ea8e84083098910528950b3
+  metadata.gz: e07d00239ccab6b2ddabff6d90076bd6c42c48b9f1a5b98f8cc8fc07a4688e5d36c357c2373c2d5629676b46a3b34fc694f3ab1e97fdd5614c9e6350c2ade28c
+  data.tar.gz: 0dbbac2900d41056e4ab37b8d298351b819c9ca42296b33962f6f087a773859afc7e7de666d3d0734f883702872f90d59bf66f7546bc43510f003b47c91e11fe

data/README.md

@@ -200,4 +200,8 @@ To See a full list of the ruby-specific APIs, see [here](lib/README.md).
 
 ## Sponsors
 
-<img src="img/faveod.jpg" width="75%">
+- <a href="https://faveod.com">https://faveod.com</a>
+
+<a href="https://faveod.com">
+  <img src="img/faveod.jpg" width="66%" />
+</a>

data/ext/tree_sitter/query.c

@@ -140,6 +140,13 @@ static VALUE query_initialize(VALUE self, VALUE language, VALUE source) {
     SELF = res;
   }
 
+  rb_iv_set(self, "@text_predicates", rb_ary_new());
+  rb_iv_set(self, "@property_predicates", rb_ary_new());
+  rb_iv_set(self, "@property_settings", rb_ary_new());
+  rb_iv_set(self, "@general_predicates", rb_ary_new());
+
+  rb_funcall(self, rb_intern("process"), 1, source);
+
   return self;
 }
 

data/ext/tree_sitter/query_cursor.c

@@ -49,7 +49,7 @@ DATA_FROM_VALUE(TSQueryCursor *, query_cursor)
  *
  * @return [QueryCursor]
  */
-static VALUE query_cursor_exec(VALUE self, VALUE query, VALUE node) {
+static VALUE query_cursor_exec_static(VALUE self, VALUE query, VALUE node) {
   VALUE res = query_cursor_allocate(cQueryCursor);
   query_cursor_t *query_cursor = unwrap(res);
   ts_query_cursor_exec(query_cursor->data, value_to_query(query),
@@ -57,6 +57,21 @@ static VALUE query_cursor_exec(VALUE self, VALUE query, VALUE node) {
   return res;
 }
 
+/**
+ * Start running a given query on a given node.
+ *
+ * @param query [Query]
+ * @param node  [Node]
+ *
+ * @return [QueryCursor]
+ */
+static VALUE query_cursor_exec(VALUE self, VALUE query, VALUE node) {
+  query_cursor_t *query_cursor = unwrap(self);
+  ts_query_cursor_exec(query_cursor->data, value_to_query(query),
+                       value_to_node(node));
+  return self;
+}
+
 /**
  * Manage the maximum number of in-progress matches allowed by this query
  * cursor.
@@ -190,13 +205,14 @@ void init_query_cursor(void) {
   rb_define_alloc_func(cQueryCursor, query_cursor_allocate);
 
   /* Module methods */
-  rb_define_module_function(cQueryCursor, "exec", query_cursor_exec, 2);
+  rb_define_module_function(cQueryCursor, "exec", query_cursor_exec_static, 2);
 
   /* Class methods */
   // Accessors
   DECLARE_ACCESSOR(cQueryCursor, query_cursor, match_limit)
 
   // Other
+  rb_define_method(cQueryCursor, "exec", query_cursor_exec, 2);
   rb_define_method(cQueryCursor, "exceed_match_limit?",
                    query_cursor_did_exceed_match_limit, 0);
   rb_define_method(cQueryCursor, "match_limit", query_cursor_get_match_limit,

data/lib/tree_sitter/helpers.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+# splits an array like [rust](https://doc.rust-lang.org/std/primitive.slice.html#method.split)
+def array_split_like_rust(array, &block)
+  return enum_for(__method__, array) if !block_given?
+
+  return [] if array.empty?
+
+  result = []
+  current_slice = []
+
+  array.each do |element|
+    if yield(element)
+      result << current_slice
+      current_slice = []
+    else
+      current_slice << element
+    end
+  end
+
+  result << current_slice
+  result
+end

data/lib/tree_sitter/mixins/language.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module TreeSitter
+  # A colon-separated list of paths pointing to directories that can contain parsers.
+  # Order matters.
+  # Takes precedence over default lookup paths.
+  ENV_PARSERS =
+    ENV['TREE_SITTER_PARSERS']
+      &.split(':')
+      &.map { |v| Pathname(v) }
+      .freeze
+
+  # The default paths we use to lookup parsers.
+  # Order matters.
+  LIBDIRS = [
+    '.vendor/parsers',
+    '.vendor/tree-sitter-parsers',
+    'vendor/parsers',
+    'vendor/tree-sitter-parsers',
+    'parsers',
+    'tree-sitter-parsers',
+    '/opt/local/lib',
+    '/opt/lib',
+    '/usr/local/lib',
+    '/usr/lib',
+  ].map { |p| Pathname(p) }.freeze
+
+  # Mixins.
+  module Mixins
+    # Language Mixin.
+    module Language
+      # Load a language from configuration or default lookup paths.
+      #
+      # @example Load java from default paths
+      #    # This will look for:
+      #    #
+      #    #   .vendor/tree-sitter-parsers/(java/)?(libtree-sitter-)?java.{ext}
+      #    #   .vendor/parsers/(java/)?(libtree-sitter-)?java.{ext}
+      #    #   vendor/tree-sitter-parsers/(java/)?(libtree-sitter-)?java.{ext}
+      #    #   vendor/parsers/(java/)?(libtree-sitter-)?java.{ext}
+      #    #   parsers/(java/)?(libtree-sitter-)?java.{ext}
+      #    #   tree-sitter-parsers/(java/)?(libtree-sitter-)?java.{ext}
+      #    #   /opt/local/lib/(java/)?(libtree-sitter-)?java.{ext}
+      #    #   /opt/lib/(java/)?(libtree-sitter-)?java.{ext}
+      #    #   /usr/local/lib/(java/)?(libtree-sitter-)?java.{ext}
+      #    #   /usr/lib/(java/)?(libtree-sitter-)?java.{ext}
+      #    #
+      #    java = TreeSitter.language('java')
+      #
+      # @example (TreeStand) Load java from a configured path
+      #    # This will look for:
+      #    #
+      #    #   /my/path/(java/)?(libtree-sitter-)?java.{ext}
+      #    #
+      #    TreeStand.config.parser_path = '/my/path'
+      #    java = TreeStand::Parser.language('java')
+      #
+      # @example (TreeStand) Load java from environment variables
+      #    # This will look for:
+      #    #
+      #    #   /my/forced/env/path/(java/)?(libtree-sitter-)?java.{ext}
+      #    #   /my/path/(java/)?(libtree-sitter-)?java.{ext}
+      #    #
+      #    # … and the same works for the default paths if `TreeStand.config.parser_path`
+      #    # was `nil`
+      #    ENV['TREE_SITTER_PARSERS'] = '/my/forced/env/path'
+      #    TreeStand.config.parser_path = '/my/path'
+      #    java = TreeStand::Parser.language('java')
+      #
+      # @param name [String] the name of the parser.
+      #   This name is used to load the symbol from the compiled parser, replacing `-` with `_`.
+      #
+      # @return [TreeSitter:language] a language object to use in your parsers.
+      #
+      # @raise [RuntimeError] if the parser was not found.
+      #
+      # @see search_for_lib
+      def language(name)
+        lib = search_for_lib(name)
+
+        if lib.nil?
+          raise <<~MSG.chomp
+            Failed to load a parser for #{name}.
+
+            #{search_lib_message}
+          MSG
+        end
+
+        # We know that the bindings will accept `lib`, but I don't know how to tell sorbet
+        # the types in ext/tree_sitter where `load` is defined.
+        TreeSitter::Language.load(name.tr('-', '_'), T.unsafe(lib))
+      end
+
+      # The platform-specific extension of the parser.
+      # @return [String] `dylib` or `so` for mac or linux.
+      def ext
+        case Gem::Platform.local.os
+        in   /darwin/ then 'dylib'
+        else               'so'
+        end
+      end
+
+      private
+
+      # The library directories we need to look into.
+      #
+      # @return [Array<Pathname>] the list of candidate places to use when searching for parsers.
+      #
+      # @see ENV_PARSERS
+      # @see LIBDIRS
+      def lib_dirs = [*TreeSitter::ENV_PARSERS, *TreeSitter::LIBDIRS]
+
+      # Lookup a parser by name.
+      #
+      # Precedence:
+      # 1. `Env['TREE_SITTER_PARSERS]`.
+      # 2. {TreeStand::Config#parser_path} if using {TreeStand}.
+      # 3. {LIBDIRS}.
+      #
+      # If a {TreeStand::Config#parser_path} is `nil`, {LIBDIRS} is used.
+      # If a {TreeStand::Config#parser_path} is a {::Pathname}, {LIBDIRS} is ignored.
+      def search_for_lib(name)
+        files = [
+          name,
+          "tree-sitter-#{name}",
+          "libtree-sitter-#{name}",
+        ].map { |v| "#{v}.#{ext}" }
+
+        lib_dirs
+          .product(files)
+          .find do |dir, so|
+            path = dir / so
+            path = dir / name / so if !path.exist?
+            break path.expand_path if path.exist?
+          end
+      end
+
+      # Generates a string message on where parser lookup happens.
+      #
+      # @return [String] A pretty message.
+      def search_lib_message
+        indent = 2
+        pretty = ->(arr) {
+          if arr
+            arr
+              .compact
+              .map { |v| "#{' ' * indent}#{v.expand_path}" }
+              .join("\n")
+          end
+        }
+        <<~MSG.chomp
+          From ENV['TREE_SITTER_PARSERS']:
+          #{pretty.call(ENV_PARSERS)}
+
+          From Defaults:
+          #{pretty.call(lib_dirs)}
+        MSG
+      end
+    end
+  end
+end

data/lib/tree_sitter/node.rb

@@ -3,6 +3,8 @@
 module TreeSitter
   # Node is a wrapper around a tree-sitter node.
   class Node
+    include Enumerable
+
     # @return [Array<Symbol>] the node's named fields
     def fields
       return @fields if @fields
@@ -87,10 +89,10 @@ module TreeSitter
     # Iterate over a node's children.
     #
     # @yieldparam child [Node] the child
-    def each
+    def each(&_block)
       return enum_for __method__ if !block_given?
 
-      (0...(child_count)).each do |i|
+      (0...child_count).each do |i|
         yield child(i)
       end
     end

data/lib/tree_sitter/query.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+require_relative 'helpers'
+
+module TreeSitter
+  # Query is a wrapper around a tree-sitter query.
+  class Query
+    attr_reader :capture_names
+    attr_reader :capture_quantifiers
+    attr_reader :text_predicates
+    attr_reader :property_predicates
+    attr_reader :property_settings
+    attr_reader :general_predicates
+
+    private
+
+    # Called from query.c on initialize.
+    #
+    # Prepares all the predicates so we could process them in places like
+    # {QueryMatch#satisfies_text_predicate?}.
+    #
+    # This is translation from the [rust bindings](https://github.com/tree-sitter/tree-sitter/blob/e553578696fe86071846ed612ee476d0167369c1/lib/binding_rust/lib.rs#L1860)
+    # Because it's a direct translation, it's way too long and we need to shut up rubocop.
+    # TODO: refactor + simplify when stable.
+    def process(source) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+      string_count = self.string_count
+      capture_count = self.capture_count
+      pattern_count = self.pattern_count
+
+      # Build a vector of strings to store the capture names.
+      capture_names = capture_count.times.map { |i| capture_name_for_id(i) }
+
+      # Build a vector to store capture qunatifiers.
+      capture_quantifiers =
+        pattern_count.times.map do |i|
+          capture_count.times.map do |j|
+            capture_quantifier_for_id(i, j)
+          end
+        end
+
+      # Build a vector of strings to represent literal values used in predicates.
+      string_values = string_count.times.map { |i| string_value_for_id(i) }
+
+      # Build a vector of predicates for each pattern.
+      pattern_count.times do |i| # rubocop:disable Metrics/BlockLength
+        predicate_steps = predicates_for_pattern(i)
+        byte_offset = start_byte_for_pattern(i)
+        row =
+          source.chars.map.with_index
+            .take_while { |_, i| i < byte_offset } # rubocop:disable Lint/ShadowingOuterLocalVariable
+            .filter { |c, _| c == "\n" }
+            .size
+        text_predicates = []
+        property_predicates = []
+        property_settings = []
+        general_predicates = []
+
+        array_split_like_rust(predicate_steps) { |s| s.type == QueryPredicateStep::DONE } # rubocop:disable Metrics/BlockLength
+          .each do |p|
+            next if p.empty?
+
+            if p[0] == QueryPredicateStep::STRING
+              cap = capture_names[p[0].value_id]
+              raise ArgumentError, <<~MSG.chomp
+                L#{row}: Expected predicate to start with a function name. Got @#{cap}.
+              MSG
+            end
+
+            # Build a predicate for each of the known predicate function names.
+            operator_name = string_values[p[0].value_id]
+
+            case operator_name
+            in 'any-eq?' | 'any-not-eq?' | 'eq?' | 'not-eq?'
+              if p.size != 3
+                raise ArgumentError, <<~MSG.chomp
+                  L#{row}: Wrong number of arguments to ##{operator_name} predicate. Expected 2, got #{p.size - 1}.
+                MSG
+              end
+
+              if p[1].type != QueryPredicateStep::CAPTURE
+                lit = string_values[p[1].value_id]
+                raise ArgumentError, <<~MSG.chomp
+                  L#{row}: First argument to ##{operator_name} predicate must be a capture name. Got literal "#{lit}".
+                MSG
+              end
+
+              is_positive = %w[eq? any-eq?].include?(operator_name)
+              match_all = %w[eq? not-eq?].include?(operator_name)
+              # NOTE: in the rust impl, match_all can hit an unreachable! but I am simplifying
+              # for readability. Same applies for the other `in` branches.
+              text_predicates <<
+                if p[2].type == QueryPredicateStep::CAPTURE
+                  TextPredicateCapture.eq_capture(p[1].value_id, p[2].value_id, is_positive, match_all)
+                else
+                  TextPredicateCapture.eq_string(p[1].value_id, string_values[p[2].value_id], is_positive, match_all)
+                end
+
+            in 'match?' | 'not-match?' | 'any-match?' | 'any-not-match?'
+              if p.size != 3
+                raise ArgumentError, <<~MSG.chomp
+                  L#{row}: Wrong number of arguments to ##{operator_name} predicate. Expected 2, got #{p.size - 1}.
+                MSG
+              end
+
+              if p[1].type != QueryPredicateStep::CAPTURE
+                lit = string_values[p[1].value_id]
+                raise ArgumentError, <<~MSG.chomp
+                  L#{row}: First argument to ##{operator_name} predicate must be a capture name. Got literal "#{lit}".
+                MSG
+              end
+
+              if p[2].type == QueryPredicateStep::CAPTURE
+                cap = capture_names[p[2].value_id]
+                raise ArgumentError, <<~MSG.chomp
+                  L#{row}: First argument to ##{operator_name} predicate must be a literal. Got capture @#{cap}".
+                MSG
+              end
+
+              is_positive = %w[match? any-match?].include?(operator_name)
+              match_all = %w[match? not-match?].include?(operator_name)
+              regex = /#{string_values[p[2].value_id]}/
+
+              text_predicates << TextPredicateCapture.match_string(p[1].value_id, regex, is_positive, match_all)
+
+            in 'set!'
+              property_settings << 'todo!'
+
+            in 'is?' | 'is-not?'
+              property_predicates << 'todo!'
+
+            in 'any-of?' | 'not-any-of?'
+              if p.size < 2
+                raise ArgumentError, <<~MSG.chomp
+                  L#{row}: Wrong number of arguments to ##{operator_name} predicate. Expected at least 1, got #{p.size - 1}.
+                MSG
+              end
+
+              if p[1].type != QueryPredicateStep::CAPTURE
+                lit = string_values[p[1].value_id]
+                raise ArgumentError, <<~MSG.chomp
+                  L#{row}: First argument to ##{operator_name} predicate must be a capture name. Got literal "#{lit}".
+                MSG
+              end
+
+              is_positive = operator_name == 'any_of'
+              values = []
+
+              p[2..].each do |arg|
+                if arg.type == QueryPredicateStep::CAPTURE
+                  lit = string_values[arg.value_id]
+                  raise ArgumentError, <<~MSG.chomp
+                    L#{row}: First argument to ##{operator_name} predicate must be a capture name. Got literal "#{lit}".
+                  MSG
+                end
+                values << string_values[arg.value_id]
+              end
+
+              # TODO: is the map to to_s necessary in ruby?
+              text_predicates <<
+                TextPredicateCapture.any_string(p[1].value_id, values.map(&:to_s), is_positive, match_all)
+            else
+              general_predicates <<
+                QueryPredicate.new(
+                  operator_name,
+                  p[1..].map do |a|
+                    if a.type == QueryPredicateStep::CAPTURE
+                      { capture: a.value_id }
+                    else
+                      { string: string_values[a.value_id] }
+                    end
+                  end,
+                )
+            end
+
+            @text_predicates << text_predicates
+            @property_predicates << property_predicates
+            @property_settings << property_settings
+            @general_predicates << general_predicates
+          end
+
+        @capture_names = capture_names
+        @capture_quantifiers = capture_quantifiers
+      end
+    end
+
+    # TODO
+    def parse_property
+      # todo
+    end
+  end
+end

data/lib/tree_sitter/query_captures.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module TreeSitter
+  # A sequence of {TreeSitter::QueryCapture} associated with a given {TreeSitter::QueryCursor}.
+  class QueryCaptures
+    include Enumerable
+
+    def initialize(cursor, query, src)
+      @cursor = cursor
+      @query = query
+      @src = src
+    end
+
+    # Iterator over captures.
+    #
+    # @yieldparam match [TreeSitter::QueryMatch]
+    # @yieldparam capture_index [Integer]
+    def each(&_block)
+      return enum_for __method__ if !block_given?
+
+      while (capture_index, match = @cursor.next_capture)
+        next if !match.is_a?(TreeSitter::QueryMatch)
+
+        if match.satisfies_text_predicate?(@query, @src)
+          yield [match, capture_index]
+        end
+      end
+    end
+  end
+end

data/lib/tree_sitter/query_cursor.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module TreeSitter
+  # A Cursor for {Query}.
+  class QueryCursor
+    # Iterate over all of the matches in the order that they were found.
+    #
+    # Each match contains the index of the pattern that matched, and a list of
+    # captures. Because multiple patterns can match the same set of nodes,
+    # one match may contain captures that appear *before* some of the
+    # captures from a previous match.
+    def matches(query, node, src)
+      self.exec(query, node)
+      QueryMatches.new(self, query, src)
+    end
+
+    # Iterate over all of the individual captures in the order that they
+    # appear.
+    #
+    # This is useful if you don't care about which pattern matched, and just
+    # want a single, ordered sequence of captures.
+    def captures(query, node, src)
+      self.exec(query, node)
+      QueryCaptures.new(self, query, src)
+    end
+  end
+end

data/lib/tree_sitter/query_match.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require_relative 'query_captures'
+
+module TreeSitter
+  # A match for a {Query}.
+  class QueryMatch
+    # All nodes at a given capture index.
+    #
+    # @param index [Integer]
+    #
+    # @return [TreeSitter::Node]
+    def nodes_for_capture_index(index) = captures.filter_map { |capture| capture.node if capture.index == index }
+
+    # Whether the {QueryMatch} satisfies the text predicates in the query.
+    #
+    # This is a translation from the [rust bindings](https://github.com/tree-sitter/tree-sitter/blob/e553578696fe86071846ed612ee476d0167369c1/lib/binding_rust/lib.rs#L2502).
+    # Because it's a direct translation, it's way too long and we need to shut up rubocop.
+    # TODO: refactor + simplify when satable.
+    def satisfies_text_predicate?(query, src) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+      return true if query.text_predicates[pattern_index].nil?
+
+      query # rubocop:disable Metrics/BlockLength
+        .text_predicates[pattern_index]
+        .all? do |predicate|
+          case predicate.type
+          in TextPredicateCapture::EQ_CAPTURE
+            fst_nodes = nodes_for_capture_index(predicate.fst)
+            snd_nodes = nodes_for_capture_index(predicate.snd)
+            res = nil
+            consumed = 0
+            fst_nodes.zip(snd_nodes).each do |node1, node2|
+              text1 = node_text(node1, src)
+              text2 = node_text(node2, src)
+              if (text1 == text2) != predicate.positive? && predicate.match_all?
+                res = false
+                break
+              end
+              if (text1 == text2) == predicate.positive? && !predicate.match_all?
+                res = true
+                break
+              end
+              consumed += 1
+            end
+            (res.nil? && consumed == fst_nodes.length && consumed == snd_nodes.length) \
+              || res
+
+          in TextPredicateCapture::EQ_STRING
+            nodes = nodes_for_capture_index(predicate.fst)
+            res = true
+            nodes.each do |node|
+              text = node_text(node, src)
+              if (predicate.snd == text) != predicate.positive? && predicate.match_all?
+                res = false
+                break
+              end
+              if (predicate.snd == text) == predicate.positive? && !predicate.match_all?
+                res = true
+                break
+              end
+            end
+            res
+
+          in TextPredicateCapture::MATCH_STRING
+            nodes = nodes_for_capture_index(predicate.fst)
+            res = true
+            nodes.each do |node|
+              text = node_text(node, src)
+              if predicate.snd.match?(text) != predicate.positive? && predicate.match_all?
+                res = false
+                break
+              end
+              if predicate.snd.match?(text) == predicate.positive? && !predicate.match_all?
+                res = true
+                break
+              end
+            end
+            res
+
+          in TextPredicateCapture::ANY_STRING
+            nodes = nodes_for_capture_index(predicate.fst)
+            res = true
+            nodes.each do |node|
+              text = node_text(node, src)
+              if predicate.snd.any? { |v| v == text } != predicate.positive?
+                res = false
+                break
+              end
+            end
+            res
+
+          end
+        end
+    end
+
+    private
+
+    def node_text(node, text) = text.byteslice(node.start_byte...node.end_byte)
+  end
+end

data/lib/tree_sitter/query_matches.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module TreeSitter
+  # A sequence of {QueryMatch} associated with a given {QueryCursor}.
+  class QueryMatches
+    include Enumerable
+
+    def initialize(cursor, query, src)
+      @cursor = cursor
+      @query = query
+      @src = src
+    end
+
+    # Iterator over matches.
+    #
+    # @yieldparam match [TreeSitter::QueryMatch]
+    def each(&_block)
+      return enum_for __method__ if !block_given?
+
+      while match = @cursor.next_match
+        if match.satisfies_text_predicate?(@query, @src)
+          yield match
+        end
+      end
+    end
+
+    # Iterate over all the results presented as hashes of `capture name => node`.
+    #
+    # @yieldparam match [Hash<String, TreeSitter::Node>]
+    def each_capture_hash(&_block)
+      # TODO: should we return [Array<Hash<Symbol, TreeSitter::Node]>>] instead?
+      return enum_for __method__ if !block_given?
+
+      each do |match|
+        yield match.captures.to_h { |cap| [@query.capture_name_for_id(cap.index), cap.node] }
+      end
+    end
+  end
+end

data/lib/tree_sitter/query_predicate.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module TreeSitter
+  # A {Query} predicate generic representation.
+  class QueryPredicate
+    attr_accessor :operator
+    attr_accessor :args
+
+    def initialize(operator, args)
+      @operator = operator
+      @args = args
+    end
+  end
+end

data/lib/tree_sitter/text_predicate_capture.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module TreeSitter
+  # A representation for text predicates.
+  class TextPredicateCapture
+    EQ_CAPTURE = 0   # Equality Capture
+    EQ_STRING = 1    # Equality String
+    MATCH_STRING = 2 # Match String
+    ANY_STRING = 3   # Any String
+
+    attr_reader :fst
+    attr_reader :snd
+    attr_reader :type
+
+    # Create a TextPredicateCapture for {EQ_CAPTURE}.
+    def self.eq_capture(...) = new(EQ_CAPTURE, ...)
+    # Create a TextPredicateCapture for {EQ_STRING}.
+    def self.eq_string(...) = new(EQ_STRING, ...)
+    # Create a TextPredicateCapture for {MATCH_STRING}.
+    def self.match_string(...) = new(MATCH_STRING, ...)
+    # Create a TextPredicateCapture for {ANY_STRING}.
+    def self.any_string(...) = new(ANY_STRING, ...)
+
+    def initialize(type, fst, snd, positive, match_all)
+      @type = type
+      @fst = fst
+      @snd = snd
+      @positive = positive
+      @match_all = match_all
+    end
+
+    # `#eq` is positive, `#not-eq` is not.
+    def positive? = @positive
+    # `#any-` means don't match all.
+    def match_all? = @match_all
+  end
+end

data/lib/tree_sitter/version.rb

@@ -4,5 +4,5 @@ module TreeSitter
   # The version of the tree-sitter library.
   TREESITTER_VERSION = '0.22.6'
   # The current version of the gem.
-  VERSION = '1.2.0'
+  VERSION = '1.4.0'
 end

data/lib/tree_sitter.rb

@@ -1,14 +1,28 @@
 # frozen_string_literal: true
 
-# TreeSitter is a Ruby interface to the tree-sitter parsing library.
-module TreeSitter
-end
-
 require 'set'
 
+require 'tree_sitter/tree_sitter'
 require 'tree_sitter/version'
 
-require 'tree_sitter/tree_sitter'
+require 'tree_sitter/mixins/language'
+
 require 'tree_sitter/node'
+require 'tree_sitter/query'
+require 'tree_sitter/query_captures'
+require 'tree_sitter/query_cursor'
+require 'tree_sitter/query_match'
+require 'tree_sitter/query_matches'
+require 'tree_sitter/query_predicate'
+require 'tree_sitter/text_predicate_capture'
+
+# TreeSitter is a Ruby interface to the tree-sitter parsing library.
+module TreeSitter
+  extend Mixins::Language
+
+  class << self
+    alias_method :lang, :language
+  end
+end
 
 ObjectSpace.define_finalizer(TreeSitter::Tree.class, proc { TreeSitter::Tree.finalizer })

data/lib/tree_stand/node.rb

@@ -97,19 +97,11 @@ module TreeStand
     sig { params(query_string: String).returns(T::Array[T::Hash[String, TreeStand::Node]]) }
     def query(query_string)
       ts_query = TreeSitter::Query.new(@tree.parser.ts_language, query_string)
-      ts_cursor = TreeSitter::QueryCursor.exec(ts_query, ts_node)
-      matches = []
-      while ts_match = ts_cursor.next_match
-        captures = {}
-
-        ts_match.captures.each do |ts_capture|
-          capture_name = ts_query.capture_name_for_id(ts_capture.index)
-          captures[capture_name] = TreeStand::Node.new(@tree, ts_capture.node)
-        end
-
-        matches << captures
-      end
-      matches
+      TreeSitter::QueryCursor
+        .new
+        .matches(ts_query, @tree.ts_tree.root_node, @tree.document)
+        .each_capture_hash
+        .map { |h| h.transform_values! { |n| TreeStand::Node.new(@tree, n) } }
     end
 
     # Returns the first captured node that matches the query string or nil if

data/lib/tree_stand/parser.rb

@@ -26,6 +26,7 @@ module TreeStand
   # @see LIBDIRS
   class Parser
     extend T::Sig
+    extend TreeSitter::Mixins::Language
 
     sig { returns(TreeSitter::Language) }
     attr_reader :ts_language
@@ -33,156 +34,6 @@ module TreeStand
     sig { returns(TreeSitter::Parser) }
     attr_reader :ts_parser
 
-    # A colon-seprated list of paths pointing to directories that can contain parsers.
-    # Order matters.
-    # Takes precedence over default lookup paths.
-    ENV_PARSERS =
-      ENV['TREE_SITTER_PARSERS']
-        &.split(':')
-        &.map { |v| Pathname(v) }
-        .freeze
-
-    # The default paths we use to lookup parsers when no specific
-    # {TreeStand::Config#parser_path} is {nil}.
-    # Order matters.
-    LIBDIRS = [
-      'tree-sitter-parsers',
-      '/opt/local/lib',
-      '/opt/lib',
-      '/usr/local/lib',
-      '/usr/lib',
-    ].map { |p| Pathname(p) }.freeze
-
-    # The library directories we need to look into.
-    #
-    # @return [Array<Pathname>] the list of candidate places to use when searching for parsers.
-    #
-    # @see ENV_PARSERS
-    # @see LIBDIRS
-    sig { returns(T::Array[Pathname]) }
-    def self.lib_dirs = [
-      *ENV_PARSERS,
-      *(TreeStand.config.parser_path ? [TreeStand.config.parser_path] : LIBDIRS),
-    ].compact
-
-    # The platform-specific extension of the parser.
-    # @return [String] `dylib` or `so` for mac or linux.
-    sig { returns(String) }
-    def self.ext
-      case Gem::Platform.local.os
-      in   /darwin/ then 'dylib'
-      else               'so'
-      end
-    end
-
-    # Lookup a parser by name.
-    #
-    # Precedence:
-    # 1. `Env['TREE_SITTER_PARSERS]`
-    # 2. {TreeStand::Config#parser_path}
-    # 3. {LIBDIRS}
-    #
-    # If a {TreeStand::Config#parser_path} is `nil`, {LIBDIRS} is used.
-    # If a {TreeStand::Config#parser_path} is a {::Pathname}, {LIBDIRS} is ignored.
-    sig { params(name: String).returns(T.nilable(Pathname)) }
-    def self.search_for_lib(name)
-      files = [
-        name,
-        "tree-sitter-#{name}",
-        "libtree-sitter-#{name}",
-      ].map { |v| "#{v}.#{ext}" }
-
-      res = lib_dirs
-        .product(files)
-        .find do |dir, so|
-          path = dir / so
-          path = dir / name / so if !path.exist?
-          break path.expand_path if path.exist?
-        end
-      res.is_a?(Array) ? nil : res
-    end
-
-    # Generates a string message on where parser lookup happens.
-    #
-    # @return [String] A pretty message.
-    sig { returns(String) }
-    def self.search_lib_message
-      indent = 2
-      pretty = ->(arr) {
-        if arr
-          arr
-            .compact
-            .map { |v| "#{' ' * indent}#{v.expand_path}" }
-            .join("\n")
-        end
-      }
-      <<~MSG
-        From ENV['TREE_SITTER_PARSERS']:
-        #{pretty.call(ENV_PARSERS)}
-
-        From TreeStand.config.parser_path:
-        #{pretty.call([TreeStand.config.parser_path])}
-
-        From Defaults:
-        #{pretty.call(LIBDIRS)}
-      MSG
-    end
-
-    # Load a language from configuration or default lookup paths.
-    #
-    # @example Load java from default paths
-    #    # This will look for:
-    #    #
-    #    #   tree-sitter-parsers/(java/)?(libtree-sitter-)?java.{ext}
-    #    #   /opt/local/lib/(java/)?(libtree-sitter-)?java.{ext}
-    #    #   /opt/lib/(java/)?(libtree-sitter-)?java.{ext}
-    #    #   /usr/local/lib/(java/)?(libtree-sitter-)?java.{ext}
-    #    #   /usr/lib/(java/)?(libtree-sitter-)?java.{ext}
-    #    #
-    #    java = TreeStand::Parser.language('java')
-    #
-    # @example Load java from a configured path
-    #    # This will look for:
-    #    #
-    #    #   /my/path/(java/)?(libtree-sitter-)?java.{ext}
-    #    #
-    #    TreeStand.config.parser_path = '/my/path'
-    #    java = TreeStand::Parser.language('java')
-    #
-    # @example Load java from environment variables
-    #    # This will look for:
-    #    #
-    #    #   /my/forced/env/path/(java/)?(libtree-sitter-)?java.{ext}
-    #    #   /my/path/(java/)?(libtree-sitter-)?java.{ext}
-    #    #
-    #    # … and the same works for the default paths if `TreeStand.config.parser_path`
-    #    # was `nil`
-    #    ENV['TREE_SITTER_PARSERS'] = '/my/forced/env/path'
-    #    TreeStand.config.parser_path = '/my/path'
-    #    java = TreeStand::Parser.language('java')
-    #
-    # @param name [String] the name of the parser.
-    #   This name is used to load the symbol from the compiled parser, replacing `-` with `_`.
-    # @return [TreeSitter:language] a language object to use in your parsers.
-    # @raise [RuntimeError] if the parser was not found.
-    # @see search_for_lib
-    sig { params(name: String).returns(TreeSitter::Language) }
-    def self.language(name)
-      lib = search_for_lib(name)
-
-      if lib.nil?
-        raise <<~MSG
-          Failed to load a parser for #{name}.
-
-          #{search_lib_message}
-        MSG
-      end
-
-      # We know that the bindings will accept `lib`, but I don't know how to tell sorbet
-      # the types in ext/tree_sitter where `load` is defined.
-      TreeSitter::Language.load(name.gsub(/-/, '_'), T.unsafe(lib))
-    end
-
     # @param language [String]
     sig { params(language: String).void }
     def initialize(language)
@@ -192,6 +43,19 @@ module TreeStand
       end
     end
 
+    # The library directories we need to look into.
+    #
+    # @return [Array<Pathname>] the list of candidate places to use when searching for parsers.
+    #
+    # @see ENV_PARSERS
+    # @see LIBDIRS
+    def self.lib_dirs
+      [
+        *TreeSitter::ENV_PARSERS,
+        *(TreeStand.config.parser_path ? [TreeStand.config.parser_path] : TreeSitter::LIBDIRS),
+      ]
+    end
+
     # Parse the provided document with the TreeSitter parser.
     # @param tree [TreeStand::Tree, nil] providing the old tree will allow the
     #   parser to take advantage of incremental parsing and improve performance

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_tree_sitter
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.4.0
 platform: x86_64-linux
 authors:
 - Firas al-Khalil
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-05-27 00:00:00.000000000 Z
+date: 2024-07-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sorbet-runtime
@@ -74,7 +74,16 @@ files:
 - ext/tree_sitter/tree_sitter.c
 - ext/tree_sitter/tree_sitter.h
 - lib/tree_sitter.rb
+- lib/tree_sitter/helpers.rb
+- lib/tree_sitter/mixins/language.rb
 - lib/tree_sitter/node.rb
+- lib/tree_sitter/query.rb
+- lib/tree_sitter/query_captures.rb
+- lib/tree_sitter/query_cursor.rb
+- lib/tree_sitter/query_match.rb
+- lib/tree_sitter/query_matches.rb
+- lib/tree_sitter/query_predicate.rb
+- lib/tree_sitter/text_predicate_capture.rb
 - lib/tree_sitter/tree_sitter.so
 - lib/tree_sitter/version.rb
 - lib/tree_stand.rb