ripper_ruby_parser 0.0.8 → 1.0.0

data/lib/ripper_ruby_parser/sexp_handlers/helper_methods.rb

@@ -13,7 +13,7 @@ module RipperRubyParser
 
       def handle_potentially_typeless_sexp_with_fallback_type type, exp
         if exp.nil?
-          s()
+          s(type)
         elsif exp.first.is_a? Symbol
           process(exp)
         else
@@ -23,14 +23,10 @@ module RipperRubyParser
         end
       end
 
-      def handle_statement_list exp
-        statements = map_body exp
-
-        wrap_in_block(statements)
-      end
-
       def extract_node_symbol_with_position exp
         return nil if exp.nil?
+        return exp if exp.is_a? Symbol
+        
         _, ident, pos = exp.shift 3
         return ident.to_sym, pos
       end
@@ -61,6 +57,9 @@ module RipperRubyParser
         _, args, splatarg = exp.shift 3
         items = handle_potentially_typeless_sexp args
         items << s(:splat, process(splatarg))
+        until exp.empty?
+          items << process(exp.shift)
+        end
         items
       end
 
@@ -81,10 +80,21 @@ module RipperRubyParser
         when 1
           statements.first
         else
-          s(:block, *statements)
+          first = statements.shift
+          if first.sexp_type == :block
+            first.shift
+            s(:block, *first, *statements)
+          else
+            s(:block, first, *statements)
+          end
         end
       end
 
+      def safe_wrap_in_block statements
+        result = wrap_in_block statements
+        result ? result : s()
+      end
+
       def handle_return_argument_list arglist
         arglist = process(arglist)
         args = arglist[1..-1]

data/lib/ripper_ruby_parser/sexp_handlers/literals.rb

@@ -1,3 +1,4 @@
+# coding: utf-8
 module RipperRubyParser
   module SexpHandlers
     module Literals
@@ -21,17 +22,20 @@ module RipperRubyParser
       def process_string_embexpr exp
         _, list = exp.shift 2
         val = process(list.first)
-        if val.sexp_type == :str
+        case val.sexp_type
+        when :str
           val
+        when :void_stmt
+          s(:dstr, "", s(:evstr))
         else
-          s(:evstr, val)
+          s(:dstr, "", s(:evstr, val))
         end
       end
 
       def process_string_dvar exp
         _, list = exp.shift 2
         val = process(list)
-        s(:evstr, val)
+        s(:dstr, "", s(:evstr, val))
       end
 
       def process_string_concat exp
@@ -45,7 +49,7 @@ module RipperRubyParser
           right
         else # Expecting left.sexp_type == :dstr
           _, first, *rest = right
-          left.push s(:str, first)
+          left.push s(:str, first) unless first.empty?
           left.push(*rest)
           left
         end
@@ -109,20 +113,9 @@ module RipperRubyParser
       private
 
       def extract_string_parts exp
-        inner = exp.shift
-
-        string = process(inner)
+        string = ""
         rest = []
 
-        if string.nil?
-          string = ""
-        elsif string.sexp_type == :str
-          string = string[1]
-        else
-          rest << string
-          string = ""
-        end
-
         until exp.empty? do
           result = process(exp.shift)
           rest << result
@@ -133,6 +126,8 @@ module RipperRubyParser
           string += str[1]
         end
 
+        rest = rest.map { |se| se.sexp_type == :dstr ? se.last : se }
+
         return string, rest
       end
 
@@ -170,8 +165,13 @@ module RipperRubyParser
           [0-7]{1,3}        | # octal character
           x[0-9a-fA-F]{1,2} | # hex byte
           u[0-9a-fA-F]{4}   | # unicode character
+          M-\\C-.           | # meta-ctrl
+          C-\\M-.           | # ctrl-meta
+          M-\\c.            | # meta-ctrl (shorthand)
+          c\\M-.            | # ctrl-meta (shorthand)
           C-.               | # control (regular)
           c.                | # control (shorthand)
+          M-.               | # meta
           .                   # single-character
         )/x) do
           bare = $1
@@ -182,8 +182,12 @@ module RipperRubyParser
             bare[1..-1].to_i(16).chr
           when /^u/
             bare[1..-1].to_i(16).chr(Encoding::UTF_8)
-          when /^(c|C-)(.)$/
-            ($2.ord & 0b1001_1111).chr
+          when /^(?:c|C-)(.)$/
+            ($1.ord & 0b1001_1111).chr
+          when /^M-(.)$/
+            ($1.ord | 0b1000_0000).chr
+          when /^(?:M-\\C-|C-\\M-|M-\\c|c\\M-)(.)$/
+            ($1.ord & 0b1001_1111 | 0b1000_0000).chr
           when /^[0-7]+/
             bare.to_i(8).chr
           else

data/lib/ripper_ruby_parser/sexp_handlers/loops.rb

