to_source 0.2.15 → 0.2.16

data/lib/to_source/emitter/access.rb

@@ -1,5 +1,7 @@
 module ToSource
   class Emitter
+
+    # Emitter for various access nodes
     class Access < self
 
       handle(Rubinius::AST::ConstantAccess)
@@ -11,6 +13,12 @@ module ToSource
 
     private
 
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      # 
       def dispatch
         emit(node.name)
       end

data/lib/to_source/emitter/actual_arguments.rb

@@ -1,40 +1,83 @@
 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? or splat?
+        normal? || splat?
       end
 
     private
 
+      # Perform dispatch
+      #
+      # @return [self]
+      #
+      # @api private
+      #
       def dispatch
         emit_normal
         emit_splat
       end
 
-      def array
-        node.array
-      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
 
-      def splat
-        node.splat
-      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?

data/lib/to_source/emitter/alias.rb

@@ -1,16 +1,25 @@
 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(node.to.value)
+        emit(to.value)
         space
-        emit(node.from.value)
+        emit(from.value)
       end
 
     end

data/lib/to_source/emitter/assignment.rb

@@ -1,11 +1,20 @@
 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_name
+        emit_target
         val = value
 
         if val
@@ -14,20 +23,26 @@ module ToSource
         end
       end
 
-      def value
-        node.value
-      end
-
+      # Emitter for constant assignments
       class Constant < self
 
         handle(Rubinius::AST::ConstantAssignment)
 
-        def emit_name
+      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)
@@ -35,42 +50,67 @@ module ToSource
         handle(Rubinius::AST::GlobalVariableAssignment)
         handle(Rubinius::AST::ClassVariableAssignment)
 
-        def emit_name
-          emit(node.name)
-        end
+      private
 
-        def name
-          node.name
+        # 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
-        emit('(')
-        visit(node.left)
-        space
-        emit(self.class::SYMBOL)
-        space
-        emit('(')
-        visit(node.right.value)
-        emit(')')
-        emit(')')
+        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
 
-        SYMBOL = :'||='
         handle(Rubinius::AST::OpAssignOr19)
+        SYMBOL = :'||='
 
       end
 
+      # Emitter for and assigmnent operator
       class And < self
 
-        SYMBOL = :'&&='
         handle(Rubinius::AST::OpAssignAnd)
+        SYMBOL = :'&&='
 
       end
 

data/lib/to_source/emitter/attribute_assignment.rb

@@ -1,15 +1,24 @@
 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(node.receiver)
+        visit(receiver)
         emit('.')
-        emit(node.name)
+        emit(name)
         space
         visit(node.arguments.array.first)
       end

data/lib/to_source/emitter/begin.rb

@@ -1,45 +1,65 @@
 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
-
-        if body.kind_of?(Rubinius::AST::Rescue)
+        case body
+        when Rubinius::AST::Rescue
           emit_rescue(body)
-          return
-        end
-
-        if body.kind_of?(Rubinius::AST::Ensure)
+        when Rubinius::AST::Ensure
           emit_ensure(body)
-          return
+        else
+          visit(body)
+          unindent
         end
-
-        visit(body)
-        unindent
       end
 
+      # Emit ensure
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
       def emit_ensure(node)
         visit(node.body)
         unindent
         emit(:ensure)
-        indent
-        visit(node.ensure)
-        unindent
+        indented do
+          visit(node.ensure)
+        end
       end
 
+      # Emit rescue
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
       def emit_rescue(node)
         visit(node.body)
         unindent

data/lib/to_source/emitter/binary_operator.rb

@@ -1,44 +1,61 @@
 module ToSource
   class Emitter
+    # Base class for binary operator emitters
     class BinaryOperator < self
 
     private
 
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
       def dispatch
-        emit('(')
-        emit_left
-        space
-        emit(self.class::SYMBOL)
-        space
-        emit_right
-        emit(')')
+        parantheses do
+          emit_left
+          emit(" #{self.class::SYMBOL} ")
+          emit_right
+        end
       end
 
+      # Emit left
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
       def emit_left
-        emit('(')
-        visit(node.left)
-        emit(')')
+        parantheses do 
+          visit(node.left)
+        end
       end
 
+      # Emit right
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
       def emit_right
-        emit('(')
-        visit(node.right)
-        emit(')')
+        parantheses do
+          visit(node.right)
+        end
       end
 
+      # Emitter for binary or operator
       class Or < self
 
-        SYMBOL = :'||'
-
         handle(Rubinius::AST::Or)
+        SYMBOL = :'||'
 
       end
 
+      # Emitter for binary and operator
       class And < self
 
-        SYMBOL = :'&&'
-
         handle(Rubinius::AST::And)
+        SYMBOL = :'&&'
 
       end
     end