unparser 0.0.1

data/lib/unparser/emitter/assignment.rb

@@ -0,0 +1,140 @@
+module Unparser
+  class Emitter
+
+    # Base class for assignment emitters
+    class Assignment < self
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        emit_left
+        emit_right
+      end
+
+      # Single assignment emitter
+      class Single < self
+
+        # Emit right
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def emit_right
+          right = right_node
+          if right
+            write(WS, O_ASN, WS)
+            visit(right)
+          end
+        end
+
+        abstract_method :emit_left
+
+        # Variable assignment emitter
+        class Variable < self
+
+          handle :lvasgn, :ivasgn, :cvasgn, :gvasgn
+
+          children :name, :right_node
+
+        private
+
+          # Emit left
+          #
+          # @return [undefined]
+          #
+          # @api private
+          #
+          def emit_left
+            write(name.to_s)
+          end
+
+        end # Variable
+
+        # Constant assignment emitter
+        class Constant < self
+
+
+          handle :casgn
+
+          children :base, :name, :right_node
+
+        private
+
+          # Emit left
+          #
+          # @return [undefined]
+          #
+          # @api private
+          #
+          def emit_left
+            visit(base) if base
+            write(name.to_s)
+          end
+
+        end # Constant
+      end # Single
+
+      # Multiple assignment
+      class Multiple < self
+
+        handle :masgn
+
+      private
+
+        # Emit left
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def emit_left
+          visit(first_child)
+        end
+
+        # Emit right
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def emit_right
+          write(WS, O_ASN, WS)
+          right = children.last
+          case right.type
+          when :array
+            delimited(right.children)
+          else
+            visit(right)
+          end
+        end
+
+      end # Multiple
+
+      # Emitter for multiple assignment left hand side
+      class MLHS < Emitter
+
+        handle :mlhs
+
+      private
+
+        # Perform dispatch
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def dispatch
+          delimited(children)
+        end
+      end # MLHS
+
+    end # Assignment
+  end # Emitter
+end # Unparser

data/lib/unparser/emitter/begin.rb

@@ -0,0 +1,179 @@
+module Unparser
+  class Emitter
+
+    # Emitter for rescue nodes
+    class Rescue < self
+
+      handle :rescue
+
+      children :body
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        k_begin
+        indented { visit(body) }
+        children[1..-2].each do |child|
+          visit(child)
+        end
+        k_end
+      end
+    end # Rescue
+
+    # Emitter for enusre nodes
+    class Ensure < self
+
+      handle :ensure
+
+      children :body, :ensure_body
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        k_begin
+        emit_body
+        write(K_ENSURE)
+        emit_ensure_body
+        k_end
+      end
+
+      # Emit body
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_body
+        indented { visit(body) }
+      end
+
+      # Emit ensure body
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_ensure_body
+        indented { visit(ensure_body) }
+      end
+
+    end # Ensure
+
+    # Emitter for rescue body nodes
+    class Resbody < self
+
+      handle :resbody
+
+      children :exception, :assignment, :body
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        write(K_RESCUE)
+        emit_exception
+        emit_assignment
+        indented { visit(body) }
+      end
+
+      # Emit exception
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_exception
+        return unless exception
+        ws
+        delimited(exception.children)
+      end
+
+      # Emit assignment
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_assignment
+        return unless assignment
+        write(WS, O_ASR, WS)
+        visit(assignment)
+      end
+
+    end # Resbody
+
+    # Emitter for begin nodes
+    class Begin < self
+
+      handle :begin
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        case children.length
+        when 0
+          write(K_NIL)
+        when 1
+          visit(first_child)
+        else
+          emit_normal
+        end
+      end
+
+      # Emit normal begin block
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_normal
+        unless parent.needs_begin?
+          emit_inner
+        else
+          k_begin
+          indented { emit_inner }
+          k_end
+        end
+      end
+
+      # Emit inner nodes
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_inner
+        childs = children
+        max = childs.length - 1
+        childs.each_with_index do |child, index|
+          visit(child)
+          nl if index < max
+        end
+      end
+
+    end # Body
+  end # Emitter
+end # Unparser

data/lib/unparser/emitter/binary.rb

