unparser 0.0.1

data/lib/unparser/emitter/literal/regexp.rb

@@ -0,0 +1,96 @@
+module Unparser
+  class Emitter
+    class Literal
+
+      # Emitter for regexp literals
+      class Regexp < self
+        DELIMITER = '/'.freeze
+
+        handle :regexp
+
+      private
+
+        # Perform dispatch
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def dispatch
+          parentheses(DELIMITER, DELIMITER) do
+            visit(dynamic_body)
+          end
+          visit(children.last)
+        end
+
+        # Return dynamic body
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def dynamic_body
+          Parser::AST::Node.new(:dyn_regexp_body, dynamic_body_children)
+        end
+
+        # Return dynamic body children
+        #
+        # @return [Enumerable<Parser::AST::Node>]
+        #
+        # @api private
+        #
+        def dynamic_body_children
+          children[0..-2].map do |child|
+            escape(child)
+          end
+        end
+
+        # Return escaped child
+        #
+        # @return [Parser::AST::Node]
+        #
+        # @api private
+        #
+        def escape(child)
+          return child unless child.type == :str
+          source = child.children.first
+          Parser::AST::Node.new(:str, [Unparser.transquote(source, delimiter, DELIMITER)])
+        end
+
+        # Return closing delimiter
+        #
+        # @return [String]
+        #
+        # @api private
+        #
+        def delimiter
+          location = node.location
+          return DELIMITER unless location
+          location.expression.source[-1]
+        end
+        memoize :delimiter
+
+      end # Regexp
+
+      # Emitter for regexp options
+      class Regopt < self
+
+        handle :regopt
+
+      private
+
+        # Perform dispatch
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def dispatch
+          write(children.map(&:to_s).join)
+        end
+
+      end # Regopt
+
+    end # Literal
+  end # Emitter
+end # Unparser

data/lib/unparser/emitter/literal/singleton.rb

@@ -0,0 +1,24 @@
+module Unparser
+  class Emitter
+    class Literal
+      # Emiter for literal singletons
+      class Singleton < self
+
+        handle :self, :true, :false, :nil
+
+      private
+
+        # Perform dispatco
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def dispatch
+          buffer.append(node.type.to_s)
+        end
+
+      end # Singleton
+    end # Literal
+  end # Emitter
+end # Unparser

data/lib/unparser/emitter/literal.rb

@@ -0,0 +1,7 @@
+module Unparser
+  class Emitter
+    # Namespace class for literal emiters
+    class Literal < self
+    end # Literal
+  end # Emitter
+end # Unparser

data/lib/unparser/emitter/module.rb

@@ -0,0 +1,37 @@
+module Unparser
+  class Emitter
+    # Emitter for module nodes
+    class Module < self
+
+      handle :module
+
+      children :name, :body
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        write(K_MODULE, WS)
+        visit(name)
+        emit_body
+        k_end
+      end
+
+      # Emit body
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_body
+        emit_non_nil_body(body)
+      end
+
+    end # Module
+  end # Emitter
+end # Unparser

data/lib/unparser/emitter/next.rb

@@ -0,0 +1,22 @@
+module Unparser
+  class Emitter
+    # Emitter for next nodes
+    class Next < self
+
+      handle :next
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        write(K_NEXT)
+      end
+
+    end # Next
+  end # Emitter
+end # Unparser

data/lib/unparser/emitter/not.rb

@@ -0,0 +1,25 @@
+module Unparser
+  class Emitter
+    # Emitter for 1.8 only not node
+    class Not < self
+
+      handle :not
+
+      children :body
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        write(O_NEG)
+        visit(body)
+      end
+
+    end # Not
+  end # Emitter
+end # Unparser

data/lib/unparser/emitter/op_assign.rb

@@ -0,0 +1,63 @@
+module Unparser
+  class Emitter
+
+    # Base class for and and or op-assign
+    class BinaryAssign < self
+
+      children :target, :expression
+
+      MAP = IceNine.deep_freeze(
+        :and_asgn => '&&=',
+        :or_asgn  => '||='
+      )
+
+      handle *MAP.keys
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        visit(target)
+        write(WS, MAP.fetch(node.type), WS)
+        visit(expression)
+      end
+
+    end # BinaryAssign
+
+    # Emitter for op assign
+    class OpAssign < self
+
+      handle :op_asgn
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        visit(first_child)
+        emit_operator
+        visit(children[2])
+      end
+
+      # Emit operator
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_operator
+        write(WS, children[1].to_s, O_ASN, WS)
+      end
+
+    end # OpAssign
+  end # Emitte
+end # Unparser

data/lib/unparser/emitter/redo.rb

@@ -0,0 +1,22 @@
+module Unparser
+  class Emitter
+    # Emitter for redo nodes
+    class Redo < self
+
+      handle :redo
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        write(K_REDO)
+      end
+
+    end # Redo
+  end # Emitter
+end # Unparser

data/lib/unparser/emitter/repetition.rb

