to_source 0.1.3 → 0.2.16

data/lib/to_source/emitter/unary_operator_method.rb

@@ -0,0 +1,27 @@
+module ToSource
+  class Emitter
+    # Emitter for unary operator method
+    class UnaryOperatorMethod < Send
+
+      UNARY_MAPPING = {
+        :-@ => :-,
+        :+@ => :+,
+      }.freeze
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        name = node.name
+        emit(UNARY_MAPPING.fetch(name, name))
+        visit(receiver)
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/unless.rb

@@ -0,0 +1,45 @@
+module ToSource
+  class Emitter
+    # Emitter for unless
+    class Unless < self
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        emit('unless ')
+        visit(condition)
+        indented do
+          visit(else_body)
+        end
+        emit_end
+      end
+
+      # Emit condition
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def condition
+        node.condition
+      end
+
+      # Emit else
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def else_body
+        node.else
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/util.rb

@@ -0,0 +1,28 @@
+module ToSource
+  class Emitter
+    # base class for utility emitters
+    class Util < self
+      # Emitter for delimited bodies
+      class DelimitedBody < self
+
+      private
+
+        # Perform dispatch
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def dispatch
+          body = node
+          max = body.length - 1
+          body.each_with_index do |member, index|
+            visit(member)
+            emit(', ') if index < max
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/to_source/emitter/when.rb

@@ -0,0 +1,63 @@
+module ToSource
+  class Emitter
+    # Emitter for when nodes
+    class When < self
+
+      handle(Rubinius::AST::When)
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        emit('when ')
+        emit_single
+        emit_conditions
+        emit_splat
+        indented do
+          visit(node.body)
+        end
+      end
+
+      # Emit single
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_single
+        single = node.single
+        visit(single) if single
+      end
+
+      # Emit splat
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_splat
+        splat = node.splat
+        return unless splat
+        visit(splat)
+      end
+
+      # Emit conditions
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_conditions
+        conditions = node.conditions 
+        return unless conditions
+        run(Util::DelimitedBody, conditions.body)
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/yield.rb

@@ -0,0 +1,28 @@
+module ToSource
+  class Emitter
+    # Emitter for yield nodes
+    class Yield < self
+
+      handle(Rubinius::AST::Yield)
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        emit('yield')
+        arguments = node.arguments
+        unless arguments.array.empty?
+          emit('(')
+          visit(arguments)
+          emit(')')
+        end
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/z_super.rb

@@ -0,0 +1,24 @@
+module ToSource
+  class Emitter
+    # Emitter for zsuper nodes
+    class ZSuper < self
+
+      handle(Rubinius::AST::ZSuper)
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        emit('super')
+        block = node.block
+        visit(block) if block
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter.rb

