unparser 0.0.1

data/lib/unparser/emitter/def.rb

@@ -0,0 +1,107 @@
+module Unparser
+  class Emitter
+    # Emitter for def node
+    class Def < self
+
+    private
+
+      # Emit name
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      abstract_method :emit_name
+      private :emit_name
+
+      # Return body node
+      #
+      # @return [Parser::AST::Node]
+      #
+      # @api private
+      #
+      abstract_method :body
+      private :body
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        write(K_DEF, WS)
+        emit_name
+        emit_arguments
+        emit_body
+        k_end
+      end
+
+      # Emit body
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_body
+        indented { visit(body) }
+      end
+
+      # Emit arguments
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_arguments
+        return if arguments.children.empty?
+        parentheses do
+          visit(arguments)
+        end
+      end
+
+      # Instance def emitter
+      class Instance < self
+
+        handle :def
+
+        children :name, :arguments, :body
+
+      private
+
+        # Emit name
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def emit_name
+          write(name.to_s)
+        end
+
+      end # Instance
+
+      # Emitter for defines on singleton
+      class Singleton < self
+
+        handle :defs
+
+        children :subject, :name, :arguments, :body
+
+      private
+
+        # Return mame
+        #
+        # @return [String]
+        #
+        # @api private
+        #
+        def emit_name
+          visit(subject)
+          write(O_DOT, name.to_s)
+        end
+
+      end # Singleton
+    end # Def
+  end # Emitter
+end # Unparser

data/lib/unparser/emitter/defined.rb

@@ -0,0 +1,27 @@
+module Unparser
+  class Emitter
+    # Emitter for defined? nodes
+    class Defined < self
+
+      handle :defined?
+
+      children :subject
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        write(K_DEFINED)
+        parentheses do
+          visit(subject)
+        end
+      end
+
+    end # Defined
+  end # Emitter
+end # Unparser

data/lib/unparser/emitter/for.rb

@@ -0,0 +1,50 @@
+module Unparser
+  class Emitter
+    # Emitter for for nodes
+    class For < self
+
+      handle :for
+
+      children :condition, :assignment, :body
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        write(K_FOR, WS)
+        emit_condition
+        emit_body
+        k_end
+      end
+
+      # Emit assignment
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_condition
+        visit(condition)
+        write(WS, K_IN, WS)
+        visit(assignment)
+        write(WS, K_DO)
+      end
+
+      # Emit body
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_body
+        indented { visit(body) }
+      end
+
+    end # For
+  end # Emitter
+end # Unparser

data/lib/unparser/emitter/hookexe.rb

@@ -0,0 +1,42 @@
+module Unparser
+  class Emitter
+    # Base class for pre and postexe emitters
+    class Hookexe < self
+
+      MAP = {
+        :preexe  => K_PREEXE,
+        :postexe => K_POSTEXE
+      }.freeze
+
+      handle *MAP.keys
+
+      children :body
+
+    private
+
+      # Perfrom dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        write(MAP.fetch(node.type), WS)
+        parentheses(*CURLY_BRACKETS) do
+          emit_body
+        end
+      end
+
+      # Emit body
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_body
+        indented { visit(body) }
+      end
+
+    end # Hookexe
+  end # Emitter
+end # Unparser

data/lib/unparser/emitter/if.rb

@@ -0,0 +1,85 @@
+module Unparser
+  class Emitter
+    # Emitter if nodes
+    class If < self
+
+      handle :if
+
+      children :condition, :if_branch, :else_branch
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        write(keyword, WS)
+        emit_condition
+        emit_if_branch
+        emit_else_branch
+        k_end
+      end
+
+      # Test for unless
+      #
+      # @return [true]
+      #   if to emit as unless
+      #
+      # @return [false]
+      #   otherwise
+      #
+      # @api private
+      #
+      def unless?
+        !if_branch
+      end
+
+      # Return keyword
+      #
+      # @return [String]
+      #
+      # @api private
+      #
+      def keyword
+        unless? ? K_UNLESS : K_IF
+      end
+
+      # Emit condition
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_condition
+        visit(condition)
+      end
+
+      # Emit if branch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_if_branch
+        return unless if_branch
+        indented { visit(if_branch) }
+      end
+
+      # Emit else branch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_else_branch
+        return unless else_branch
+        write(K_ELSE) unless unless?
+        indented { visit(else_branch) }
+      end
+
+    end # If
+  end # Emitter
+end # Unparser

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

@@ -0,0 +1,64 @@
+module Unparser
+  class Emitter
+    class Literal
+
+      # Emitter for hash keyvalue pair
+      class HashPair < self
+        HASHROCKET = ' => '.freeze
+
+        handle :pair
+
+      private
+
+        # Perform dispatch
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def dispatch
+          delimited(children, HASHROCKET)
+        end
+
+      end # HashPair
+
+      # Base class for compound literal emitters
+      class Compound < self
+
+      private
+
+        # Perform dispatch
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def dispatch
+          util = self.class
+          parentheses(util::OPEN, util::CLOSE) do
+            delimited(children, util::DELIMITER)
+          end
+        end
+
+        # Hash literal emitter
+        class Hash < self
+          OPEN      = '{'.freeze
+          CLOSE     = '}'.freeze
+          DELIMITER = ', '.freeze
+
+          handle :hash
+        end # Hash
+
+        # Array literal emitter
+        class Array < self
+          OPEN = '['.freeze
+          CLOSE = ']'.freeze
+          DELIMITER = ', '.freeze
+
+          handle :array
+        end # Array
+
+      end # Compound
+    end # Literal
+  end # Emitter
+end # Unparser

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

