ripper_ruby_parser 1.1.2 → 1.2.0

data/lib/ripper_ruby_parser/sexp_handlers/blocks.rb

@@ -1,94 +1,87 @@
 module RipperRubyParser
   module SexpHandlers
+    # Sexp handlers for blocks and related constructs
     module Blocks
-      def process_method_add_block exp
+      def process_method_add_block(exp)
         _, call, block = exp.shift 3
         block = process(block)
-        args = block[1]
-        stmt = block[2].first
+        _, args, stmt = block
         call = process(call)
-        make_iter call, args, stmt
+        stmts = stmt.first || s()
+        make_iter call, args, stmts
       end
 
-      def process_brace_block exp
+      def process_brace_block(exp)
         handle_generic_block exp
       end
 
-      def process_do_block exp
+      def process_do_block(exp)
         handle_generic_block exp
       end
 
-      def process_params exp
-        if exp.size == 6
-          _, normal, defaults, splat, rest, block = exp.shift 6
-        else
-          _, normal, defaults, splat, rest, kwargs, doublesplat, block = exp.shift 8
-        end
+      def process_params(exp)
+        _, normal, defaults, splat, rest, kwargs, doublesplat, block = exp.shift 8
 
         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
-        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?
+        args += handle_normal_arguments normal
+        args += handle_default_arguments defaults
+        args += handle_splat splat
+        args += handle_normal_arguments rest
+        args += handle_kwargs kwargs
+        args += handle_double_splat doublesplat
+        args += handle_block_argument block
 
         s(:args, *args)
       end
 
-      def process_block_var exp
-        _, args, _ = exp.shift 3
+      def process_kwrest_param(exp)
+        _, sym, = exp.shift 3
+        process(sym)
+      end
+
+      def process_block_var(exp)
+        _, args, = exp.shift 3
 
         names = process(args)
 
         convert_special_args names
       end
 
-      def process_begin exp
+      def process_begin(exp)
         _, body = exp.shift 2
 
         body = process(body)
-        strip_typeless_sexp(body)
+        convert_empty_to_nil_symbol(body)
       end
 
-      def process_rescue exp
+      def process_rescue(exp)
         _, eclass, evar, block, after = exp.shift 5
-        rescue_block = map_body(block)
+        rescue_block = map_process_sexp_body_compact(block)
         rescue_block << nil if rescue_block.empty?
 
         arr = []
         if eclass
-          eclass = handle_potentially_typeless_sexp eclass
           if eclass.first.is_a? Symbol
-            arr += eclass[1..-1]
+            arr += process(eclass).sexp_body
           else
-            arr << eclass[0]
+            arr << process(eclass[0])
           end
         end
 
-        if evar
-          arr << create_assignment_sub_type(process(evar), s(:gvar, :$!))
-        end
+        arr << create_assignment_sub_type(process(evar), s(:gvar, :$!)) if evar
 
         s(
           s(:resbody, s(:array, *arr), *rescue_block),
           *process(after))
       end
 
-      def process_bodystmt exp
-        _, body, rescue_block, else_block, ensure_block = exp.shift 5
-
-        body = map_body body
+      def process_bodystmt(exp)
+        _, main, rescue_block, else_block, ensure_block = exp.shift 5
 
-        body = wrap_in_block(body)
+        body = s()
 
-        body = if body.nil?
-                 s()
-               else
-                 s(body)
-               end
+        main = wrap_in_block map_process_sexp_body_compact(main)
+        body << main if main
 
         if rescue_block
           body.push(*process(rescue_block))
@@ -103,65 +96,77 @@ module RipperRubyParser
           body = s(s(:ensure, *body))
         end
 
-        body = wrap_in_block(body)
-
-        body = if body.nil?
-                 s()
-               else
-                 s(body)
-               end
-
-        body
+        wrap_in_block(body) || s()
       end
 
-      def process_rescue_mod exp
+      def process_rescue_mod(exp)
         _, scary, safe = exp.shift 3
         s(:rescue, process(scary), s(:resbody, s(:array), process(safe)))
       end
 
-      def process_ensure exp
+      def process_ensure(exp)
         _, block = exp.shift 2
-        strip_typeless_sexp safe_wrap_in_block map_body(block)
+        convert_empty_to_nil_symbol safe_unwrap_void_stmt process(block)
       end
 
