to_source 0.1.3 → 0.2.16

data/lib/to_source/emitter/actual_arguments.rb

@@ -0,0 +1,89 @@
+module ToSource
+  class Emitter
+    # Emitter for arguments node
+    class ActualArguments < self
+
+      handle(Rubinius::AST::ActualArguments)
+
+      # Test if any arguments are present
+      #
+      # @return [true]
+      #   if any argument is present
+      #
+      # @return [false]
+      #   otherwise
+      #
+      # @api private
+      #
+      def any?
+        normal? || splat?
+      end
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [self]
+      #
+      # @api private
+      #
+      def dispatch
+        emit_normal
+        emit_splat
+      end
+
+      delegate :array, :splat
+
+      # Test for splat argument
+      #
+      # @return [true]
+      #   if splate argument is present
+      #
+      # @return [false]
+      #   otherwise
+      #
+      # @api private
+      #
+      def splat?
+        !!splat
+      end
+
+      # Test if normal arguments are present
+      #
+      # @return [true]
+      #   if normal arguments are present
+      #
+      # @return [false]
+      #   otherwise
+      #
+      # @api private
+      #
+      def normal?
+        !array.empty?
+      end
+
+      # Emit normal arguments
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_normal
+        run(Util::DelimitedBody, array)
+      end
+
+      # Emit splat argument
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_splat
+        return unless splat?
+        emit(', ') if normal?
+        visit(splat) 
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/alias.rb

@@ -0,0 +1,27 @@
+module ToSource
+  class Emitter
+    # Emiter for alias node
+    class Alias < self
+
+      handle(Rubinius::AST::Alias)
+
+    private
+
+      delegate(:to, :from)
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        emit('alias ')
+        emit(to.value)
+        space
+        emit(from.value)
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/assignment.rb

@@ -0,0 +1,119 @@
+module ToSource
+  class Emitter
+    # Base class for various assignment nodes
+    class Assignment < self
+
+    private
+
+      delegate :value
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        emit_target
+        val = value
+
+        if val
+          emit(' = ')
+          visit(val)
+        end
+      end
+
+      # Emitter for constant assignments
+      class Constant < self
+
+        handle(Rubinius::AST::ConstantAssignment)
+
+      private
+
+        # Emit name
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def emit_target
+          visit(node.constant)
+        end
+
+      end
+
+      # Emitter for various variabe assignments
+      class Variable < self
+
+        handle(Rubinius::AST::LocalVariableAssignment)
+        handle(Rubinius::AST::InstanceVariableAssignment)
+        handle(Rubinius::AST::GlobalVariableAssignment)
+        handle(Rubinius::AST::ClassVariableAssignment)
+
+      private
+
+        # Emit target
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def emit_target
+          emit(node.name)
+        end
+
+      end
+    end
+
+    # Base class for assignment operators
+    class AssignmentOperator < self
+
+    private
+
+      delegate(:left, :right)
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        parantheses do
+          visit(left)
+          emit(" #{self.class::SYMBOL} ")
+          emit_right
+        end
+      end
+
+      # Emit right
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_right
+        parantheses do
+          visit(right.value)
+        end
+      end
+
+      # Emitter for or assigmnent operator
+      class Or < self
+
+        handle(Rubinius::AST::OpAssignOr19)
+        SYMBOL = :'||='
+
+      end
+
+      # Emitter for and assigmnent operator
+      class And < self
+
+        handle(Rubinius::AST::OpAssignAnd)
+        SYMBOL = :'&&='
+
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/attribute_assignment.rb

@@ -0,0 +1,28 @@
+module ToSource
+  class Emitter
+    # Emitter for attribute assignments
+    class AttributeAssignment < self
+
+      handle(Rubinius::AST::AttributeAssignment)
+
+    private
+
+      delegate(:receiver, :name)
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        visit(receiver)
+        emit('.')
+        emit(name)
+        space
+        visit(node.arguments.array.first)
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/begin.rb

