to_source 0.1.3 → 0.2.16

data/lib/to_source/emitter/define.rb

@@ -0,0 +1,99 @@
+module ToSource
+  class Emitter
+
+    # Emitter for define singleton nodes
+    class DefineSingleton < self
+
+      handle(Rubinius::AST::DefineSingleton)
+
+    private
+
+      delegate(:receiver, :body)
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        emit('def ')
+        visit(receiver)
+        emit('.')
+        visit(body)
+      end
+    end
+
+    # Base class for define emitters
+    class Define < self
+
+    private
+
+      delegate(:name, :body)
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def shared_dispatch
+        emit(name)
+        emit_arguments
+        indented do
+          visit(body)
+        end
+        emit_end
+      end
+
+      # Emit arguments
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_arguments
+        run(FormalArguments::Method)
+      end
+
+      # Emitter for singeton level defines
+      class Singleton < self
+
+        handle(Rubinius::AST::DefineSingletonScope)
+
+      private
+  
+        # Perform dispatch
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def dispatch
+          shared_dispatch
+        end
+
+      end
+
+      # Emitter for instance level defines
+      class Instance < self
+
+        handle(Rubinius::AST::Define)
+
+      private
+  
+        # Perform dispatch
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def dispatch
+          emit('def ')
+          shared_dispatch
+        end
+
+      end
+    end
+  end
+end

data/lib/to_source/emitter/defined.rb

@@ -0,0 +1,24 @@
+module ToSource
+  class Emitter
+    # Emitter for defined? node
+    class Defined < self
+
+      handle(Rubinius::AST::Defined)
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        emit('defined?(')
+        visit(node.expression)
+        emit(')')
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/element_assignment.rb

@@ -0,0 +1,29 @@
+module ToSource
+  class Emitter
+    # Emitter for element assignment nodes
+    class ElementAssignment < self
+
+      handle(Rubinius::AST::ElementAssignment)
+
+    private
+
+      delegate(:receiver)
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        index, value = node.arguments.array
+        visit(receiver)
+        emit('[')
+        visit(index)
+        emit('] = ')
+        visit(value)
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/element_reference.rb

@@ -0,0 +1,25 @@
+module ToSource
+  class Emitter
+    # Emitter for element reference nodes
+    class ElementReference < self
+
+    private
+
+      delegate(:receiver)
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        visit(receiver)
+        emit('[')
+        visit(node.arguments.array.first)
+        emit(']')
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/empty_body.rb

@@ -0,0 +1,21 @@
+module ToSource
+  class Emitter
+    # Emitter for empty body
+    class EmptyBody < self
+
+      handle(Rubinius::AST::EmptyBody)
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/ensure.rb

@@ -0,0 +1,50 @@
+module ToSource
+  class Emitter
+    # Emitter for ensure nodes
+    class Ensure < self
+
+      handle(Rubinius::AST::Ensure)
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        emit_begin
+        emit_enusure
+      end
+
+      # Emit begin
+      #
+      # @return [undefined]
+      #
+      # @api private
+      # 
+      def emit_begin
+        emit(:begin)
+        indented do
+          visit(node.body)
+        end
+      end
+
+      # Emit ensure
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_enusure
+        emit(:ensure)
+        indented do
+          visit(node.ensure)
+        end
+        emit_end
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/ensure_body.rb

@@ -0,0 +1,27 @@
+module ToSource
+  class Emitter
+    # Emitter for ensure body
+    class EnsureBody < self
+
+    private
+
+      delegate(:body)
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        visit(body)
+        unindent
+        emit(:ensure)
+        indented do
+          visit(node.ensure)
+        end
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/execute_string.rb

@@ -0,0 +1,22 @@
+module ToSource
+  class Emitter
+    # Emitter for execute string
+    class ExecuteString < self
+
+      handle(Rubinius::AST::ExecuteString)
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        emit("`#{node.string}`")
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/formal_arguments.rb

