syntax_tree 2.1.1 → 2.3.1

data/lib/syntax_tree/parser.rb

@@ -516,12 +516,46 @@ module SyntaxTree
     def on_aryptn(constant, requireds, rest, posts)
       parts = [constant, *requireds, rest, *posts].compact
 
+      # If there aren't any parts (no constant, no positional arguments), then
+      # we're matching an empty array. In this case, we're going to look for the
+      # left and right brackets explicitly. Otherwise, we'll just use the bounds
+      # of the various parts.
+      location =
+        if parts.empty?
+          find_token(LBracket).location.to(find_token(RBracket).location)
+        else
+          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.
+      if rest.is_a?(VarField) && rest.value.nil?
+        tokens.rindex do |token|
+          case token
+          in Op[value: "*"]
+            rest = VarField.new(value: nil, location: token.location)
+            break
+          in Comma
+            break
+          else
+          end
+        end
+      end
+
       AryPtn.new(
         constant: constant,
         requireds: requireds || [],
         rest: rest,
         posts: posts || [],
-        location: parts[0].location.to(parts[-1].location)
+        location: location
       )
     end
 
@@ -1373,15 +1407,35 @@ module SyntaxTree
     #     VarField right
     #   ) -> FndPtn
     def on_fndptn(constant, left, values, right)
-      beginning = constant || find_token(LBracket)
-      ending = find_token(RBracket)
+      # The opening of this find pattern is either going to be a left bracket, a
+      # right left parenthesis, or the left splat. We're going to use this to
+      # determine how to find the closing of the pattern, as well as determining
+      # the location of the node.
+      opening =
+        find_token(LBracket, consume: false) ||
+        find_token(LParen, consume: false) ||
+        left
+
+      # The closing is based on the opening, which is either the matched
+      # punctuation or the right splat.
+      closing =
+        case opening
+        in LBracket
+          tokens.delete(opening)
+          find_token(RBracket)
+        in LParen
+          tokens.delete(opening)
+          find_token(RParen)
+        else
+          right
+        end
 
       FndPtn.new(
         constant: constant,
         left: left,
         values: values,
         right: right,
-        location: beginning.location.to(ending.location)
+        location: (constant || opening).location.to(closing.location)
       )
     end
 
@@ -1468,6 +1522,7 @@ module SyntaxTree
       @heredocs[-1] = Heredoc.new(
         beginning: heredoc.beginning,
         ending: heredoc.ending,
+        dedent: width,
         parts: string.parts,
         location: heredoc.location
       )
