syntax_tree 4.2.0 → 4.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 444c1c74319e55d9c3a656ff1796e6658237c0433a257eb6e2c66d8625d47243
-  data.tar.gz: 2662a60c92265c6b257f6545ee1947269e1990f96003c60caef790eeb871eb32
+  metadata.gz: 4ca1eae46ba326b73e129d5b066d144aeac2743947956efc1453a3539c2caac9
+  data.tar.gz: 7c833e7b7bf25df7a82653d9dddb30aa172320a625a0655c52a29640c7a2154f
 SHA512:
-  metadata.gz: 9dddc08b2d7c2c3c7cec089f301b88220cf18a625ef7b155ad71810eaefd4cfe54c063279a4f817bc823b1eb586a222b106aa5889f3b736da901ca0404feedb5
-  data.tar.gz: eaabea185c2f53aaf62ea76b1bb89987d7c472538025ae3f3e457f97eafe38b2533895f504100ed534785ffebaa18a013dd8d1f27432da974beedf0b7202861c
+  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/.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,18 @@ 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
@@ -414,7 +426,8 @@ 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.2.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

data/Gemfile.lock

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

data/lib/syntax_tree/cli.rb

@@ -192,9 +192,10 @@ module SyntaxTree
     # would match the first expression of the input given.
     class Expr < Action
       def run(item)
-        case item.handler.parse(item.source)
-        in Program[statements: Statements[body: [expression]]]
-          puts expression.construct_keys
+        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)

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

@@ -75,98 +75,213 @@ module SyntaxTree
 
     private
 
+    # Shortcut for combining two procs into one that returns true if both return
+    # true.
     def combine_and(left, right)
-      ->(node) { left.call(node) && right.call(node) }
+      ->(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)
-      ->(node) { left.call(node) || right.call(node) }
+      ->(other) { left.call(other) || right.call(other) }
     end
 
-    def compile_node(root)
-      case root
-      in AryPtn[constant:, requireds:, rest: nil, posts: []]
-        compiled_constant = compile_node(constant) if constant
+    # 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
 
-        preprocessed = requireds.map { |required| compile_node(required) }
+      if parts.length == 1 && (part = parts.first) && part.is_a?(TStringContent)
+        part.value
+      end
+    end
 
-        compiled_requireds = ->(node) do
-          deconstructed = node.deconstruct
+    # in [foo, bar, baz]
+    def compile_aryptn(node)
+      compile_error(node) if !node.rest.nil? || node.posts.any?
 
-          deconstructed.length == preprocessed.length &&
-            preprocessed
-              .zip(deconstructed)
-              .all? { |(matcher, value)| matcher.call(value) }
-        end
+      constant = node.constant
+      compiled_constant = compile_node(constant) if constant
 
-        if compiled_constant
-          combine_and(compiled_constant, compiled_requireds)
-        else
-          compiled_requireds
-        end
-      in Binary[left:, operator: :|, right:]
-        combine_or(compile_node(left), compile_node(right))
-      in Const[value:] if SyntaxTree.const_defined?(value)
+      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)
 
-        ->(node) { node.is_a?(clazz) }
-      in Const[value:] if Object.const_defined?(value)
+        ->(other) { clazz === other }
+      elsif Object.const_defined?(value)
         clazz = Object.const_get(value)
 
-        ->(node) { node.is_a?(clazz) }
-      in ConstPathRef[
-           parent: VarRef[value: Const[value: "SyntaxTree"]], constant:
-         ]
-        compile_node(constant)
-      in DynaSymbol[parts: []]
+        ->(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 = :""
 
-        ->(node) { node == symbol }
-      in DynaSymbol[parts: [TStringContent[value:]]]
+        ->(other) { symbol === other }
+      elsif (value = extract_string(node))
         symbol = value.to_sym
 
-        ->(attribute) { attribute == value }
-      in HshPtn[constant:, keywords:, keyword_rest: nil]
-        compiled_constant = compile_node(constant)
-
-        preprocessed =
-          keywords.to_h do |keyword, value|
-            raise NoMatchingPatternError unless keyword.is_a?(Label)
-            [keyword.value.chomp(":").to_sym, compile_node(value)]
-          end
+        ->(other) { symbol === other }
+      else
+        compile_error(root)
+      end
+    end
 
-        compiled_keywords = ->(node) do
-          deconstructed = node.deconstruct_keys(preprocessed.keys)
+    # 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.all? do |keyword, matcher|
-            matcher.call(deconstructed[keyword])
-          end
+      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
 
-        if compiled_constant
-          combine_and(compiled_constant, compiled_keywords)
-        else
-          compiled_keywords
+      compiled_keywords = ->(other) do
+        deconstructed = other.deconstruct_keys(preprocessed.keys)
+
+        preprocessed.all? do |keyword, matcher|
+          matcher.call(deconstructed[keyword])
         end
-      in RegexpLiteral[parts: [TStringContent[value:]]]
+      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.match?(attribute) }
-      in StringLiteral[parts: []]
-        ->(attribute) { attribute == "" }
-      in StringLiteral[parts: [TStringContent[value:]]]
-        ->(attribute) { attribute == value }
-      in SymbolLiteral[value:]
-        symbol = value.value.to_sym
+        ->(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) { attribute == symbol }
-      in VarRef[value: Const => value]
+      ->(attribute) { symbol === attribute }
+    end
+
+    # in Foo
+    # in nil
+    def compile_var_ref(node)
+      value = node.value
+
+      if value.is_a?(Const)
         compile_node(value)
-      in VarRef[value: Kw[value: "nil"]]
-        ->(attribute) { attribute.nil? }
+      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
-    rescue NoMatchingPatternError
-      raise CompilationError, PP.pp(root, +"").chomp
     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/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: syntax_tree
 version: !ruby/object:Gem::Version
-  version: 4.2.0
+  version: 4.3.0
 platform: ruby
 authors:
 - Kevin Newton
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-10-25 00:00:00.000000000 Z
+date: 2022-10-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: prettier_print