ripper_ruby_parser 1.1.2 → 1.2.0

data/lib/ripper_ruby_parser/sexp_handlers/literals.rb

@@ -1,14 +1,13 @@
 module RipperRubyParser
   module SexpHandlers
+    # Sexp handlers for literals, except hash and array literals
     module Literals
-      def process_string_literal exp
+      def process_string_literal(exp)
         _, content = exp.shift 2
         process(content)
       end
 
-      def process_string_content exp
-        exp.shift
-
+      def process_string_content(exp)
         string, rest = extract_unescaped_string_parts exp
 
         if rest.empty?
@@ -18,9 +17,13 @@ module RipperRubyParser
         end
       end
 
-      def process_string_embexpr exp
+      alias process_word process_string_content
+
+      def process_string_embexpr(exp)
         _, list = exp.shift 2
-        val = process(list.first)
+
+        val = process(list.sexp_body.first)
+
         case val.sexp_type
         when :str
           val
@@ -31,30 +34,26 @@ module RipperRubyParser
         end
       end
 
-      def process_string_dvar exp
+      def process_string_dvar(exp)
         _, list = exp.shift 2
         val = process(list)
         s(:dstr, '', s(:evstr, val))
       end
 
-      def process_string_concat exp
+      def process_string_concat(exp)
         _, left, right = exp.shift 3
 
         left = process(left)
         right = process(right)
 
         if left.sexp_type == :str
-          right[1] = left[1] + right[1]
-          right
-        else # Expecting left.sexp_type == :dstr
-          _, first, *rest = right
-          left.push s(:str, first) if !first.empty? || rest.empty?
-          left.push(*rest)
-          left
+          merge_left_into_right(left, right)
+        else
+          merge_right_into_left(left, right)
         end
       end
 
-      def process_xstring_literal exp
+      def process_xstring_literal(exp)
         _, content = exp.shift 2
         string, rest = extract_unescaped_string_parts content
         if rest.empty?
@@ -64,8 +63,8 @@ module RipperRubyParser
         end
       end
 
-      def process_regexp_literal exp
-        _, content, (_, flags, _) = exp.shift 3
+      def process_regexp_literal(exp)
+        _, content, (_, flags,) = exp.shift 3
 
         string, rest = extract_string_parts content
         numflags = character_flags_to_numerical flags
@@ -83,39 +82,41 @@ module RipperRubyParser
         end
       end
 
-      def process_symbol_literal exp
+      def process_symbol_literal(exp)
         _, symbol = exp.shift 2
         process(symbol)
       end
 
-      def process_symbol exp
+      def process_symbol(exp)
         _, node = exp.shift 2
-        with_position_from_node_symbol(node) { |sym| s(:lit, sym) }
+        handle_symbol_content(node)
       end
 
-      def process_dyna_symbol exp
-        _, list = exp.shift 2
+      def process_dyna_symbol(exp)
+        _, node = exp.shift 2
+        handle_dyna_symbol_content(node)
+      end
 
-        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
-          s(:dsym, string, *rest)
-        end
+      def process_qsymbols(exp)
+        _, *items = shift_all(exp)
+        items = items.map { |item| handle_symbol_content(item) }
+        s(:qsymbols, *items)
       end
 
-      def process_at_tstring_content exp
-        _, string, _ = exp.shift 3
+      def process_symbols(exp)
+        _, *items = shift_all(exp)
+        items = items.map { |item| handle_dyna_symbol_content(item) }
+        s(:symbols, *items)
+      end
+
+      def process_at_tstring_content(exp)
+        _, string, = exp.shift 3
         s(:str, string)
       end
 
       private
 
-      def extract_string_parts exp
+      def extract_string_parts(exp)
         parts = internal_process_string_parts(exp)
 
         string = ''
@@ -129,31 +130,18 @@ module RipperRubyParser
         return string, rest
       end
 
-      def internal_process_string_parts exp
-        rest = []
-
-        until exp.empty?
-          part = exp.shift
-          result = if part.is_a? String
-                     # FIXME: Extract escaping into separate method
-                     s(:str, part.inspect[1..-2])
-                   else
-                     process(part)
-                   end
-          rest << result
-        end
-        rest
+      def internal_process_string_parts(exp)
+        _, *rest = shift_all exp
+        map_process_list rest
       end
 
