to_source 0.1.3 → 0.2.16

data/lib/to_source/emitter/rescue_condition.rb

@@ -0,0 +1,93 @@
+module ToSource
+  class Emitter
+    # Emitter for rescue condition within rescue nodes
+    class RescueCondition < self
+
+      handle(Rubinius::AST::RescueCondition)
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        emit('rescue')
+        emit_conditions
+        emit_splat
+        emit_assignment
+        emit_body
+        emit_next
+      end
+
+      # Emit body
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_body
+        indented do
+          visit(node.body)
+        end
+      end
+
+      # Emit conditions
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_conditions
+        conditions = node.conditions || return
+        body = conditions.body
+
+        first = body.first
+        unless body.one? and first.kind_of?(Rubinius::AST::ConstantAccess) and first.name == :StandardError
+          space
+          run(Util::DelimitedBody, body)
+        end
+      end
+
+      # Emit splat
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_splat
+        util = node
+        splat = util.splat || return
+        emit(',') if util.conditions
+        space
+        visit(splat)
+      end
+
+      # Emit assignment
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_assignment
+        assignment = node.assignment || return
+        emit(' => ')
+        emit(assignment.name)
+      end
+
+      # Emit next
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_next
+        next_rescue = node.next || return
+        visit(next_rescue)
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/scope.rb

@@ -0,0 +1,24 @@
+module ToSource
+  class Emitter
+    # Emitter for class module or singleton class scopes
+    class Scope < self
+
+      handle(Rubinius::AST::ClassScope)
+      handle(Rubinius::AST::ModuleScope)
+      handle(Rubinius::AST::SClassScope)
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        visit(node.body)
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/scope_name.rb

@@ -0,0 +1,23 @@
+module ToSource
+  class Emitter
+    # Emitter for class or modue scope names
+    class ScopeName < self
+
+      handle(Rubinius::AST::ClassName)
+      handle(Rubinius::AST::ModuleName)
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        emit(node.name)
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/scoped_name.rb

@@ -0,0 +1,28 @@
+module ToSource
+  class Emitter
+    # Emitter for scoped cass module or constant names
+    class ScopedName < self
+
+      handle(Rubinius::AST::ScopedClassName)
+      handle(Rubinius::AST::ScopedModuleName)
+      handle(Rubinius::AST::ScopedConstant)
+
+    private
+
+      delegate(:parent, :name)
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        visit(parent)
+        emit('::')
+        emit(name)
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/send.rb

@@ -0,0 +1,133 @@
+module ToSource
+  class Emitter
+    class Send < self
+
+      handle(Rubinius::AST::Send)
+
+      UNARY_OPERATORS = %w(
+        ! ~ -@ +@
+      ).map(&:to_sym).to_set.freeze
+
+    private
+
+      delegate(:block, :name, :receiver)
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        if unary_operator_method?
+          run(UnaryOperatorMethod, node)
+          return
+        end
+
+        normal_dispatch
+      end
+
+      # Test for unary operator method
+      #
+      # @return [true]
+      #   if node is an unary operator method
+      #
+      # @return [false]
+      #   otherwise
+      #
+      # @api private
+      #
+      def unary_operator_method?
+        UNARY_OPERATORS.include?(name)
+      end
+
+      # Perform normal dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def normal_dispatch
+        emit_receiver
+        emit_name
+        emit_block_pass
+        emit_block
+      end
+
+      # Test for block
+      #
+      # @return [true]
+      #   if block is present
+      #
+      # @return [false]
+      #   otherwise
+      #
+      # @api private
+      #
+      def block?
+        !!block
+      end
+
+      # Test for block pass
+      #
+      # @return [true]
+      #   if block pass is present
+      #
+      # @return [false]
+      #   otherwise
+      #
+      # @api private
+      #
+      def block_pass?
+        block? && block.kind_of?(Rubinius::AST::BlockPass19)
+      end
+
+      # Emit name
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_name
+        emit(name)
+      end
+
+      # Emit receiver
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_receiver
+        return if node.privately
+        visit(receiver)
+        emit('.')
+      end
+
+      # Emit block
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_block
+        return unless block? and !block_pass?
+        visit(block)
+      end
+
+      # Emit block pass
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_block_pass
+        return unless block_pass?
+        emit('(')
+        visit(block)
+        emit(')')
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/send_with_arguments.rb

