ripper2ruby 0.0.1

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

@@ -0,0 +1,55 @@
+class Ripper
+  class RubyBuilder < Ripper::SexpBuilder
+    module Assignment
+      def on_assign(left, right)
+        Ruby::Assignment.new(left, right, pop_token(:'@='))
+      end
+
+      def on_massign(left, right)
+        Ruby::Assignment.new(left, right, pop_token(:'@='))
+      end
+      
+      def on_opassign(left, operator, right)
+        Ruby::Assignment.new(left, right, pop_assignment_operator)
+      end
+
+      def on_mlhs_new
+        Ruby::MultiAssignment.new(:left, nil, pop_token(:@lparen))
+      end
+
+      def on_mlhs_add(assignment, ref)
+        assignment << ref
+        assignment
+      end
+
+      def on_mlhs_paren(arg)
+        arg.rdelim ||= pop_token(:@rparen) if arg.respond_to?(:rdelim)
+        arg.ldelim ||= pop_token(:@lparen) if arg.respond_to?(:ldelim)
+        arg
+      end
+
+      def on_mrhs_new
+        Ruby::MultiAssignment.new(:right, nil)
+      end
+
+      def on_mrhs_new_from_args(args)
+        Ruby::MultiAssignment.new(:right, args.elements)
+      end
+
+      def on_mrhs_add(assignment, ref)
+        assignment << ref
+        assignment
+      end
+
+      def on_mlhs_add_star(assignment, ref)
+        assignment << Ruby::Arg.new(ref, pop_token(:'@*'))
+        assignment
+      end
+
+      def on_mrhs_add_star(assignment, ref)
+        assignment << Ruby::Arg.new(ref, pop_token(:'@*'))
+        assignment
+      end
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+class Ripper
+  class RubyBuilder < Ripper::SexpBuilder
+    module Block
+      def on_method_add_block(call, block)
+        call.block = block
+        call
+      end
+
+      def on_do_block(params, statements)
+        rdelim = pop_token(:@end)
+        ldelim = pop_token(:@do)
+        statements.to_block(params, ldelim, rdelim)
+      end
+
+      def on_brace_block(params, statements)
+        rdelim = pop_token(:@rbrace)
+        ldelim = pop_token(:@lbrace)
+        statements.to_block(params, ldelim, rdelim)
+      end
+
+      def on_begin(body)
+        body = body.to_chained_block unless body.is_a?(Ruby::ChainedBlock)
+        body.rdelim = pop_token(:@end)
+        body.identifier = pop_token(:@begin)
+        body
+      end
+
+      def on_rescue(types, var, statements, block)
+        identifier = pop_token(:@rescue)
+        ldelim = pop_token(:@then)
+        operator = pop_token(:'@=>', :left => identifier)
+        params = Ruby::RescueParams.new(types, var, operator)
+        statements.to_chained_block(identifier, block, params, ldelim)
+      end
+
+      def on_ensure(statements)
+        identifier = pop_token(:@ensure)
+        Ruby::NamedBlock.new(identifier, statements)
+      end
+
+      def on_rescue_mod(expression, statements)
+        args = Ruby::ArgsList.new(args) unless args.is_a?(Ruby::List)
+        statements, expression = *[statements, expression].sort
+        identifier = pop_token(:@rescue)
+        Ruby::RescueMod.new(identifier, expression, statements)
+      end
+
+      def on_block_var(params, something)
+        params.rdelim = pop_token(:'@|')
+        params.ldelim = pop_token(:'@|')
+        params.ldelim, params.rdelim = empty_block_params_delimiters(params) if stack.last.type == :'@||'
+        params
+      end
+
+      def on_params(params, optionals, rest, something, block)
+        optionals = to_assignments(optionals) if optionals
+        params = (Array(params) + Array(optionals) << rest << block).flatten.compact
+        Ruby::Params.new(params)
+      end
+
+      def on_rest_param(param)
+        Ruby::Param.new(param, pop_token(:'@*'))
+      end
+      
+      protected
+      
+        def to_assignments(array)
+          array.reverse.map { |left, right| Ruby::Assignment.new(left, right, pop_token(:'@=')) }.reverse
+        end
+      
+        # gosh, yes. ripper regards empty block param delims (as in in do || ; end) as an operator
+        def empty_block_params_delimiters(params)
+          op = pop_token(:'@||')
+          ldelim = Ruby::Token.new('|', op.position, op.prolog)
+          rdelim = Ruby::Token.new('|', op.position).tap { |o| o.position.col += 1 }
+          [ldelim, rdelim]
+        end
+    end
+  end
+end

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

