ripper2ruby 0.0.1

data/lib/ripper/ruby_builder/events/lexer.rb

@@ -0,0 +1,159 @@
+class Ripper
+  class RubyBuilder < Ripper::SexpBuilder
+    module Lexer
+      # unimplemented = :tlambda, :tlambeg
+
+      def on_parse_error(msg)
+        raise ParseError.new("#{filename}:#{position.row + 1}: #{msg}")
+      end
+      
+      def on_param_error(param)
+        raise ParseError.new("#{filename}:#{position.row + 1}: syntax error, invalid parameter type: #{param.to_ruby}")
+      end
+
+      def on_ignored_nl(*args)
+        token = push(super)
+        on_heredoc_literal if end_heredoc?(token)
+        token
+      end
+
+      def on_nl(*args)
+        token = push(super)
+        on_heredoc_literal if end_heredoc?(token)
+        token
+      end
+
+      def on_comment(*args)
+        token = push(super)
+        on_heredoc_literal if end_heredoc?(token)
+        token
+      end
+
+      def on_sp(*args)
+        token = push(super)
+        on_heredoc_literal if end_heredoc?(token) # ripper counts \ + nl ("\\\n") as whitespace
+        token
+      end
+
+      def on_semicolon(*args)
+        push(super)
+      end
+
+      def on_period(*args)
+        push(super)
+      end
+
+      def on_comma(*args)
+        push(super)
+      end
+
+      def on_backtick(*args)
+        push(super)
+      end
+
+      def on_symbeg(*args)
+        push(super)
+      end
+
+      def on_tstring_beg(*args)
+        push(super)
+      end
+
+      def on_tstring_content(token)
+        push(super)
+        nil
+      end
+
+      def on_tstring_end(token)
+        push(super)
+        on_words_end(token) if closes_words?(token) # simulating on_words_end event
+      end
+
+      def on_qwords_beg(*args)
+        push(super)
+      end
+
+      def on_words_beg(*args)
+        push(super)
+      end
+
+      def on_words_sep(token)
+        token.each_char do |token|
+          case token
+          when "\n"
+            push([:@nl, token, position])
+          when /\s+/
+            push([:@sp, token, position])
+          else
+            push([:@words_end, token, position])
+            on_words_end(token) if closes_words?(token) # simulating on_words_end event
+          end
+        end
+      end
+
+      def on_embexpr_beg(*args)
+        push(super)
+      end
+
+      def on_embexpr_end(*args)
+        push(super)
+      end
+
+      def on_regexp_beg(*args)
+        push(super)
+      end
+
+      def on_regexp_end(*args)
+        push(super)
+      end
+
+      def on_lparen(*args)
+        push(super)
+      end
+
+      def on_rparen(*args)
+        push(super)
+      end
+
+      def on_lbracket(*args)
+        push(super)
+      end
+
+      def on_rbracket(*args)
+        push(super)
+      end
+
+      def on_lbrace(*args)
+        push(super)
+      end
+
+      def on_rbrace(*args)
+        push(super)
+      end
+
+      def on_op(*args)
+        push(super)
+      end
+
+      def on_embdoc(doc)
+        push([:@comment, doc, position])
+      end
+
+      def on_embdoc_beg(doc)
+        push([:@comment, doc, position])
+      end
+
+      def on_embdoc_end(doc)
+        push([:@comment, doc, position])
+      end
+
+      def on_embvar(*args)
+        push(super)
+      end
+
+      def on___end__(*args)
+        push(super)
+      end
+    end
+  end
+end

data/lib/ripper/ruby_builder/events/literal.rb

@@ -0,0 +1,47 @@
+class Ripper
+  class RubyBuilder < Ripper::SexpBuilder
+    module Literal
+      @@tokens = %w(class module def do begin rescue ensure retry end 
+                    if unless then else elsif case when while until for in
+                    not and or alias undef super yield return next redo break 
+                    defined? BEGIN END)
+
+      def on_kw(token)
+        if @@tokens.include?(token)
+          push(super) # these aren't passed to the next parser event, so we need them on the stack
+        else
+          push(super)
+          build_keyword(pop_token(:"@#{token}"))
+        end
+      end
+
+      def on_int(token)
+        push
+        Ruby::Integer.new(token, position, prolog)
+      end
+      
+      def on_float(token)
+        push
+        Ruby::Float.new(token, position, prolog)
+      end
+      
+      def on_dot2(left, right)
+        Ruby::Range.new(left, pop_token(:'@..'), right)
+      end
+      
+      def on_dot3(left, right)
+        Ruby::Range.new(left, pop_token(:'@...'), right)
+      end
+      
+      def on_CHAR(token)
+        push
+        Ruby::Char.new(token, position, prolog)
+      end
+      
+      def on_label(label)
+        push
+        Ruby::Label.new(label, position, prolog)
+      end
+    end
+  end
+end