@@ -1481,6 +1536,7 @@ module SyntaxTree
       @heredocs[-1] = Heredoc.new(
         beginning: heredoc.beginning,
         ending: value.chomp,
+        dedent: heredoc.dedent,
         parts: heredoc.parts,
         location:
           Location.new(
@@ -1501,12 +1557,23 @@ module SyntaxTree
     #     (nil | VarField) keyword_rest
     #   ) -> HshPtn
     def on_hshptn(constant, keywords, keyword_rest)
+      # Create an artificial VarField if we find an extra ** on the end
+      if !keyword_rest && (token = find_token(Op, "**", consume: false))
+        tokens.delete(token)
+        keyword_rest = VarField.new(value: nil, location: token.location)
+      end
+
+      # Delete the optional then keyword
+      if token = find_token(Kw, "then", consume: false)
+        tokens.delete(token)
+      end
+
       parts = [constant, *keywords&.flatten(1), keyword_rest].compact
       location =
-        if parts.empty?
-          find_token(LBrace).location.to(find_token(RBrace).location)
-        else
+        if parts.any?
           parts[0].location.to(parts[-1].location)
+        else
+          find_token(LBrace).location.to(find_token(RBrace).location)
         end
 
       HshPtn.new(
@@ -2012,12 +2079,16 @@ module SyntaxTree
       keyword_rest,
       block
     )
+      # This is to make it so that required keyword arguments
+      # have a `nil` for the value instead of a `false`.
+      keywords&.map! { |(key, value)| [key, value || nil] }
+
       parts = [
         *requireds,
         *optionals&.flatten(1),
         rest,
         *posts,
-        *keywords&.flat_map { |(key, value)| [key, value || nil] },
+        *keywords&.flatten(1),
         (keyword_rest if keyword_rest != :nil),
         (block if block != :&)
       ].compact
@@ -2638,6 +2709,7 @@ module SyntaxTree
         Heredoc.new(
           beginning: heredoc.beginning,
           ending: heredoc.ending,
+          dedent: heredoc.dedent,
           parts: string.parts,
           location: heredoc.location
         )
@@ -3190,6 +3262,7 @@ module SyntaxTree
         Heredoc.new(
           beginning: heredoc.beginning,
           ending: heredoc.ending,
+          dedent: heredoc.dedent,
           parts: xstring.parts,
           location: heredoc.location
         )

data/lib/syntax_tree/prettyprint.rb

@@ -79,7 +79,7 @@ class PrettyPrint
     end
 
     def pretty_print(q)
-      q.group(2, "align([", "])") do
+      q.group(2, "align#{indent}([", "])") do
         q.seplist(contents) { |content| q.pp(content) }
       end
     end
@@ -161,7 +161,7 @@ class PrettyPrint
     end
 
     def pretty_print(q)
-      q.group(2, "group([", "])") do
+      q.group(2, break? ? "breakGroup([" : "group([", "])") do
         q.seplist(contents) { |content| q.pp(content) }
       end
     end
@@ -458,6 +458,10 @@ class PrettyPrint
       IfBreakBuilder.new
     end
 
+    # Also effectively unnecessary, but here for compatibility.
+    def if_flat
+    end
+
     # A noop that immediately yields.
     def indent
       yield
@@ -759,9 +763,7 @@ class PrettyPrint
 
     # This is a linear stack instead of a mutually recursive call defined on
     # the individual doc nodes for efficiency.
-    while commands.any?
-      indent, mode, doc = commands.pop
-
+    while (indent, mode, doc = commands.pop)
       case doc
       when Text
         doc.objects.each { |object| buffer << object }
@@ -789,10 +791,10 @@ class PrettyPrint
           end
         end
       when IfBreak
-        if mode == MODE_BREAK
-          commands << [indent, mode, doc.break_contents] if doc.break_contents
-        elsif mode == MODE_FLAT
-          commands << [indent, mode, doc.flat_contents] if doc.flat_contents
+        if mode == MODE_BREAK && doc.break_contents.any?
+          commands << [indent, mode, doc.break_contents]
+        elsif mode == MODE_FLAT && doc.flat_contents.any?
+          commands << [indent, mode, doc.flat_contents]
         end
       when LineSuffix
         line_suffixes << [indent, mode, doc.contents, doc.priority]
@@ -1011,6 +1013,16 @@ class PrettyPrint
     IfBreakBuilder.new(self, doc)
   end
 
+  # This is similar to if_break in that it also inserts an IfBreak node into the
+  # print tree, however it's starting from the flat contents, and cannot be used
+  # to build the break contents.
+  def if_flat
+    doc = IfBreak.new
+    target << doc
+
+    with_target(doc.flat_contents) { yield }
+  end
+
   # Very similar to the #nest method, this indents the nested content by one
   # level by inserting an Indent node into the print tree. The contents of the
   # node are determined by the block.
@@ -1116,10 +1128,10 @@ class PrettyPrint
       when Group
         commands << [indent, doc.break? ? MODE_BREAK : mode, doc.contents]
       when IfBreak
-        if mode == MODE_BREAK
-          commands << [indent, mode, doc.break_contents] if doc.break_contents
-        else
-          commands << [indent, mode, doc.flat_contents] if doc.flat_contents
+        if mode == MODE_BREAK && doc.break_contents.any?
+          commands << [indent, mode, doc.break_contents]
+        elsif mode == MODE_FLAT && doc.flat_contents.any?
+          commands << [indent, mode, doc.flat_contents]
         end
       when Breakable
         if mode == MODE_FLAT && !doc.force?

data/lib/syntax_tree/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: syntax_tree
 version: !ruby/object:Gem::Version
-  version: 2.1.1
+  version: 2.3.1
 platform: ruby
 authors:
 - Kevin Newton
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-04-17 00:00:00.000000000 Z
+date: 2022-04-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -123,7 +123,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