@@ -4,7 +4,7 @@ module RipperRubyParser
       def process_until exp
         _, cond, block = exp.shift 3
 
-        make_until(process(cond), handle_statement_list(block), true)
+        s(:until, process(cond), wrap_in_block(map_body(block)), true)
       end
 
       def process_until_mod exp
@@ -12,13 +12,13 @@ module RipperRubyParser
 
         check_at_start = check_at_start?(block)
 
-        make_until(process(cond), process(block), check_at_start)
+        s(:until, process(cond), process(block), check_at_start)
       end
 
       def process_while exp
         _, cond, block = exp.shift 3
 
-        make_while(process(cond), handle_statement_list(block), true)
+        s(:while, process(cond), wrap_in_block(map_body(block)), true)
       end
 
       def process_while_mod exp
@@ -26,33 +26,22 @@ module RipperRubyParser
 
         check_at_start = check_at_start?(block)
 
-        make_while(process(cond), process(block), check_at_start)
+        s(:while, process(cond), process(block), check_at_start)
       end
 
       def process_for exp
         _, var, coll, block = exp.shift 4
-        s(:for, process(coll),
-          s(:lasgn, process(var)[1]),
-          handle_statement_list(block))
-      end
-
-      private
-
-      def make_guarded_block(type, inverse, cond, block, check_at_start)
-        if cond.sexp_type == :not
-          type = inverse
-          cond = cond[1]
+        coll = process(coll)
+        assgn = s(:lasgn, process(var)[1])
+        block = wrap_in_block(map_body(block))
+        if block.nil?
+          s(:for, coll, assgn)
+        else
+          s(:for, coll, assgn, block)
         end
-        s(type, cond, block, check_at_start)
       end
 
-      def make_until(cond, block, check_at_start)
-        make_guarded_block(:until, :while, cond, block, check_at_start)
-      end
-
-      def make_while(cond, block, check_at_start)
-        make_guarded_block(:while, :until, cond, block, check_at_start)
-      end
+      private
 
       def check_at_start?(block)
         block.sexp_type != :begin

data/lib/ripper_ruby_parser/sexp_handlers/method_calls.rb

@@ -4,42 +4,50 @@ module RipperRubyParser
       def process_method_add_arg exp
         _, call, parens = exp.shift 3
         call = process(call)
-        call[3] = process(parens) unless parens.empty?
+        unless parens.empty?
+          parens = process(parens)
+          parens.shift
+        end
+        parens.each do |arg|
+          call << arg
+        end
         call
       end
 
       def process_call exp
         _, receiver, _, ident = exp.shift 4
         with_position_from_node_symbol(ident) {|method|
-          s(:call, process(receiver), method, s(:arglist)) }
+          s(:call, process(receiver), method) }
       end
 
       def process_command exp
         _, ident, arglist = exp.shift 3
         with_position_from_node_symbol(ident) {|method|
-          s(:call, nil, method,
-            handle_potentially_typeless_sexp_with_fallback_type(:arglist, arglist))
+          args = handle_potentially_typeless_sexp_with_fallback_type(:arglist, arglist)
+          args.shift
+          s(:call, nil, method, *args)
         }
       end
 
       def process_command_call exp
         _, receiver, _, ident, arguments = exp.shift 5
         with_position_from_node_symbol(ident) {|method|
-          s(:call, process(receiver), method,
-            handle_potentially_typeless_sexp_with_fallback_type(:arglist, arguments))
+          args = handle_potentially_typeless_sexp_with_fallback_type(:arglist, arguments)
+          args.shift
+          s(:call, process(receiver), method, *args)
         }
       end
 
       def process_vcall exp
         _, ident = exp.shift 2
         with_position_from_node_symbol(ident) {|method|
-          s(:call, nil, method, s(:arglist)) }
+          s(:call, nil, method) }
       end
 
       def process_fcall exp
         _, ident = exp.shift 2
         with_position_from_node_symbol(ident) {|method|
-          s(:call, nil, method, s(:arglist)) }
+          s(:call, nil, method) }
       end
 
       def process_super exp

data/lib/ripper_ruby_parser/sexp_handlers/methods.rb

@@ -6,15 +6,26 @@ module RipperRubyParser
         ident, pos = extract_node_symbol_with_position ident
         params = convert_special_args(process(params))
         with_position(pos,
-                      s(:defn, ident, params, method_body(body)))
+                      s(:defn, ident, params, *method_body(body)))
       end
 
       def process_defs exp
         _, receiver, _, method, params, body = exp.shift 6
         params = convert_special_args(process(params))
-        s(:defs, process(receiver),
+
+        body = in_method do
+          process(body)
+        end
+
+        if body.length == 1 && body.first.sexp_type == :block
+          body = body.first
+          body.shift
+        end
+
+        s(:defs,
+          process(receiver),
           extract_node_symbol(method),
-          params, in_method { process(body) })
+          params, *body)
       end
 
       def process_return exp
