to_source 0.2.9 → 0.2.11

data/lib/to_source/emitter/match3.rb

@@ -0,0 +1,17 @@
+module ToSource
+  class Emitter
+    class Match3 < self
+
+      handle(Rubinius::AST::Match3)
+
+    private
+
+      def dispatch
+        visit(node.value)
+        emit(' =~ ')
+        visit(node.pattern)
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/module.rb

@@ -0,0 +1,21 @@
+module ToSource
+  class Emitter
+    class Module < self
+
+      handle(Rubinius::AST::Module)
+
+    private
+
+      def dispatch
+        emit(:module)
+        space
+        visit(node.name)
+        indent
+        visit(node.body)
+        unindent
+        emit_end
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/multiple_assignment.rb

@@ -0,0 +1,23 @@
+module ToSource
+  class Emitter
+    class MultipleAssignment < self
+
+      handle(Rubinius::AST::MultipleAssignment)
+
+    private
+
+      def dispatch
+        body = node.left.body
+        run(Util::DelimitedBody, node.left.body)
+        emit(' = ')
+        right = node.right
+        if node.right.kind_of?(Rubinius::AST::ArrayLiteral)
+          run(Util::DelimitedBody, right.body)
+        else
+          visit(right)
+        end
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/nth_ref.rb

@@ -0,0 +1,15 @@
+module ToSource
+  class Emitter
+    class NthRef < self
+
+      handle(Rubinius::AST::NthRef)
+
+    private
+
+      def dispatch
+        emit("$#{node.which}")
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/op_assign1.rb

@@ -0,0 +1,19 @@
+module ToSource
+  class Emitter
+    class OpAssign1 < self
+
+      handle(Rubinius::AST::OpAssign1)
+
+    private
+
+      def dispatch
+        visit(node.receiver)
+        emit('[')
+        visit(node.arguments.array.first)
+        emit('] ||= ')
+        visit(node.value)
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/op_assign2.rb

@@ -0,0 +1,19 @@
+module ToSource
+  class Emitter
+    class OpAssign2 < self
+
+      handle(Rubinius::AST::OpAssign2)
+
+    private
+
+      def dispatch
+        visit(node.receiver)
+        emit('.')
+        emit(node.name)
+        emit(' |= ')
+        visit(node.value)
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/pattern_arguments.rb

@@ -0,0 +1,17 @@
+module ToSource
+  class Emitter
+    class PatternArguments < self
+
+      handle(Rubinius::AST::PatternArguments)
+
+    private
+
+      def dispatch
+        emit('(')
+        run(Util::DelimitedBody, node.arguments.body)
+        emit(')')
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/receiver_case.rb

@@ -0,0 +1,35 @@
+module ToSource
+  class Emitter
+    class ReceiverCase < self
+
+      handle(Rubinius::AST::ReceiverCase)
+
+      def dispatch
+        emit('case ')
+        visit(node.receiver)
+        emit_whens
+        emit_else
+        emit_end
+      end
+
+      def emit_else
+        body = node.else
+        return if body.kind_of?(Rubinius::AST::NilLiteral)
+        emit('else')
+        indent
+        visit(body)
+        unindent
+      end
+
+      def emit_whens
+        first = true
+        node.whens.each do |member|
+          new_line if first
+          first = false
+          visit(member)
+        end
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/rescue.rb

@@ -0,0 +1,21 @@
+module ToSource
+  class Emitter
+
+    class Rescue < self
+
+      handle(Rubinius::AST::Rescue)
+
+    private
+
+      def dispatch
+        emit('begin')
+        indent
+        visit(node.body)
+        unindent
+        visit(node.rescue)
+        emit_end
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/rescue_condition.rb

@@ -0,0 +1,56 @@
+module ToSource
+  class Emitter
+    class RescueCondition < self
+
+      handle(Rubinius::AST::RescueCondition)
+
+    private
+
+      def dispatch
+        emit('rescue')
+        emit_condition
+        emit_splat
+        emit_assignment
+        emit_body
+        emit_next
+      end
+
+      def emit_body
+        indent
+        visit(node.body)
+        unindent
+      end
+
+      def emit_condition
+        conditions = node.conditions || return
+
+        body = conditions.body
+
+        first = body.first
+        unless body.one? and first.kind_of?(Rubinius::AST::ConstantAccess) and first.name == :StandardError
+          emit(' ')
+          run(Util::DelimitedBody, body)
+        end
+      end
+
+      def emit_splat
+        splat = node.splat || return
+        emit(',') if node.conditions
+        emit(' ')
+        visit(node.splat)
+      end
+
+      def emit_assignment
+        assignment = node.assignment || return
+        emit(' => ')
+        emit(assignment.name)
+      end
+
+      def emit_next
+        condition = node.next || return
+        visit(node.next)
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/scope.rb