@@ -0,0 +1,54 @@
+module Unparser
+  class Emitter
+    class Literal
+
+      # Base class for dynamic literal emitters
+      class Dynamic < self
+
+      private
+
+        # Perform dispatch
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def dispatch
+          util = self.class
+          parentheses(util::OPEN, util::CLOSE) do
+            visit(dynamic_body)
+          end
+        end
+
+        # Return dynamic body
+        #
+        # @return [Parser::AST::Node]
+        #
+        # @api private
+        #
+        def dynamic_body
+          Parser::AST::Node.new(:dyn_str_body, children)
+        end
+
+        # Dynamic string literal emitter
+        class String < self
+
+          OPEN = CLOSE = '"'.freeze
+          handle :dstr
+
+        end # String
+
+        # Dynamic symbol literal emitter
+        class Symbol < self
+
+          OPEN = ':"'.freeze
+          CLOSE = '"'.freeze
+
+          handle :dsym
+
+        end # Symbol
+
+      end
+    end # Literal
+  end # Emitter
+end # Unparser

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

@@ -0,0 +1,109 @@
+module Unparser
+  class Emitter
+    class Literal
+
+      # Emitter for dynamic bodies
+      class DynamicBody < self
+
+        OPEN = '#{'.freeze
+        CLOSE = '}'.freeze
+
+      private
+
+        # Perform dispatch
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def dispatch
+          children.each do |node|
+            emit_segment(node)
+          end
+        end
+
+        # Emit segment
+        #
+        # @param [Parser::Node] node
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def emit_segment(node)
+          if node.type == :str
+            emit_str_segment(node)
+            return
+          end
+          emit_interpolated_segment(node)
+        end
+
+        ESCAPES = IceNine.deep_freeze(
+          "\n" => '\n'
+        )
+
+        REPLACEMENTS = ::Regexp.union(ESCAPES.keys)
+
+        # Emit str segment
+        #
+        # @param [Parser::Node] node
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def emit_str_segment(node)
+          util = self.class
+          str = node.children.first
+          str = str.
+            gsub(util::DELIMITER, util::REPLACEMENT).
+            gsub(REPLACEMENTS, ESCAPES)
+          write(str)
+        end
+
+        # Emit interpolated segment
+        #
+        # @param [Parser::Node] node
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def emit_interpolated_segment(node)
+          parentheses(OPEN, CLOSE) { visit(node) }
+        end
+
+        # Dynamic string body
+        class String < self
+
+          handle :dyn_str_body
+
+          DELIMITER   = '"'.freeze
+          REPLACEMENT = '\"'.freeze
+
+        end # String
+
+        # Dynamic regexp body
+        class Regexp < self
+
+          handle :dyn_regexp_body
+
+          DELIMITER   = '/'.freeze
+          REPLACEMENT = '/'.freeze
+
+        end # Regexp
+
+        # Dynamic regexp body
+        class ExecuteString < self
+
+          handle :dyn_xstr_body
+
+          DELIMITER   = '`'.freeze
+          REPLACEMENT = '\`'.freeze
+
+        end # ExecuteString
+
+      end # DynamicBody
+    end # Literal
+  end # Emitter
+end # Unparser

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

@@ -0,0 +1,38 @@
+module Unparser
+  class Emitter
+    class Literal
+      # Emitter for execute strings (xstr) nodes
+      class ExecuteString < self
+
+        OPEN = CLOSE = '`'.freeze
+
+        handle :xstr
+
+      private
+
+        # Perform dispatch
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def dispatch
+          parentheses(OPEN, CLOSE) do
+            visit(dynamic_body)
+          end
+        end
+
+        # Return dynamic body
+        #
+        # @return [Parser::AST::Node]
+        #
+        # @api private
+        #
+        def dynamic_body
+          Parser::AST::Node.new(:dyn_xstr_body, children)
+        end
+
+      end # ExecuteString
+    end # Literal
+  end # Emitter
+end # Unparser

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

@@ -0,0 +1,49 @@
+module Unparser
+  class Emitter
+    class Literal
+
+      # Base class for primitive emitters
+      class Primitive < self
+
+        children :value
+
+      private
+
+        # Dispatch node
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def dispatch
+          if node.location
+            emit_source_map
+          else
+            dispatch_value
+          end
+        end
+
+        abstract_method :disaptch_value
+
+        # Emitter for primitives based on Object#inspect
+        class Inspect < self
+
+          handle :int, :str, :float, :sym
+
+        private
+
+          # Dispatch value
+          #
+          # @return [undefined]
+          #
+          # @api private
+          #
+          def dispatch_value
+            buffer.append(value.inspect)
+          end
+
+        end # Inspect
+      end # Primitive
+    end # Literal
+  end # Emitter
+end # Unparser

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

@@ -0,0 +1,33 @@
+module Unparser
+  class Emitter
+    class Literal
+      # Abstract base class for literal range emitter
+      class Range < self
+
+        TOKENS = IceNine.deep_freeze(
+          :irange => '..',
+          :erange => '...'
+        )
+
+        handle *TOKENS.keys
+
+        children :begin_node, :end_node
+
+      private
+
+        # Perform dispatch
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def dispatch
+          visit(begin_node)
+          write(TOKENS.fetch(node.type))
+          visit(end_node)
+        end
+
+      end # Range
+    end # Literal
+  end # Emitter
+end # Unparser