-      def process_next exp
+      def process_next(exp)
         _, args = exp.shift 2
+        args = handle_return_argument_list(args)
         if args.empty?
           s(:next)
         else
-          s(:next, handle_return_argument_list(args))
+          s(:next, args)
         end
       end
 
-      def process_break exp
+      def process_break(exp)
         _, args = exp.shift 2
+        args = handle_return_argument_list(args)
         if args.empty?
           s(:break)
         else
-          s(:break, handle_return_argument_list(args))
+          s(:break, args)
         end
       end
 
-      def process_lambda exp
+      def process_lambda(exp)
         _, args, statements = exp.shift 3
         old_type = args.sexp_type
         args = convert_special_args(process(args))
         args = 0 if args == s(:args) && old_type == :params
         make_iter(s(:call, nil, :lambda),
                   args,
-                  wrap_in_block(map_body(statements)))
+                  safe_unwrap_void_stmt(process(statements)))
       end
 
       private
 
-      def handle_generic_block exp
-        _, args, stmts = exp.shift 3
+      def handle_generic_block(exp)
+        type, args, stmts = exp.shift 3
         args = process(args)
-        # FIXME: Symbol :block is irrelevant.
-        s(:block, args, s(wrap_in_block(map_body(stmts))))
+        s(type, args, s(unwrap_nil(process(stmts))))
+      end
+
+      def handle_normal_arguments(normal)
+        return [] unless normal
+        map_process_list normal
+      end
+
+      def handle_default_arguments(defaults)
+        return [] unless defaults
+        defaults.map { |sym, val| s(:lasgn, process(sym)[1], process(val)) }
+      end
+
+      def handle_splat(splat)
+        if splat && splat != 0
+          [process(splat)]
+        else
+          []
+        end
       end
 
       def handle_kwargs(kwargs)
+        return [] unless kwargs
         kwargs.map do |sym, val|
           symbol = process(sym)[1]
           if val
@@ -172,25 +177,44 @@ module RipperRubyParser
         end
       end
 
-      def strip_typeless_sexp block
+      def handle_double_splat(doublesplat)
+        return [] unless doublesplat
+        [s(:dsplat, process(doublesplat))]
+      end
+
+      def handle_block_argument(block)
+        return [] unless block
+        [process(block)]
+      end
+
+      def convert_empty_to_nil_symbol(block)
         case block.length
         when 0
           s(:nil)
-        when 1
-          block[0]
         else
           block
         end
       end
 
-      def make_iter call, args, stmt
+      def make_iter(call, args, stmt)
         args ||= 0
-        if stmt.nil?
+        if stmt.empty?
           s(:iter, call, args)
         else
           s(:iter, call, args, stmt)
         end
       end
+
+      def wrap_in_block(statements)
+        case statements.length
+        when 0
+          nil
+        when 1
+          statements.first
+        else
+          s(:block, *statements)
+        end
+      end
     end
   end
 end

data/lib/ripper_ruby_parser/sexp_handlers/conditionals.rb

@@ -1,23 +1,25 @@
 module RipperRubyParser
   module SexpHandlers
+    # Sexp handlers for conditionals
     module Conditionals
-      def process_if exp
+      def process_if(exp)
         _, cond, truepart, falsepart = exp.shift 4
 
         construct_conditional(handle_condition(cond),
-                              wrap_in_block(map_body(truepart)),
-                              process(falsepart))
+                              handle_consequent(truepart),
+                              handle_consequent(falsepart))
       end
 
-      def process_elsif exp
+      def process_elsif(exp)
         _, cond, truepart, falsepart = exp.shift 4
 
-        s(:if, process(cond),
-          wrap_in_block(map_body(truepart)),
-          process(falsepart))
+        s(:if,
+          process(cond),
+          handle_consequent(truepart),
+          handle_consequent(falsepart))
       end
 
-      def process_if_mod exp
+      def process_if_mod(exp)
         _, cond, truepart = exp.shift 3
 
         construct_conditional(handle_condition(cond),
@@ -25,15 +27,15 @@ module RipperRubyParser
                               nil)
       end
 
