ripper_ruby_parser 1.1.1 → 1.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 24bee2a5b16f3e73b0ee4ab6f4d9047c02838ed2
-  data.tar.gz: bbd519d4b303b61f2ba83d8393b1c8193e877c4a
+  metadata.gz: 44bd9ec7c716649fbcf3698e39d9d7951b70a3d0
+  data.tar.gz: 1b54fd14347e28a5c253b8f00be1a641dc7cbda5
 SHA512:
-  metadata.gz: 0a4572c224a31698738e9cfd10e0474a0fef689e1ec79aab95c29dfc67ce597008896c76dcfb96f67824c61cfb0445f3c60f294ec56699be631566f09276ca8e
-  data.tar.gz: edd4c9d7b15846b34c4d586bdea846f484b91ed2d4df52324b95922c180850f659569e0703742c87fa67866376a76af57bc5424835d157a5aeaed1466f64508a
+  metadata.gz: 4fd9c3ffee9de0d9948a126ca5e44d3dc46b50b36b4fd7d9537263b84b123ebeac09118f3b0ae12f203f7c3ee1eb438bca92b2b630502b7bc83f6d3ea1a47668
+  data.tar.gz: c24028ea9320a5fdba4eee182d257e9f3c5db7fc57f9b3e6ba15471e90eb96b48c291b7046e8ca52b83af4957a62e6b4321901179d53fe53ea549f431baf7f85

data/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Change log
 
+## 1.1.2 / 2017-10-07
+
+* Fix support for newer Ruby syntax
+  - Handle optional keyword arguments
+  - Handle mandatory keyword arguments (Ruby 2.1 and up)
+  - Handle double splat arguments in function definitions
+  - Handle double splat in hash literals and method calls
+  - Handle symbol arrays with %i and %I
+  - Handle use of dynamic symbols as hash keys (Ruby 2.2 and up)
+  - Handle safe call operator (Ruby 2.3 and up)
+* Other bug fixes
+  - Fix handling of return and yield with a function call without parentheses
+  - Handle stabby lambdas with any number of statements
+  - Handle more complex interpolation in %W word arrays
+  - Distinguish unary minus from negative sign for int and float literals
+* Compatibility improvements
+  - Match RubyParser's rewriting of conditionals with the negative match
+    operator
+
 ## 1.1.1 / 2017-10-03
 
 * Fix handling of non-final splats in LHS

data/Rakefile

@@ -1,5 +1,5 @@
 require 'rake/clean'
-require "bundler/gem_tasks"
+require 'bundler/gem_tasks'
 require 'rake/testtask'
 
 namespace :test do
@@ -21,7 +21,7 @@ namespace :test do
     t.warning = true
   end
 
-  desc "Run all three test suites"
+  desc 'Run all three test suites'
   task run: [:unit, :end_to_end, :pt_testcase]
 end
 

data/lib/ripper_ruby_parser/commenting_ripper_parser.rb

@@ -14,20 +14,20 @@ module RipperRubyParser
 
     def parse
       result = suppress_warnings { super }
-      raise "Ripper parse failed." unless result
+      raise 'Ripper parse failed.' unless result
 
       Sexp.from_array(result)
     end
 
     def on_comment tok
-      @comment ||= ""
+      @comment ||= ''
       @comment += tok
       super
     end
 
     def on_kw tok
       case tok
-      when "class", "def", "module"
+      when 'class', 'def', 'module'
         unless @in_symbol
           @comment_stack.push [tok.to_sym, @comment]
           @comment = nil
@@ -56,6 +56,57 @@ module RipperRubyParser
       commentize(:def, super)
     end
 