@@ -0,0 +1,212 @@
+module ToSource
+  class Emitter
+    # Emitter for formal arguments
+    class FormalArguments < self
+
+    private
+
+      delegate(:arguments)
+      predicate(:splat, :block_arg, :defaults)
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        return unless any?
+        util = self.class
+        emit(util::OPEN)
+        emit_required
+        emit_defaults
+        emit_splat
+        emit_block_arg
+        emit(util::CLOSE)
+      end
+
+      # Test if any argument is present
+      #
+      # @return [true]
+      #   if any argument is present
+      #
+      # @return [false]
+      #   otherwise
+      #
+      # @api private
+      #
+      def any?
+        required? || defaults? || splat? || block_arg?
+      end
+
+      # Return required
+      #
+      # @return [Array]
+      #
+      # @api private
+      #
+      def required
+        arguments.required
+      end
+
+      # Test if any required arguments are present
+      #
+      # @return [true]
+      #   if any required arguments are presnet
+      #
+      # @return [false]
+      #   otherwise
+      #
+      # @api private
+      #
+      def required?
+        required.any?
+      end
+
+      # Return defaults
+      #
+      # @return [Rubinius::AST::Node]
+      #
+      # @api private
+      #
+      def defaults
+        arguments.defaults
+      end
+
+      # Return splat arguments
+      #
+      # @return [Rubinius::AST::Node]
+      #
+      # @api private
+      #
+      def splat
+        arguments.splat
+      end
+
+      # Return block argument
+      #
+      # @return [Rubinius::AST::Node]
+      #
+      # @api private
+      #
+      def block_arg
+        arguments.block_arg
+      end
+
+      # Emit required
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_required
+        array = required
+        max = array.length - 1
+        array.each_with_index do |member, index|
+          emit_member(member)
+          emit(', ') if index < max
+        end
+      end
+
+      # Emit member
+      #
+      # @param [Object, Rubinius::AST::Node] member
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_member(member)
+        if member.kind_of?(Rubinius::AST::Node)
+          visit(member)
+        else
+          emit(member)
+        end
+      end
+
+      # Emit defaults
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_defaults
+        return unless defaults?
+        emit(', ') if required?
+        visit(defaults)
+      end
+
+      # Emit splat
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_splat
+        return unless splat?
+
+        emit(', ') if required? or defaults?
+        emit('*')
+        emit_splat_value(splat)
+      end
+
+      # Emit splat value
+      #
+      # @param [Object] value
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_splat_value(value)
+        unless value == :@unnamed_splat
+          emit(value)
+        end
+      end
+
+      # Emit block arg
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_block_arg
+        return unless block_arg?
+        emit(', ') if required? or defaults? or splat?
+        visit(block_arg)
+      end
+
+      # Emmiter for block arguments
+      class Block < self
+        OPEN = ' |'.freeze
+        CLOSE = '|'.freeze
+      end
+
+      # Emitter for method arguments
+      class Method < self
+        OPEN = '('.freeze
+        CLOSE = ')'.freeze
+
+        # Generic emitter for method arguments
+        class Generic < self
+
+          handle(Rubinius::AST::FormalArguments19)
+
+        private
+
+          # Return arguments
+          #
+          # @return [Rubnius::AST::Node]
+          #
+          # @api private
+          #
+          def arguments
+            node
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/to_source/emitter/if.rb

@@ -0,0 +1,96 @@
+module ToSource
+  class Emitter
+    # Emitter for if nodes
+    class If < self
+
+      handle(Rubinius::AST::If)
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        if else_branch? and !if_branch?
+          run(Unless, node)
+          return
+        end
+
+        normal_dispatch
+      end
+
+      # Test if if branch is present
+      #
+      # @return [true]
+      #   if if branch is present
+      #
+      # @return [false]
+      #   otherwise
+      #
+      # @api private
+      #
+      def if_branch?
+        !node.body.kind_of?(Rubinius::AST::NilLiteral)
+      end
+
+      # Test if else branch is present
+      #
+      # @return [true]
+      #   if else branch is present
+      #
+      # @return [false]
+      #   otherwise
+      #
+      # @api private
+      #
+      def else_branch?
+        !node.else.kind_of?(Rubinius::AST::NilLiteral)
+      end
+
+      # Perform normal dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def normal_dispatch
+        emit('if ')
+        visit(node.condition)
+        emit_if_branch
+        emit_else_branch
+        emit('end')
+      end
+
+      # Emit if brnach
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_if_branch
+        indented do
+          visit(node.body)
+        end
+      end
+
+      # Emit else branch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_else_branch
+        body = node.else
+        return unless else_branch?
+        emit('else')
+        indented do
+          visit(body)
+        end
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/iter.rb

@@ -0,0 +1,27 @@
+module ToSource
+  class Emitter
+    # Emitter for iter nodes
+    class Iter < self
+
+      handle(Rubinius::AST::Iter19)
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        emit(' do')
+        run(FormalArguments::Block)
+        indented do
+          visit(node.body)
+        end
+        emit_end
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/keyword_value.rb

@@ -0,0 +1,67 @@
+module ToSource
+  class Emitter
+
+    # Base class for keyword with value emitters
+    class KeywordValue < self
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        emit(self.class::SYMBOL)
+        if value?
+          emit('(')
+          visit(node.value)
+          emit(')')
+        end
+      end
+
+      # Emitter for return nodes 
+      class Return < self
+
+        handle(Rubinius::AST::Return)
+        SYMBOL = :return
+
+      private
+  
+        # Perform dispatch
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def value?
+          !!node.value
+        end
+      end
+
+      # Emitter for break nodes
+      class Break < self
+
+        handle(Rubinius::AST::Break)
+        SYMBOL = :break
+
+        # Test if value is present
+        #
+        # @return [true]
+        #   if value is present
+        #
+        # @return [false]
+        #   otherwise
+        #
+        # @api private
+        #
+        def value?
+          !node.value.kind_of?(Rubinius::AST::NilLiteral)
+        end
+
+      end
+
+    end
+  end
+end