syntax_tree 4.1.0 → 4.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 61bd75fb26dcf665293adb21c2cf21a5f0f26b56a2077d80ce5ff6806eaf434d
-  data.tar.gz: 545306a76376f972805159e8eed622e825011b7fa9ef6b93cb9649c6caf9eccf
+  metadata.gz: 4ca1eae46ba326b73e129d5b066d144aeac2743947956efc1453a3539c2caac9
+  data.tar.gz: 7c833e7b7bf25df7a82653d9dddb30aa172320a625a0655c52a29640c7a2154f
 SHA512:
-  metadata.gz: 633701480cbe5c34bfcff52c4dd6c48f10cb22cba377b295ac56f2c288ce6a5dfdde57df5e682a3226f3d49ca7c3dd8d02db5d2d6d37acfc54df5c304be8a16f
-  data.tar.gz: e4224136ab12c158c45bd6375308e01a4e7075c7da30536f82f77ebecd3d4c426c4798e80fb5eb6fef9a1771036d4ac7e5d709dc49c5b620cbe9a2c3f2dd15a0
+  metadata.gz: 1720e9ef9dd52399564607a9eca7794875e41f36f8ee2c4af2d97fb973c38ec0bf3a3cc254d26f3d656e67256543afed7c818e274395af122790ae6730ccab8c
+  data.tar.gz: 0f00dbe7739f71bfa1b81ff204fdd4dc505277a65e374810d2f482c6ef3c81078b39f864d55d8deed001a5b7a294491feb0b930948546bcd4194a88058ca9783

data/.github/workflows/main.yml

@@ -12,10 +12,12 @@ jobs:
         - '3.0'
         - '3.1'
         - head
+        - truffleruby-head
     name: CI
     runs-on: ubuntu-latest
     env:
       CI: true
+      TESTOPTS: --verbose
     steps:
     - uses: actions/checkout@master
     - uses: ruby/setup-ruby@v1

data/.gitignore

@@ -9,3 +9,4 @@
 /vendor/
 
 test.rb
+query.txt

data/.rubocop.yml

@@ -46,6 +46,9 @@ Naming/MethodParameterName:
 Naming/RescuedExceptionsVariableName:
   PreferredName: error
 
+Style/CaseEquality:
+  Enabled: false
+
 Style/ExplicitBlockArgument:
   Enabled: false
 

data/CHANGELOG.md

@@ -6,6 +6,29 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) a
 
 ## [Unreleased]
 