+    def on_qsymbols_add list, elem
+      super list, [:dyna_symbol, [elem]]
+    end
+
+    def on_symbols_add list, elem
+      super list, [:dyna_symbol, elem]
+    end
+
+    def on_words_add list, elem
+      if elem.count == 1
+        super
+      else
+        super list, [:string_content, *elem]
+      end
+    end
+
+    def on_op(token)
+      @seen_space = false
+      super
+    end
+
+    def on_sp(_token)
+      @seen_space = true
+      super
+    end
+
+    def on_int(_token)
+      @space_before = @seen_space
+      super
+    end
+
+    def on_float(_token)
+      @space_before = @seen_space
+      super
+    end
+
+    NUMBER_LITERAL_TYPES = [:@int, :@float]
+
+    def on_unary(op, value)
+      if !@space_before && op == :-@ && NUMBER_LITERAL_TYPES.include?(value.first)
+        type, literal, lines = value
+        if literal[0] == '-'
+          super
+        else
+          [type, "-#{literal}", lines]
+        end
+      else
+        super
+      end
+    end
+
     def on_symbeg *args
       @in_symbol = true
       super
@@ -105,7 +156,7 @@ module RipperRubyParser
       unless tok == name
         raise "Expected on_#{tok} event, got on_#{name}"
       end
-      [:comment, comment || "", exp]
+      [:comment, comment || '', exp]
     end
 
     def suppress_warnings

data/lib/ripper_ruby_parser/sexp_handlers/blocks.rb

@@ -22,21 +22,17 @@ module RipperRubyParser
         if exp.size == 6
           _, normal, defaults, splat, rest, block = exp.shift 6
         else
-          _, normal, defaults, splat, rest, _, _, block = exp.shift 8
+          _, normal, defaults, splat, rest, kwargs, doublesplat, block = exp.shift 8
         end
 
-        args = [*normal].map do |id|
-          process(id)
-        end
-
-        [*defaults].each do |pair|
-          sym = process(pair[0])
-          val = process(pair[1])
-          args << s(:lasgn, sym[1], val)
-        end
+        args = []
+        args += normal.map { |id| process(id) } if normal
+        args += defaults.map { |sym, val| s(:lasgn, process(sym)[1], process(val)) } if defaults
 
         args << process(splat) unless splat.nil? || splat == 0
-        [*rest].each { |arg| args << process(arg) }
+        args += rest.map { |it| process(it) } if rest
+        args += handle_kwargs kwargs if kwargs
+        args << s(:dsplat, process(doublesplat)) if doublesplat
         args << process(block) unless block.nil?
 
         s(:args, *args)
@@ -125,7 +121,7 @@ module RipperRubyParser
 
       def process_ensure exp
         _, block = exp.shift 2
-        strip_typeless_sexp safe_wrap_in_block s(*map_body(block))
+        strip_typeless_sexp safe_wrap_in_block map_body(block)
       end
 
       def process_next exp
@@ -153,7 +149,7 @@ module RipperRubyParser
         args = 0 if args == s(:args) && old_type == :params
         make_iter(s(:call, nil, :lambda),
                   args,
-                  *handle_potentially_typeless_sexp(statements))
+                  wrap_in_block(map_body(statements)))
       end
 
       private
@@ -165,6 +161,17 @@ module RipperRubyParser
         s(:block, args, s(wrap_in_block(map_body(stmts))))
       end
 
+      def handle_kwargs(kwargs)
+        kwargs.map do |sym, val|
+          symbol = process(sym)[1]
+          if val
+            s(:kwarg, symbol, process(val))
+          else
+            s(:kwarg, symbol)
+          end
+        end
+      end
+
       def strip_typeless_sexp block
         case block.length
         when 0

data/lib/ripper_ruby_parser/sexp_handlers/conditionals.rb

@@ -4,9 +4,9 @@ module RipperRubyParser
       def process_if exp
         _, cond, truepart, falsepart = exp.shift 4
 
-        s(:if, handle_condition(cond),
-          wrap_in_block(map_body(truepart)),
-          process(falsepart))
+        construct_conditional(handle_condition(cond),
+                              wrap_in_block(map_body(truepart)),
+                              process(falsepart))
       end
 
       def process_elsif exp
@@ -19,20 +19,26 @@ module RipperRubyParser
 
       def process_if_mod exp
         _, cond, truepart = exp.shift 3
-        s(:if, handle_condition(cond), process(truepart), nil)
-      end
 
