unparser 0.0.1

data/lib/unparser/emitter.rb

@@ -0,0 +1,308 @@
+module Unparser
+
+  # Emitter base class
+  class Emitter
+    include Adamantium::Flat, AbstractType, Constants
+    include Equalizer.new(:node, :buffer, :parent)
+
+    # Registry for node emitters
+    REGISTRY = {}
+
+    DEFAULT_DELIMITER = ', '.freeze
+
+    CURLY_BRACKETS = IceNine.deep_freeze(%w({ }))
+
+    # Create name helpers
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def self.children(*names)
+      names.each_with_index do |name, index|
+        define_method(name) do
+          children[index]
+        end
+        private name
+      end
+    end
+    private_class_method :children
+
+    # Register emitter for type
+    #
+    # @param [Symbol] type
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def self.handle(*types)
+      types.each do |type|
+        REGISTRY[type] = self
+      end
+    end
+    private_class_method :handle
+
+    # Emit node into buffer
+    #
+    # @return [self]
+    #
+    # @api private
+    #
+    def self.emit(*arguments)
+      new(*arguments)
+      self
+    end
+
+    # Initialize object
+    #
+    # @param [Parser::AST::Node] node
+    # @param [Buffer] buffer
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def initialize(node, buffer, parent)
+      @node, @buffer, @parent = node, buffer, parent
+      dispatch
+    end
+
+    private_class_method :new
+
+    # Visit node
+    #
+    # @param [Parser::AST::Node] node
+    # @param [Buffer] buffer
+    #
+    # @return [Emitter]
+    #
+    # @api private
+    #
+    def self.visit(node, buffer, parent = Root)
+      type = node.type
+      emitter = REGISTRY.fetch(type) do
+        raise ArgumentError, "No emitter for node: #{type.inspect}"
+      end
+      emitter.emit(node, buffer, parent)
+      self
+    end
+
+    # Test if node needs begin
+    #
+    # @return [true]
+    #   if if node needs begin
+    #
+    # @return [false]
+    #   otherwise
+    #
+    # @api private
+    #
+    def needs_begin?
+      false
+    end
+
+    # Return node
+    #
+    # @return [Parser::AST::Node] node
+    #
+    # @api private
+    #
+    attr_reader :node
+
+  private
+
+    # Return buffer
+    #
+    # @return [Buffer] buffer
+    #
+    # @api private
+    #
+    attr_reader :buffer
+    protected :buffer
+
+    # Return parent emitter
+    #
+    # @return [Parent]
+    #
+    # @api private
+    #
+    attr_reader :parent
+    protected :parent
+
+    # Emit contents of block within parentheses
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def parentheses(open=M_PO, close=M_PC)
+      write(open)
+      yield
+      write(close)
+    end
+
+    # Emit nodes source map
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def emit_source_map
+      SourceMap.emit(node, buffer)
+    end
+
+    # Dispatch helper
+    #
+    # @param [Parser::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def visit(node)
+      self.class.visit(node, buffer, self)
+    end
+
+    # Emit delimited body
+    #
+    # @param [Enumerable<Parser::AST::Node>] nodes
+    # @param [String] delimiter
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def delimited(nodes, delimiter = DEFAULT_DELIMITER)
+      max = nodes.length - 1
+      nodes.each_with_index do |node, index|
+        visit(node)
+        write(delimiter) if index < max
+      end
+    end
+
+    # Return children of node
+    #
+    # @return [Array<Parser::AST::Node>]
+    #
+    # @api private
+    #
+    def children
+      node.children
+    end
+
+    # Write newline
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def nl
+      buffer.nl
+    end
+
+    # Write strings into buffer
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def write(*strings)
+      strings.each do |string|
+        buffer.append(string)
+      end
+    end
+
+    # Write begin keyword
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def k_begin
+      write(K_BEGIN)
+    end
+
+    # Write end keyword
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def k_end
+      write(K_END)
+    end
+
+    # Return first child
+    #
+    # @return [Parser::AST::Node]
+    #   if present
+    #
+    # @return [nil]
+    #   otherwise
+    #
+    # @api private
+    #
+    def first_child
+      children.first
+    end
+
+    # Write whitespace
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def ws
+      write(WS)
+    end
+
+    # Call emit contents of block indented
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def indented
+      buffer = self.buffer
+      buffer.indent
+      yield
+      buffer.unindent
+    end
+
+    # Emit non nil body
+    #
+    # @param [Parser::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def emit_non_nil_body(node)
+      if node.type == :nil
+        nl
+        return
+      end
+      indented { visit(node) }
+    end
+
+    # Emitter that fully relies on parser source maps
+    class SourceMap < self
+
+      # Perform dispatch
+      #
+      # @param [Node] node
+      # @param [Buffer] buffer
+      #
+      # @return [self]
+      #
+      # @api private
+      #
+      def self.emit(node, buffer)
+        buffer.append(node.location.expression.source)
+        self
+      end
+
+    end # SourceMap
+  end # Emitter
+end # Unparser

