syntax_tree 2.6.0 → 2.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f3d700916c1fab01ddc92117fd2b99c26b699df9e03f06b83eafa1415167ef7d
-  data.tar.gz: f5499912fe7bf422b44360bf66ce3f7e74145f3a2cc3ef5668e20fc97bd61948
+  metadata.gz: ad3c35843b6e3148499ac001d05a9c5d613d69debff5fdc411dff89a9adc5ca4
+  data.tar.gz: 570ae99edf8b17b5d205142872621b0551632d29ac4671ee14fed8415cf9cfe4
 SHA512:
-  metadata.gz: e287bcace78e800140ce6b30044a684587e8514f7f0b4c8a57f7b4f3926717a96eb966828e42325a44c1af23715cc602c3cb327dcab27d5390b0353b6a595744
-  data.tar.gz: 7cb34f0d9d423b3129033f04dc543d1bb9b19e62dcc7a9a140eb5c3a3159caaf389746930d15e6556df753e10f0651e38ab5e4db95bad63737836e14f14a86c1
+  metadata.gz: 7ec0e9d8f5f4f828ba0d451d49bd7fa9f5576570f7427c91973503e795fe068e21a61dac4f1880be12dbd551855eb0b8d27f359a9a682b964f3183aaf687e1da
+  data.tar.gz: b8ae5c0132ebc445d060b1d5cef477253c724ea2c7a22a536d4ea78b3fb2d905c560e1f044f8843b92f79e0dbc1a434cda2a38e76b2732b426719150785a59af

data/.rubocop.yml

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

data/CHANGELOG.md

@@ -6,6 +6,42 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) a
 
 ## [Unreleased]
 