@@ -0,0 +1,71 @@
+module ToSource
+  class Emitter
+    # Emitter for begin constructs
+    class Begin < self
+
+      handle(Rubinius::AST::Begin)
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        emit('begin')
+        emit_body
+        emit_end
+      end
+
+      # Emit body
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_body
+        indent
+        body = node.rescue
+        case body
+        when Rubinius::AST::Rescue
+          emit_rescue(body)
+        when Rubinius::AST::Ensure
+          emit_ensure(body)
+        else
+          visit(body)
+          unindent
+        end
+      end
+
+      # Emit ensure
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_ensure(node)
+        visit(node.body)
+        unindent
+        emit(:ensure)
+        indented do
+          visit(node.ensure)
+        end
+      end
+
+      # Emit rescue
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      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,63 @@
+module ToSource
+  class Emitter
+    # Base class for binary operator emitters
+    class BinaryOperator < self
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        parantheses do
+          emit_left
+          emit(" #{self.class::SYMBOL} ")
+          emit_right
+        end
+      end
+
+      # Emit left
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_left
+        parantheses do 
+          visit(node.left)
+        end
+      end
+
+      # Emit right
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_right
+        parantheses do
+          visit(node.right)
+        end
+      end
+
+      # Emitter for binary or operator
+      class Or < self
+
+        handle(Rubinius::AST::Or)
+        SYMBOL = :'||'
+
+      end
+
+      # Emitter for binary and operator
+      class And < self
+
+        handle(Rubinius::AST::And)
+        SYMBOL = :'&&'
+
+      end
+    end
+  end
+end

data/lib/to_source/emitter/binary_operator_method.rb

@@ -0,0 +1,58 @@
+module ToSource
+  class Emitter
+    # Emitter for binary operator methods
+    class BinaryOperatorMethod < self
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        parantheses do
+          emit_left
+          emit(" #{node.name} ")
+          emit_right
+        end
+      end
+
+      # Emit right
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_right
+        parantheses do
+          visit(right)
+        end
+      end
+
+      # Emit left
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_left
+        parantheses do
+          visit(node.receiver)
+        end
+      end
+
+      # Return right
+      #
+      # @return [Rubinius::AST::Node]
+      #
+      # @api private
+      #
+      def right
+        node.arguments.array.first
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/block.rb

@@ -0,0 +1,29 @@
+module ToSource
+  class Emitter
+    # Emiter for blocks
+    class Block < self
+      
+      handle(Rubinius::AST::Block)
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api 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,23 @@
+module ToSource
+  class Emitter
+    # Emitter for block argument
+    class BlockArgument < self
+
+      handle(Rubinius::AST::BlockArgument)
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        emit('&')
+        emit(node.name)
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/block_pass.rb

@@ -0,0 +1,23 @@
+module ToSource
+  class Emitter
+    # Emitter for block pass
+    class BlockPass < self
+
+      handle(Rubinius::AST::BlockPass19)
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        emit('&')
+        visit(node.body)
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/case.rb

@@ -0,0 +1,85 @@
+module ToSource
+  class Emitter
+
+    # Emitter for case statment nodes
+    class Case < self
+
+      handle(Rubinius::AST::Case)
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        emit('case ')
+        emit_receiver
+        emit_whens
+        emit_else
+        emit_end
+      end
+
+      # Emit receiver
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_receiver
+      end
+
+      # Emit else
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_else
+        body = node.else
+        return if body.kind_of?(Rubinius::AST::NilLiteral)
+        emit('else')
+        indented do
+          visit(body)
+        end
+      end
+
+      # Emit whens
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_whens
+        first = true
+        node.whens.each do |member|
+          new_line if first
+          first = false
+          visit(member)
+        end
+      end
+
+      # Emitter for receiver case nodes
+      class ReceiverCase  < self
+
+        handle(Rubinius::AST::ReceiverCase)
+
+      private
+         
+        # Emit receiver
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def emit_receiver
+          visit(node.receiver)
+        end
+
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/class.rb

@@ -0,0 +1,44 @@
+module ToSource
+  class Emitter
+    # Emitter for class nodes
+    class Class < self
+
+      handle(Rubinius::AST::Class)
+
+    private
+
+      delegate(:name, :body)
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        emit(:class)
+        space
+        visit(name)
+        emit_superclass
+        indented do
+          visit(body)
+        end
+        emit_end
+      end
+
+      # Emit superclass
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_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,28 @@
+module ToSource
+  class Emitter
+    # Emitter for concat arguments
+    class ConcatArguments < self
+
+      handle(Rubinius::AST::ConcatArgs)
+
+    private
+
+      delegate(:rest)
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        emit('[')
+        run(Util::DelimitedBody, node.array.body)
+        emit(', *')
+        visit(rest)
+        emit(']')
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/default_arguments.rb

@@ -0,0 +1,22 @@
+module ToSource
+  class Emitter
+    # Emitter for default arguments
+    class DefaultArguments < self
+
+      handle(Rubinius::AST::DefaultArguments)
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        run(Util::DelimitedBody, node.arguments)
+      end
+
+    end
+  end
+end