syntax_tree 5.2.0 → 5.3.0

data/lib/syntax_tree/node.rb

@@ -775,6 +775,10 @@ module SyntaxTree
       other.is_a?(ArgParen) && arguments === other.arguments
     end
 
+    def arity
+      arguments&.arity || 0
+    end
+
     private
 
     def trailing_comma?
@@ -848,6 +852,21 @@ module SyntaxTree
     def ===(other)
       other.is_a?(Args) && ArrayMatch.call(parts, other.parts)
     end
+
+    def arity
+      parts.sum do |part|
+        case part
+        when ArgStar, ArgsForward
+          Float::INFINITY
+        when BareAssocHash
+          part.assocs.sum do |assoc|
+            assoc.is_a?(AssocSplat) ? Float::INFINITY : 1
+          end
+        else
+          1
+        end
+      end
+    end
   end
 
   # ArgBlock represents using a block operator on an expression.
@@ -1008,6 +1027,10 @@ module SyntaxTree
     def ===(other)
       other.is_a?(ArgsForward)
     end
+
+    def arity
+      Float::INFINITY
+    end
   end
 
   # ArrayLiteral represents an array literal, which can optionally contain
@@ -1080,58 +1103,6 @@ module SyntaxTree
       end
     end
 
-    # Formats an array that contains only a list of variable references. To make
-    # things simpler, if there are a bunch, we format them all using the "fill"
-    # algorithm as opposed to breaking them into a ton of lines. For example,
-    #
-    #     [foo, bar, baz]
-    #
-    # instead of becoming:
-    #
-    #     [
-    #       foo,
-    #       bar,
-    #       baz
-    #     ]
-    #
-    # would instead become:
-    #
-    #     [
-    #       foo, bar,
-    #       baz
-    #     ]
-    #
-    # provided the line length was hit between `bar` and `baz`.
-    class VarRefsFormatter
-      # The separator for the fill algorithm.
-      class Separator
-        def call(q)
-          q.text(",")
-          q.fill_breakable
-        end
-      end
-
-      # [Args] the contents of the array
-      attr_reader :contents
-
-      def initialize(contents)
-        @contents = contents
-      end
-
-      def format(q)
-        q.text("[")
-        q.group do
-          q.indent do
-            q.breakable_empty
-            q.seplist(contents.parts, Separator.new) { |part| q.format(part) }
-            q.if_break { q.text(",") } if q.trailing_comma?
-          end
-          q.breakable_empty
-        end
-        q.text("]")
-      end
-    end
-
     # This is a special formatter used if the array literal contains no values
     # but _does_ contain comments. In this case we do some special formatting to
     # make sure the comments gets indented properly.
@@ -1206,19 +1177,17 @@ module SyntaxTree
     end
 
     def format(q)
-      if qwords?
-        QWordsFormatter.new(contents).format(q)
-        return
-      end
-
-      if qsymbols?
-        QSymbolsFormatter.new(contents).format(q)
-        return
-      end
+      if lbracket.comments.empty? && contents && contents.comments.empty? &&
+           contents.parts.length > 1
+        if qwords?
+          QWordsFormatter.new(contents).format(q)
+          return
+        end
 
-      if var_refs?(q)
-        VarRefsFormatter.new(contents).format(q)
-        return
+        if qsymbols?
+          QSymbolsFormatter.new(contents).format(q)
+          return
+        end
       end
 
       if empty_with_comments?
@@ -1250,39 +1219,24 @@ module SyntaxTree
     private
 
     def qwords?
-      lbracket.comments.empty? && contents && contents.comments.empty? &&
-        contents.parts.length > 1 &&
-        contents.parts.all? do |part|
-          case part
-          when StringLiteral
-            part.comments.empty? && part.parts.length == 1 &&
-              part.parts.first.is_a?(TStringContent) &&
-              !part.parts.first.value.match?(/[\s\[\]\\]/)
-          when CHAR
-            !part.value.match?(/[\[\]\\]/)
-          else
-            false
-          end
+      contents.parts.all? do |part|
+        case part
+        when StringLiteral
+          part.comments.empty? && part.parts.length == 1 &&
+            part.parts.first.is_a?(TStringContent) &&
+            !part.parts.first.value.match?(/[\s\[\]\\]/)
+        when CHAR
+          !part.value.match?(/[\[\]\\]/)
+        else
+          false
         end