+## [2.8.0] - 2022-06-21
+
+### Added
+
+- [#95](https://github.com/ruby-syntax-tree/syntax_tree/pull/95) - The `HeredocEnd` node has been added which effectively results in the ability to determine the location of the ending of a heredoc from source.
+- [#99](https://github.com/ruby-syntax-tree/syntax_tree/pull/99) - The LSP now allows you to pass the same configuration options as the other CLI commands which allows formatting to be modified in the VSCode extension.
+- [#100](https://github.com/ruby-syntax-tree/syntax_tree/pull/100) - The LSP now explicitly responds to the shutdown request so that VSCode never deadlocks.
+
+### Changed
+
+- [#96](https://github.com/ruby-syntax-tree/syntax_tree/pull/96) - The CLI now runs in parallel by default. There is a worker created for each processor on the running machine (as determined by `Etc.nprocessors`).
+- [#97](https://github.com/ruby-syntax-tree/syntax_tree/pull/97) - Syntax Tree now handles the case where `DidYouMean` is not available for whatever reason, as well as handles the newer `detailed_message` API for errors.
+
+## [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
@@ -236,7 +272,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.6.0...HEAD
+[unreleased]: https://github.com/ruby-syntax-tree/syntax_tree/compare/v2.8.0...HEAD
+[2.8.0]: https://github.com/ruby-syntax-tree/syntax_tree/compare/v2.7.1...v2.8.0
+[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

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    syntax_tree (2.6.0)
+    syntax_tree (2.8.0)
       prettier_print
 
 GEM
@@ -9,25 +9,25 @@ GEM
   specs:
     ast (2.4.2)
     docile (1.4.0)
-    minitest (5.15.0)
+    minitest (5.16.0)
     parallel (1.22.1)
     parser (3.1.2.0)
       ast (~> 2.4.1)
     prettier_print (0.1.0)
     rainbow (3.1.1)
     rake (13.0.6)
-    regexp_parser (2.4.0)
+    regexp_parser (2.5.0)
     rexml (3.2.5)
-    rubocop (1.29.1)
+    rubocop (1.30.1)
       parallel (~> 1.10)
       parser (>= 3.1.0.0)
       rainbow (>= 2.2.2, < 4.0)
       regexp_parser (>= 1.8, < 3.0)
       rexml (>= 3.2.5, < 4.0)
-      rubocop-ast (>= 1.17.0, < 2.0)
+      rubocop-ast (>= 1.18.0, < 2.0)
       ruby-progressbar (~> 1.7)
       unicode-display_width (>= 1.4.0, < 3.0)
-    rubocop-ast (1.17.0)
+    rubocop-ast (1.18.0)
       parser (>= 3.1.1.0)
     ruby-progressbar (1.11.0)
     simplecov (0.21.2)

data/README.md

@@ -32,6 +32,7 @@ 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)
@@ -373,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:

data/lib/syntax_tree/basic_visitor.rb

@@ -0,0 +1,78 @@
+# 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
+
+      # In some setups with Ruby you can turn off DidYouMean, so we're going to
+      # respect that setting here.
+      if defined?(DidYouMean) && DidYouMean.method_defined?(:correct_error)
+        DidYouMean.correct_error(VisitMethodError, self)
+      end
+    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/cli.rb

@@ -34,9 +34,41 @@ module SyntaxTree
       end
     end
 
+    # An item of work that corresponds to a file to be processed.
+    class FileItem
+      attr_reader :filepath
+
+      def initialize(filepath)
+        @filepath = filepath
+      end
+
+      def handler
+        HANDLERS[File.extname(filepath)]
+      end
+
+      def source
+        handler.read(filepath)
+      end
+    end
+
+    # An item of work that corresponds to the stdin content.
+    class STDINItem
+      def handler
+        HANDLERS[".rb"]
+      end
+
+      def filepath
+        :stdin
+      end
+
+      def source
+        $stdin.read
+      end
+    end
+
     # The parent action class for the CLI that implements the basics.
     class Action
-      def run(handler, filepath, source)
+      def run(item)
       end
 
       def success
@@ -48,8 +80,8 @@ module SyntaxTree
 
     # An action of the CLI that prints out the AST for the given source.
     class AST < Action
-      def run(handler, _filepath, source)
-        pp handler.parse(source)
+      def run(item)
+        pp item.handler.parse(item.source)
       end
     end
 
@@ -59,10 +91,11 @@ module SyntaxTree
       class UnformattedError < StandardError
       end
 
-      def run(handler, filepath, source)
-        raise UnformattedError if source != handler.format(source)
+      def run(item)
+        source = item.source
+        raise UnformattedError if source != item.handler.format(source)
       rescue StandardError
-        warn("[#{Color.yellow("warn")}] #{filepath}")
+        warn("[#{Color.yellow("warn")}] #{item.filepath}")
         raise
       end
 
@@ -81,9 +114,11 @@ module SyntaxTree
       class NonIdempotentFormatError < StandardError
       end
 
-      def run(handler, filepath, source)
-        warning = "[#{Color.yellow("warn")}] #{filepath}"
-        formatted = handler.format(source)
+      def run(item)
+        handler = item.handler
+
+        warning = "[#{Color.yellow("warn")}] #{item.filepath}"
+        formatted = handler.format(item.source)
 
         raise NonIdempotentFormatError if formatted != handler.format(formatted)
       rescue StandardError
@@ -102,25 +137,27 @@ module SyntaxTree
 
     # An action of the CLI that prints out the doc tree IR for the given source.
     class Doc < Action
-      def run(handler, _filepath, source)
+      def run(item)
+        source = item.source
+
         formatter = Formatter.new(source, [])
-        handler.parse(source).format(formatter)
+        item.handler.parse(source).format(formatter)
         pp formatter.groups.first
       end
     end
 
     # An action of the CLI that formats the input source and prints it out.
     class Format < Action
-      def run(handler, _filepath, source)
-        puts handler.format(source)
+      def run(item)
+        puts item.handler.format(item.source)
       end
     end
 
     # An action of the CLI that converts the source into its equivalent JSON
     # representation.
     class Json < Action
-      def run(handler, _filepath, source)
-        object = Visitor::JSONVisitor.new.visit(handler.parse(source))
+      def run(item)
+        object = Visitor::JSONVisitor.new.visit(item.handler.parse(item.source))
         puts JSON.pretty_generate(object)
       end
     end
@@ -128,27 +165,28 @@ module SyntaxTree
     # An action of the CLI that outputs a pattern-matching Ruby expression that
     # would match the input given.
     class Match < Action
-      def run(handler, _filepath, source)
-        puts handler.parse(source).construct_keys
+      def run(item)
+        puts item.handler.parse(item.source).construct_keys
       end
     end
 
     # An action of the CLI that formats the input source and writes the
     # formatted output back to the file.
     class Write < Action
-      def run(handler, filepath, source)
-        print filepath
+      def run(item)
+        filepath = item.filepath
         start = Time.now
 
-        formatted = handler.format(source)
+        source = item.source
+        formatted = item.handler.format(source)
         File.write(filepath, formatted) if filepath != :stdin
 
         color = source == formatted ? Color.gray(filepath) : filepath
         delta = ((Time.now - start) * 1000).round
 
-        puts "\r#{color} #{delta}ms"
+        puts "#{color} #{delta}ms"
       rescue StandardError
-        puts "\r#{filepath}"
+        puts filepath
         raise
       end
     end
@@ -180,7 +218,7 @@ module SyntaxTree
       #{Color.bold("stree help")}
         Display this help message
 
-      #{Color.bold("stree lsp")}
+      #{Color.bold("stree lsp [OPTIONS]")}
         Run syntax tree in language server mode
 
       #{Color.bold("stree version")}
@@ -201,6 +239,20 @@ module SyntaxTree
       def run(argv)
         name, *arguments = argv
 
+        # If there are any plugins specified on the command line, then load them
+        # by requiring them here. We do this by transforming something like
+        #
+        #     stree format --plugins=haml template.haml
+        #
+        # into
+        #
+        #     require "syntax_tree/haml"
+        #
+        if arguments.first&.start_with?("--plugins=")
+          plugins = arguments.shift[/^--plugins=(.*)$/, 1]
+          plugins.split(",").each { |plugin| require "syntax_tree/#{plugin}" }
+        end
+
         case name
         when "help"
           puts HELP
@@ -244,38 +296,41 @@ module SyntaxTree
           return 1
         end
 
-        # If there are any plugins specified on the command line, then load them
-        # by requiring them here. We do this by transforming something like
-        #
-        #     stree format --plugins=haml template.haml
-        #
-        # into
-        #
-        #     require "syntax_tree/haml"
-        #
-        if arguments.first&.start_with?("--plugins=")
-          plugins = arguments.shift[/^--plugins=(.*)$/, 1]
-          plugins.split(",").each { |plugin| require "syntax_tree/#{plugin}" }
-        end
+        # We're going to build up a queue of items to process.
+        queue = Queue.new
 
-        # Track whether or not there are any errors from any of the files that
-        # we take action on so that we can properly clean up and exit.
-        errored = false
-
-        each_file(arguments) do |handler, filepath, source|
-          action.run(handler, filepath, source)
-        rescue Parser::ParseError => error
-          warn("Error: #{error.message}")
-          highlight_error(error, source)
-          errored = true
-        rescue Check::UnformattedError, Debug::NonIdempotentFormatError
-          errored = true
-        rescue StandardError => error
-          warn(error.message)
-          warn(error.backtrace)
-          errored = true
+        # If we're reading from stdin, then we'll just add the stdin object to
+        # the queue. Otherwise, we'll add each of the filepaths to the queue.
+        if $stdin.tty? || arguments.any?
+          arguments.each do |pattern|
+            Dir
+              .glob(pattern)
+              .each do |filepath|
+                queue << FileItem.new(filepath) if File.file?(filepath)
+              end
+          end
+        else
+          queue << STDINItem.new
         end
 
+        # At the end, we're going to return whether or not this worker ever
+        # encountered an error.
+        errored =
+          with_workers(queue) do |item|
+            action.run(item)
+            false
+          rescue Parser::ParseError => error
+            warn("Error: #{error.message}")
+            highlight_error(error, item.source)
+            true
+          rescue Check::UnformattedError, Debug::NonIdempotentFormatError
+            true
+          rescue StandardError => error
+            warn(error.message)
+            warn(error.backtrace)
+            true
+          end
+
         if errored
           action.failure
           1
@@ -287,22 +342,33 @@ module SyntaxTree
 
       private
 
-      def each_file(arguments)
-        if $stdin.tty? || arguments.any?
-          arguments.each do |pattern|
-            Dir
-              .glob(pattern)
-              .each do |filepath|
-                next unless File.file?(filepath)
-
-                handler = HANDLERS[File.extname(filepath)]
-                source = handler.read(filepath)
-                yield handler, filepath, source
-              end
+      def with_workers(queue)
+        # If the queue is just 1 item, then we're not going to bother going
+        # through the whole ceremony of parallelizing the work.
+        return yield queue.shift if queue.size == 1
+
+        workers =
+          Etc.nprocessors.times.map do
+            Thread.new do
+              # Propagate errors in the worker threads up to the parent thread.
+              Thread.current.abort_on_exception = true
+
+              # Track whether or not there are any errors from any of the files
+              # that we take action on so that we can properly clean up and
+              # exit.
+              errored = false
+
+              # While there is still work left to do, shift off the queue and
+              # process the item.
+              (errored ||= yield queue.shift) until queue.empty?
+
+              # At the end, we're going to return whether or not this worker
+              # ever encountered an error.
+              errored
+            end
           end
-        else
-          yield HANDLERS[".rb"], :stdin, $stdin.read
-        end
+
+        workers.inject(false) { |accum, thread| accum || thread.value }
       end
 
       # Highlights a snippet from a source and parse error.

data/lib/syntax_tree/formatter.rb

@@ -4,6 +4,18 @@ 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
 
@@ -14,13 +26,20 @@ module SyntaxTree
     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 = "\""
-      @trailing_comma = false
+
+      # 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

@@ -36,8 +36,9 @@ module SyntaxTree
           write(id: id, result: { capabilities: capabilities })
         in method: "initialized"
           # ignored
-        in method: "shutdown"
+        in method: "shutdown" # tolerate missing ID to be a good citizen
           store.clear
+          write(id: request[:id], result: {})
           return
         in {
              method: "textDocument/didChange",
@@ -70,13 +71,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 +108,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

@@ -1123,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
@@ -2139,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:
@@ -2777,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
@@ -3864,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
 
@@ -3981,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
@@ -4573,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
@@ -4804,7 +4813,7 @@ module SyntaxTree
     # [HeredocBeg] the opening of the heredoc
     attr_reader :beginning
 
-    # [String] the ending of the heredoc
+    # [HeredocEnd] the ending of the heredoc
     attr_reader :ending
 
     # [Integer] how far to dedent the heredoc
@@ -4838,7 +4847,7 @@ module SyntaxTree
     end
 
     def child_nodes
-      [beginning, *parts]
+      [beginning, *parts, ending]
     end
 
     alias deconstruct child_nodes
@@ -4874,7 +4883,7 @@ module SyntaxTree
               end
             end
 
-            q.text(ending)
+            q.format(ending)
           end
         end
       end
@@ -4920,6 +4929,45 @@ module SyntaxTree
     end
   end
 
+  # HeredocEnd represents the closing declaration of a heredoc.
+  #
+  #     <<~DOC
+  #       contents
+  #     DOC
+  #
+  # In the example above the HeredocEnd node represents the closing DOC.
+  class HeredocEnd < Node
+    # [String] the closing declaration of the heredoc
+    attr_reader :value
+
+    # [Array[ Comment | EmbDoc ]] the comments attached to this node
+    attr_reader :comments
+
+    def initialize(value:, location:, comments: [])
+      @value = value
+      @location = location
+      @comments = comments
+    end
+
+    def accept(visitor)
+      visitor.visit_heredoc_end(self)
+    end
+
+    def child_nodes
+      []
+    end
+
+    alias deconstruct child_nodes
+
+    def deconstruct_keys(_keys)
+      { value: value, location: location, comments: comments }
+    end
+
+    def format(q)
+      q.text(value)
+    end
+  end
+
   # HshPtn represents matching against a hash pattern using the Ruby 2.7+
   # pattern matching syntax.
   #
@@ -5465,12 +5513,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
 
@@ -8404,7 +8454,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.
@@ -1647,9 +1640,19 @@ module SyntaxTree
     def on_heredoc_end(value)
       heredoc = @heredocs[-1]
 
+      location =
+      Location.token(
+        line: lineno,
+        char: char_pos,
+        column: current_column,
+        size: value.size + 1
+      )
+
+      heredoc_end = HeredocEnd.new(value: value.chomp, location: location)
+
       @heredocs[-1] = Heredoc.new(
         beginning: heredoc.beginning,
-        ending: value.chomp,
+        ending: heredoc_end,
         dedent: heredoc.dedent,
         parts: heredoc.parts,
         location:
@@ -1698,12 +1701,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 || [],
@@ -3013,6 +3010,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

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

data/lib/syntax_tree/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SyntaxTree
-  VERSION = "2.6.0"
+  VERSION = "2.8.0"
 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)
@@ -499,6 +497,10 @@ module SyntaxTree
         visit_token(node, "heredoc_beg")
       end
 
+      def visit_heredoc_end(node)
+        visit_token(node, "heredoc_end")
+      end
+
       def visit_hshptn(node)
         node(node, "hshptn") do
           field("constant", node.constant) if node.constant

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
 
@@ -259,6 +194,9 @@ module SyntaxTree
     # Visit a HeredocBeg node.
     alias visit_heredoc_beg visit_child_nodes
 
+    # Visit a HeredocEnd node.
+    alias visit_heredoc_end visit_child_nodes
+
     # Visit a HshPtn node.
     alias visit_hshptn visit_child_nodes
 

data/lib/syntax_tree.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "etc"
 require "json"
 require "pp"
 require "prettier_print"
@@ -10,6 +11,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.6.0
+  version: 2.8.0
 platform: ruby
 authors:
 - Kevin Newton
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-05-16 00:00:00.000000000 Z
+date: 2022-06-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: prettier_print
@@ -121,10 +121,9 @@ 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/formatter/trailing_comma.rb
 - lib/syntax_tree/language_server.rb
 - lib/syntax_tree/language_server/inlay_hints.rb
 - lib/syntax_tree/node.rb
@@ -161,7 +160,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.0.dev
+rubygems_version: 3.3.3
 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

data/lib/syntax_tree/formatter/trailing_comma.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-module SyntaxTree
-  class Formatter
-    # This module overrides the trailing_comma? method on the formatter to
-    # return true.
-    module TrailingComma
-      def trailing_comma?
-        true
-      end
-    end
-  end
-end