syntax_tree 2.5.0 → 2.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3b1505fca44f379d951132dafb8122a2591fe46607c8402d096bab67bd53d0a3
-  data.tar.gz: 0d58e60b6779ec1acd22ca776f3610f290c4b048cc1bf41b425f9c5a74e80db8
+  metadata.gz: 4e90bde4f4aa60ce6784fd2c03234853bc281b7012cdb496d3f2bd97a1d825a9
+  data.tar.gz: 24c4a344934acc5fb0b8b7d8931f689f98185f00fd9b71726f5aeab2499dea98
 SHA512:
-  metadata.gz: 42d4dea2571b21b3cf877a129f0a840f30125eb918c558b25b5bc303c915bb758b731151cdf2cfb6e70e92cbc4957d915095d1284312529675fec71f3a6af3a7
-  data.tar.gz: 5178b395ddcfdcf795c18f7c986e86a12f6ca2bdec871792de2c21220dffc7c2a2238a02926cece3021635f42859ab5084ba4dba21932ce7f1791c2a17a5bc49
+  metadata.gz: 70d191270dbe2efd07300169410e4e0674b7abd8ec1ed4d95e87f7bb986b790195f8366f27b77f38eeeb94de1a08ce3467d64fbb126910922857366389ce66c0
+  data.tar.gz: c3994813de2fa53eb132dce7e4d176e58a83071232bcdefe3ded77a3fdd35ed52639d99989878b4cf5ca3d13c0a5bc14cbdfb95555b9705e2dd08c88d2abf360

data/.github/workflows/main.yml

@@ -38,7 +38,7 @@ jobs:
         ruby-version: '3.1'
     - name: Check
       run: |
-        bundle exec rake check
+        bundle exec rake stree:check
         bundle exec rubocop
 
   automerge:

data/.rubocop.yml

@@ -78,3 +78,6 @@ Style/PerlBackrefs:
 
 Style/SpecialGlobalVars:
   Enabled: false
+
+Style/StructInheritance:
+  Enabled: false

data/CHANGELOG.md

@@ -6,6 +6,41 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) a
 
 ## [Unreleased]
 