+      end
     end
 
     def qsymbols?
-      lbracket.comments.empty? && contents && contents.comments.empty? &&
-        contents.parts.length > 1 &&
-        contents.parts.all? do |part|
-          part.is_a?(SymbolLiteral) && part.comments.empty?
-        end
-    end
-
-    def var_refs?(q)
-      lbracket.comments.empty? && contents && contents.comments.empty? &&
-        contents.parts.all? do |part|
-          part.is_a?(VarRef) && part.comments.empty?
-        end &&
-        (
-          contents.parts.sum { |part| part.value.value.length + 2 } >
-            q.maxwidth * 2
-        )
+      contents.parts.all? do |part|
+        part.is_a?(SymbolLiteral) && part.comments.empty?
+      end
     end
 
     # If we have an empty array that contains only comments, then we're going
@@ -3068,6 +3022,10 @@ module SyntaxTree
         end
       end
     end
+
+    def arity
+      arguments&.arity || 0
+    end
   end
 
   # Case represents the beginning of a case chain.
@@ -3481,6 +3439,10 @@ module SyntaxTree
         arguments === other.arguments && block === other.block
     end
 
+    def arity
+      arguments.arity
+    end
+
     private
 
     def align(q, node, &block)
@@ -3646,6 +3608,10 @@ module SyntaxTree
         arguments === other.arguments && block === other.block
     end
 
+    def arity
+      arguments&.arity || 0
+    end
+
     private
 
     def argument_alignment(q, doc)
@@ -4175,6 +4141,17 @@ module SyntaxTree
     def endless?
       !bodystmt.is_a?(BodyStmt)
     end
+
+    def arity
+      case params
+      when Params
+        params.arity
+      when Paren
+        params.contents.arity
+      else
+        0..0
+      end
+    end
   end
 
   # Defined represents the use of the +defined?+ operator. It can be used with
@@ -4362,6 +4339,15 @@ module SyntaxTree
       opening.is_a?(Kw)
     end
 
+    def arity
+      case block_var
+      when BlockVar
+        block_var.params.arity
+      else
+        0..0
+      end
+    end
+
     private
 
     # If this is nested anywhere inside certain nodes, then we can't change
@@ -6153,7 +6139,7 @@ module SyntaxTree
   module Ternaryable
     class << self
       def call(q, node)
-        return false if ENV["STREE_FAST_FORMAT"]
+        return false if ENV["STREE_FAST_FORMAT"] || q.disable_auto_ternary?
 
         # If this is a conditional inside of a parentheses as the only content,
         # then we don't want to transform it into a ternary. Presumably the user
@@ -6496,9 +6482,26 @@ module SyntaxTree
 
     def format(q)
       force_flat = [
-        AliasNode, Assign, Break, Command, CommandCall, Heredoc, IfNode, IfOp,
-        Lambda, MAssign, Next, OpAssign, RescueMod, ReturnNode, Super, Undef,
-        UnlessNode, VoidStmt, YieldNode, ZSuper
+        AliasNode,
+        Assign,
+        Break,
+        Command,
+        CommandCall,
+        Heredoc,
+        IfNode,
+        IfOp,
+        Lambda,
+        MAssign,
+        Next,
+        OpAssign,
+        RescueMod,
+        ReturnNode,
+        Super,
+        Undef,
+        UnlessNode,
+        VoidStmt,
+        YieldNode,
+        ZSuper
       ]
 
       if q.parent.is_a?(Paren) || force_flat.include?(truthy.class) ||
@@ -8325,6 +8328,29 @@ module SyntaxTree
         keyword_rest === other.keyword_rest && block === other.block
     end
 
+    # Returns a range representing the possible number of arguments accepted
+    # by this params node not including the block. For example:
+    #
+    #     def foo(a, b = 1, c:, d: 2, &block)
+    #       ...
+    #     end
+    #
+    # has arity 2..4.
+    #
+    def arity
+      optional_keywords = keywords.count { |_label, value| value }
+
+      lower_bound =
+        requireds.length + posts.length + keywords.length - optional_keywords
+
+      upper_bound =
+        if keyword_rest.nil? && rest.nil?
+          lower_bound + optionals.length + optional_keywords
+        end
+
+      lower_bound..upper_bound
+    end
+
     private
 
     def format_contents(q, parts)
