to_source 0.2.9 → 0.2.11

data/lib/to_source/emitter/attribute_assignment.rb

@@ -0,0 +1,19 @@
+module ToSource
+  class Emitter
+    class AttributeAssignment < self
+
+      handle(Rubinius::AST::AttributeAssignment)
+
+    private
+
+      def dispatch
+        visit(node.receiver)
+        emit('.')
+        emit(node.name)
+        space
+        visit(node.arguments.array.first)
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/begin.rb

@@ -0,0 +1,51 @@
+module ToSource
+  class Emitter
+    class Begin < self
+
+      handle(Rubinius::AST::Begin)
+
+    private
+
+      def dispatch
+        emit('begin')
+        emit_body
+        emit_end
+      end
+
+      def emit_body
+        indent
+
+        body = node.rescue
+
+        if body.kind_of?(Rubinius::AST::Rescue)
+          emit_rescue(body)
+          return
+        end
+
+        if body.kind_of?(Rubinius::AST::Ensure)
+          emit_ensure(body)
+          return
+        end
+
+        visit(body)
+        unindent
+      end
+
+      def emit_ensure(node)
+        visit(node.body)
+        unindent
+        emit(:ensure)
+        indent
+        visit(node.ensure)
+        unindent
+      end
+
+      def emit_rescue(node)
+        visit(node.body)
+        unindent
+        visit(node.rescue)
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/binary_operator.rb

@@ -0,0 +1,36 @@
+module ToSource
+  class Emitter
+    class BinaryOperator < self
+
+    private
+
+      def dispatch
+        emit('(')
+        visit(node.left)
+        emit(')')
+        space
+        emit(self.class::SYMBOL)
+        space
+        emit('(')
+        visit(node.right)
+        emit(')')
+      end
+
+      class Or < self
+
+        SYMBOL = :'||'
+
+        handle(Rubinius::AST::Or)
+
+      end
+
+      class And < self
+
+        SYMBOL = :'&&'
+
+        handle(Rubinius::AST::And)
+
+      end
+    end
+  end
+end

data/lib/to_source/emitter/binary_operator_method.rb

@@ -0,0 +1,29 @@
+module ToSource
+  class Emitter
+    class BinaryOperatorMethod < self
+
+    private
+
+      def dispatch
+        emit('(')
+        visit(left)
+        emit(')')
+        space
+        emit(node.name)
+        space
+        emit('(')
+        visit(right)
+        emit(')')
+      end
+
+      def left
+        node.receiver
+      end
+
+      def right
+        node.arguments.array.first
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/block.rb

@@ -0,0 +1,22 @@
+module ToSource
+  class Emitter
+    class Block < self
+      
+      handle(Rubinius::AST::Block)
+
+    private
+
+      def dispatch
+        array = node.array
+        max = array.length-1
+        array.each_with_index do |node, index|
+          visit(node)
+          if index < max
+            new_line
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/block_argument.rb

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

data/lib/to_source/emitter/block_pass.rb

@@ -0,0 +1,16 @@
+module ToSource
+  class Emitter
+    class BlockPass < self
+
+      handle(Rubinius::AST::BlockPass19)
+
+    private
+
+      def dispatch
+        emit('&')
+        visit(node.body)
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/class.rb

@@ -0,0 +1,29 @@
+module ToSource
+  class Emitter
+    class Class < self
+
+      handle(Rubinius::AST::Class)
+
+    private
+
+      def dispatch
+        emit(:class)
+        space
+        visit(node.name)
+        superclass
+        indent
+        visit(node.body)
+        unindent
+        emit_end
+      end
+
+      def superclass
+        superclass = node.superclass
+        return if superclass.kind_of?(Rubinius::AST::NilLiteral)
+        emit(' < ')
+        visit(superclass)
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/concat_arguments.rb

@@ -0,0 +1,20 @@
+module ToSource
+  class Emitter
+    class ConcatArguments < self
+
+      handle(Rubinius::AST::ConcatArgs)
+
+    private
+
+      def dispatch
+        emit('[')
+        run(Util::DelimitedBody, node.array.body)
+        emit(', ')
+        emit('*')
+        visit(node.rest)
+        emit(']')
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/default_arguments.rb

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

data/lib/to_source/emitter/define.rb

@@ -0,0 +1,61 @@
+module ToSource
+  class Emitter
+
+    class DefineSingleton < self
+
+      handle(Rubinius::AST::DefineSingleton)
+
+    private
+
+      def dispatch
+        emit('def ')
+        visit(node.receiver)
+        emit('.')
+        visit(node.body)
+      end
+    end
+
+    class Define < self
+
+    private
+
+      def shared_dispatch
+        emit(node.name)
+        emit_arguments
+        indent
+        visit(node.body)
+        unindent
+        emit_end
+      end
+
+      def emit_arguments
+        run(FormalArguments::Method)
+      end
+
+      class Singleton < self
+
+        handle(Rubinius::AST::DefineSingletonScope)
+
+      private
+
+        def dispatch
+          shared_dispatch
+        end
+
+      end
+
+      class Instance < self
+
+        handle(Rubinius::AST::Define)
+
+      private
+
+        def dispatch
+          emit('def ')
+          shared_dispatch
+        end
+
+      end
+    end
+  end
+end

data/lib/to_source/emitter/defined.rb

@@ -0,0 +1,17 @@
+module ToSource
+  class Emitter
+    class Defined < self
+
+      handle(Rubinius::AST::Defined)
+
+    private
+
+      def dispatch
+        emit('defined?(')
+        visit(node.expression)
+        emit(')')
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/element_assignment.rb

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

data/lib/to_source/emitter/element_reference.rb

@@ -0,0 +1,16 @@
+module ToSource
+  class Emitter
+    class ElementReference < self
+
+    private
+
+      def dispatch
+        visit(node.receiver)
+        emit('[')
+        visit(node.arguments.array.first)
+        emit(']')
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/empty_body.rb

@@ -0,0 +1,12 @@
+module ToSource
+  class Emitter
+    class EmptyBody < self
+
+      handle(Rubinius::AST::EmptyBody)
+
+      def dispatch
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/ensure.rb

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

data/lib/to_source/emitter/ensure_body.rb

@@ -0,0 +1,18 @@
+module ToSource
+  class Emitter
+    class EnsureBody < self
+
+    private
+
+      def dispatch
+        visit(node.body)
+        unindent
+        emit('ensure')
+        indent
+        visit(node.ensure)
+        unindent
+      end
+
+    end
+  end
+end