-      def process_unless_mod exp
-        _, cond, truepart = exp.shift 3
-        s(:if, handle_condition(cond), nil, process(truepart))
+        construct_conditional(handle_condition(cond),
+                              process(truepart),
+                              nil)
       end
 
       def process_unless exp
         _, cond, truepart, falsepart = exp.shift 4
-        s(:if,
-          handle_condition(cond),
-          process(falsepart),
-          wrap_in_block(map_body(truepart)))
+
+        construct_conditional(handle_condition(cond),
+                              process(falsepart),
+                              wrap_in_block(map_body(truepart)))
+      end
+
+      def process_unless_mod exp
+        _, cond, truepart = exp.shift 3
+
+        construct_conditional(handle_condition(cond),
+                              nil,
+                              process(truepart))
       end
 
       def process_case exp
@@ -83,6 +89,15 @@ module RipperRubyParser
           cond
         end
       end
+
+      def construct_conditional(cond, truepart, falsepart)
+        if cond.sexp_type == :not
+          _, inner = cond
+          s(:if, inner, falsepart, truepart)
+        else
+          s(:if, cond, truepart, falsepart)
+        end
+      end
     end
   end
 end

data/lib/ripper_ruby_parser/sexp_handlers/hashes.rb

@@ -1,21 +1,28 @@
 module RipperRubyParser
   module SexpHandlers
     module Hashes
+      # Handle hash literals sexps. These can be either empty, or contain a
+      # nested :assoclist_from_args Sexp.
+      #
+      # @example Empty hash
+      #   s(:hash, nil)
+      # @example Hash with contents
+      #   s(:hash, s(:assoclist_from_args, ...))
       def process_hash exp
-        _, elems = exp.shift 2
-        s(:hash, *process(elems))
-      end
-
-      def process_assoclist_from_args exp
-        _, elems = exp.shift 2
-        make_hash_items elems
+        _, body = exp.shift 2
+        return s(:hash) unless body
+        _, elems = body
+        s(:hash, *make_hash_items(elems))
       end
 
-      def process_assoc_new exp
-        _, left, right = exp.shift 3
-        s(process(left), process(right))
+      # @example
+      #   s(:assoc_splat, s(:vcall, s(:@ident, "bar")))
+      def process_assoc_splat exp
+        _, param = exp.shift 2
+        s(:kwsplat, process(param))
       end
 
+      # Handle implied hashes, such as at the end of argument lists.
       def process_bare_assoc_hash exp
         _, elems = exp.shift 2
         s(:hash, *make_hash_items(elems))
@@ -23,11 +30,17 @@ module RipperRubyParser
 
       private
 
+      # Process list of items that can be either :assoc_new or :assoc_splat
       def make_hash_items elems
         result = s()
         elems.each do |sub_exp|
-          process(sub_exp).each do |elm|
-            result << elm
+          case sub_exp.sexp_type
+          when :assoc_new
+            sub_exp.sexp_body.each { |elem| result << process(elem) }
+          when :assoc_splat
+            result << process(sub_exp)
+          else
+            raise ArgumentError
           end
         end
         result

data/lib/ripper_ruby_parser/sexp_handlers/helper_methods.rb

@@ -92,8 +92,10 @@ module RipperRubyParser
       end
 
       def handle_return_argument_list arglist
-        arglist = process(arglist)
-        args = arglist[1..-1]
+        args = handle_potentially_typeless_sexp(arglist)
+        if args.sexp_type == :arglist
+          args = args[1..-1]
+        end
 
         if args.length == 1
           arg = args[0]

data/lib/ripper_ruby_parser/sexp_handlers/literals.rb

@@ -25,16 +25,16 @@ module RipperRubyParser
         when :str
           val
         when :void_stmt
-          s(:dstr, "", s(:evstr))
+          s(:dstr, '', s(:evstr))
         else
-          s(:dstr, "", s(:evstr, val))
+          s(:dstr, '', s(:evstr, val))
         end
       end
 
       def process_string_dvar exp
         _, list = exp.shift 2
         val = process(list)