@@ -0,0 +1,33 @@
+module Unparser
+  class Emitter
+
+    # Base class for while and until emitters
+    class Repetition < self
+
+      MAP = {
+        :while => K_WHILE,
+        :until => K_UNTIL
+      }.freeze
+
+      handle *MAP.keys
+
+      children :condition, :body
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        write(MAP.fetch(node.type), WS)
+        visit(condition)
+        indented { visit(body) }
+        k_end
+      end
+
+    end # Repetition
+  end # Emitter
+end # Unparser

data/lib/unparser/emitter/retry.rb

@@ -0,0 +1,22 @@
+module Unparser
+  class Emitter
+    # Emitter for retry nodes
+    class Retry < self
+
+      handle :retry
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        write(K_RETRY)
+      end
+
+    end # Break
+  end # Emitter
+end # Unparser

data/lib/unparser/emitter/return.rb

@@ -0,0 +1,38 @@
+module Unparser
+  class Emitter
+    # Emitter for return nodes
+    class Return < self
+
+      handle :return
+
+      children :argument
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        write(K_RETURN)
+        emit_argument
+      end
+
+      # Emit argument
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_argument
+        return unless argument
+        parentheses do
+          visit(argument)
+        end
+      end
+
+    end # Return
+  end # Emitter
+end # Unparser

data/lib/unparser/emitter/root.rb

@@ -0,0 +1,7 @@
+module Unparser
+  class Emitter
+    Root = ::Class.new(self) do
+      def initialize(); end
+    end.send(:new)
+  end
+end

data/lib/unparser/emitter/send/binary.rb

@@ -0,0 +1,100 @@
+module Unparser
+  class Emitter
+    class Send
+      # Emitter for binary sends
+      class Binary < self
+
+      private
+
+        # Return undefined
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def dispatch
+          emit_receiver
+          emit_operator
+          emit_right
+        end
+
+        # Emit receiver
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def emit_receiver
+          emit_unambiguous_receiver
+          write(O_DOT) if parentheses?
+        end
+
+        # Emit operator 
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def emit_operator
+          parens = parentheses? ? EMPTY_STRING : WS
+          parentheses(parens, parens) { write(selector) }
+        end
+
+        # Return right node
+        #
+        # @return [Parser::AST::Node]
+        #
+        # @api private
+        #
+        def right_node
+          children[2]
+        end
+
+        # Test for splat argument
+        #
+        # @return [true]
+        #   if first argument is a splat
+        #
+        # @return [false]
+        #   otherwise
+        #
+        # @api private
+        #
+        def splat?
+          right_node.type == :splat
+        end
+
+        # Test if parentheses are needed
+        #
+        # @return [true]
+        #   if parenthes are needed
+        #
+        # @return [false]
+        #   otherwise
+        #
+        # @api private
+        #
+        def parentheses?
+          splat? || children.length >= 4
+        end
+        memoize :parentheses?
+
+        # Emit right
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def emit_right
+          node = right_node
+          if parentheses?
+            parentheses { delimited(children[2..-1]) }
+            return
+          end
+          visit(node)
+        end
+
+      end # Binary
+    end # Send
+  end # Emitter
+end # Unparser

data/lib/unparser/emitter/send/index.rb

@@ -0,0 +1,82 @@
+module Unparser
+  class Emitter
+    class Send
+      # Emitter for send to index references
+      class Index < self
+
+      private
+
+        # Perform dispatch
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def dispatch
+          emit_receiver
+          emit_arguments
+        end
+
+        # Emit block within parentheses
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def parentheses(&block)
+          super(*INDEX_PARENS, &block)
+        end
+
+        # Emit receiver
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def emit_receiver
+          visit(first_child)
+        end
+
+        # Emitter for index reference nodes
+        class Reference < self
+
+        private
+
+          # Emit arguments
+          #
+          # @return [undefined]
+          #
+          # @api private
+          #
+          def emit_arguments
+            parentheses do
+              delimited(arguments)
+            end
+          end
+        end # Reference
+
+        # Emitter for assign to index nodes
+        class Assign < self
+
+          # Emit arguments
+          #
+          # @return [undefined]
+          #
+          # @api private
+          #
+          def emit_arguments
+            index, *assignment = arguments
+            parentheses do
+              delimited([index])
+            end
+            return if assignment.empty? # mlhs
+            write(WS, O_ASN, WS)
+            delimited(assignment)
+          end
+
+        end # Assign
+
+      end # Index
+    end # Send
+  end # Emitter
+end # Unparser

data/lib/unparser/emitter/send/unary.rb

@@ -0,0 +1,29 @@
+module Unparser
+  class Emitter
+    class Send
+      # Emitter for unary sends
+      class Unary < self
+
+      private
+
+        MAP = IceNine.deep_freeze(
+          '-@' => '-',
+          '+@' => '+'
+        )
+
+        # Perform dispatch
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def dispatch
+          name = selector
+          write(MAP.fetch(name, name))
+          emit_unambiguous_receiver
+        end
+
+      end # Unary
+    end # Send
+  end # Emitter
+end # Unparser