ripper_ruby_parser 1.7.0 → 1.9.0

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,134 +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
-        line, string, rest = extract_string_parts(rest)
-
-        if rest.empty?
-          with_line_number(line, 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
-        line, string, rest = extract_string_parts(rest)
-        if rest.empty?
-          s(:xstr, string).line(line)
-        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
-
-        if content.length == 2
-          return with_line_number(content.line, s(:lit, Regexp.new(content.last, numflags)))
-        end
-
-        content.sexp_type = :dregx_once if /o/.match?(flags)
-        content << numflags unless numflags == 0
-        content
-      end
-
-      def process_regexp(exp)
-        _, *rest = shift_all exp
-        line, string, rest = extract_string_parts(rest)
-        with_line_number(line, 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, pos, delim = exp.shift 4
-        string = handle_string_unescaping(content, delim)
-        string = handle_string_encoding(string, delim)
-        with_position(pos, s(:str, string))
+      # character literals
+      def process_at_CHAR(exp)
+        _, val, pos = exp.shift 3
+        with_position(pos, s(:str, fix_encoding(unescape(val[1..-1]))))
       end
 
       def process_array(exp)
@@ -163,134 +39,31 @@ module RipperRubyParser
         s(:kwsplat, process(param))
       end
 
-      private
-
-      def extract_string_parts(list)
-        return nil, "", [] 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
-          line ||= str.line
-          string += str.last
-        end
-
-        return line, 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 /m/.match?(flags)
-        numflags |= Regexp::EXTENDED if /x/.match?(flags)
-        numflags |= Regexp::IGNORECASE if /i/.match?(flags)
-
-        numflags |= Regexp::NOENCODING if /n/.match?(flags)
-        numflags |= Regexp::FIXEDENCODING if /[ues]/.match?(flags)
-
-        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
+      # number literals
+      def process_at_int(exp)
+        make_literal(exp) { |val| Integer(val) }
       end
 
-      def handle_symbol_content(node)
-        if node.sexp_type == :'@kw'
-          symbol, position = extract_node_symbol_with_position(node)
-          with_position(position, s(:lit, symbol))
-        else
-          processed = process(node)
-          symbol = processed.last.to_sym
-          line = processed.line
-          with_line_number(line, s(:lit, symbol))
-        end
+      def process_at_float(exp)
+        make_literal(exp, &:to_f)
       end
 
-      def merge_left_into_right(left, right)
-        right[1] = left.last + right[1]
-        right
+      def process_at_rational(exp)
+        make_literal(exp, &:to_r)
       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_imaginary(exp)
+        make_literal(exp, &:to_c)
       end
 
-      def handle_string_unescaping(content, delim)
-        case delim
-        when INTERPOLATING_HEREDOC
-          unescape(content)
-        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
-      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/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
@@ -26,7 +26,11 @@ module RipperRubyParser
         _, call, parens = exp.shift 3
         call = process(call)
         parens = process(parens)
-        call.push(*parens.sexp_body)
+        if parens.sexp_type == :forward_args
+          call.push(parens)
+        else
+          call.push(*parens.sexp_body)
+        end
       end
 
       # Handle implied hashes, such as at the end of argument lists.
@@ -36,9 +40,9 @@ module RipperRubyParser
       end
 
       CALL_OP_MAP = {
-        '.': :call,
-        '::': :call,
-        '&.': :safe_call
+        ".": :call,
+        "::": :call,
+        "&.": :safe_call
       }.freeze
 
       def process_call(exp)

data/lib/ripper_ruby_parser/sexp_handlers/methods.rb

@@ -72,6 +72,11 @@ module RipperRubyParser
         s(:alias, process(left), process(right))
       end
 
+      def process_args_forward(exp)
+        _ = exp.shift
+        s(:forward_args)
+      end
+
       private
 
       def in_method
@@ -83,8 +88,8 @@ module RipperRubyParser
 
       def method_body(exp)
         block = process exp
-        case block.length
-        when 0
+        case block.sexp_type
+        when :void_stmt
           [s(:nil).line(block.line)]
         else
           unwrap_block block
@@ -98,21 +103,21 @@ module RipperRubyParser
       }.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
 

data/lib/ripper_ruby_parser/sexp_handlers/operators.rb

@@ -5,8 +5,8 @@ module RipperRubyParser
     # Sexp handlers for operators
     module Operators
       BINARY_OPERATOR_MAP = {
-        '&&': :and,
-        '||': :or,
+        "&&": :and,
+        "||": :or,
         and: :and,
         or: :or
       }.freeze
@@ -16,7 +16,7 @@ module RipperRubyParser
       }.freeze
 
       NEGATED_BINARY_OPERATOR_MAP = {
-        '!~': :=~
+        "!~": :=~
       }.freeze
 
       SHIFT_OPERATORS = [:<<, :>>].freeze