ripper_ruby_parser 1.6.0 → 1.8.0

data/lib/ripper_ruby_parser/sexp_handlers/conditionals.rb

@@ -47,33 +47,20 @@ module RipperRubyParser
 
       def process_case(exp)
         _, expr, clauses = exp.shift 3
-        s(:case, process(expr), *process(clauses))
+        s(:case, process(expr), *process(clauses).sexp_body)
       end
 
       def process_when(exp)
         _, values, truepart, falsepart = exp.shift 4
 
-        falsepart = process(falsepart)
-        falsepart = unwrap_nil falsepart if falsepart
-
-        if falsepart.nil?
-          falsepart = [nil]
-        elsif falsepart.first.is_a? Symbol
-          falsepart = s(falsepart)
-        end
+        falsepart ||= s(:void_stmt)
 
+        falsepart = unwrap_case_body process(falsepart)
         values = process(values).sexp_body
+        truepart = unwrap_block process(truepart)
 
-        truepart = map_process_list_compact truepart.sexp_body
-        truepart = if truepart.empty?
-                     [nil]
-                   else
-                     unwrap_block(truepart.shift) + truepart
-                   end
-
-        s(s(:when,
-            s(:array, *values),
-            *truepart),
+        s(:case_body,
+          s(:when, s(:array, *values), *truepart),
           *falsepart)
       end
 
@@ -109,6 +96,17 @@ module RipperRubyParser
           s(:if, cond, truepart, falsepart)
         end
       end
+
+      def unwrap_case_body(exp)
+        case exp.sexp_type
+        when :case_body
+          exp.sexp_body
+        when :void_stmt
+          [nil]
+        else
+          [exp]
+        end
+      end
     end
   end
 end

data/lib/ripper_ruby_parser/sexp_handlers/helper_methods.rb

@@ -41,7 +41,7 @@ module RipperRubyParser
       end
 
       def integer_literal?(exp)
-        exp.sexp_type == :lit && exp[1].is_a?(Integer)
+        exp && exp.sexp_type == :lit && exp[1].is_a?(Integer)
       end
 
       def reject_void_stmt(body)
@@ -81,13 +81,46 @@ module RipperRubyParser
       end
 
       def unwrap_block(exp)
-        if exp.sexp_type == :block
+        case exp.sexp_type
+        when :block
           exp.sexp_body
+        when :void_stmt
+          [nil]
         else
           [exp]
         end
       end
 
+      def wrap_in_block(statements, line)
+        case statements.length
+        when 0
+          s(:void_stmt).line(line)
+        when 1
+          statements.first
+        else
+          first = statements.shift
+          s(:block, *unwrap_block(first), *statements)
+        end
+      end
+
+      def convert_void_stmt_to_nil_symbol(block)
+        case block.sexp_type
+        when :void_stmt
+          s(:nil)
+        else
+          block
+        end
+      end
+
+      def convert_empty_to_nil_symbol(block)
+        case block.length
+        when 0
+          s(:nil)
+        else
+          block
+        end
+      end
+
       def handle_return_argument_list(arglist)
         args = process(arglist).sexp_body
 

data/lib/ripper_ruby_parser/sexp_handlers/literals.rb

@@ -4,132 +4,10 @@ module RipperRubyParser
   module SexpHandlers
     # Sexp handlers for literals
     module Literals
-      def process_string_literal(exp)
-        _, content = exp.shift 2
-        process(content)
-      end
-
-      def process_string_content(exp)
-        _, *rest = shift_all exp
-        string, rest = extract_string_parts(rest)
-
-        if rest.empty?
-          s(:str, string)
-        else
-          s(:dstr, string, *rest)
-        end
-      end
-
-      alias process_word process_string_content
-
-      def process_string_embexpr(exp)
-        _, list = exp.shift 2
-
-        val = process(list.sexp_body.first)
-
-        case val.sexp_type
-        when :str, :dstr
-          val
-        when :void_stmt
-          s(:dstr, '', s(:evstr))
-        else
-          s(:dstr, '', s(:evstr, val))
-        end
-      end
-
-      def process_string_dvar(exp)
-        _, list = exp.shift 2
-        val = process(list)
-        s(:dstr, '', s(:evstr, val))
-      end
-
-      def process_string_concat(exp)
-        _, left, right = exp.shift 3
-
-        left = process(left)
-        right = process(right)
-
-        if left.sexp_type == :str
-          merge_left_into_right(left, right)
-        else
-          merge_right_into_left(left, right)
-        end
-      end
-
-      def process_xstring_literal(exp)
-        _, content = exp.shift 2
-        process(content)
-      end
-
-      def process_xstring(exp)
-        _, *rest = shift_all exp
-        string, rest = extract_string_parts(rest)
-        if rest.empty?
-          s(:xstr, string)
-        else
-          s(:dxstr, string, *rest)
-        end
-      end
-
-      def process_regexp_literal(exp)
-        _, content, (_, flags,) = exp.shift 3
-
-        content = process(content)
-        numflags = character_flags_to_numerical flags
-
-        return s(:lit, Regexp.new(content.last, numflags)) if content.length == 2
-
-        content.sexp_type = :dregx_once if flags =~ /o/
-        content << numflags unless numflags == 0
-        content
-      end
-
-      def process_regexp(exp)
-        _, *rest = shift_all exp
-        string, rest = extract_string_parts(rest)
-        s(:dregx, string, *rest)
-      end
-
-      def process_symbol_literal(exp)
-        _, symbol = exp.shift 2
-        handle_symbol_content(symbol)
-      end
-
-      def process_symbol(exp)
-        _, node = exp.shift 2
-        handle_symbol_content(node)
-      end
-
-      def process_dyna_symbol(exp)
-        _, node = exp.shift 2
-        handle_dyna_symbol_content(node)
-      end
-
-      def process_qsymbols(exp)
-        _, *items = shift_all(exp)
-        items = items.map { |item| handle_symbol_content(item) }
-        s(:qsymbols, *items)
-      end
-
-      def process_symbols(exp)
-        _, *items = shift_all(exp)
-        items = items.map { |item| handle_dyna_symbol_content(item) }
-        s(:symbols, *items)
-      end
-
-      INTERPOLATING_HEREDOC = /^<<[-~]?[^-~']/.freeze
-      NON_INTERPOLATING_HEREDOC = /^<<[-~]?'/.freeze
-      INTERPOLATING_STRINGS = ['"', '`', ':"', /^%Q.$/, /^%.$/].freeze
-      NON_INTERPOLATING_STRINGS = ["'", ":'", /^%q.$/].freeze
-      INTERPOLATING_WORD_LIST = /^%[WI].$/.freeze
-      NON_INTERPOLATING_WORD_LIST = /^%[wi].$/.freeze
-      REGEXP_LITERALS = ['/', /^%r.$/].freeze
-
-      def process_at_tstring_content(exp)
-        _, content, _, delim = exp.shift 4
-        string = handle_string_unescaping(content, delim)
-        string = handle_string_encoding(string, delim)
-        s(:str, string)
+      # character literals
+      def process_at_CHAR(exp)
+        _, val, pos = exp.shift 3
+        with_position(pos, s(:str, unescape(val[1..-1])))
       end
 
       def process_array(exp)
@@ -161,136 +39,31 @@ module RipperRubyParser
         s(:kwsplat, process(param))
       end
 
-      private
-
-      def extract_string_parts(list)
-        return '', [] if list.empty?
-
-        list = merge_raw_string_literals list
-        list = map_process_list list
-
-        parts = list.flat_map do |item|
-          type, val, *rest = item
-          if type == :dstr
-            if val.empty?
-              rest
-            else
-              [s(:str, val), *rest]
-            end
-          else
-            [item]
-          end
-        end
-
-        string = ''
-        while parts.first&.sexp_type == :str
-          str = parts.shift
-          string += str.last
-        end
-
-        return string, parts
-      end
-
-      def merge_raw_string_literals(list)
-        chunks = list.chunk { |it| it.sexp_type == :@tstring_content }
-        chunks.flat_map do |is_simple, items|
-          if is_simple && items.count > 1
-            head = items.first
-            contents = items.map { |it| it[1] }.join
-            [s(:@tstring_content, contents, head[2], head[3])]
-          else
-            items
-          end
-        end
-      end
-
-      def character_flags_to_numerical(flags)
-        numflags = 0
-
-        numflags = Regexp::MULTILINE if flags =~ /m/
-        numflags |= Regexp::EXTENDED if flags =~ /x/
-        numflags |= Regexp::IGNORECASE if flags =~ /i/
-
-        numflags |= Regexp::NOENCODING if flags =~ /n/
-        numflags |= Regexp::FIXEDENCODING if flags =~ /[ues]/
-
-        numflags
-      end
-
-      def handle_dyna_symbol_content(node)
-        type, *body = *process(node)
-        case type
-        when :str, :xstr
-          s(:lit, body.first.to_sym)
-        when :dstr, :dxstr
-          s(:dsym, *body)
-        end
-      end
-
-      def handle_symbol_content(node)
-        if node.sexp_type == :'@kw'
-          symbol, position = extract_node_symbol_with_position(node)
-        else
-          processed = process(node)
-          symbol = processed.last.to_sym
-          position = processed.line
-        end
-        with_line_number(position, s(:lit, symbol))
+      # number literals
+      def process_at_int(exp)
+        make_literal(exp) { |val| Integer(val) }
       end
 
-      def merge_left_into_right(left, right)
-        right[1] = left.last + right[1]
-        right
+      def process_at_float(exp)
+        make_literal(exp, &:to_f)
       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
+      def process_at_rational(exp)
+        make_literal(exp, &:to_r)
       end
 
-      def handle_string_unescaping(content, delim)
-        case delim
-        when INTERPOLATING_HEREDOC
-          if extra_compatible
-            unescape(content).delete("\r")
-          else
-            unescape(content)
-          end
-        when *INTERPOLATING_STRINGS
-          unescape(content)
-        when INTERPOLATING_WORD_LIST
-          unescape_wordlist_word(content)
-        when *NON_INTERPOLATING_STRINGS
-          simple_unescape(content)
-        when *REGEXP_LITERALS
-          unescape_regexp(content)
-        when NON_INTERPOLATING_WORD_LIST
-          simple_unescape_wordlist_word(content)
-        else
-          content
-        end
+      def process_at_imaginary(exp)
+        make_literal(exp, &:to_c)
       end
 
-      def handle_string_encoding(string, delim)
-        case delim
-        when INTERPOLATING_HEREDOC, INTERPOLATING_WORD_LIST, *INTERPOLATING_STRINGS
-          fix_encoding string
-        else
-          string
-        end
-      end
+      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|
           if sub_exp.sexp_type == :assoc_new
-            sub_exp.sexp_body.each { |elem| result << process(elem) }
+            result += process(sub_exp).sexp_body
           else # :assoc_splat
             result << process(sub_exp)
           end

data/lib/ripper_ruby_parser/sexp_handlers/loops.rb

@@ -52,10 +52,12 @@ module RipperRubyParser
       def handle_conditional_loop_mod(type, negated_type, exp)
         _, cond, body = exp.shift 3
 
+        cond = process(cond)
+        body = process(body)
         check_at_start = check_at_start?(body)
         construct_conditional_loop(type, negated_type,
-                                   unwrap_begin(process(cond)),
-                                   unwrap_begin(process(body)),
+                                   unwrap_begin(cond),
+                                   unwrap_begin(body),
                                    check_at_start)
       end
 

data/lib/ripper_ruby_parser/sexp_handlers/method_calls.rb

@@ -17,7 +17,7 @@ module RipperRubyParser
 
       def process_arg_paren(exp)
         _, args = exp.shift 2
-        return s() if args.nil?
+        return s(:arglist) if args.nil?
 
         process(args)
       end

data/lib/ripper_ruby_parser/sexp_handlers/methods.rb

@@ -5,9 +5,9 @@ module RipperRubyParser
     # Sexp handers for method definitions and related constructs
     module Methods
       def process_def(exp)
-        _, ident, params, body = exp.shift 4
+        _, ident, params, body, pos = exp.shift 5
 
-        ident, pos = extract_node_symbol_with_position ident
+        ident, = extract_node_symbol_with_position ident
 
         in_method do
           params = convert_arguments(process(params))
@@ -19,7 +19,7 @@ module RipperRubyParser
       end
 
       def process_defs(exp)
-        _, receiver, _, ident, params, body = exp.shift 6
+        _, receiver, _, ident, params, body, = exp.shift 7
 
         ident, = extract_node_symbol_with_position ident
 
@@ -83,36 +83,36 @@ module RipperRubyParser
 
       def method_body(exp)
         block = process exp
-        case block.length
-        when 0
-          [s(:nil)]
+        case block.sexp_type
+        when :void_stmt
+          [s(:nil).line(block.line)]
         else
           unwrap_block block
         end
       end
 
       SPECIAL_ARG_MARKER = {
-        splat: '*',
-        dsplat: '**',
-        blockarg: '&'
+        splat: "*",
+        dsplat: "**",
+        blockarg: "&"
       }.freeze
 
       def convert_arguments(args)
-        args.map! do |item|
-          if item.is_a? Symbol
-            item
-          else
-            case item.sexp_type
-            when :lvar
-              item.last
-            when *SPECIAL_ARG_MARKER.keys
-              convert_marked_argument(item)
-            when :masgn
-              convert_masgn_argument(item)
-            else
-              item
-            end
-          end
+        args.line ||= args.sexp_body.first&.line
+        args.sexp_body = args.sexp_body.map { |item| convert_argument item }
+        args
+      end
+
+      def convert_argument(item)
+        case item.sexp_type
+        when :lvar
+          item.last
+        when *SPECIAL_ARG_MARKER.keys
+          convert_marked_argument(item)
+        when :masgn
+          convert_masgn_argument(item)
+        else
+          item
         end
       end