to_source 0.1.3 → 0.2.16

data/lib/to_source/emitter/literal/dynamic.rb

@@ -0,0 +1,178 @@
+module ToSource
+  class Emitter
+    class Literal
+      # Base class for dynamic literal emitters
+      class Dynamic < self
+
+      private
+  
+        # Perform dispatch
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def dispatch
+          emit_open
+          emit_first
+          emit_segments
+          emit_close
+        end
+
+        # Emit open
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def emit_open
+          emit(self.class::OPEN)
+        end
+
+        # Emit close
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def emit_close
+          emit(self.class::CLOSE)
+        end
+
+        # Return first value
+        #
+        # @return [String]
+        #
+        # @api private
+        #
+        def first_value
+          node.string
+        end
+
+        # Emit literal
+        #
+        # @param [Object] literal
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def emit_literal(literal)
+          emit(literal.inspect[1..-2])
+        end
+        
+        # Emit literal node
+        #
+        # @param [Rubinius::AST::Node] node
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def emit_literal_node(node)
+          emit_literal(node.string)
+        end
+
+        # Emit first
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def emit_first
+          emit_literal(first_value)
+        end
+
+        # Emit segments
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def emit_segments
+          array.each do |segment|
+            emit_segment(segment)
+          end
+        end
+
+        # Emit segment
+        #
+        # @param [Rubinius::AST::Node] segment
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def emit_segment(segment)
+          case segment
+          when Rubinius::AST::StringLiteral
+            emit_literal_node(segment)
+          else
+            visit(segment)
+          end
+        end
+
+        delegate :array
+
+        # Return max segment number
+        #
+        # @return [Fixnum]
+        #
+        # @api private
+        #
+        def max
+          array.length - 1
+        end
+        memoize :max
+
+        # Emitter for dynamic symbol literals
+        class Symbol < self
+
+          handle(Rubinius::AST::DynamicSymbol)
+          OPEN = ':"'.freeze
+          CLOSE = '"'.freeze
+
+        end
+
+        # Emitter for dynamic string literals
+        class String < self
+
+          handle(Rubinius::AST::DynamicString)
+          OPEN = CLOSE = '"'.freeze
+
+        end
+
+        # Emitter for dynamic execute string literals
+        class Execute < self
+
+          handle(Rubinius::AST::DynamicExecuteString)
+          OPEN = CLOSE = '`'.freeze
+
+        end
+
+        # Emitter for dynamic regexp literals
+        class Regex < self
+
+          handle(Rubinius::AST::DynamicRegex)
+          OPEN = CLOSE = '/'.freeze
+
+        private
+
+          # Emit literal
+          #
+          # @param [String] literal
+          #
+          # @return [undefined]
+          #
+          # @api private
+          #
+          def emit_literal(literal)
+            emit(literal)
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/to_source/emitter/literal.rb

@@ -0,0 +1,232 @@
+module ToSource
+  class Emitter
+    # Base class for literal emitters
+    class Literal < self
+
+      # Emitter for empty array nodes
+      class EmptyArray < self
+
+        handle(Rubinius::AST::EmptyArray)
+
+      private
+  
+        # Perform dispatch
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def dispatch
+          emit('[]')
+        end
+      end
+
+      # Emitter for array nodes
+      class Array < self
+
+        handle(Rubinius::AST::ArrayLiteral)
+
+      private
+  
+        # Perform dispatch
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def dispatch
+          emit('[')
+          run(Util::DelimitedBody, node.body)
+          emit(']')
+        end
+      end
+
+      # Base class for range emitters
+      class Range < self
+
+      private
+  
+        # Perform dispatch
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def dispatch
+          util = node
+          visit(util.start)
+          emit(self.class::TOKEN)
+          visit(util.finish)
+        end
+
+        # Emitter for incluive range nodes
+        class Inclusive < self
+
+          handle(Rubinius::AST::Range)
+          TOKEN = '..'.freeze
+
+        end
+
+        # Emitter for exclusive range nodes
+        class Exclude < self
+
+          handle(Rubinius::AST::RangeExclude)
+          TOKEN = '...'.freeze
+
+        end
+
+      end
+
+      # Emitter for hash nodes
+      class Hash < self
+
+        handle(Rubinius::AST::HashLiteral)
+
+      private
+  
+        # Perform dispatch
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def dispatch
+          emit '{'
+          emit_body
+          emit '}'
+        end
+
+        # Emit body
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def emit_body
+          body = node.array.each_slice(2).to_a
+          max  = body.length - 1
+          body.each_with_index do |(key, value), index|
+            visit(key)
+            emit(' => ')
+            visit(value)
+
+            if index < max 
+              emit(', ')
+            end
+          end
+        end
+
+      end
+
+      # Base class for emiiters that emit via #inspect
+      class Inspect < self
+
+        handle(Rubinius::AST::SymbolLiteral)
+
+      private
+  
+        # Perform dispatch
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def dispatch
+          emit(value.inspect)
+        end
+
+        delegate :value
+
+        # Base class for emitters with static value
+        class Static < self
+
+        private
+
+          # Return value
+          #
+          # @return [Object]
+          #
+          # @api private
+          #
+          def value
+            self.class::VALUE
+          end
+
+          # Emitter for true literal nodes
+          class True < self
+            handle(Rubinius::AST::TrueLiteral)
+            VALUE = true
+          end
+
+          # Emitter for false literal nodes
+          class False < self
+            handle(Rubinius::AST::FalseLiteral)
+            VALUE = false
+          end
+
+          # Emitter for nil literal nodes
+          class Nil < self
+            handle(Rubinius::AST::NilLiteral)
+            VALUE = nil
+          end
+        end
+
+        # Emitter for regexp literal nodes
+        class Regexp < self
+
+          handle(Rubinius::AST::RegexLiteral)
+
+        private
+
+          # Return value to inspect
+          #
+          # @return [Regexp]
+          #
+          # @api private
+          #
+          def value
+            ::Regexp.new(node.source)
+          end
+        end
+
+        # Emitter for string litera nodes
+        class String < self
+
+          handle(Rubinius::AST::StringLiteral)
+
+        private
+
+          # Return value to inspect
+          #
+          # @return [String]
+          #
+          # @api private
+          #
+          def value
+            node.string
+          end
+        end
+      end
+
+      # Emitters that emitt via vlaue pass through
+      class PassThrough < self
+
+        handle(Rubinius::AST::FixnumLiteral)
+        handle(Rubinius::AST::FloatLiteral)
+
+      private
+  
+        # Perform dispatch
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def dispatch
+          emit(node.value)
+        end
+
+      end
+    end
+  end
+end