+## [4.3.0] - 2022-10-28
+
+### Added
+
+- [#183](https://github.com/ruby-syntax-tree/syntax_tree/pull/183) - Support TruffleRuby by eliminating internal pattern matching in some places and stopping some tests from running in other places.
+- [#184](https://github.com/ruby-syntax-tree/syntax_tree/pull/184) - Remove internal pattern matching entirely.
+
+### Changed
+
+- [#183](https://github.com/ruby-syntax-tree/syntax_tree/pull/183) - Pattern matching works against dynamic symbols now.
+- [#184](https://github.com/ruby-syntax-tree/syntax_tree/pull/184) - Exit with the correct exit status within the rake tasks.
+
+## [4.2.0] - 2022-10-25
+
+### Added
+
+- [#182](https://github.com/ruby-syntax-tree/syntax_tree/pull/182) - The new `stree expr` CLI command will function similarly to the `stree match` CLI command except that it only outputs the first expression of the program.
+- [#182](https://github.com/ruby-syntax-tree/syntax_tree/pull/182) - Added the `SyntaxTree::Pattern` class for compiling `in` expressions into procs.
+
+### Changed
+
+- [#182](https://github.com/ruby-syntax-tree/syntax_tree/pull/182) - Much more syntax is now supported by the search command.
+
 ## [4.1.0] - 2022-10-24
 
 ### Added
@@ -403,7 +426,9 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) a
 
 - 🎉 Initial release! 🎉
 
-[unreleased]: https://github.com/ruby-syntax-tree/syntax_tree/compare/v4.1.0...HEAD
+[unreleased]: https://github.com/ruby-syntax-tree/syntax_tree/compare/v4.3.0...HEAD
+[4.3.0]: https://github.com/ruby-syntax-tree/syntax_tree/compare/v4.2.0...v4.3.0
+[4.2.0]: https://github.com/ruby-syntax-tree/syntax_tree/compare/v4.1.0...v4.2.0
 [4.1.0]: https://github.com/ruby-syntax-tree/syntax_tree/compare/v4.0.2...v4.1.0
 [4.0.2]: https://github.com/ruby-syntax-tree/syntax_tree/compare/v4.0.1...v4.0.2
 [4.0.1]: https://github.com/ruby-syntax-tree/syntax_tree/compare/v4.0.0...v4.0.1

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    syntax_tree (4.1.0)
+    syntax_tree (4.3.0)
       prettier_print (>= 1.0.2)
 
 GEM

data/README.md

@@ -15,6 +15,7 @@ It is built with only standard library dependencies. It additionally ships with
 - [CLI](#cli)
   - [ast](#ast)
   - [check](#check)
+  - [expr](#expr)
   - [format](#format)
   - [json](#json)
   - [match](#match)
@@ -26,6 +27,7 @@ It is built with only standard library dependencies. It additionally ships with
   - [SyntaxTree.read(filepath)](#syntaxtreereadfilepath)
   - [SyntaxTree.parse(source)](#syntaxtreeparsesource)
   - [SyntaxTree.format(source)](#syntaxtreeformatsource)
+  - [SyntaxTree.search(source, query, &block)](#syntaxtreesearchsource-query-block)
 - [Nodes](#nodes)
   - [child_nodes](#child_nodes)
   - [Pattern matching](#pattern-matching)
@@ -129,6 +131,24 @@ To change the print width that you are checking against, specify the `--print-wi
 stree check --print-width=100 path/to/file.rb
 ```
 
+### expr
+
+This command will output a Ruby case-match expression that would match correctly against the first expression of the input.
+
+```sh
+stree expr path/to/file.rb
+```
+
+For a file that contains `1 + 1`, you will receive:
+
+```ruby
+SyntaxTree::Binary[
+  left: SyntaxTree::Int[value: "1"],
+  operator: :+,
+  right: SyntaxTree::Int[value: "1"]
+]
+```
+
 ### format
 
 This command will output the formatted version of each of the listed files. Importantly, it will not write that content back to the source files. It is meant to display the formatted version only.
@@ -226,7 +246,7 @@ stree search VarRef path/to/file.rb
 
 For a file that contains `Foo + Bar` you will receive:
 
-```ruby
+```
 path/to/file.rb:1:0: Foo + Bar
 path/to/file.rb:1:6: Foo + Bar
 ```
@@ -312,6 +332,10 @@ This function takes an input string containing Ruby code and returns the syntax
 
 This function takes an input string containing Ruby code, parses it into its underlying syntax tree, and formats it back out to a string. You can optionally pass a second argument to this method as well that is the maximum width to print. It defaults to `80`.
 
+### SyntaxTree.search(source, query, &block)
+
+This function takes an input string containing Ruby code, an input string containing a valid Ruby `in` clause expression that can be used to match against nodes in the tree (can be generated using `stree expr`, `stree match`, or `Node#construct_keys`), and a block. Each node that matches the given query will be yielded to the block. The block will receive the node as its only argument.
+
 ## Nodes
 
 There are many different node types in the syntax tree. They are meant to be treated as immutable structs containing links to child nodes with minimal logic contained within their implementation. However, for the most part they all respond to a certain set of APIs, listed below.

data/lib/syntax_tree/cli.rb

@@ -188,6 +188,21 @@ module SyntaxTree
       end
     end
 
+    # An action of the CLI that outputs a pattern-matching Ruby expression that
+    # would match the first expression of the input given.
+    class Expr < Action
+      def run(item)
+        program = item.handler.parse(item.source)
+
+        if (expressions = program.statements.body) && expressions.size == 1
+          puts expressions.first.construct_keys
+        else
+          warn("The input to `stree expr` must be a single expression.")
+          exit(1)
+        end
+      end
+    end
+
     # An action of the CLI that formats the input source and prints it out.
     class Format < Action
       def run(item)
@@ -219,10 +234,15 @@ module SyntaxTree
 
       def initialize(query)
         query = File.read(query) if File.readable?(query)
-        @search = SyntaxTree::Search.new(query)
-      rescue SyntaxTree::Search::UncompilableError => error
-        warn(error.message)
-        exit(1)
+        pattern =
+          begin
+            Pattern.new(query).compile
+          rescue Pattern::CompilationError => error
+            warn(error.message)
+            exit(1)
+          end
+
+        @search = SyntaxTree::Search.new(pattern)
       end
 
       def run(item)
@@ -281,6 +301,10 @@ module SyntaxTree
       #{Color.bold("stree doc [--plugins=...] [-e SCRIPT] FILE")}
         Print out the doc tree that would be used to format the given files
 
+      #{Color.bold("stree expr [-e SCRIPT] FILE")}
+        Print out a pattern-matching Ruby expression that would match the first
+        expression of the given files
+
       #{Color.bold("stree format [--plugins=...] [--print-width=NUMBER] [-e SCRIPT] FILE")}
         Print out the formatted version of the given files
 
@@ -436,6 +460,8 @@ module SyntaxTree
             Debug.new(options)
           when "doc"
             Doc.new(options)
+          when "e", "expr"
+            Expr.new(options)
           when "f", "format"
             Format.new(options)
           when "help"

data/lib/syntax_tree/language_server/inlay_hints.rb

@@ -69,11 +69,10 @@ module SyntaxTree
       #
       def visit_binary(node)
         case stack[-2]
-        in Assign | OpAssign
+        when Assign, OpAssign
           parentheses(node.location)
-        in Binary[operator: operator] if operator != node.operator
-          parentheses(node.location)
-        else
+        when Binary
+          parentheses(node.location) if stack[-2].operator != node.operator
         end
 
         super
@@ -91,9 +90,8 @@ module SyntaxTree
       #
       def visit_if_op(node)
         case stack[-2]
-        in Assign | Binary | IfOp | OpAssign
+        when Assign, Binary, IfOp, OpAssign
           parentheses(node.location)
-        else
         end
 
         super

data/lib/syntax_tree/language_server.rb

@@ -13,6 +13,50 @@ module SyntaxTree
   #     stree lsp
   #
   class LanguageServer
+    # This is a small module that effectively mirrors pattern matching. We're
+    # using it so that we can support truffleruby without having to ignore the
+    # language server.
+    module Request
+      # Represents a hash pattern.
+      class Shape
+        attr_reader :values
+
+        def initialize(values)
+          @values = values
+        end
+
+        def ===(other)
+          values.all? do |key, value|
+            value == :any ? other.key?(key) : value === other[key]
+          end
+        end
+      end
+
+      # Represents an array pattern.
+      class Tuple
+        attr_reader :values
+
+        def initialize(values)
+          @values = values
+        end
+
+        def ===(other)
+          values.each_with_index.all? { |value, index| value === other[index] }
+        end
+      end
+
+      def self.[](value)
+        case value
+        when Array
+          Tuple.new(value.map { |child| self[child] })
+        when Hash
+          Shape.new(value.transform_values { |child| self[child] })
+        else
+          value
+        end
+      end
+    end
+
     attr_reader :input, :output, :print_width
 
     def initialize(
@@ -39,30 +83,33 @@ module SyntaxTree
 
         # stree-ignore
         case request
-        in { method: "initialize", id: }
+        when Request[method: "initialize", id: :any]
           store.clear
-          write(id: id, result: { capabilities: capabilities })
-        in { method: "initialized" }
+          write(id: request[:id], result: { capabilities: capabilities })
+        when Request[method: "initialized"]
           # ignored
-        in { method: "shutdown" } # tolerate missing ID to be a good citizen
+        when Request[method: "shutdown"] # tolerate missing ID to be a good citizen
           store.clear
           write(id: request[:id], result: {})
           return
-        in { method: "textDocument/didChange", params: { textDocument: { uri: }, contentChanges: [{ text: }, *] } }
-          store[uri] = text
-        in { method: "textDocument/didOpen", params: { textDocument: { uri:, text: } } }
-          store[uri] = text
-        in { method: "textDocument/didClose", params: { textDocument: { uri: } } }
-          store.delete(uri)
-        in { method: "textDocument/formatting", id:, params: { textDocument: { uri: } } }
+        when Request[method: "textDocument/didChange", params: { textDocument: { uri: :any }, contentChanges: [{ text: :any }] }]
+          store[request.dig(:params, :textDocument, :uri)] = request.dig(:params, :contentChanges, 0, :text)
+        when Request[method: "textDocument/didOpen", params: { textDocument: { uri: :any, text: :any } }]
+          store[request.dig(:params, :textDocument, :uri)] = request.dig(:params, :textDocument, :text)
+        when Request[method: "textDocument/didClose", params: { textDocument: { uri: :any } }]
+          store.delete(request.dig(:params, :textDocument, :uri))
+        when Request[method: "textDocument/formatting", id: :any, params: { textDocument: { uri: :any } }]
+          uri = request.dig(:params, :textDocument, :uri)
           contents = store[uri]
-          write(id: id, result: contents ? format(contents, uri.split(".").last) : nil)
-        in { method: "textDocument/inlayHint", id:, params: { textDocument: { uri: } } }
+          write(id: request[:id], result: contents ? format(contents, uri.split(".").last) : nil)
+        when Request[method: "textDocument/inlayHint", id: :any, params: { textDocument: { uri: :any } }]
+          uri = request.dig(:params, :textDocument, :uri)
           contents = store[uri]
-          write(id: id, result: contents ? inlay_hints(contents) : nil)
-        in { method: "syntaxTree/visualizing", id:, params: { textDocument: { uri: } } }
-          write(id: id, result: PP.pp(SyntaxTree.parse(store[uri]), +""))
-        in { method: %r{\$/.+} }
+          write(id: request[:id], result: contents ? inlay_hints(contents) : nil)
+        when Request[method: "syntaxTree/visualizing", id: :any, params: { textDocument: { uri: :any } }]
+          uri = request.dig(:params, :textDocument, :uri)
+          write(id: request[:id], result: PP.pp(SyntaxTree.parse(store[uri]), +""))
+        when Request[method: %r{\$/.+}]
           # ignored
         else
           raise ArgumentError, "Unhandled: #{request}"

data/lib/syntax_tree/pattern.rb

@@ -0,0 +1,287 @@
+# frozen_string_literal: true
+
+module SyntaxTree
+  # A pattern is an object that wraps a Ruby pattern matching expression. The
+  # expression would normally be passed to an `in` clause within a `case`
+  # expression or a rightward assignment expression. For example, in the
+  # following snippet:
+  #
+  #     case node
+  #     in Const[value: "SyntaxTree"]
+  #     end
+  #
+  # the pattern is the `Const[value: "SyntaxTree"]` expression. Within Syntax
+  # Tree, every node generates these kinds of expressions using the
+  # #construct_keys method.
+  #
+  # The pattern gets compiled into an object that responds to call by running
+  # the #compile method. This method itself will run back through Syntax Tree to
+  # parse the expression into a tree, then walk the tree to generate the
+  # necessary callable objects. For example, if you wanted to compile the
+  # expression above into a callable, you would:
+  #
+  #     callable = SyntaxTree::Pattern.new("Const[value: 'SyntaxTree']").compile
+  #     callable.call(node)
+  #
+  # The callable object returned by #compile is guaranteed to respond to #call
+  # with a single argument, which is the node to match against. It also is
+  # guaranteed to respond to #===, which means it itself can be used in a `case`
+  # expression, as in:
+  #
+  #     case node
+  #     when callable
+  #     end
+  #
+  # If the query given to the initializer cannot be compiled into a valid
+  # matcher (either because of a syntax error or because it is using syntax we
+  # do not yet support) then a SyntaxTree::Pattern::CompilationError will be
+  # raised.
+  class Pattern
+    # Raised when the query given to a pattern is either invalid Ruby syntax or
+    # is using syntax that we don't yet support.
+    class CompilationError < StandardError
+      def initialize(repr)
+        super(<<~ERROR)
+          Syntax Tree was unable to compile the pattern you provided to search
+          into a usable expression. It failed on to understand the node
+          represented by:
+
+          #{repr}
+
+          Note that not all syntax supported by Ruby's pattern matching syntax
+          is also supported by Syntax Tree's code search. If you're using some
+          syntax that you believe should be supported, please open an issue on
+          GitHub at https://github.com/ruby-syntax-tree/syntax_tree/issues/new.
+        ERROR
+      end
+    end
+
+    attr_reader :query
+
+    def initialize(query)
+      @query = query
+    end
+
+    def compile
+      program =
+        begin
+          SyntaxTree.parse("case nil\nin #{query}\nend")
+        rescue Parser::ParseError
+          raise CompilationError, query
+        end
+
+      compile_node(program.statements.body.first.consequent.pattern)
+    end
+
+    private
+
+    # Shortcut for combining two procs into one that returns true if both return
+    # true.
+    def combine_and(left, right)
+      ->(other) { left.call(other) && right.call(other) }
+    end
+
+    # Shortcut for combining two procs into one that returns true if either
+    # returns true.
+    def combine_or(left, right)
+      ->(other) { left.call(other) || right.call(other) }
+    end
+
+    # Raise an error because the given node is not supported.
+    def compile_error(node)
+      raise CompilationError, PP.pp(node, +"").chomp
+    end
+
+    # There are a couple of nodes (string literals, dynamic symbols, and regexp)
+    # that contain list of parts. This can include plain string content,
+    # interpolated expressions, and interpolated variables. We only support
+    # plain string content, so this method will extract out the plain string
+    # content if it is the only element in the list.
+    def extract_string(node)
+      parts = node.parts
+
+      if parts.length == 1 && (part = parts.first) && part.is_a?(TStringContent)
+        part.value
+      end
+    end
+
+    # in [foo, bar, baz]
+    def compile_aryptn(node)
+      compile_error(node) if !node.rest.nil? || node.posts.any?
+
+      constant = node.constant
+      compiled_constant = compile_node(constant) if constant
+
+      preprocessed = node.requireds.map { |required| compile_node(required) }
+
+      compiled_requireds = ->(other) do
+        deconstructed = other.deconstruct
+
+        deconstructed.length == preprocessed.length &&
+          preprocessed
+            .zip(deconstructed)
+            .all? { |(matcher, value)| matcher.call(value) }
+      end
+
+      if compiled_constant
+        combine_and(compiled_constant, compiled_requireds)
+      else
+        compiled_requireds
+      end
+    end
+
+    # in foo | bar
+    def compile_binary(node)
+      compile_error(node) if node.operator != :|
+
+      combine_or(compile_node(node.left), compile_node(node.right))
+    end
+
+    # in Ident
+    # in String
+    def compile_const(node)
+      value = node.value
+
+      if SyntaxTree.const_defined?(value)
+        clazz = SyntaxTree.const_get(value)
+
+        ->(other) { clazz === other }
+      elsif Object.const_defined?(value)
+        clazz = Object.const_get(value)
+
+        ->(other) { clazz === other }
+      else
+        compile_error(node)
+      end
+    end
+
+    # in SyntaxTree::Ident
+    def compile_const_path_ref(node)
+      parent = node.parent
+      compile_error(node) if !parent.is_a?(VarRef) || !parent.value.is_a?(Const)
+
+      if parent.value.value == "SyntaxTree"
+        compile_node(node.constant)
+      else
+        compile_error(node)
+      end
+    end
+
+    # in :""
+    # in :"foo"
+    def compile_dyna_symbol(node)
+      if node.parts.empty?
+        symbol = :""
+
+        ->(other) { symbol === other }
+      elsif (value = extract_string(node))
+        symbol = value.to_sym
+
+        ->(other) { symbol === other }
+      else
+        compile_error(root)
+      end
+    end
+
+    # in Ident[value: String]
+    # in { value: String }
+    def compile_hshptn(node)
+      compile_error(node) unless node.keyword_rest.nil?
+      compiled_constant = compile_node(node.constant) if node.constant
+
+      preprocessed =
+        node.keywords.to_h do |keyword, value|
+          compile_error(node) unless keyword.is_a?(Label)
+          [keyword.value.chomp(":").to_sym, compile_node(value)]
+        end
+
+      compiled_keywords = ->(other) do
+        deconstructed = other.deconstruct_keys(preprocessed.keys)
+
+        preprocessed.all? do |keyword, matcher|
+          matcher.call(deconstructed[keyword])
+        end
+      end
+
+      if compiled_constant
+        combine_and(compiled_constant, compiled_keywords)
+      else
+        compiled_keywords
+      end
+    end
+
+    # in /foo/
+    def compile_regexp_literal(node)
+      if (value = extract_string(node))
+        regexp = /#{value}/
+
+        ->(attribute) { regexp === attribute }
+      else
+        compile_error(node)
+      end
+    end
+
+    # in ""
+    # in "foo"
+    def compile_string_literal(node)
+      if node.parts.empty?
+        ->(attribute) { "" === attribute }
+      elsif (value = extract_string(node))
+        ->(attribute) { value === attribute }
+      else
+        compile_error(node)
+      end
+    end
+
+    # in :+
+    # in :foo
+    def compile_symbol_literal(node)
+      symbol = node.value.value.to_sym
+
+      ->(attribute) { symbol === attribute }
+    end
+
+    # in Foo
+    # in nil
+    def compile_var_ref(node)
+      value = node.value
+
+      if value.is_a?(Const)
+        compile_node(value)
+      elsif value.is_a?(Kw) && value.value.nil?
+        ->(attribute) { nil === attribute }
+      else
+        compile_error(node)
+      end
+    end
+
+    # Compile any kind of node. Dispatch out to the individual compilation
+    # methods based on the type of node.
+    def compile_node(node)
+      case node
+      when AryPtn
+        compile_aryptn(node)
+      when Binary
+        compile_binary(node)
+      when Const
+        compile_const(node)
+      when ConstPathRef
+        compile_const_path_ref(node)
+      when DynaSymbol
+        compile_dyna_symbol(node)
+      when HshPtn
+        compile_hshptn(node)
+      when RegexpLiteral
+        compile_regexp_literal(node)
+      when StringLiteral
+        compile_string_literal(node)
+      when SymbolLiteral
+        compile_symbol_literal(node)
+      when VarRef
+        compile_var_ref(node)
+      else
+        compile_error(node)
+      end
+    end
+  end
+end

data/lib/syntax_tree/rake/task.rb

@@ -78,7 +78,7 @@ module SyntaxTree
 
         arguments << "--ignore-files=#{ignore_files}" if ignore_files != ""
 
-        SyntaxTree::CLI.run(arguments + Array(source_files))
+        abort if SyntaxTree::CLI.run(arguments + Array(source_files)) != 0
       end
     end
   end

data/lib/syntax_tree/search.rb

@@ -4,14 +4,10 @@ module SyntaxTree
   # Provides an interface for searching for a pattern of nodes against a
   # subtree of an AST.
   class Search
-    class UncompilableError < StandardError
-    end
-
-    attr_reader :matcher
+    attr_reader :pattern
 
-    def initialize(query)
-      root = SyntaxTree.parse("case nil\nin #{query}\nend")
-      @matcher = compile(root.statements.body.first.consequent.pattern)
+    def initialize(pattern)
+      @pattern = pattern
     end
 
     def scan(root)
@@ -22,71 +18,9 @@ module SyntaxTree
         node = queue.shift
         next unless node
 
-        yield node if matcher.call(node)
+        yield node if pattern.call(node)
         queue += node.child_nodes
       end
     end
-
-    private
-
-    def compile(pattern)
-      case pattern
-      in Binary[left:, operator: :|, right:]
-        compiled_left = compile(left)
-        compiled_right = compile(right)
-
-        ->(node) { compiled_left.call(node) || compiled_right.call(node) }
-      in Const[value:] if SyntaxTree.const_defined?(value)
-        clazz = SyntaxTree.const_get(value)
-
-        ->(node) { node.is_a?(clazz) }
-      in Const[value:] if Object.const_defined?(value)
-        clazz = Object.const_get(value)
-
-        ->(node) { node.is_a?(clazz) }
-      in ConstPathRef[parent: VarRef[value: Const[value: "SyntaxTree"]]]
-        compile(pattern.constant)
-      in HshPtn[constant:, keywords:, keyword_rest: nil]
-        compiled_constant = compile(constant)
-
-        preprocessed_keywords =
-          keywords.to_h do |keyword, value|
-            raise NoMatchingPatternError unless keyword.is_a?(Label)
-            [keyword.value.chomp(":").to_sym, compile(value)]
-          end
-
-        compiled_keywords = ->(node) do
-          deconstructed = node.deconstruct_keys(preprocessed_keywords.keys)
-          preprocessed_keywords.all? do |keyword, matcher|
-            matcher.call(deconstructed[keyword])
-          end
-        end
-
-        ->(node) do
-          compiled_constant.call(node) && compiled_keywords.call(node)
-        end
-      in RegexpLiteral[parts: [TStringContent[value:]]]
-        regexp = /#{value}/
-
-        ->(attribute) { regexp.match?(attribute) }
-      in StringLiteral[parts: [TStringContent[value:]]]
-        ->(attribute) { attribute == value }
-      in VarRef[value: Const => value]
-        compile(value)
-      end
-    rescue NoMatchingPatternError
-      raise UncompilableError, <<~ERROR
-        Syntax Tree was unable to compile the pattern you provided to search
-        into a usable expression. It failed on the node within the pattern
-        matching expression represented by:
-
-        #{PP.pp(pattern, +"").chomp}
-
-        Note that not all syntax supported by Ruby's pattern matching syntax is
-        also supported by Syntax Tree's code search. If you're using some syntax
-        that you believe should be supported, please open an issue on the GitHub
-        repository at https://github.com/ruby-syntax-tree/syntax_tree.
-      ERROR
-    end
   end
 end

data/lib/syntax_tree/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SyntaxTree
-  VERSION = "4.1.0"
+  VERSION = "4.3.0"
 end

data/lib/syntax_tree.rb

@@ -21,6 +21,7 @@ require_relative "syntax_tree/visitor/environment"
 require_relative "syntax_tree/visitor/with_environment"
 
 require_relative "syntax_tree/parser"
+require_relative "syntax_tree/pattern"
 require_relative "syntax_tree/search"
 
 # Syntax Tree is a suite of tools built on top of the internal CRuby parser. It
@@ -74,4 +75,10 @@ module SyntaxTree
 
     File.read(filepath, encoding: encoding)
   end
+
+  # Searches through the given source using the given pattern and yields each
+  # node in the tree that matches the pattern to the given block.
+  def self.search(source, query, &block)
+    Search.new(Pattern.new(query).compile).scan(parse(source), &block)
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: syntax_tree
 version: !ruby/object:Gem::Version
-  version: 4.1.0
+  version: 4.3.0
 platform: ruby
 authors:
 - Kevin Newton
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-10-24 00:00:00.000000000 Z
+date: 2022-10-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: prettier_print
@@ -129,6 +129,7 @@ files:
 - lib/syntax_tree/language_server/inlay_hints.rb
 - lib/syntax_tree/node.rb
 - lib/syntax_tree/parser.rb
+- lib/syntax_tree/pattern.rb
 - lib/syntax_tree/plugin/single_quotes.rb
 - lib/syntax_tree/plugin/trailing_comma.rb
 - lib/syntax_tree/rake/check_task.rb