-      def extract_unescaped_string_parts exp
+      def extract_unescaped_string_parts(exp)
         string, rest = extract_string_parts exp
 
         string = unescape(string)
 
         rest.each do |sub_exp|
-          if sub_exp.sexp_type == :str
-            sub_exp[1] = unescape(sub_exp[1])
-          end
+          sub_exp[1] = unescape(sub_exp[1]) if sub_exp.sexp_type == :str
         end
 
         return string, rest
@@ -174,7 +162,7 @@ module RipperRubyParser
       SINGLE_LETTER_ESCAPES_REGEXP =
         Regexp.new("^[#{SINGLE_LETTER_ESCAPES.keys.join}]$")
 
-      def unescape string
+      def unescape(string)
         string.gsub(/\\(
           [0-7]{1,3}        | # octal character
           x[0-9a-fA-F]{1,2} | # hex byte
@@ -210,7 +198,7 @@ module RipperRubyParser
         end
       end
 
-      def character_flags_to_numerical flags
+      def character_flags_to_numerical(flags)
         numflags = 0
 
         flags =~ /m/ and numflags |= Regexp::MULTILINE
@@ -222,6 +210,34 @@ module RipperRubyParser
 
         numflags
       end
+
+      def handle_dyna_symbol_content(list)
+        string, rest = extract_unescaped_string_parts list
+        if rest.empty?
+          s(:lit, string.to_sym)
+        else
+          s(:dsym, string, *rest)
+        end
+      end
+
+      def handle_symbol_content(node)
+        with_position_from_node_symbol(node) { |sym| s(:lit, sym) }
+      end
+
+      def merge_left_into_right(left, right)
+        right[1] = left[1] + right[1]
+        right
+      end
+
+      def merge_right_into_left(left, right)
+        if right.sexp_type == :str
+          left.push right
+        else
+          _, first, *rest = right
+          left.push s(:str, first) unless first.empty?
+          left.push(*rest)
+        end
+      end
     end
   end
 end

data/lib/ripper_ruby_parser/sexp_handlers/loops.rb

@@ -1,50 +1,51 @@
 module RipperRubyParser
   module SexpHandlers
+    # Sexp handlers for loops
     module Loops
-      def process_until exp
+      def process_until(exp)
         handle_conditional_loop :until, :while, exp
       end
 
-      def process_until_mod exp
+      def process_until_mod(exp)
         handle_conditional_loop_mod :until, :while, exp
       end
 
-      def process_while exp
+      def process_while(exp)
         handle_conditional_loop :while, :until, exp
       end
 
-      def process_while_mod exp
+      def process_while_mod(exp)
         handle_conditional_loop_mod :while, :until, exp
       end
 
-      def process_for exp
+      def process_for(exp)
         _, var, coll, block = exp.shift 4
         coll = process(coll)
         assgn = s(:lasgn, process(var)[1])
-        block = wrap_in_block(map_body(block))
-        if block.nil?
-          s(:for, coll, assgn)
-        else
+        block = unwrap_nil process(block)
+        if block
           s(:for, coll, assgn, block)
+        else
+          s(:for, coll, assgn)
         end
       end
 
       private
 
-      def check_at_start? block
+      def check_at_start?(block)
         block.sexp_type != :begin
       end
 
-      def handle_conditional_loop type, negated_type, exp
+      def handle_conditional_loop(type, negated_type, exp)
         _, cond, body = exp.shift 3
 
         construct_conditional_loop(type, negated_type,
                                    process(cond),
-                                   wrap_in_block(map_body(body)),
+                                   unwrap_nil(process(body)),
                                    true)
       end
 
-      def handle_conditional_loop_mod type, negated_type, exp
+      def handle_conditional_loop_mod(type, negated_type, exp)
         _, cond, body = exp.shift 3
 
         check_at_start = check_at_start?(body)

data/lib/ripper_ruby_parser/sexp_handlers/method_calls.rb

@@ -1,7 +1,8 @@
 module RipperRubyParser
   module SexpHandlers
+    # Sexp handlers for method calls
     module MethodCalls
-      def process_method_add_arg exp
+      def process_method_add_arg(exp)
         _, call, parens = exp.shift 3
         call = process(call)
         unless parens.empty?
@@ -15,20 +16,25 @@ module RipperRubyParser
       end
 
       CALL_OP_MAP = {
-        :'.'  => :call,
-        :'::' => :call,
-        :'&.' => :safe_call
-      }
+        '.': :call,
+        '::': :call,
+        '&.': :safe_call
+      }.freeze
 
-      def process_call exp
+      def process_call(exp)
         _, receiver, op, ident = exp.shift 4
         type = CALL_OP_MAP.fetch op
-        with_position_from_node_symbol(ident) do |method|
-          s(type, process(receiver), method)
+        case ident
+        when :call
+          s(type, process(receiver), :call)
+        else
+          with_position_from_node_symbol(ident) do |method|
+            s(type, process(receiver), method)
+          end
         end
       end
 
-      def process_command exp
+      def process_command(exp)
         _, ident, arglist = exp.shift 3
         with_position_from_node_symbol(ident) do |method|
           args = handle_argument_list(arglist)
@@ -36,7 +42,7 @@ module RipperRubyParser
         end
       end
 
-      def process_command_call exp
+      def process_command_call(exp)
         _, receiver, op, ident, arguments = exp.shift 5
         type = CALL_OP_MAP.fetch op
         with_position_from_node_symbol(ident) do |method|
@@ -45,21 +51,21 @@ module RipperRubyParser
         end
       end
 
-      def process_vcall exp
+      def process_vcall(exp)
         _, ident = exp.shift 2
         with_position_from_node_symbol(ident) do |method|
           s(:call, nil, method)
         end
       end
 
-      def process_fcall exp
+      def process_fcall(exp)
         _, ident = exp.shift 2
         with_position_from_node_symbol(ident) do |method|
           s(:call, nil, method)
         end
       end
 
-      def process_super exp
+      def process_super(exp)
         _, args = exp.shift 2
         args = process(args)
         args.shift

data/lib/ripper_ruby_parser/sexp_handlers/methods.rb

@@ -1,7 +1,8 @@
 module RipperRubyParser
   module SexpHandlers
+    # Sexp handers for method definitions and related constructs
     module Methods
-      def process_def exp
+      def process_def(exp)
         _, ident, params, body = exp.shift 4
         ident, pos = extract_node_symbol_with_position ident
         params = convert_special_args(process(params))
@@ -9,7 +10,7 @@ module RipperRubyParser
                       s(:defn, ident, params, *method_body(body)))
       end
 