data/lib/to_source/emitter/loop.rb

@@ -0,0 +1,40 @@
+module ToSource
+  class Emitter
+    # Base class for loop node emittrs
+    class Loop < self
+
+    private
+      
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        emit(self.class::KEYWORD)
+        space
+        visit(condition)
+        indented do
+          visit(body)
+        end
+        emit_end
+      end
+
+      delegate :condition, :body
+
+      # Emitter for while nodes
+      class While < self
+        handle(Rubinius::AST::While)
+        KEYWORD = :while
+      end
+
+      # Emitter for until nodes
+      class Until < self
+        handle(Rubinius::AST::Until)
+        KEYWORD = :until
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/match3.rb

@@ -0,0 +1,25 @@
+module ToSource
+  class Emitter
+    # Emitter for match operator
+    class Match3 < self
+
+      handle(Rubinius::AST::Match3)
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        util = node
+        visit(util.value)
+        emit(' =~ ')
+        visit(util.pattern)
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/module.rb

@@ -0,0 +1,28 @@
+module ToSource
+  class Emitter
+    # Emitter for module nodes
+    class Module < self
+
+      handle(Rubinius::AST::Module)
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        util = node
+        emit('module ')
+        visit(util.name)
+        indented do
+          visit(util.body)
+        end
+        emit_end
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/multiple_assignment.rb

@@ -0,0 +1,49 @@
+module ToSource
+  class Emitter
+    # Emitter for multiple assignment nodes
+    class MultipleAssignment < self
+
+      handle(Rubinius::AST::MultipleAssignment)
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        emit_left
+        emit(' = ')
+        emit_right
+      end
+
+      # Emit left
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_left
+        run(Util::DelimitedBody, node.left.body)
+      end
+
+      # Emit left
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_right
+        right = node.right
+        if 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,22 @@
+module ToSource
+  class Emitter
+    # Emitter for nth global variable reference
+    class NthRef < self
+
+      handle(Rubinius::AST::NthRef)
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        emit("$#{node.which}")
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/op_assign1.rb

@@ -0,0 +1,27 @@
+module ToSource
+  class Emitter
+    # Emitter for conditiona element assignment
+    class OpAssign1 < self
+
+      handle(Rubinius::AST::OpAssign1)
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        util = node
+        visit(util.receiver)
+        emit('[')
+        visit(util.arguments.array.first)
+        emit('] ||= ')
+        visit(util.value)
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/op_assign2.rb

@@ -0,0 +1,27 @@
+module ToSource
+  class Emitter
+    # Emitter for conditiona attribute assignment
+    class OpAssign2 < self
+
+      handle(Rubinius::AST::OpAssign2)
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        util = node
+        visit(util.receiver)
+        emit('.')
+        emit(util.name)
+        emit(' |= ')
+        visit(util.value)
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/pattern_arguments.rb

@@ -0,0 +1,24 @@
+module ToSource
+  class Emitter
+    # Emitter for pattern argument node
+    class PatternArguments < self
+
+      handle(Rubinius::AST::PatternArguments)
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        emit('(')
+        run(Util::DelimitedBody, node.arguments.body)
+        emit(')')
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/rescue.rb

@@ -0,0 +1,28 @@
+module ToSource
+  class Emitter
+    # Emitter for rescue nodes
+    class Rescue < self
+
+      handle(Rubinius::AST::Rescue)
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        util = node
+        emit('begin')
+        indented do
+          visit(util.body)
+        end
+        visit(util.rescue)
+        emit_end
+      end
+
+    end
+  end
+end