to_source 0.2.15 → 0.2.16

data/lib/to_source/emitter/iter.rb

@@ -1,17 +1,24 @@
 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)
-        indent
-        visit(node.body)
-        unindent
+        indented do
+          visit(node.body)
+        end
         emit_end
       end
 

data/lib/to_source/emitter/keyword_value.rb

@@ -1,10 +1,17 @@
 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?
@@ -14,23 +21,41 @@ module ToSource
         end
       end
 
+      # Emitter for return nodes 
       class Return < self
-        SYMBOL = :return
+
         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
@@ -38,6 +63,5 @@ module ToSource
       end
 
     end
-
   end
 end

data/lib/to_source/emitter/literal.rb

@@ -1,22 +1,39 @@
 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)
@@ -24,45 +41,67 @@ module ToSource
         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(token)
+          emit(self.class::TOKEN)
           visit(util.finish)
         end
 
-        def token
-          self.class::TOKEN
-        end
-
+        # Emitter for incluive range nodes
         class Inclusive < self
+
           handle(Rubinius::AST::Range)
-          TOKEN = '..'
+          TOKEN = '..'.freeze
+
         end
 
+        # Emitter for exclusive range nodes
         class Exclude < self
+
           handle(Rubinius::AST::RangeExclude)
-          TOKEN = '...'
+          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
@@ -79,64 +118,110 @@ module ToSource
 
       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
 
-        def value
-          node.value
-        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

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

@@ -1,10 +1,17 @@
 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
@@ -12,37 +19,91 @@ module ToSource
           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_with_index do |segment, index|
-            emit_segment(segment, index)
+          array.each do |segment|
+            emit_segment(segment)
           end
         end
 
-        def emit_segment(segment, index)
+        # 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)
@@ -51,46 +112,60 @@ module ToSource
           end
         end
 
-        def array
-          node.array
-        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 = ':"'
-          CLOSE = '"'
+          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
 
-          handle(Rubinius::AST::DynamicRegex)
+        private
 
+          # Emit literal
+          #
+          # @param [String] literal
+          #
+          # @return [undefined]
+          #
+          # @api private
+          #
           def emit_literal(literal)
             emit(literal)
           end