-      def process_unless exp
+      def process_unless(exp)
         _, cond, truepart, falsepart = exp.shift 4
 
         construct_conditional(handle_condition(cond),
-                              process(falsepart),
-                              wrap_in_block(map_body(truepart)))
+                              handle_consequent(falsepart),
+                              handle_consequent(truepart))
       end
 
-      def process_unless_mod exp
+      def process_unless_mod(exp)
         _, cond, truepart = exp.shift 3
 
         construct_conditional(handle_condition(cond),
@@ -41,27 +43,27 @@ module RipperRubyParser
                               process(truepart))
       end
 
-      def process_case exp
+      def process_case(exp)
         _, expr, clauses = exp.shift 3
         s(:case, process(expr), *process(clauses))
       end
 
-      def process_when exp
+      def process_when(exp)
         _, values, truepart, falsepart = exp.shift 4
 
+        falsepart = process(falsepart)
+        falsepart = unwrap_nil falsepart if falsepart
+
         if falsepart.nil?
           falsepart = [nil]
-        else
-          falsepart = process(falsepart)
-          if falsepart.first.is_a? Symbol
-            falsepart = s(falsepart)
-          end
+        elsif falsepart.first.is_a? Symbol
+          falsepart = s(falsepart)
         end
         falsepart = [nil] if falsepart.empty?
 
-        values = handle_array_elements values
+        values = handle_argument_list values
 