+## [2.7.1] - 2022-05-25
+
+### Added
+
+- [#92](https://github.com/ruby-syntax-tree/syntax_tree/pull/92) - (Internal) Drastically increase test coverage, including many more tests for the language server and the CLI.
+
+### Changed
+
+- [#87](https://github.com/ruby-syntax-tree/syntax_tree/pull/87) - Don't convert quotes on strings if it would result in more escapes.
+- [#91](https://github.com/ruby-syntax-tree/syntax_tree/pull/91) - Always use `[]` with array patterns. There are just too many edge cases where you have to use them anyway. This simplifies the look and makes it more consistent.
+- [#92](https://github.com/ruby-syntax-tree/syntax_tree/pull/92) - Remodel the currently shipped plugins such that they're modifying an options hash instead of overriding methods. This should make it easier for other plugins to reference the already loaded plugins, e.g., the RBS plugin referencing the quotes.
+- [#92](https://github.com/ruby-syntax-tree/syntax_tree/pull/92) - Fix up the language server inlay hints to continue walking the tree once a pattern is found. This should increase useability.
+
+## [2.7.0] - 2022-05-19
+
+### Added
+
+- [#88](https://github.com/ruby-syntax-tree/syntax_tree/pull/88) - Provide a `SyntaxTree::BasicVisitor` that has no visit methods implemented.
+
+### Changed
+
+- [#90](https://github.com/ruby-syntax-tree/syntax_tree/pull/90) - Provide better formatting for `SyntaxTree::AryPtn` when its nested inside a `SyntaxTree::RAssign`.
+
+## [2.6.0] - 2022-05-16
+
+### Added
+
+- [#74](https://github.com/ruby-syntax-tree/syntax_tree/pull/74) - Add Rake test to run check and format commands.
+- [#83](https://github.com/ruby-syntax-tree/syntax_tree/pull/83) - Add a trailing commas plugin.
+- [#84](https://github.com/ruby-syntax-tree/syntax_tree/pull/84) - Handle lambda block-local variables.
+
+### Changed
+
+- [#85](https://github.com/ruby-syntax-tree/syntax_tree/pull/85) - Better handle trailing operators on command calls.
+
 ## [2.5.0] - 2022-05-13
 
 ### Added
@@ -224,7 +259,10 @@ 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/v2.5.0...HEAD
+[unreleased]: https://github.com/ruby-syntax-tree/syntax_tree/compare/v2.7.1...HEAD
+[2.7.1]: https://github.com/ruby-syntax-tree/syntax_tree/compare/v2.7.0...v2.7.1
+[2.7.0]: https://github.com/ruby-syntax-tree/syntax_tree/compare/v2.6.0...v2.7.0
+[2.6.0]: https://github.com/ruby-syntax-tree/syntax_tree/compare/v2.5.0...v2.6.0
 [2.5.0]: https://github.com/ruby-syntax-tree/syntax_tree/compare/v2.4.1...v2.5.0
 [2.4.1]: https://github.com/ruby-syntax-tree/syntax_tree/compare/v2.4.0...v2.4.1
 [2.4.0]: https://github.com/ruby-syntax-tree/syntax_tree/compare/v2.3.1...v2.4.0

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    syntax_tree (2.5.0)
+    syntax_tree (2.7.1)
       prettier_print
 
 GEM

data/README.md

@@ -32,12 +32,16 @@ It is built with only standard library dependencies. It additionally ships with
   - [construct_keys](#construct_keys)
 - [Visitor](#visitor)
   - [visit_method](#visit_method)
+  - [BasicVisitor](#basicvisitor)
 - [Language server](#language-server)
   - [textDocument/formatting](#textdocumentformatting)
   - [textDocument/inlayHints](#textdocumentinlayhints)
   - [syntaxTree/visualizing](#syntaxtreevisualizing)
 - [Plugins](#plugins)
+  - [Configuration](#configuration)
+  - [Languages](#languages)
 - [Integration](#integration)
+  - [Rake](#rake)
   - [RuboCop](#rubocop)
   - [VSCode](#vscode)
 - [Contributing](#contributing)
@@ -223,7 +227,7 @@ This function takes an input string containing Ruby code and returns the syntax
 
 ### SyntaxTree.format(source)
 
-This function takes an input string containing Ruby code, parses it into its underlying syntax tree, and formats it back out to a string.
+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`.
 
 ## Nodes
 
@@ -370,6 +374,20 @@ Did you mean?  visit_binary
 	from bin/console:8:in `<main>'
 ```
 
+### BasicVisitor
+
+When you're defining your own visitor, by default it will walk down the tree even if you don't define `visit_*` methods. This is to ensure you can define a subset of the necessary methods in order to only interact with the nodes you're interested in. If you'd like to change this default to instead raise an error if you visit a node you haven't explicitly handled, you can instead inherit from `BasicVisitor`.
+
+```ruby
+class MyVisitor < SyntaxTree::BasicVisitor
+  def visit_int(node)
+    # ...
+  end
+end
+```
+
+The visitor defined above will error out unless it's only visiting a `SyntaxTree::Int` node. This is useful in a couple of ways, e.g., if you're trying to define a visitor to handle the whole tree but it's currently a work-in-progress.
+
 ## Language server
 
 Syntax Tree additionally ships with a language server conforming to the [language server protocol](https://microsoft.github.io/language-server-protocol/). It can be invoked through the CLI by running:
@@ -408,9 +426,12 @@ You can register additional configuration and additional languages that can flow
 
 ### Configuration
 
-To register additional configuration, define a file somewhere in your load path named `syntax_tree/my_plugin` directory. Then when invoking the CLI, you will pass `--plugins=my_plugin`. That will get required. In this way, you can modify Syntax Tree however you would like. Some plugins ship with Syntax Tree itself. They are:
+To register additional configuration, define a file somewhere in your load path named `syntax_tree/my_plugin`. Then when invoking the CLI, you will pass `--plugins=my_plugin`. To require multiple, separate them by a comma. In this way, you can modify Syntax Tree however you would like. Some plugins ship with Syntax Tree itself. They are:
 
 * `plugin/single_quotes` - This will change all of your string literals to use single quotes instead of the default double quotes.
+* `plugin/trailing_comma` - This will put trailing commas into multiline array literals, hash literals, and method calls that can support trailing commas.
+
+If you're using Syntax Tree as a library, you should require those files directly.
 
 ### Languages
 
@@ -436,6 +457,46 @@ Below are listed all of the "official" language plugins hosted under the same Gi
 
 Syntax Tree's goal is to seemlessly integrate into your workflow. To this end, it provides a couple of additional tools beyond the CLI and the Ruby library.
 
+### Rake
+
+Syntax Tree ships with the ability to define [rake](https://github.com/ruby/rake) tasks that will trigger runs of the CLI. To define them in your application, add the following configuration to your `Rakefile`:
+
+```ruby
+require "syntax_tree/rake_tasks"
+SyntaxTree::Rake::CheckTask.new
+SyntaxTree::Rake::WriteTask.new
+```
+
+These calls will define `rake stree:check` and `rake stree:write` (equivalent to calling `stree check` and `stree write` with the CLI respectively). You can configure them by either passing arguments to the `new` method or by using a block.
+
+#### `name`
+
+If you'd like to change the default name of the rake task, you can pass that as the first argument, as in:
+
+```ruby
+SyntaxTree::Rake::WriteTask.new(:format)
+```
+
+#### `source_files`
+
+If you wanted to configure Syntax Tree to check or write different files than the default (`lib/**/*.rb`), you can set the `source_files` field, as in:
+
+```ruby
+SyntaxTree::Rake::WriteTask.new do |t|
+  t.source_files = FileList[%w[Gemfile Rakefile lib/**/*.rb test/**/*.rb]]
+end
+```
+
+#### `plugins`
+
+If you're running Syntax Tree with plugins (either your own or the pre-built ones), you can pass that to the `plugins` field, as in:
+
+```ruby
+SyntaxTree::Rake::WriteTask.new do |t|
+  t.plugins = ["plugin/single_quotes"]
+end
+```
+
 ### RuboCop
 
 RuboCop and Syntax Tree serve different purposes, but there is overlap with some of RuboCop's functionality. Syntax Tree provides a RuboCop configuration file to disable rules that are redundant with Syntax Tree. To use this configuration file, add the following snippet to the top of your project's `.rubocop.yml`:

data/Rakefile

@@ -2,6 +2,7 @@
 
 require "bundler/gem_tasks"
 require "rake/testtask"
+require "syntax_tree/rake_tasks"
 
 Rake::TestTask.new(:test) do |t|
   t.libs << "test"
@@ -11,24 +12,8 @@ end
 
 task default: :test
 
-FILEPATHS = %w[
-  Gemfile
-  Rakefile
-  syntax_tree.gemspec
-  lib/**/*.rb
-  test/*.rb
-].freeze
+SOURCE_FILES =
+  FileList[%w[Gemfile Rakefile syntax_tree.gemspec lib/**/*.rb test/*.rb]]
 
-task :syntax_tree do
-  $:.unshift File.expand_path("lib", __dir__)
-  require "syntax_tree"
-  require "syntax_tree/cli"
-end
-
-task check: :syntax_tree do
-  exit SyntaxTree::CLI.run(["check"] + FILEPATHS)
-end
-
-task format: :syntax_tree do
-  exit SyntaxTree::CLI.run(["write"] + FILEPATHS)
-end
+SyntaxTree::Rake::CheckTask.new { |t| t.source_files = SOURCE_FILES }
+SyntaxTree::Rake::WriteTask.new { |t| t.source_files = SOURCE_FILES }

data/lib/syntax_tree/basic_visitor.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module SyntaxTree
+  # BasicVisitor is the parent class of the Visitor class that provides the
+  # ability to walk down the tree. It does not define any handlers, so you
+  # should extend this class if you want your visitor to raise an error if you
+  # attempt to visit a node that you don't handle.
+  class BasicVisitor
+    # This is raised when you use the Visitor.visit_method method and it fails.
+    # It is correctable to through DidYouMean.
+    class VisitMethodError < StandardError
+      attr_reader :visit_method
+
+      def initialize(visit_method)
+        @visit_method = visit_method
+        super("Invalid visit method: #{visit_method}")
+      end
+    end
+
+    # This class is used by DidYouMean to offer corrections to invalid visit
+    # method names.
+    class VisitMethodChecker
+      attr_reader :visit_method
+
+      def initialize(error)
+        @visit_method = error.visit_method
+      end
+
+      def corrections
+        @corrections ||=
+          DidYouMean::SpellChecker.new(
+            dictionary: Visitor.visit_methods
+          ).correct(visit_method)
+      end
+
+      DidYouMean.correct_error(VisitMethodError, self)
+    end
+
+    class << self
+      # This method is here to help folks write visitors.
+      #
+      # It's not always easy to ensure you're writing the correct method name in
+      # the visitor since it's perfectly valid to define methods that don't
+      # override these parent methods.
+      #
+      # If you use this method, you can ensure you're writing the correct method
+      # name. It will raise an error if the visit method you're defining isn't
+      # actually a method on the parent visitor.
+      def visit_method(method_name)
+        return if visit_methods.include?(method_name)
+
+        raise VisitMethodError, method_name
+      end
+
+      # This is the list of all of the valid visit methods.
+      def visit_methods
+        @visit_methods ||=
+          Visitor.instance_methods.grep(/^visit_(?!child_nodes)/)
+      end
+    end
+
+    def visit(node)
+      node&.accept(self)
+    end
+
+    def visit_all(nodes)
+      nodes.map { |node| visit(node) }
+    end
+
+    def visit_child_nodes(node)
+      visit_all(node.child_nodes)
+    end
+  end
+end

data/lib/syntax_tree/formatter.rb

@@ -4,17 +4,42 @@ module SyntaxTree
   # A slightly enhanced PP that knows how to format recursively including
   # comments.
   class Formatter < PrettierPrint
+    # We want to minimize as much as possible the number of options that are
+    # available in syntax tree. For the most part, if users want non-default
+    # formatting, they should override the format methods on the specific nodes
+    # themselves. However, because of some history with prettier and the fact
+    # that folks have become entrenched in their ways, we decided to provide a
+    # small amount of configurability.
+    #
+    # Note that we're keeping this in a global-ish hash instead of just
+    # overriding methods on classes so that other plugins can reference this if
+    # necessary. For example, the RBS plugin references the quote style.
+    OPTIONS = { quote: "\"", trailing_comma: false }
+
     COMMENT_PRIORITY = 1
     HEREDOC_PRIORITY = 2
 
-    attr_reader :source, :stack, :quote
+    attr_reader :source, :stack
+
+    # These options are overridden in plugins to we need to make sure they are
+    # available here.
+    attr_reader :quote, :trailing_comma
+    alias trailing_comma? trailing_comma
 
-    def initialize(source, ...)
-      super(...)
+    def initialize(
+      source,
+      *args,
+      quote: OPTIONS[:quote],
+      trailing_comma: OPTIONS[:trailing_comma]
+    )
+      super(*args)
 
       @source = source
       @stack = []
-      @quote = "\""
+
+      # Memoizing these values per formatter to make access faster.
+      @quote = quote
+      @trailing_comma = trailing_comma
     end
 
     def self.format(source, node)

data/lib/syntax_tree/language_server/inlay_hints.rb

@@ -38,6 +38,7 @@ module SyntaxTree
       #
       def visit_assign(node)
         parentheses(node.location) if stack[-2].is_a?(Params)
+        super
       end
 
       # Adds parentheses around binary expressions to make it clear which
@@ -57,6 +58,8 @@ module SyntaxTree
           parentheses(node.location)
         else
         end
+
+        super
       end
 
       # Adds parentheses around ternary operators contained within certain
@@ -70,9 +73,13 @@ module SyntaxTree
       #     a ? b : ₍c ? d : e₎
       #
       def visit_if_op(node)
-        if stack[-2] in Assign | Binary | IfOp | OpAssign
+        case stack[-2]
+        in Assign | Binary | IfOp | OpAssign
           parentheses(node.location)
+        else
         end
+
+        super
       end
 
       # Adds the implicitly rescued StandardError into a bare rescue clause. For
@@ -92,6 +99,8 @@ module SyntaxTree
         if node.exception.nil?
           after[node.location.start_char + "rescue".length] << " StandardError"
         end
+
+        super
       end
 
       # Adds parentheses around unary statements using the - operator that are
@@ -107,6 +116,8 @@ module SyntaxTree
         if stack[-2].is_a?(Binary) && (node.operator == "-")
           parentheses(node.location)
         end
+
+        super
       end
 
       def self.find(program)

data/lib/syntax_tree/language_server.rb

@@ -70,13 +70,11 @@ module SyntaxTree
              id:,
              params: { textDocument: { uri: } }
            }
-          output = []
-          PP.pp(SyntaxTree.parse(store[uri]), output)
-          write(id: id, result: output.join)
+          write(id: id, result: PP.pp(SyntaxTree.parse(store[uri]), +""))
         in method: %r{\$/.+}
           # ignored
         else
-          raise "Unhandled: #{request}"
+          raise ArgumentError, "Unhandled: #{request}"
         end
       end
     end
@@ -109,10 +107,6 @@ module SyntaxTree
       }
     end
 
-    def log(message)
-      write(method: "window/logMessage", params: { type: 4, message: message })
-    end
-
     def inlay_hints(source)
       inlay_hints = InlayHints.find(SyntaxTree.parse(source))
       serialize = ->(position, text) { { position: position, text: text } }

data/lib/syntax_tree/node.rb

@@ -597,10 +597,30 @@ module SyntaxTree
         q.indent do
           q.breakable("")
           q.format(arguments)
+          q.if_break { q.text(",") } if q.trailing_comma? && trailing_comma?
         end
         q.breakable("")
       end
     end
+
+    private
+
+    def trailing_comma?
+      case arguments
+      in Args[parts: [*, ArgBlock]]
+        # If the last argument is a block, then we can't put a trailing comma
+        # after it without resulting in a syntax error.
+        false
+      in Args[parts: [Command | CommandCall]]
+        # If the only argument is a command or command call, then a trailing
+        # comma would be parsed as part of that expression instead of on this
+        # one, so we don't want to add a trailing comma.
+        false
+      else
+        # Otherwise, we should be okay to add a trailing comma.
+        true
+      end
+    end
   end
 
   # Args represents a list of arguments being passed to a method call or array
@@ -859,6 +879,7 @@ module SyntaxTree
             end
 
             q.seplist(contents.parts, separator) { |part| q.format(part) }
+            q.if_break { q.text(",") } if q.trailing_comma?
           end
           q.breakable("")
         end
@@ -954,6 +975,7 @@ module SyntaxTree
           q.indent do
             q.breakable("")
             q.format(contents)
+            q.if_break { q.text(",") } if q.trailing_comma?
           end
         end
 
@@ -1101,30 +1123,20 @@ module SyntaxTree
     end
 
     def format(q)
-      parts = [*requireds]
-      parts << RestFormatter.new(rest) if rest
-      parts += posts
+      q.group do
+        q.format(constant) if constant
+        q.text("[")
+        q.indent do
+          q.breakable("")
+
+          parts = [*requireds]
+          parts << RestFormatter.new(rest) if rest
+          parts += posts
 
-      if constant
-        q.group do
-          q.format(constant)
-          q.text("[")
           q.seplist(parts) { |part| q.format(part) }
-          q.text("]")
         end
-
-        return
-      end
-
-      parent = q.parent
-      if parts.length == 1 || PATTERNS.include?(parent.class)
-        q.text("[")
-        q.seplist(parts) { |part| q.format(part) }
+        q.breakable("")
         q.text("]")
-      elsif parts.empty?
-        q.text("[]")
-      else
-        q.group { q.seplist(parts) { |part| q.format(part) } }
       end
     end
   end
@@ -2117,11 +2129,13 @@ module SyntaxTree
           #
           #     break
           #
-        in [Paren[
-             contents: {
-               body: [ArrayLiteral[contents: { parts: [_, _, *] }] => array]
-             }
-           ]]
+        in [
+             Paren[
+               contents: {
+                 body: [ArrayLiteral[contents: { parts: [_, _, *] }] => array]
+               }
+             ]
+           ]
           # Here we have a single argument that is a set of parentheses wrapping
           # an array literal that has at least 2 elements. We're going to print
           # the contents of the array directly. This would be like if we had:
@@ -2755,10 +2769,17 @@ module SyntaxTree
         q.format(value)
         q.text(" ")
         q.format(operator)
-        q.group do
-          q.indent do
-            q.breakable
-            q.format(pattern)
+
+        case pattern
+        in AryPtn | FndPtn | HshPtn
+          q.text(" ")
+          q.format(pattern)
+        else
+          q.group do
+            q.indent do
+              q.breakable
+              q.format(pattern)
+            end
           end
         end
       end
@@ -3030,8 +3051,20 @@ module SyntaxTree
         doc =
           q.nest(0) do
             q.format(receiver)
-            q.format(CallOperatorFormatter.new(operator), stackable: false)
-            q.format(message)
+
+            # If there are leading comments on the message then we know we have
+            # a newline in the source that is forcing these things apart. In
+            # this case we will have to use a trailing operator.
+            if message.comments.any?(&:leading?)
+              q.format(CallOperatorFormatter.new(operator), stackable: false)
+              q.indent do
+                q.breakable("")
+                q.format(message)
+              end
+            else
+              q.format(CallOperatorFormatter.new(operator), stackable: false)
+              q.format(message)
+            end
           end
 
         case arguments
@@ -3830,9 +3863,9 @@ module SyntaxTree
     # whichever quote the user chose. (If they chose single quotes, then double
     # quoting would activate the escape sequence, and if they chose double
     # quotes, then single quotes would deactivate it.)
-    def self.locked?(node)
+    def self.locked?(node, quote)
       node.parts.any? do |part|
-        !part.is_a?(TStringContent) || part.value.match?(/\\|#[@${]/)
+        !part.is_a?(TStringContent) || part.value.match?(/\\|#[@${]|#{quote}/)
       end
     end
 
@@ -3947,12 +3980,12 @@ module SyntaxTree
 
         if matched
           [quote, matching]
-        elsif Quotes.locked?(self)
+        elsif Quotes.locked?(self, q.quote)
           ["#{":" unless hash_key}'", "'"]
         else
           ["#{":" unless hash_key}#{q.quote}", q.quote]
         end
-      elsif Quotes.locked?(self)
+      elsif Quotes.locked?(self, q.quote)
         if quote.start_with?(":")
           [hash_key ? quote[1..] : quote, quote[1..]]
         else
@@ -4539,16 +4572,26 @@ module SyntaxTree
 
     def format(q)
       q.format(constant) if constant
-      q.group(0, "[", "]") do
-        q.text("*")
-        q.format(left)
-        q.comma_breakable
 
-        q.seplist(values) { |value| q.format(value) }
-        q.comma_breakable
+      q.group do
+        q.text("[")
 
-        q.text("*")
-        q.format(right)
+        q.indent do
+          q.breakable("")
+
+          q.text("*")
+          q.format(left)
+          q.comma_breakable
+
+          q.seplist(values) { |value| q.format(value) }
+          q.comma_breakable
+
+          q.text("*")
+          q.format(right)
+        end
+
+        q.breakable("")
+        q.text("]")
       end
     end
   end
@@ -4751,6 +4794,7 @@ module SyntaxTree
         q.indent do
           q.breakable
           q.seplist(assocs) { |assoc| q.format(assoc) }
+          q.if_break { q.text(",") } if q.trailing_comma?
         end
         q.breakable
       end
@@ -5430,12 +5474,14 @@ module SyntaxTree
       q.format(predicate)
       q.text(" ?")
 
-      q.breakable
-      q.format(truthy)
-      q.text(" :")
+      q.indent do
+        q.breakable
+        q.format(truthy)
+        q.text(" :")
 
-      q.breakable
-      q.format(falsy)
+        q.breakable
+        q.format(falsy)
+      end
     end
   end
 
@@ -5877,7 +5923,7 @@ module SyntaxTree
   #     ->(value) { value * 2 }
   #
   class Lambda < Node
-    # [Params | Paren] the parameter declaration for this lambda
+    # [LambdaVar | Paren] the parameter declaration for this lambda
     attr_reader :params
 
     # [BodyStmt | Statements] the expressions to be executed in this lambda
@@ -5932,24 +5978,100 @@ module SyntaxTree
                 node.is_a?(Command) || node.is_a?(CommandCall)
               end
 
-            q.text(force_parens ? "{" : "do")
-            q.indent do
+            if force_parens
+              q.text("{")
+
+              unless statements.empty?
+                q.indent do
+                  q.breakable
+                  q.format(statements)
+                end
+                q.breakable
+              end
+
+              q.text("}")
+            else
+              q.text("do")
+
+              unless statements.empty?
+                q.indent do
+                  q.breakable
+                  q.format(statements)
+                end
+              end
+
               q.breakable
-              q.format(statements)
+              q.text("end")
             end
-
-            q.breakable
-            q.text(force_parens ? "}" : "end")
           end
           .if_flat do
-            q.text("{ ")
-            q.format(statements)
-            q.text(" }")
+            q.text("{")
+
+            unless statements.empty?
+              q.text(" ")
+              q.format(statements)
+              q.text(" ")
+            end
+
+            q.text("}")
           end
       end
     end
   end
 
+  # LambdaVar represents the parameters being declared for a lambda. Effectively
+  # this node is everything contained within the parentheses. This includes all
+  # of the various parameter types, as well as block-local variable
+  # declarations.
+  #
+  #     -> (positional, optional = value, keyword:, &block; local) do
+  #     end
+  #
+  class LambdaVar < Node
+    # [Params] the parameters being declared with the block
+    attr_reader :params
+
+    # [Array[ Ident ]] the list of block-local variable declarations
+    attr_reader :locals
+
+    # [Array[ Comment | EmbDoc ]] the comments attached to this node
+    attr_reader :comments
+
+    def initialize(params:, locals:, location:, comments: [])
+      @params = params
+      @locals = locals
+      @location = location
+      @comments = comments
+    end
+
+    def accept(visitor)
+      visitor.visit_lambda_var(self)
+    end
+
+    def child_nodes
+      [params, *locals]
+    end
+
+    alias deconstruct child_nodes
+
+    def deconstruct_keys(_keys)
+      { params: params, locals: locals, location: location, comments: comments }
+    end
+
+    def empty?
+      params.empty? && locals.empty?
+    end
+
+    def format(q)
+      q.format(params)
+
+      if locals.any?
+        q.text("; ")
+        q.seplist(locals, -> { q.text(", ") }) { |local| q.format(local) }
+      end
+    end
+  end
+
   # LBrace represents the use of a left brace, i.e., {.
   class LBrace < Node
     # [String] the left brace
@@ -8293,7 +8415,7 @@ module SyntaxTree
       end
 
       opening_quote, closing_quote =
-        if !Quotes.locked?(self)
+        if !Quotes.locked?(self, q.quote)
           [q.quote, q.quote]
         elsif quote.start_with?("%")
           [quote, Quotes.matching(quote[/%[qQ]?(.)/, 1])]

data/lib/syntax_tree/parser.rb

@@ -548,13 +548,6 @@ module SyntaxTree
           parts[0].location.to(parts[-1].location)
         end
 
-      # If there's the optional then keyword, then we'll delete that and use it
-      # as the end bounds of the location.
-      if (token = find_token(Kw, "then", consume: false))
-        tokens.delete(token)
-        location = location.to(token.location)
-      end
-
       # If there is a plain *, then we're going to fix up the location of it
       # here because it currently doesn't have anything to use for its precise
       # location. If we hit a comma, then we've gone too far.
@@ -1698,12 +1691,6 @@ module SyntaxTree
         end
       end
 
-      # Delete the optional then keyword
-      if (token = find_token(Kw, "then", consume: false))
-        parts << token
-        tokens.delete(token)
-      end
-
       HshPtn.new(
         constant: constant,
         keywords: keywords || [],
@@ -1940,6 +1927,41 @@ module SyntaxTree
             token.location.start_char > beginning.location.start_char
         end
 
+      # We need to do some special mapping here. Since ripper doesn't support
+      # capturing lambda var until 3.2, we need to normalize all of that here.
+      params =
+        case params
+        in Paren[contents: Params]
+          # In this case we've gotten to the <3.2 parentheses wrapping a set of
+          # parameters case. Here we need to manually scan for lambda locals.
+          range = (params.location.start_char + 1)...params.location.end_char
+          locals = lambda_locals(source[range])
+
+          location = params.contents.location
+          location = location.to(locals.last.location) if locals.any?
+
+          Paren.new(
+            lparen: params.lparen,
+            contents:
+              LambdaVar.new(
+                params: params.contents,
+                locals: locals,
+                location: location
+              ),
+            location: params.location,
+            comments: params.comments
+          )
+        in Params
+          # In this case we've gotten to the <3.2 plain set of parameters. In
+          # this case there cannot be lambda locals, so we will wrap the
+          # parameters into a lambda var that has no locals.
+          LambdaVar.new(params: params, locals: [], location: params.location)
+        in LambdaVar
+          # In this case we've gotten to 3.2+ lambda var. In this case we don't
+          # need to do anything and can just the value as given.
+          params
+        end
+
       if braces
         opening = find_token(TLamBeg)
         closing = find_token(RBrace)
@@ -1962,6 +1984,83 @@ module SyntaxTree
       )
     end
 
+    # :call-seq:
+    #   on_lambda_var: (Params params, Array[ Ident ] locals) -> LambdaVar
+    def on_lambda_var(params, locals)
+      location = params.location
+      location = location.to(locals.last.location) if locals.any?
+
+      LambdaVar.new(params: params, locals: locals || [], location: location)
+    end
+
+    # Ripper doesn't support capturing lambda local variables until 3.2. To
+    # mitigate this, we have to parse that code for ourselves. We use the range
+    # from the parentheses to find where we _should_ be looking. Then we check
+    # if the resulting tokens match a pattern that we determine means that the
+    # declaration has block-local variables. Once it does, we parse those out
+    # and convert them into Ident nodes.
+    def lambda_locals(source)
+      tokens = Ripper.lex(source)
+
+      # First, check that we have a semi-colon. If we do, then we can start to
+      # parse the tokens _after_ the semicolon.
+      index = tokens.rindex { |token| token[1] == :on_semicolon }
+      return [] unless index
+
+      # Next, map over the tokens and convert them into Ident nodes. Bail out
+      # midway through if we encounter a token we didn't expect. Basically we're
+      # making our own mini-parser here. To do that we'll walk through a small
+      # state machine:
+      #
+      #     ┌────────┐               ┌────────┐                ┌─────────┐
+      #     │        │               │        │                │┌───────┐│
+      # ──> │  item  │ ─── ident ──> │  next  │ ─── rparen ──> ││ final ││
+      #     │        │ <── comma ─── │        │                │└───────┘│
+      #     └────────┘               └────────┘                └─────────┘
+      #        │  ^                     │  ^
+      #        └──┘                     └──┘
+      #    ignored_nl, sp              nl, sp
+      #
+      state = :item
+      transitions = {
+        item: {
+          on_ignored_nl: :item,
+          on_sp: :item,
+          on_ident: :next
+        },
+        next: {
+          on_nl: :next,
+          on_sp: :next,
+          on_comma: :item,
+          on_rparen: :final
+        },
+        final: {
+        }
+      }
+
+      tokens[(index + 1)..].each_with_object([]) do |token, locals|
+        (lineno, column), type, value, = token
+
+        # Make the state transition for the parser. If there isn't a transition
+        # from the current state to a new state for this type, then we're in a
+        # pattern that isn't actually locals. In that case we can return [].
+        state = transitions[state].fetch(type) { return [] }
+
+        # If we hit an identifier, then add it to our list.
+        next if type != :on_ident
+
+        location =
+          Location.token(
+            line: lineno,
+            char: line_counts[lineno - 1][column],
+            column: column,
+            size: value.size
+          )
+
+        locals << Ident.new(value: value, location: location)
+      end
+    end
+
     # :call-seq:
     #   on_lbrace: (String value) -> LBrace
     def on_lbrace(value)
@@ -2901,6 +3000,11 @@ module SyntaxTree
     #     (StringEmbExpr | StringDVar | TStringContent) part
     #   ) -> StringContent
     def on_string_add(string, part)
+      # Due to some eccentricities in how ripper works, you need this here in
+      # case you have a syntax error with an embedded expression that doesn't
+      # finish, as in: "#{"
+      return string if part.is_a?(String)
+
       location =
         string.parts.any? ? string.location.to(part.location) : part.location
 

data/lib/syntax_tree/plugin/single_quotes.rb

@@ -1,4 +1,3 @@
 # frozen_string_literal: true
 
-require "syntax_tree/formatter/single_quotes"
-SyntaxTree::Formatter.prepend(SyntaxTree::Formatter::SingleQuotes)
+SyntaxTree::Formatter::OPTIONS[:quote] = "'"

data/lib/syntax_tree/plugin/trailing_comma.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+SyntaxTree::Formatter::OPTIONS[:trailing_comma] = true

data/lib/syntax_tree/rake/check_task.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "rake"
+require "rake/tasklib"
+
+require "syntax_tree"
+require "syntax_tree/cli"
+
+module SyntaxTree
+  module Rake
+    # A Rake task that runs check on a set of source files.
+    #
+    # Example:
+    #
+    #   require 'syntax_tree/rake/check_task'
+    #
+    #   SyntaxTree::Rake::CheckTask.new do |t|
+    #     t.source_files = '{app,config,lib}/**/*.rb'
+    #   end
+    #
+    # This will create task that can be run with:
+    #
+    #   rake stree_check
+    #
+    class CheckTask < ::Rake::TaskLib
+      # Name of the task.
+      # Defaults to :"stree:check".
+      attr_accessor :name
+
+      # Glob pattern to match source files.
+      # Defaults to 'lib/**/*.rb'.
+      attr_accessor :source_files
+
+      # The set of plugins to require.
+      # Defaults to [].
+      attr_accessor :plugins
+
+      def initialize(
+        name = :"stree:check",
+        source_files = ::Rake::FileList["lib/**/*.rb"],
+        plugins = []
+      )
+        @name = name
+        @source_files = source_files
+        @plugins = plugins
+
+        yield self if block_given?
+        define_task
+      end
+
+      private
+
+      def define_task
+        desc "Runs `stree check` over source files"
+        task(name) { run_task }
+      end
+
+      def run_task
+        arguments = ["check"]
+        arguments << "--plugins=#{plugins.join(",")}" if plugins.any?
+
+        SyntaxTree::CLI.run(arguments + Array(source_files))
+      end
+    end
+  end
+end

data/lib/syntax_tree/rake/write_task.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "rake"
+require "rake/tasklib"
+
+require "syntax_tree"
+require "syntax_tree/cli"
+
+module SyntaxTree
+  module Rake
+    # A Rake task that runs format on a set of source files.
+    #
+    # Example:
+    #
+    #   require 'syntax_tree/rake/write_task'
+    #
+    #   SyntaxTree::Rake::WriteTask.new do |t|
+    #     t.source_files = '{app,config,lib}/**/*.rb'
+    #   end
+    #
+    # This will create task that can be run with:
+    #
+    #   rake stree_write
+    #
+    class WriteTask < ::Rake::TaskLib
+      # Name of the task.
+      # Defaults to :"stree:write".
+      attr_accessor :name
+
+      # Glob pattern to match source files.
+      # Defaults to 'lib/**/*.rb'.
+      attr_accessor :source_files
+
+      # The set of plugins to require.
+      # Defaults to [].
+      attr_accessor :plugins
+
+      def initialize(
+        name = :"stree:write",
+        source_files = ::Rake::FileList["lib/**/*.rb"],
+        plugins = []
+      )
+        @name = name
+        @source_files = source_files
+        @plugins = plugins
+
+        yield self if block_given?
+        define_task
+      end
+
+      private
+
+      def define_task
+        desc "Runs `stree write` over source files"
+        task(name) { run_task }
+      end
+
+      def run_task
+        arguments = ["write"]
+        arguments << "--plugins=#{plugins.join(",")}" if plugins.any?
+
+        SyntaxTree::CLI.run(arguments + Array(source_files))
+      end
+    end
+  end
+end

data/lib/syntax_tree/rake_tasks.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative "rake/check_task"
+require_relative "rake/write_task"

data/lib/syntax_tree/version.rb

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

data/lib/syntax_tree/visitor/field_visitor.rb

@@ -49,9 +49,7 @@ module SyntaxTree
     # of circumstances, like when visiting the list of optional parameters
     # defined on a method.
     #
-    class FieldVisitor < Visitor
-      attr_reader :q
-
+    class FieldVisitor < BasicVisitor
       def visit_aref(node)
         node(node, "aref") do
           field("collection", node.collection)
@@ -586,6 +584,14 @@ module SyntaxTree
         end
       end
 
+      def visit_lambda_var(node)
+        node(node, "lambda_var") do
+          field("params", node.params)
+          list("locals", node.locals) if node.locals.any?
+          comments(node)
+        end
+      end
+
       def visit_lbrace(node)
         visit_token(node, "lbrace")
       end

data/lib/syntax_tree/visitor.rb

@@ -4,72 +4,7 @@ module SyntaxTree
   # Visitor is a parent class that provides the ability to walk down the tree
   # and handle a subset of nodes. By defining your own subclass, you can
   # explicitly handle a node type by defining a visit_* method.
-  class Visitor
-    # This is raised when you use the Visitor.visit_method method and it fails.
-    # It is correctable to through DidYouMean.
-    class VisitMethodError < StandardError
-      attr_reader :visit_method
-
-      def initialize(visit_method)
-        @visit_method = visit_method
-        super("Invalid visit method: #{visit_method}")
-      end
-    end
-
-    # This class is used by DidYouMean to offer corrections to invalid visit
-    # method names.
-    class VisitMethodChecker
-      attr_reader :visit_method
-
-      def initialize(error)
-        @visit_method = error.visit_method
-      end
-
-      def corrections
-        @corrections ||=
-          DidYouMean::SpellChecker.new(
-            dictionary: Visitor.visit_methods
-          ).correct(visit_method)
-      end
-
-      DidYouMean.correct_error(VisitMethodError, self)
-    end
-
-    class << self
-      # This method is here to help folks write visitors.
-      #
-      # It's not always easy to ensure you're writing the correct method name in
-      # the visitor since it's perfectly valid to define methods that don't
-      # override these parent methods.
-      #
-      # If you use this method, you can ensure you're writing the correct method
-      # name. It will raise an error if the visit method you're defining isn't
-      # actually a method on the parent visitor.
-      def visit_method(method_name)
-        return if visit_methods.include?(method_name)
-
-        raise VisitMethodError, method_name
-      end
-
-      # This is the list of all of the valid visit methods.
-      def visit_methods
-        @visit_methods ||=
-          Visitor.instance_methods.grep(/^visit_(?!child_nodes)/)
-      end
-    end
-
-    def visit(node)
-      node&.accept(self)
-    end
-
-    def visit_all(nodes)
-      nodes.map { |node| visit(node) }
-    end
-
-    def visit_child_nodes(node)
-      visit_all(node.child_nodes)
-    end
-
+  class Visitor < BasicVisitor
     # Visit an ARef node.
     alias visit_aref visit_child_nodes
 
@@ -301,6 +236,9 @@ module SyntaxTree
     # Visit a Lambda node.
     alias visit_lambda visit_child_nodes
 
+    # Visit a LambdaVar node.
+    alias visit_lambda_var visit_child_nodes
+
     # Visit a LBrace node.
     alias visit_lbrace visit_child_nodes
 

data/lib/syntax_tree.rb

@@ -10,6 +10,8 @@ require_relative "syntax_tree/formatter"
 require_relative "syntax_tree/node"
 require_relative "syntax_tree/parser"
 require_relative "syntax_tree/version"
+
+require_relative "syntax_tree/basic_visitor"
 require_relative "syntax_tree/visitor"
 require_relative "syntax_tree/visitor/field_visitor"
 require_relative "syntax_tree/visitor/json_visitor"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: syntax_tree
 version: !ruby/object:Gem::Version
-  version: 2.5.0
+  version: 2.7.1
 platform: ruby
 authors:
 - Kevin Newton
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-05-14 00:00:00.000000000 Z
+date: 2022-05-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: prettier_print
@@ -121,14 +121,18 @@ files:
 - doc/logo.svg
 - exe/stree
 - lib/syntax_tree.rb
+- lib/syntax_tree/basic_visitor.rb
 - lib/syntax_tree/cli.rb
 - lib/syntax_tree/formatter.rb
-- lib/syntax_tree/formatter/single_quotes.rb
 - lib/syntax_tree/language_server.rb
 - lib/syntax_tree/language_server/inlay_hints.rb
 - lib/syntax_tree/node.rb
 - lib/syntax_tree/parser.rb
 - lib/syntax_tree/plugin/single_quotes.rb
+- lib/syntax_tree/plugin/trailing_comma.rb
+- lib/syntax_tree/rake/check_task.rb
+- lib/syntax_tree/rake/write_task.rb
+- lib/syntax_tree/rake_tasks.rb
 - lib/syntax_tree/version.rb
 - lib/syntax_tree/visitor.rb
 - lib/syntax_tree/visitor/field_visitor.rb
@@ -156,7 +160,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.3
+rubygems_version: 3.4.0.dev
 signing_key:
 specification_version: 4
 summary: A parser based on ripper

data/lib/syntax_tree/formatter/single_quotes.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-module SyntaxTree
-  class Formatter
-    # This module overrides the quote method on the formatter to use single
-    # quotes for everything instead of double quotes.
-    module SingleQuotes
-      def quote
-        "'"
-      end
-    end
-  end
-end