@@ -0,0 +1,52 @@
+module Unparser
+  class Emitter
+    # Base class for binary emitters
+    class Binary < self
+
+      handle :or, :and
+      children :left, :right
+
+      MAP = {
+        :or => O_OR,
+        :and => O_AND
+      }.freeze
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        parentheses do
+          emit_left
+          write(WS, MAP.fetch(node.type), WS)
+          emit_right
+        end
+      end
+
+      # Emit left
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_left
+        parentheses { visit(left) }
+      end
+
+      # Emit right
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_right
+        parentheses { visit(right) }
+      end
+
+    end # Binary
+  end # Emitter
+end # Unparser

data/lib/unparser/emitter/block.rb

@@ -0,0 +1,53 @@
+module Unparser
+  class Emitter
+
+    # Block emitter
+    class Block < self
+
+      handle :block
+
+      children :send, :arguments, :body
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        visit(send)
+        write(WS, K_DO)
+        emit_block_arguments
+        indented { emit_body }
+        k_end
+      end
+
+      # Emit arguments
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_block_arguments
+        return if arguments.children.empty?
+        ws
+        parentheses(O_PIPE, O_PIPE) do
+          visit(arguments)
+        end
+      end
+
+      # Emit body
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_body
+        visit(body)
+      end
+
+    end # Block
+  end # Emitter
+end # Unparser

data/lib/unparser/emitter/break.rb

@@ -0,0 +1,28 @@
+module Unparser
+  class Emitter
+    # Emitter for break nodes
+    class Break < self
+
+      handle :break
+
+      children :arguments
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        write(K_BREAK)
+        return unless arguments
+        parentheses do
+          visit(arguments)
+        end
+      end
+
+    end # Break
+  end # Emitter
+end # Unparser

data/lib/unparser/emitter/case.rb

@@ -0,0 +1,97 @@
+module Unparser
+  class Emitter
+    # Emitter for case nodes
+    class Case < self
+
+      handle :case
+
+      children :condition
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        write(K_CASE)
+        emit_condition
+        emit_whens
+        emit_else
+        k_end
+      end
+
+      # Emit else
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_else
+        else_branch = children.last
+        return unless else_branch
+        write(K_ELSE)
+        indented { visit(else_branch) }
+      end
+
+      # Emit whens
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_whens
+        nl
+        children[1..-2].each do |child|
+          visit(child)
+        end
+      end
+
+      # Emit condition
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_condition
+        return unless condition
+        write(WS)
+        visit(condition)
+      end
+
+    end # Case
+
+    # Emitter for when nodes
+    class When < self
+
+      handle :when
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        write(K_WHEN, WS)
+        emit_captures
+        indented { visit(children.last) }
+      end
+
+      # Emit captures
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_captures
+        delimited(children[0..-2])
+      end
+
+    end
+  end # Emitter
+end # Unparser

data/lib/unparser/emitter/cbase.rb

@@ -0,0 +1,22 @@
+module Unparser
+  class Emitter
+    # Emitter for toplevel constant reference nodes
+    class CBase < self
+
+      handle :cbase
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        write(O_DCL)
+      end
+
+    end # CBase
+  end # Emitter
+end # Unparser

data/lib/unparser/emitter/class.rb

@@ -0,0 +1,72 @@
+module Unparser
+  class Emitter
+    # Emitter for class nodes
+    class Class < self
+
+      handle :class
+
+      children :name, :superclass, :body
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        write(K_CLASS, WS)
+        visit(name)
+        emit_superclass
+        emit_body
+        k_end
+      end
+
+      # Emit superclass
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_superclass
+        return unless superclass
+        write(WS, O_LT, WS)
+        visit(superclass)
+      end
+
+      # Emit body
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_body
+        emit_non_nil_body(body)
+      end
+
+    end # Class
+
+    # Emitter for sclass nodes
+    class SClass  < self
+
+      handle :sclass
+
+      children :object, :body
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        write(K_CLASS, WS, O_DLT, WS)
+        visit(object)
+        emit_non_nil_body(body)
+        k_end
+      end
+
+    end # SClass
+  end # Emitter
+end # Unparser