@@ -0,0 +1,103 @@
+module ToSource
+  class Emitter
+    class SendWithArguments < Send
+
+      handle(Rubinius::AST::SendWithArguments)
+
+      BINARY_OPERATORS = %w(
+        + - * / & | && || << >> == 
+        === != <= < <=> > >= =~ !~ ^ 
+        **
+      ).map(&:to_sym).to_set
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        if element_reference?
+          run(ElementReference)
+          return
+        end
+        if binary_operator_method?
+          run(BinaryOperatorMethod)
+          return
+        end
+        normal_dispatch
+      end
+      
+      # Test for element reference
+      #
+      # @return [true]
+      #   if node is an element reference
+      #
+      # @return [false]
+      #   otherwise
+      #
+      # @api private
+      #
+      def element_reference?
+        name == :[]
+      end
+
+      # Test for binary operator method
+      #
+      # @return [true]
+      #   if node is a binary operator method
+      #
+      # @return [false]
+      #   otherwise
+      #
+      # @api private
+      #
+      def binary_operator_method?
+        BINARY_OPERATORS.include?(name)
+      end
+
+      # Perform normal dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      # 
+      def normal_dispatch
+        emit_receiver
+        emit_name
+        emit_arguments
+        emit_block
+      end
+
+      # Emit arguments
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_arguments
+        emit('(')
+        emitter = visit(node.arguments)
+        emit_block_pass(emitter)
+        emit(')')
+      end
+
+      # Emit block pass
+      #
+      # @param [Class:Emitter] emitter
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_block_pass(emitter)
+        return unless block_pass?
+        emit(', ') if emitter.any?
+        visit(block)
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/singleton_class.rb

@@ -0,0 +1,38 @@
+module ToSource
+  class Emitter
+    # Emitter for singleton class nodes
+    class SingletonClass < self
+
+      handle(Rubinius::AST::SClass)
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        emit('class << ')
+        visit(node.receiver)
+        emit_body
+        emit_end
+      end
+
+      # Emit body
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_body
+        indented do
+          # FIXME: attr_reader missing on Rubinius::AST::SClass
+          visit(node.instance_variable_get(:@body))
+        end
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/splat.rb

@@ -0,0 +1,24 @@
+module ToSource
+  class Emitter
+    # Emitter for splat nodes
+    class Splat < self
+
+      handle(Rubinius::AST::SplatValue)
+      handle(Rubinius::AST::RescueSplat)
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        emit('*')
+        visit(node.value)
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/splat_when.rb

@@ -0,0 +1,23 @@
+module ToSource
+  class Emitter
+    # Emitter for spat when nodes
+    class SplatWhen < self
+
+      handle(Rubinius::AST::SplatWhen)
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        emit('*')
+        visit(node.condition)
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/static.rb

@@ -0,0 +1,52 @@
+module ToSource
+  class Emitter
+    # Base class for emitters with static content
+    class Static < self
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        emit(self.class::SYMBOL)
+      end
+
+      # Emitter for next nodes
+      class Next < self
+
+        handle(Rubinius::AST::Next)
+        SYMBOL = :next
+
+      end
+
+      # Emitter for current exception node
+      class CurrentException < self
+
+        handle(Rubinius::AST::CurrentException)
+        SYMBOL = :'$!'
+
+      end
+
+      # Emitter for self node
+      class Self < self
+
+        handle(Rubinius::AST::Self)
+        SYMBOL = :self
+
+      end
+
+      # Emitter for file node
+      class File < self
+
+        handle(Rubinius::AST::File)
+        SYMBOL = :__FILE__
+
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/super.rb

@@ -0,0 +1,92 @@
+module ToSource
+  class Emitter
+    # emitter for super node
+    class Super < self
+
+      handle(Rubinius::AST::Super)
+
+    private
+
+      delegate(:block)
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        emit('super')
+        emit_arguments
+        emit_block
+      end
+
+      # Emit arguments
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_arguments
+        emit('(')
+        emitter = visit(node.arguments)
+        emit_block_pass(emitter)
+        emit(')')
+      end
+
+      # Test for block presence
+      #
+      # @return [true]
+      #   if block is present
+      #
+      # @return [false]
+      #   otherwise
+      #
+      # @api private
+      #
+      def block?
+        !!block
+      end
+
+      # Test for block pass
+      #
+      # @return [true]
+      #   if block pass is present
+      #
+      # @return [false]
+      #   otherwise
+      #
+      # @api private
+      #
+      def block_pass?
+        block.kind_of?(Rubinius::AST::BlockPass19)
+      end
+
+      # Emit block pass
+      #
+      # @param [Class:Emitter] emitter
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_block_pass(emitter)
+        return unless block? and block_pass?
+        emit(', ') if emitter.any?
+        visit(block)
+      end
+
+      # Emit block
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_block
+        return unless block? and !block_pass?
+        visit(block)
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/to_array.rb

@@ -0,0 +1,22 @@
+module ToSource
+  class Emitter
+    # Emit to array node
+    class ToArray < self
+
+      handle(Rubinius::AST::ToArray)
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        visit(node.value)
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/to_string.rb

@@ -0,0 +1,24 @@
+module ToSource
+  class Emitter
+    # Emit to string node
+    class ToString < self
+
+      handle(Rubinius::AST::ToString)
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        emit('#{')
+        visit(node.value)
+        emit('}')
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/toplevel.rb

@@ -0,0 +1,24 @@
+module ToSource
+  class Emitter
+    # Emitter for toplevel constants or classes
+    class Toplevel < self
+
+      handle(Rubinius::AST::ToplevelClassName)
+      handle(Rubinius::AST::ToplevelConstant)
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        emit('::')
+        emit(node.name)
+      end
+
+    end
+  end
+end