data/lib/ripper/ruby_builder/events/method.rb

@@ -0,0 +1,21 @@
+class Ripper
+  class RubyBuilder < Ripper::SexpBuilder
+    module Method
+      def on_def(identifier, params, body)
+        rdelim = pop_token(:@end)
+        # the identifier might be a keyword, e.g. def class; end. could even be def def; end
+        identifier = pop_identifier(identifier.type, :right => rdelim) if identifier.is_a?(Ripper::RubyBuilder::Token)
+        ldelim = pop_token(:@def, :pass => true)
+        Ruby::Method.new(nil, nil, identifier, params, body, ldelim, rdelim)
+      end
+      
+      def on_defs(target, separator, identifier, params, body)
+        rdelim = pop_token(:@end)
+        ldelim = pop_token(:@def, :pass => true)
+        identifier = pop_identifier(identifier.type, :left => ldelim, :right => rdelim) if identifier.is_a?(Ripper::RubyBuilder::Token)
+        separator = pop_token(:@period, :'@::')
+        Ruby::Method.new(target, separator, identifier, params, body, ldelim, rdelim)
+      end
+    end
+  end
+end

data/lib/ripper/ruby_builder/events/operator.rb

@@ -0,0 +1,23 @@
+class Ripper
+  class RubyBuilder < Ripper::SexpBuilder
+    module Operator
+      def on_unary(operator, operand)
+        operator = pop_unary_operator(:pass => true, :right => operand) # e.g. not(1)
+        ldelim = pop_token(:@lparen, :left => operator)
+        rdelim = pop_token(:@rparen, :left => operator) if ldelim
+        Ruby::Unary.new(operator, operand, ldelim, rdelim) if operator
+      end
+
+      def on_binary(left, operator, right)
+        operator = pop_token(:"@#{operator}", :pass => true, :right => right) 
+        Ruby::Binary.new(operator, left, right) if operator
+      end
+
+      def on_ifop(condition, left, right)
+        operators = pop_ternary_operator(:left => condition, :right => left),
+                    pop_ternary_operator(:left => left, :right => right)
+        Ruby::IfOp.new(condition, left, right, operators)
+      end
+    end
+  end
+end

data/lib/ripper/ruby_builder/events/statements.rb

@@ -0,0 +1,50 @@
+class Ripper
+  class RubyBuilder < Ripper::SexpBuilder
+    module Statements
+      def on_program(statements)
+        program = statements.to_program(src, filename, pop_end_data)
+        program << Ruby::Token.new('', position, prolog) unless stack.buffer.empty?
+        program
+      end
+
+      def on_body_stmt(body, rescue_block, else_block, ensure_block)
+        statements = [rescue_block, else_block, ensure_block].compact
+        body = body.to_chained_block(nil, statements) unless statements.empty?
+        body
+      end
+
+      def on_paren(node)
+        node = Ruby::Statements.new(node) unless node.is_a?(Ruby::ArgsList) || node.is_a?(Ruby::Params)
+        node.rdelim ||= pop_token(:@rparen)
+        node.ldelim ||= pop_token(:@lparen)
+        node
+      end
+
+      def on_stmts_add(target, statement)
+        on_words_end if statement.is_a?(Ruby::Array) && !string_stack.empty? # simulating on_words_end event
+        target.elements << statement if statement
+        target
+      end
+
+      def on_stmts_new
+        Ruby::Statements.new
+      end
+
+      def on_void_stmt
+        nil
+      end
+
+      def on_var_ref(ref)
+        ref.instance_of?(Ruby::Identifier) ? Ruby::Variable.new(ref.token, ref.position, ref.prolog) : ref
+      end
+
+      def on_const_ref(const)
+        const
+      end
+
+      def on_var_field(field)
+        field
+      end
+    end
+  end
+end