-        s(:dstr, "", s(:evstr, val))
+        s(:dstr, '', s(:evstr, val))
       end
 
       def process_string_concat exp
@@ -48,7 +48,7 @@ module RipperRubyParser
           right
         else # Expecting left.sexp_type == :dstr
           _, first, *rest = right
-          left.push s(:str, first) unless first.empty?
+          left.push s(:str, first) if !first.empty? || rest.empty?
           left.push(*rest)
           left
         end
@@ -96,7 +96,11 @@ module RipperRubyParser
       def process_dyna_symbol exp
         _, list = exp.shift 2
 
-        string, rest = extract_unescaped_string_parts list
+        if list.sexp_type == :string_content
+          string, rest = extract_unescaped_string_parts list.sexp_body
+        else
+          string, rest = extract_unescaped_string_parts list
+        end
         if rest.empty?
           s(:lit, string.to_sym)
         else
@@ -114,7 +118,7 @@ module RipperRubyParser
       def extract_string_parts exp
         parts = internal_process_string_parts(exp)
 
-        string = ""
+        string = ''
         while !parts.empty? && parts.first.sexp_type == :str
           str = parts.shift
           string += str[1]
@@ -156,15 +160,15 @@ module RipperRubyParser
       end
 
       SINGLE_LETTER_ESCAPES = {
-        "a" => "\a",
-        "b" => "\b",
-        "e" => "\e",
-        "f" => "\f",
-        "n" => "\n",
-        "r" => "\r",
-        "s" => "\s",
-        "t" => "\t",
-        "v" => "\v"
+        'a' => "\a",
+        'b' => "\b",
+        'e' => "\e",
+        'f' => "\f",
+        'n' => "\n",
+        'r' => "\r",
+        's' => "\s",
+        't' => "\t",
+        'v' => "\v"
       }.freeze
 
       SINGLE_LETTER_ESCAPES_REGEXP =

data/lib/ripper_ruby_parser/sexp_handlers/loops.rb

@@ -2,19 +2,19 @@ module RipperRubyParser
   module SexpHandlers
     module Loops
       def process_until exp
-        handle_conditional_loop(:until, exp)
+        handle_conditional_loop :until, :while, exp
       end
 
       def process_until_mod exp
-        handle_conditional_loop_mod(:until, exp)
+        handle_conditional_loop_mod :until, :while, exp
       end
 
       def process_while exp
-        handle_conditional_loop(:while, exp)
+        handle_conditional_loop :while, :until, exp
       end
 
       def process_while_mod exp
-        handle_conditional_loop_mod(:while, exp)
+        handle_conditional_loop_mod :while, :until, exp
       end
 
       def process_for exp
@@ -35,18 +35,32 @@ module RipperRubyParser
         block.sexp_type != :begin
       end
 
-      def handle_conditional_loop type, exp
-        _, cond, block = exp.shift 3
+      def handle_conditional_loop type, negated_type, exp
+        _, cond, body = exp.shift 3
 
-        s(type, process(cond), wrap_in_block(map_body(block)), true)
+        construct_conditional_loop(type, negated_type,
+                                   process(cond),
+                                   wrap_in_block(map_body(body)),
+                                   true)
       end
 
-      def handle_conditional_loop_mod type, exp
-        _, cond, block = exp.shift 3
+      def handle_conditional_loop_mod type, negated_type, exp
+        _, cond, body = exp.shift 3
 
-        check_at_start = check_at_start?(block)
+        check_at_start = check_at_start?(body)
+        construct_conditional_loop(type, negated_type,
+                                   process(cond),
+                                   process(body),
+                                   check_at_start)
+      end
 
-        s(type, process(cond), process(block), check_at_start)
+      def construct_conditional_loop(type, negated_type, cond, body, check_at_start)
+        if cond.sexp_type == :not
+          _, inner = cond
+          s(negated_type, inner, body, check_at_start)
+        else
+          s(type, cond, body, check_at_start)
+        end
       end
     end
   end