@@ -0,0 +1,123 @@
+class Ripper
+  class RubyBuilder < Ripper::SexpBuilder
+    module Call
+      def on_command(identifier, args)
+        Ruby::Call.new(nil, nil, identifier, args)
+      end
+
+      def on_command_call(target, separator, identifier, args)
+        # happens for identifiers that are operators, e.g. a.<<(foo)
+        identifier = pop_identifier(identifier.type) if identifier.try(:known?)
+        separator = pop_token(:@period, :"@::")
+        Ruby::Call.new(target, separator, identifier, args)
+      end
+
+      def on_call(target, separator, identifier)
+        # happens for identifiers that are also keywords, e.g. :if
+        identifier = pop_identifier(identifier.type) if identifier.try(:known?)
+        separator = pop_token(:@period, :"@::", :left => target, :right => identifier)
+        Ruby::Call.new(target, separator, identifier)
+      end
+
+      def on_fcall(identifier)
+        Ruby::Call.new(nil, nil, identifier)
+      end
+
+      # assignment methods, e.g. a.b = :c
+      def on_field(target, separator, identifier)
+        separator = pop_token(:@period, :"@::")
+        Ruby::Call.new(target, separator, identifier)
+      end
+
+      def on_zsuper(*args)
+        identifier = pop_identifier(:@super)
+        Ruby::Call.new(nil, nil, identifier)
+      end
+      
+      def on_super(args)
+        identifier = pop_identifier(:@super)
+        Ruby::Call.new(nil, nil, identifier, args)
+      end
+
+      def on_yield(args)
+        identifier = pop_identifier(:@yield)
+        Ruby::Call.new(nil, nil, identifier, args)
+      end
+
+      def on_yield0
+        identifier = pop_identifier(:@yield)
+        Ruby::Call.new(nil, nil, identifier)
+      end
+
+      def on_alias(*args)
+        args.map! { |arg| arg.try(:to_identifier) || arg }
+        identifier = pop_identifier(:@alias)
+        Ruby::Alias.new(identifier, args)
+      end
+      
+      def on_var_alias(*args)
+        args.map! { |arg| arg.try(:to_identifier) || arg }
+        identifier = pop_identifier(:@alias)
+        Ruby::Alias.new(identifier, args)
+      end
+
+      def on_undef(args)
+        args = Ruby::ArgsList.new(args, pop_tokens(:@comma))
+        identifier = pop_identifier(:@undef)
+        Ruby::Call.new(nil, nil, identifier, args)
+      end
+
+      def on_return0
+        identifier = pop_identifier(:@return)
+        Ruby::Call.new(nil, nil, identifier, nil)
+      end
+
+      def on_return(args)
+        identifier = pop_identifier(:@return)
+        Ruby::Call.new(nil, nil, identifier, args)
+      end
+
+      def on_next(args)
+        identifier = pop_identifier(:@next)
+        Ruby::Call.new(nil, nil, identifier, args)
+      end
+
+      def on_break(args)
+        identifier = pop_identifier(:@break)
+        Ruby::Call.new(nil, nil, identifier, args)
+      end
+
+      def on_redo
+        identifier = pop_identifier(:@redo)
+        Ruby::Call.new(nil, nil, identifier)
+      end
+
+      def on_retry
+        identifier = pop_identifier(:@retry)
+        Ruby::Call.new(nil, nil, identifier)
+      end
+
+      def on_defined(ref)
+        identifer = pop_identifier(:@defined, :pass => true)
+        ldelim = pop_token(:@lparen, :left => identifer)
+        rdelim = pop_token(:@rparen) if ldelim
+        args = Ruby::ArgsList.new(ref, ldelim, rdelim)
+        Ruby::Call.new(nil, nil, identifer, args)
+      end
+      
+      def on_BEGIN(statements)
+        statements.ldelim = pop_token(:@lbrace)
+        statements.rdelim = pop_token(:@rbrace)
+        identifier = pop_identifier(:@BEGIN)
+        Ruby::Call.new(nil, nil, identifier, nil, statements)
+      end
+      
+      def on_END(statements)
+        statements.ldelim = pop_token(:@lbrace)
+        statements.rdelim = pop_token(:@rbrace)
+        identifier = pop_identifier(:@END)
+        Ruby::Call.new(nil, nil, identifier, nil, statements)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+class Ripper
+  class RubyBuilder < Ripper::SexpBuilder
+    module Case
+      def on_case(args, when_block)
+        rdelim = pop_token(:@end)
+        identifier = pop_token(:@case)
+        Ruby::Case.new(identifier, args, when_block, rdelim)
+      end
+      
+      def on_when(expression, statements, next_block)
+        ldelim = pop_token(:@then)
+        identifier = pop_token(:@when)
+        Ruby::When.new(identifier, expression, statements, ldelim, next_block)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+class Ripper
+  class RubyBuilder < Ripper::SexpBuilder
+    module Const
+      def on_class(const, super_class, body)
+        rdelim = pop_token(:@end)
+        operator = super_class ? pop_token(:'@<') : nil
+        ldelim = pop_token(:@class)
+        Ruby::Class.new(const, operator, super_class, body, ldelim, rdelim)
+      end
+      
+      def on_sclass(super_class, body)
+        rdelim = pop_token(:@end)
+        operator = pop_token(:'@<<')
+        ldelim = pop_token(:@class)
+        Ruby::Class.new(nil, operator, super_class, body, ldelim, rdelim)
+      end
+
+      def on_module(const, body)
+        rdelim = pop_token(:@end)
+        ldelim = pop_token(:@module)
+        Ruby::Module.new(const, body, ldelim, rdelim)
+      end
+      
+      def on_const_path_ref(namespace, const)
+        const.prolog.unshift(pop_token(:'@::'))
+        const.namespace = namespace
+        const
+      end
+      
+      def on_const_path_field(namespace, const)
+        const.prolog.unshift(pop_token(:'@::'))
+        const.namespace = namespace
+        const
+      end
+      
+      def on_top_const_ref(const)
+        const.prolog.unshift(pop_token(:'@::'))
+        const
+      end
+      
+      def on_top_const_field(const)
+        const.prolog.unshift(pop_token(:'@::'))
+        const
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+class Ripper
+  class RubyBuilder < Ripper::SexpBuilder
+    module For
+      def on_for(variable, range, statements)
+        rdelim     = pop_token(:@end)
+        identifier = pop_token(:@for, :pass => true)
+        ldelim     = pop_token(:@do, :left => identifier, :right => rdelim)
+        operator   = pop_token(:@in, :pass => true)
+        Ruby::For.new(identifier, variable, operator, range, statements, ldelim, rdelim)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+class Ripper
+  class RubyBuilder < Ripper::SexpBuilder
+    module Hash
+      def on_hash(assocs)
+        rdelim = pop_token(:@rbrace)
+        ldelim = pop_token(:@lbrace)
+        Ruby::Hash.new(assocs, ldelim, rdelim)
+      end
+
+      def on_assoclist_from_args(args)
+        args
+      end
+
+      def on_bare_assoc_hash(assocs)
+        Ruby::Hash.new(assocs)
+      end
+
+      def on_assoc_new(key, value)
+        Ruby::Assoc.new(key, value, pop_token(:'@=>'))
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,41 @@
+class Ripper
+  class RubyBuilder < Ripper::SexpBuilder
+    module Identifier
+      def on_const(token)
+        push(super)
+        token = pop_token(:@const)
+        Ruby::Const.new(token.token, token.position, token.prolog)
+      end
+      
+      def on_ident(token)
+        push(super)
+        token = pop_token(:@ident)
+        Ruby::Identifier.new(token.token, token.position, token.prolog)
+      end
+
+      def on_cvar(token)
+        push(super)
+        token = pop_token(:@cvar)
+        Ruby::Variable.new(token.token, token.position, token.prolog)
+      end
+      
+      def on_ivar(token)
+        push(super)
+        token = pop_token(:@ivar)
+        Ruby::Variable.new(token.token, token.position, token.prolog)
+      end
+      
+      def on_gvar(token)
+        push(super)
+        token = pop_token(:@gvar)
+        Ruby::Variable.new(token.token, token.position, token.prolog)
+      end
+
+      def on_backref(arg)
+        push(super)
+        token = pop_token(:@backref)
+        Ruby::Variable.new(token.token, token.position, token.prolog)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+class Ripper
+  class RubyBuilder < Ripper::SexpBuilder
+    module If
+      def build_if(klass, type, expression, statements, else_block)
+        rdelim = pop_token(:@end)
+        ldelim = pop_token(:@then)
+        identifier = pop_token(type)
+        klass.new(identifier, expression, statements, ldelim, rdelim, else_block)
+      end
+      
+      def on_if(expression, statements, else_block)
+        build_if(Ruby::If, :@if, expression, statements, else_block)
+      end
+
+      def on_unless(expression, statements, else_block)
+        build_if(Ruby::Unless, :@unless, expression, statements, else_block)
+      end
+      
+      def on_elsif(expression, statements, else_block)
+        build_if(Ruby::If, :@elsif, expression, statements, else_block)
+      end
+      
+      def on_else(statements)
+        keyword = pop_token(:@else)
+        block = Ruby::Else.new(keyword, statements)
+      end
+      
+      def on_if_mod(expression, statement)
+        Ruby::IfMod.new(pop_token(:@if), expression, statement)
+      end
+      
+      def on_unless_mod(expression, statement)
+        Ruby::UnlessMod.new(pop_token(:@unless), expression, statement)
+      end
+    end
+  end
+end