-      def process_defs exp
+      def process_defs(exp)
         _, receiver, _, method, params, body = exp.shift 6
         params = convert_special_args(process(params))
 
@@ -19,31 +20,27 @@ module RipperRubyParser
           params, *method_body(body))
       end
 
-      def process_return exp
+      def process_return(exp)
         _, arglist = exp.shift 2
         s(:return, handle_return_argument_list(arglist))
       end
 
-      def process_return0 exp
+      def process_return0(exp)
         _ = exp.shift
         s(:return)
       end
 
-      def process_yield exp
+      def process_yield(exp)
         _, arglist = exp.shift 2
-        args = handle_potentially_typeless_sexp(arglist)
-        if args.sexp_type == :arglist
-          args = args[1..-1]
-        end
-        s(:yield, *args)
+        s(:yield, *handle_argument_list(arglist))
       end
 
-      def process_yield0 exp
+      def process_yield0(exp)
         _ = exp.shift
         s(:yield)
       end
 
-      def process_undef exp
+      def process_undef(exp)
         _, args = exp.shift 2
 
         args.map! do |sub_exp|
@@ -57,7 +54,7 @@ module RipperRubyParser
         end
       end
 
-      def process_alias exp
+      def process_alias(exp)
         _, left, right = exp.shift 3
 
         s(:alias,
@@ -74,22 +71,22 @@ module RipperRubyParser
         result
       end
 
-      def make_method_name_literal exp
+      def make_method_name_literal(exp)
         process(exp).tap { |it| it[0] = :lit }
       end
 
-      def method_body exp
+      def method_body(exp)
         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
+          [s(:nil)]
+        else
+          if block.sexp_type == :block
+            block.sexp_body
+          else
+            [block]
           end
         end
-        block
       end
 
       SPECIAL_ARG_MARKER = {
@@ -98,7 +95,7 @@ module RipperRubyParser
         blockarg: '&'
       }.freeze
 
-      def convert_special_args args
+      def convert_special_args(args)
         args.map! do |item|
           if item.is_a? Symbol
             item