-        truepart = map_body(truepart)
+        truepart = map_process_sexp_body_compact(truepart)
         truepart = [nil] if truepart.empty?
 
         s(s(:when,
@@ -70,14 +72,14 @@ module RipperRubyParser
           *falsepart)
       end
 
-      def process_else exp
+      def process_else(exp)
         _, body = exp.shift 2
-        safe_wrap_in_block(map_body(body))
+        process(body)
       end
 
       private
 
-      def handle_condition cond
+      def handle_condition(cond)
         cond = process(cond)
         if (cond.sexp_type == :lit) && cond[1].is_a?(Regexp)
           s(:match, cond)
@@ -90,6 +92,10 @@ module RipperRubyParser
         end
       end
 
+      def handle_consequent(exp)
+        unwrap_nil process(exp) if exp
+      end
+
       def construct_conditional(cond, truepart, falsepart)
         if cond.sexp_type == :not
           _, inner = cond

data/lib/ripper_ruby_parser/sexp_handlers/hashes.rb

@@ -1,5 +1,6 @@
 module RipperRubyParser
   module SexpHandlers
+    # Sexp handlers for hash literals
     module Hashes
       # Handle hash literals sexps. These can be either empty, or contain a
       # nested :assoclist_from_args Sexp.
@@ -8,7 +9,7 @@ module RipperRubyParser
       #   s(:hash, nil)
       # @example Hash with contents
       #   s(:hash, s(:assoclist_from_args, ...))
-      def process_hash exp
+      def process_hash(exp)
         _, body = exp.shift 2
         return s(:hash) unless body
         _, elems = body
@@ -17,13 +18,13 @@ module RipperRubyParser
 
       # @example
       #   s(:assoc_splat, s(:vcall, s(:@ident, "bar")))
-      def process_assoc_splat exp
+      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
+      def process_bare_assoc_hash(exp)
         _, elems = exp.shift 2
         s(:hash, *make_hash_items(elems))
       end
@@ -31,16 +32,13 @@ module RipperRubyParser
       private
 
       # Process list of items that can be either :assoc_new or :assoc_splat
-      def make_hash_items elems
+      def make_hash_items(elems)
         result = s()
         elems.each do |sub_exp|
-          case sub_exp.sexp_type
-          when :assoc_new
+          if sub_exp.sexp_type == :assoc_new
             sub_exp.sexp_body.each { |elem| result << process(elem) }
-          when :assoc_splat
+          else # :assoc_splat
             result << process(sub_exp)
-          else
-            raise ArgumentError
           end
         end
         result

data/lib/ripper_ruby_parser/sexp_handlers/helper_methods.rb

@@ -1,104 +1,85 @@
 module RipperRubyParser
   module SexpHandlers
+    # Utility methods used in several of the sexp handler modules
     module HelperMethods
-      def handle_potentially_typeless_sexp exp
-        if exp.nil?
-          s()
-        elsif exp.first.is_a? Symbol
-          process(exp)
-        else
-          exp.map! { |sub_exp| handle_potentially_typeless_sexp(sub_exp) }
-        end
-      end
-
-      def handle_argument_list exp
-        if exp.nil?
-          s()
-        elsif exp.first.is_a? Symbol
-          process(exp).tap(&:shift)
-        else
-          exp.map! { |sub_exp| process(sub_exp) }
-        end
-      end
-
-      def extract_node_symbol_with_position exp
-        return nil if exp.nil?
-        return exp if exp.is_a? Symbol
-
+      def extract_node_symbol_with_position(exp)
         _, ident, pos = exp.shift 3
         return ident.to_sym, pos
       end
 
-      def extract_node_symbol exp
+      def extract_node_symbol(exp)
         return nil if exp.nil?
-        _, ident, _ = exp.shift 3
+        _, ident, = exp.shift 3
         ident.to_sym
       end
 
-      def with_position pos, exp = nil
-        (line, _) = pos
+      def with_position(pos, exp = nil)
+        (line,) = pos
         exp = yield if exp.nil?
         with_line_number line, exp
       end
 
-      def with_line_number line, exp
+      def with_line_number(line, exp)
         exp.line = line
         exp
       end
 
-      def with_position_from_node_symbol exp
+      def with_position_from_node_symbol(exp)
         sym, pos = extract_node_symbol_with_position exp
         with_position(pos, yield(sym))
       end
 
-      def generic_add_star exp
-        _, args, splatarg = exp.shift 3
-        items = handle_potentially_typeless_sexp args
-        items << s(:splat, process(splatarg))
-        items << process(exp.shift) until exp.empty?
-        items
+      def generic_add_star(exp)
+        _, args, splatarg, *rest = shift_all exp
+        items = process args
+        items.push s(:splat, process(splatarg))
+        items.push(*map_process_list(rest))
       end
 
-      def literal? exp
+      def literal?(exp)
         exp.sexp_type == :lit
       end
 
-      def map_body body
-        body.
-          map { |sub_exp| process(sub_exp) }.
-          reject { |sub_exp| sub_exp.sexp_type == :void_stmt }
+      def reject_void_stmt(body)
+        body.reject { |sub_exp| sub_exp.sexp_type == :void_stmt }
       end
 
-      def wrap_in_block statements
-        case statements.length
-        when 0
+      def map_process_sexp_body_compact(list)
+        reject_void_stmt map_process_sexp_body list
+      end
+
+      def map_process_sexp_body(list)
+        map_process_list(list.sexp_body)
+      end
+
+      def map_process_list(list)
+        list.map { |exp| process(exp) }
+      end
+
+      def unwrap_nil(exp)
+        if exp.sexp_type == :void_stmt
           nil
-        when 1
-          statements.first
         else
-          first = statements.shift
-          if first.sexp_type == :block
-            first.shift
-            s(:block, *first, *statements)
-          else
-            s(:block, first, *statements)
-          end
+          exp
         end
       end
 
-      def safe_wrap_in_block statements
-        result = wrap_in_block statements
-        result ? result : s()
+      def safe_unwrap_void_stmt(exp)
+        unwrap_nil(exp) || s()
       end
 
-      def handle_return_argument_list arglist
-        args = handle_potentially_typeless_sexp(arglist)
-        if args.sexp_type == :arglist
-          args = args[1..-1]
-        end
+      def handle_argument_list(exp)
+        process(exp).tap(&:shift)
+      end
 
-        if args.length == 1
-          arg = args[0]
+      def handle_return_argument_list(arglist)
+        args = handle_argument_list(arglist)
+
+        case args.length
+        when 0
+          args
+        when 1
+          arg = args.first
           if arg.sexp_type == :splat
             s(:svalue, arg)
           else
@@ -109,14 +90,13 @@ module RipperRubyParser
         end
       end
 
-      def handle_array_elements elems
-        elems = handle_potentially_typeless_sexp(elems)
-        elems.map do |elem|
-          if elem.first.is_a? Symbol
-            elem
-          else
-            elem.first
-          end
+      def handle_array_elements(elems)
+        process(elems).sexp_body
+      end
+
+      def shift_all(exp)
+        [].tap do |result|
+          result << exp.shift until exp.empty?
         end
       end
     end