data/lib/ripper_ruby_parser/sexp_handlers/method_calls.rb

@@ -14,10 +14,17 @@ module RipperRubyParser
         call
       end
 
+      CALL_OP_MAP = {
+        :'.'  => :call,
+        :'::' => :call,
+        :'&.' => :safe_call
+      }
+
       def process_call exp
-        _, receiver, _, ident = exp.shift 4
+        _, receiver, op, ident = exp.shift 4
+        type = CALL_OP_MAP.fetch op
         with_position_from_node_symbol(ident) do |method|
-          s(:call, process(receiver), method)
+          s(type, process(receiver), method)
         end
       end
 
@@ -30,10 +37,11 @@ module RipperRubyParser
       end
 
       def process_command_call exp
-        _, receiver, _, ident, arguments = exp.shift 5
+        _, receiver, op, ident, arguments = exp.shift 5
+        type = CALL_OP_MAP.fetch op
         with_position_from_node_symbol(ident) do |method|
           args = handle_argument_list(arguments)
-          s(:call, process(receiver), method, *args)
+          s(type, process(receiver), method, *args)
         end
       end
 

data/lib/ripper_ruby_parser/sexp_handlers/methods.rb

@@ -31,8 +31,11 @@ module RipperRubyParser
 
       def process_yield exp
         _, arglist = exp.shift 2
-        arglist = process arglist
-        s(:yield, *arglist[1..-1])
+        args = handle_potentially_typeless_sexp(arglist)
+        if args.sexp_type == :arglist
+          args = args[1..-1]
+        end
+        s(:yield, *args)
       end
 
       def process_yield0 exp
@@ -90,8 +93,9 @@ module RipperRubyParser
       end
 
       SPECIAL_ARG_MARKER = {
-        splat: "*",
-        blockarg: "&"
+        splat: '*',
+        dsplat: '**',
+        blockarg: '&'
       }.freeze
 
       def convert_special_args args

data/lib/ripper_ruby_parser/sexp_handlers/operators.rb

@@ -52,11 +52,7 @@ module RipperRubyParser
         _, op, arg = exp.shift 3
         arg = process(arg)
         op = UNARY_OPERATOR_MAP[op] || op
-        if literal?(arg) && op != :!
-          s(:lit, arg[1].send(op))
-        else
-          s(:call, arg, op)
-        end
+        s(:call, arg, op)
       end
 
       def process_dot2 exp

data/lib/ripper_ruby_parser/version.rb

@@ -1,3 +1,3 @@
 module RipperRubyParser
-  VERSION = '1.1.1'.freeze
+  VERSION = '1.1.2'.freeze
 end

data/lib/ripper_ruby_parser.rb

@@ -1,5 +1,5 @@
-if RUBY_VERSION < "1.9.3"
-  raise LoadError, "Only ruby version 1.9.3 and up are supported"
+if RUBY_VERSION < '1.9.3'
+  raise LoadError, 'Only ruby version 1.9.3 and up are supported'
 end
 
 require 'ripper_ruby_parser/version'

data/test/end_to_end/comments_test.rb

@@ -1,7 +1,7 @@
 require File.expand_path('../test_helper.rb', File.dirname(__FILE__))
 require 'ruby_parser'
 
-describe "Using RipperRubyParser and RubyParser" do
+describe 'Using RipperRubyParser and RubyParser' do
   let :newparser do
     RipperRubyParser::Parser.new
   end
@@ -10,7 +10,7 @@ describe "Using RipperRubyParser and RubyParser" do
     RubyParser.new
   end
 
-  describe "for a program with quite some comments" do
+  describe 'for a program with quite some comments' do
     let :program do
       <<-END
       # Foo
@@ -46,11 +46,11 @@ describe "Using RipperRubyParser and RubyParser" do
       newparser.parse program
     end
 
-    it "gives the same result" do
+    it 'gives the same result' do
       imitation.must_equal original
     end
 
-    it "gives the same result with comments" do
+    it 'gives the same result with comments' do
       to_comments(imitation).must_equal to_comments(original)
     end
   end