@@ -53,13 +64,11 @@ module RipperRubyParser
       end
 
       def process_alias exp
-        _, *args = exp.shift 3
+        _, left, right = exp.shift 3
 
-        args.map! do |sub_exp|
-          make_method_name_literal sub_exp
-        end
-
-        s(:alias, *args)
+        s(:alias,
+          make_method_name_literal(left),
+          make_method_name_literal(right))
       end
 
       private
@@ -76,12 +85,17 @@ module RipperRubyParser
       end
 
       def method_body exp
-        scope = in_method { process exp }
-        block = scope[1]
-        if block.length == 1
+        block = in_method { process exp }
+        case block.length
+        when 0
           block.push s(:nil)
+        when 1
+          if block.first.sexp_type == :block
+            block = block.first
+            block.shift
+          end
         end
-        scope
+        block
       end
 
       SPECIAL_ARG_MARKER = {
@@ -94,11 +108,23 @@ module RipperRubyParser
           if item.is_a? Symbol
             item
           else
-            if (marker = SPECIAL_ARG_MARKER[item.sexp_type])
+            case item.sexp_type
+            when *SPECIAL_ARG_MARKER.keys
+              marker = SPECIAL_ARG_MARKER[item.sexp_type]
               name = extract_node_symbol item[1]
               :"#{marker}#{name}"
-            elsif item.sexp_type == :lvar
+            when :lvar
               item[1]
+            when :masgn
+              args = item[1]
+              args.shift
+              s(:masgn, *convert_special_args(args))
+            when :lasgn
+              if item.length == 2
+                item[1]
+              else
+                item
+              end
             else
               item
             end

data/lib/ripper_ruby_parser/sexp_handlers/operators.rb

@@ -2,54 +2,60 @@ module RipperRubyParser
   module SexpHandlers
     module Operators
       BINARY_OPERATOR_MAP = {
-        "&&".to_sym => :and,
-        "||".to_sym => :or,
+        :"&&" => :and,
+        :"||" => :or,
         :and => :and,
         :or => :or
       }
 
       UNARY_OPERATOR_MAP = {
-        :"!" => :not,
-        :not => :not
+        :not => :!
       }
 
       NEGATED_BINARY_OPERATOR_MAP = {
         :"!~" => :=~,
-        :"!=" => :==
       }
 
       def process_binary exp
         _, left, op, right = exp.shift 4
 
         if op == :=~
-          if left.sexp_type == :regexp_literal
-            s(:match2, process(left), process(right))
-          elsif right.sexp_type == :regexp_literal
-            s(:match3, process(right), process(left))
-          else
-            s(:call, process(left), op, s(:arglist, process(right)))
-          end
+          make_regexp_match_operator(op, left, right)
         elsif (mapped = NEGATED_BINARY_OPERATOR_MAP[op])
-          s(:not, process(s(:binary, left, mapped, right)))
+          s(:not, make_regexp_match_operator(mapped, left, right))
         elsif (mapped = BINARY_OPERATOR_MAP[op])
-          rebalance_binary(s(mapped, process(left), process(right)))
+          make_boolean_operator(mapped, left, right)
         else
-          s(:call, process(left), op, s(:arglist, process(right)))
+          s(:call, process(left), op, process(right))
+        end
+      end
+
+      def make_boolean_operator(op, left, right)
+        if left.first == :paren
+          s(op, process(left), process(right))
+        else
+          rebalance_binary(s(op, process(left), process(right)))
+        end
+      end
+
+      def make_regexp_match_operator(op, left, right)
+        if left.sexp_type == :regexp_literal
+          s(:match2, process(left), process(right))
+        elsif right.sexp_type == :regexp_literal
+          s(:match3, process(right), process(left))
+        else
+          s(:call, process(left), op, process(right))
         end
       end
 
       def process_unary exp
         _, op, arg = exp.shift 3
         arg = process(arg)
-        mapped = UNARY_OPERATOR_MAP[op]
-        if mapped
-          s(mapped, arg)
+        op = UNARY_OPERATOR_MAP[op] || op
+        if is_literal?(arg) && op != :!
+          s(:lit, arg[1].send(op))
         else
-          if is_literal? arg
-            s(:lit, arg[1].send(op))
-          else
-            s(:call, arg, op, s(:arglist))
-          end
+          s(:call, arg, op)
         end
       end
 
@@ -64,6 +70,17 @@ module RipperRubyParser
         end
       end
 
+      def process_dot3 exp
+        _, left, right = exp.shift 3
+        left = process(left)
+        right = process(right)
+        if is_literal?(left) && is_literal?(right)
+          s(:lit, Range.new(left[1], right[1], true))
+        else
+          s(:dot3, left, right)
+        end
+      end
+
       def process_ifop exp
         _, cond, truepart, falsepart = exp.shift 4
         s(:if, process(cond), process(truepart), process(falsepart))