@@ -0,0 +1,17 @@
+module ToSource
+  class Emitter
+    class Scope < self
+
+      handle(Rubinius::AST::ClassScope)
+      handle(Rubinius::AST::ModuleScope)
+      handle(Rubinius::AST::SClassScope)
+
+    private
+
+      def dispatch
+        visit(node.body)
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/scope_name.rb

@@ -0,0 +1,16 @@
+module ToSource
+  class Emitter
+    class ScopeName < self
+
+      handle(Rubinius::AST::ClassName)
+      handle(Rubinius::AST::ModuleName)
+
+    private
+
+      def dispatch
+        emit(node.name)
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/scoped_name.rb

@@ -0,0 +1,17 @@
+module ToSource
+  class Emitter
+    class ScopedName < self
+
+      handle(Rubinius::AST::ScopedClassName)
+      handle(Rubinius::AST::ScopedModuleName)
+      handle(Rubinius::AST::ScopedConstant)
+
+      def dispatch
+        visit(node.parent)
+        emit('::')
+        emit(node.name)
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/send.rb

@@ -0,0 +1,47 @@
+module ToSource
+  class Emitter
+    class Send < self
+
+      handle(Rubinius::AST::Send)
+
+      UNARY_OPERATORS = %w(
+        ! ~ -@ +@
+      ).map(&:to_sym).to_set.freeze
+
+    private
+
+      def unary_operator_method?
+        UNARY_OPERATORS.include?(node.name)
+      end
+
+      def dispatch
+        if unary_operator_method?
+          run(UnaryOperatorMethod, node)
+          return
+        end
+
+        normal_dispatch
+      end
+
+      def normal_dispatch
+        unless node.privately
+          visit(node.receiver)
+          emit('.')
+        end
+
+        emit(node.name)
+        emit_block
+      end
+
+      def emit_block
+        block = node.block
+        return unless block
+        pass = block.kind_of?(Rubinius::AST::BlockPass19)
+        emit('(') if pass
+        visit(node.block)
+        emit(')') if pass
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/send_with_arguments.rb

@@ -0,0 +1,62 @@
+module ToSource
+  class Emitter
+    class SendWithArguments < self
+
+      handle(Rubinius::AST::SendWithArguments)
+
+    private
+
+      def dispatch
+        if node.name == :[]
+          run(ElementReference, node)
+          return
+        end
+        if binary_operator_method?
+          run(BinaryOperatorMethod, node)
+          return
+        end
+        normal_dispatch
+      end
+
+      BINARY_OPERATORS = %w(
+        + - * / & | && || << >> == 
+        === != <= < <=> > >= =~ !~ ^ 
+        **
+      ).map(&:to_sym).to_set
+
+      def binary_operator_method?
+        BINARY_OPERATORS.include?(node.name)
+      end
+
+      def emit_receiver
+        unless node.privately
+          visit(node.receiver)
+          emit('.')
+        end
+      end
+
+      def normal_dispatch
+        emit_receiver
+        emit(node.name)
+        emit_arguments
+      end
+
+      def emit_arguments
+        emit('(')
+        emitter = visit(node.arguments)
+        emit_block_pass(emitter)
+        emit(')')
+      end
+
+      def emit_block_pass(emitter)
+        block = node.block
+
+        if block && block.kind_of?(Rubinius::AST::BlockPass19)
+          emit(', ') if emitter.any?
+          visit(block)
+        end
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/singleton_class.rb

@@ -0,0 +1,23 @@
+module ToSource
+  class Emitter
+
+    class SingletonClass < self
+
+      handle(Rubinius::AST::SClass)
+
+      def dispatch
+        emit(:class)
+        space
+        emit(:<<)
+        space
+        visit(node.receiver)
+        indent
+        # FIXME: attr_reader missing on Rubinius::AST::SClass
+        visit(node.instance_variable_get(:@body))
+        unindent
+        emit_end
+      end
+
+    end
+  end
+end