data/lib/unparser.rb

@@ -0,0 +1,87 @@
+require 'abstract_type'
+require 'concord'
+require 'parser/all'
+
+# Library namespace
+module Unparser
+
+  EMPTY_STRING = ''.freeze
+
+  # Unparse ast into string
+  #
+  # @param [Parser::Node] node
+  #
+  # @return [String]
+  #
+  # @api private
+  #
+  def self.unparse(node)
+    buffer = Buffer.new
+    Emitter.visit(node, buffer)
+    buffer.content
+  end
+
+  # Transquote string
+  #
+  # @param [String] raw_quoted
+  # @param [String] current_delimiter
+  # @param [String] target_delimiter
+  #
+  # @return [String]
+  #
+  # @api private
+  #
+  def self.transquote(raw_quoted, current_delimiter, target_delimiter)
+    raw = raw_quoted.gsub("\\#{current_delimiter}", current_delimiter)
+    raw.gsub(target_delimiter, "\\#{target_delimiter}").freeze
+  end
+
+end # Unparser
+
+require 'unparser/buffer'
+require 'unparser/constants'
+require 'unparser/emitter'
+require 'unparser/emitter/literal'
+require 'unparser/emitter/literal/primitive'
+require 'unparser/emitter/literal/singleton'
+require 'unparser/emitter/literal/dynamic'
+require 'unparser/emitter/literal/regexp'
+require 'unparser/emitter/literal/composed'
+require 'unparser/emitter/literal/range'
+require 'unparser/emitter/literal/dynamic_body'
+require 'unparser/emitter/literal/execute_string'
+require 'unparser/emitter/send'
+require 'unparser/emitter/send/unary'
+require 'unparser/emitter/send/binary'
+require 'unparser/emitter/send/index'
+require 'unparser/emitter/block'
+require 'unparser/emitter/assignment'
+require 'unparser/emitter/variable'
+require 'unparser/emitter/splat'
+require 'unparser/emitter/cbase'
+require 'unparser/emitter/argument'
+require 'unparser/emitter/begin'
+require 'unparser/emitter/return'
+require 'unparser/emitter/undef'
+require 'unparser/emitter/def'
+require 'unparser/emitter/class'
+require 'unparser/emitter/module'
+require 'unparser/emitter/op_assign'
+require 'unparser/emitter/defined'
+require 'unparser/emitter/hookexe'
+require 'unparser/emitter/super'
+require 'unparser/emitter/break'
+require 'unparser/emitter/retry'
+require 'unparser/emitter/redo'
+require 'unparser/emitter/next'
+require 'unparser/emitter/if'
+require 'unparser/emitter/alias'
+require 'unparser/emitter/yield'
+require 'unparser/emitter/not'
+require 'unparser/emitter/binary'
+require 'unparser/emitter/case'
+require 'unparser/emitter/for'
+require 'unparser/emitter/repetition'
+require 'unparser/emitter/root'
+
+Unparser::Emitter::REGISTRY.freeze