data/lib/ripper/ruby_builder/events/string.rb

@@ -0,0 +1,117 @@
+class Ripper
+  class RubyBuilder < Ripper::SexpBuilder
+    module String
+      def on_string_concat(*strings)
+        Ruby::StringConcat.new(strings)
+      end
+
+      def on_string_literal(string)
+        string_stack.pop if string == string_stack.last
+        string.rdelim = pop_token(:@tstring_end) if string.respond_to?(:rdelim)
+        string
+      end
+
+      def on_string_add(string, content)
+        content = pop_string_content unless content
+        target = heredoc? ? string_stack.last : string
+        target << content
+        string
+      end
+
+      def on_string_content(*args)
+        if token = pop_token(:@heredoc_beg)
+          Ruby::HeredocBegin.new(token.token, token.position, token.prolog)
+        else
+          string_stack << Ruby::String.new(nil, pop_token(:@tstring_beg))
+          string_stack.last
+        end
+      end
+
+      def on_xstring_literal(string, type = :@tstring_end)
+        string_stack.pop if string == string_stack.last
+        string.rdelim = pop_token(type) if string.respond_to?(:rdelim)
+        string
+      end
+      
+      def on_regexp_literal(string, rdelim)
+        on_xstring_literal(string, rdelim.type)
+      end
+
+      def on_xstring_new(*args)
+        if token = pop_token(:@heredoc_beg)
+          Ruby::HeredocBegin.new(token.token, token.position, token.prolog)
+        else
+          ldelim = pop(:@symbeg, :@backtick, :@regexp_beg, :max => 1, :pass => true).first
+          string_stack << build_xstring(ldelim)
+          string_stack.last
+        end
+      end
+
+      def on_xstring_add(string, content)
+        on_string_add(string, content)
+      end
+
+      def on_word_new
+        Ruby::String.new
+      end
+
+      def on_word_add(string, word)
+        word = pop_string_content unless word
+        string << word
+      end
+
+      def on_heredoc_literal(*args)
+        string_stack.flush.each { |heredoc| push([:@heredoc, heredoc]) }
+      end
+      
+      def on_heredoc_new
+        string_stack << Ruby::Heredoc.new
+      end
+
+      def on_heredoc_beg(*args)
+        token = push(super)
+        on_heredoc_new
+      end
+
+      def on_heredoc_end(token)
+        string_stack.last.rdelim = Ruby::Token.new(token, position)
+        nil
+      end
+
+      def on_string_embexpr(expression)
+        expression.ldelim = pop_token(:@embexpr_beg)
+        expression.rdelim = pop_token(:@rbrace)
+        expression
+      end
+
+      def on_string_dvar(variable)
+        variable = Ruby::DelimitedVariable.new(variable.to_identifier)
+        ldelim = pop_token(:@embvar)
+        variable.ldelim = ldelim
+        variable
+      end
+
+      protected
+
+        def heredocs
+          @heredoc ||= []
+        end
+
+        def heredoc?
+          string_stack.last.is_a?(Ruby::Heredoc)
+        end
+
+        def end_heredoc?(token)
+          extra_heredoc_stage? && extra_heredoc_char?(token)
+        end
+
+        def extra_heredoc_stage?
+          heredoc? && !!string_stack.last.rdelim
+        end
+
+        def extra_heredoc_char?(token)
+          token && (token.newline? || token.comment? || token.token == "\\\n")
+        end
+    end
+  end
+end

data/lib/ripper/ruby_builder/events/symbol.rb

@@ -0,0 +1,22 @@
+class Ripper
+  class RubyBuilder < Ripper::SexpBuilder
+    module Symbol
+      def on_symbol_literal(symbol)
+        symbol = pop_identifier(symbol.type) if symbol.try(:known?) # happens w/ symbols that are also keywords, e.g. :class
+        symbol
+      end
+      
+      def on_symbol(token)
+        push
+        token = pop_identifier(token.type) if token.try(:known?)
+        Ruby::Symbol.new(token, pop_token(:@symbeg))
+      end
+
+      def on_dyna_symbol(symbol)
+        string_stack.pop if symbol == string_stack.last
+        symbol.rdelim = pop_token(:@tstring_end)
+        symbol
+      end
+    end
+  end
+end