@@ -11594,6 +11620,10 @@ module SyntaxTree
     def access_control?
       @access_control ||= %w[private protected public].include?(value.value)
     end
+
+    def arity
+      0
+    end
   end
 
   # VoidStmt represents an empty lexical block of code.

data/lib/syntax_tree/parser.rb

@@ -1103,6 +1103,7 @@ module SyntaxTree
     # :call-seq:
     #   on_comment: (String value) -> Comment
     def on_comment(value)
+      # char is the index of the # character in the source.
       char = char_pos
       location =
         Location.token(
@@ -1112,8 +1113,24 @@ module SyntaxTree
           size: value.size - 1
         )
 
-      index = source.rindex(/[^\t ]/, char - 1) if char != 0
-      inline = index && (source[index] != "\n")
+      # Loop backward in the source string, starting from the beginning of the
+      # comment, and find the first character that is not a space or a tab. If
+      # index is -1, this indicates that we've checked all of the characters
+      # back to the start of the source, so this comment must be at the
+      # beginning of the file.
+      #
+      # We are purposefully not using rindex or regular expressions here because
+      # they check if there are invalid characters, which is actually possible
+      # with the use of __END__ syntax.
+      index = char - 1
+      while index > -1 && (source[index] == "\t" || source[index] == " ")
+        index -= 1
+      end
+
+      # If we found a character that was not a space or a tab before the comment
+      # and it's a newline, then this comment is inline. Otherwise, it stands on
+      # its own and can be attached as its own node in the tree.
+      inline = index != -1 && source[index] != "\n"
       comment =
         Comment.new(value: value.chomp, inline: inline, location: location)
 

data/lib/syntax_tree/plugin/disable_ternary.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module SyntaxTree
+  class Formatter
+    DISABLE_TERNARY = true
+  end
+end

data/lib/syntax_tree/version.rb

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

data/lib/syntax_tree/yarv/assembler.rb

@@ -62,22 +62,26 @@ module SyntaxTree
         "constant-from"
       ].freeze
 
-      attr_reader :filepath
+      attr_reader :lines
 
-      def initialize(filepath)
-        @filepath = filepath
+      def initialize(lines)
+        @lines = lines
       end
 
       def assemble
         iseq = InstructionSequence.new("<main>", "<compiled>", 1, :top)
-        assemble_iseq(iseq, File.readlines(filepath, chomp: true))
+        assemble_iseq(iseq, lines)
 
         iseq.compile!
         iseq
       end
 
-      def self.assemble(filepath)
-        new(filepath).assemble
+      def self.assemble(source)
+        new(source.lines(chomp: true)).assemble
+      end
+
+      def self.assemble_file(filepath)
+        new(File.readlines(filepath, chomp: true)).assemble
       end
 
       private

data/lib/syntax_tree/yarv/compiler.rb

@@ -285,7 +285,7 @@ module SyntaxTree
       # if we need to return the value of the last statement.
       attr_reader :last_statement
 
-      def initialize(options)
+      def initialize(options = Options.new)
         @options = options
         @iseq = nil
         @last_statement = false

data/lib/syntax_tree/yarv/decompiler.rb

@@ -97,7 +97,7 @@ module SyntaxTree
             clause << Next(Args([]))
           when Leave
             value = Args([clause.pop])
-            clause << (iseq.type == :top ? Break(value) : ReturnNode(value))
+            clause << (iseq.type != :top ? Break(value) : ReturnNode(value))
           when OptAnd, OptDiv, OptEq, OptGE, OptGT, OptLE, OptLT, OptLTLT,
                OptMinus, OptMod, OptMult, OptOr, OptPlus
             left, right = clause.pop(2)

data/lib/syntax_tree/yarv/instruction_sequence.rb

@@ -70,7 +70,7 @@ module SyntaxTree
             [Fiddle::TYPE_VOIDP] * 3,
             Fiddle::TYPE_VOIDP
           )
-        rescue NameError
+        rescue NameError, Fiddle::DLError
         end
 
       # This object is used to track the size of the stack at any given time. It