@@ -0,0 +1,278 @@
+module ToSource
+  # Abstract base class for emitter
+  class Emitter
+    include Adamantium::Flat, Equalizer.new(:node)
+
+    # The emitter registry
+    REGISTRY = {}
+
+    # Build emitter for node
+    #
+    # @param [Rubinius::AST::Node] node
+    # @param [Array] buffer
+    #
+    # @return [Emitter]
+    #
+    # @api private
+    #
+    def self.build(node, buffer = [])
+      REGISTRY.fetch(node.class).new(node, buffer)
+    end
+
+    # Run emitter for node
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [String]
+    #
+    # @api private
+    #
+    def self.run(node)
+      build(node).source
+    end
+
+    # Declare predicates
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def self.predicate(*names)
+      names.each do |name|
+        define_predicate(name)
+      end
+    end
+
+    private_class_method :predicate
+
+    # Declare node delegators
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def self.delegate(*names)
+      names.each do |name|
+        define_delegator(name)
+      end
+    end
+
+    private_class_method :delegate
+
+    # Register emitter for node class
+    #
+    # @param [Class:Rubinius::AST::Node] node_class
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def self.handle(node_class)
+      REGISTRY[node_class]=self
+    end
+
+    private_class_method :handle
+
+    # Define node delegator
+    #
+    # @param [Symbol] name
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def self.define_delegator(name)
+      define_method(name) do
+        node.public_send(name)
+      end
+      private(name)
+    end
+
+    private_class_method :define_delegator
+
+    # Define predicate
+    #
+    # @param [Symbol] name
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def self.define_predicate(name)
+      predicate = :"#{name}?"
+      define_method(predicate) do
+        !!send(name)
+      end
+      private(predicate)
+    end
+
+    private_class_method :define_delegator
+
+    # Return buffer
+    #
+    # @return [Array<Command>]
+    #
+    # @api private
+    #
+    attr_reader :buffer
+
+    # Return node
+    #
+    # @return [Rubinius::AST::Node]
+    #
+    # @api private
+    # 
+    attr_reader :node
+
+    # Initialize object
+    #
+    # @param [Rubinius::AST::Node] node
+    # @param [Array<Command>] buffer
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def initialize(node, buffer)
+      @node, @buffer = node, buffer
+      dispatch
+    end
+
+    # Return source
+    #
+    # @return [String]
+    #
+    # @api private
+    #
+    def source
+      buffer.each_with_object(State.new) do |command, state|
+        state.execute(command)
+      end.source
+    end
+
+  private
+
+    # Push command
+    #
+    # @param [Command] command
+    #
+    # @return [undefined]
+    #
+    # @api private
+    # 
+    def push(command)
+      buffer.push(command)
+    end
+
+    # Emit new line
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def new_line
+      emit("\n")
+    end
+
+    # Emit single whitespace
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def space
+      emit(' ')
+    end
+
+    # Emit end keyword
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def emit_end
+      emit(:end)
+    end
+
+    # Push indent command
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def indent
+      push(Command::Shift::INDENT)
+    end
+
+    # Push unindent command
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def unindent
+      push(Command::Shift::UNINDENT)
+    end
+
+    # Push token with content
+    #
+    # @param [String] content
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def emit(content)
+      push(Command::Token.new(content))
+    end
+
+    # Run block indented
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def indented
+      indent
+      yield
+      unindent
+    end
+
+    # Run block in parantheses
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def parantheses
+      emit('(')
+      yield
+      emit(')')
+    end
+
+    # Visit descendant node
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def visit(node)
+      self.class.build(node, buffer)
+    end
+
+    # Run emitter on buffer
+    #
+    # @param [Class:Emitter] emitter
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def run(emitter, node = self.node)
+      emitter.new(node, buffer)
+    end
+  end
+end

data/lib/to_source/state.rb

@@ -0,0 +1,144 @@
+module ToSource
+  # Emitter state
+  class State
+
+    # Return last command
+    #
+    # @return [Command]
+    #
+    # @api private
+    #
+    attr_reader :last
+
+    # Return current indentation level
+    #
+    # @return [Fixnum]
+    #
+    # @api private
+    #
+    attr_reader :identation
+
+    # Return buffer
+    #
+    # @return [Array]
+    #
+    # @api private
+    #
+    attr_reader :buffer
+
+    # Initialize object
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def initialize
+      @last        = Command::NULL
+      @indentation = 0
+      @buffer      = []
+    end
+
+    # Execute command 
+    #
+    # @param [Command] command
+    #
+    # @return [self]
+    #
+    # @api private
+    #
+    def execute(command)
+      command.run(self)
+      @last = command
+      self
+    end
+
+    # Write string to buffer
+    #
+    # @param [String] string
+    #
+    # @return [self]
+    #
+    # @api private
+    #
+    def write(string)
+      @buffer << string
+      self
+    end
+
+    # Return source
+    #
+    # @return [String]
+    # 
+    # @api private
+    #
+    def source
+      buffer.join('')
+    end
+
+    # Push command
+    #
+    # @param [Command] command
+    #
+    # @return [self]
+    #
+    # @api private
+    #
+    def push(command)
+      indent
+      write(command.content)
+      self
+    end
+ 
+    # Indent line if needed
+    #
+    # @return [self]
+    #
+    # @api private
+    #
+    def indent
+      return unless blank?
+      write(' ' * @indentation)
+      self
+    end
+
+    # Test for blank line
+    #
+    # @return [true]
+    #   if line is blank
+    #
+    # @return [false]
+    #   otherwise
+    #
+    # @api private
+    #
+    def blank?
+      buffer.last == "\n"
+    end
+
+    # Write newline
+    #
+    # @return [self]
+    #
+    # @api private
+    #
+    def new_line
+      write("\n")
+      self
+    end
+
+    # Perform shift by width
+    #
+    # @param [Fixnum] width
+    #
+    # @return [self]
+    #
+    # @api private
+    #
+    def shift(width)
+      @indentation += width
+      @indentation = 0 if @indentation < 0
+      new_line
+    end
+
+  end
+end