to_source 0.2.9 → 0.2.11

data/lib/to_source/emitter/splat.rb

@@ -0,0 +1,17 @@
+module ToSource
+  class Emitter
+    class Splat < self
+
+      handle(Rubinius::AST::SplatValue)
+      handle(Rubinius::AST::RescueSplat)
+
+    private
+
+      def dispatch
+        emit('*')
+        visit(node.value)
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/splat_when.rb

@@ -0,0 +1,16 @@
+module ToSource
+  class Emitter
+    class SplatWhen < self
+
+      handle(Rubinius::AST::SplatWhen)
+
+    private
+
+      def dispatch
+        emit('*')
+        visit(node.condition)
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/static.rb

@@ -0,0 +1,33 @@
+module ToSource
+  class Emitter
+    class Static < self
+
+    private
+
+      def dispatch
+        emit(self.class::SYMBOL)
+      end
+
+      class Next < self
+        handle(Rubinius::AST::Next)
+        SYMBOL = :next
+      end
+
+      class CurrentException < self
+        handle(Rubinius::AST::CurrentException)
+        SYMBOL = :'$!'
+      end
+
+      class Self < self
+        handle(Rubinius::AST::Self)
+        SYMBOL = :self
+      end
+
+      class File < self
+        handle(Rubinius::AST::File)
+        SYMBOL = :__FILE__
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/super.rb

@@ -0,0 +1,47 @@
+module ToSource
+  class Emitter
+    class Super < self
+
+      handle(Rubinius::AST::Super)
+
+    private
+
+      def dispatch
+        emit('super')
+        emit_arguments
+        emit_block
+      end
+
+      def emit_arguments
+        emit('(')
+        emitter = visit(node.arguments)
+        emit_block_pass(emitter)
+        emit(')')
+      end
+
+      def block
+        node.block
+      end
+
+      def block?
+        !!block
+      end
+
+      def block_pass?
+        block.kind_of?(Rubinius::AST::BlockPass19)
+      end
+
+      def emit_block_pass(emitter)
+        return unless block? and block_pass?
+        emit(', ') if emitter.any?
+        visit(block)
+      end
+
+      def emit_block
+        return unless block? and !block_pass?
+        visit(block)
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/to_array.rb

@@ -0,0 +1,15 @@
+module ToSource
+  class Emitter
+    class ToArray < self
+
+      handle(Rubinius::AST::ToArray)
+
+    private
+
+      def dispatch
+        visit(node.value)
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/to_string.rb

@@ -0,0 +1,17 @@
+module ToSource
+  class Emitter
+    class ToString < self
+
+      handle(Rubinius::AST::ToString)
+
+    private
+
+      def dispatch
+        emit('#{')
+        visit(node.value)
+        emit('}')
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/toplevel.rb

@@ -0,0 +1,15 @@
+module ToSource
+  class Emitter
+    class Toplevel < self
+
+      handle(Rubinius::AST::ToplevelClassName)
+      handle(Rubinius::AST::ToplevelConstant)
+
+      def dispatch
+        emit('::')
+        emit(node.name)
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/unary_operator_method.rb

@@ -0,0 +1,20 @@
+module ToSource
+  class Emitter
+    class UnaryOperatorMethod < self
+
+      UNARY_MAPPING = {
+        :-@ => :-,
+        :+@ => :+,
+      }.freeze
+
+    private
+
+      def dispatch
+        name = node.name
+        emit(UNARY_MAPPING.fetch(name, name))
+        visit(node.receiver)
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/unless.rb

@@ -0,0 +1,16 @@
+module ToSource
+  class Emitter
+    class Unless < self
+      
+      def dispatch
+        emit('unless ')
+        visit(node.condition)
+        indent
+        visit(node.else)
+        unindent
+        emit_end
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/until.rb

@@ -0,0 +1,20 @@
+module ToSource
+  class Emitter
+    class Until < self
+
+      handle(Rubinius::AST::Until)
+
+    private
+
+      def dispatch
+        emit('until ')
+        visit(node.condition)
+        indent
+        visit(node.body)
+        unindent
+        emit_end
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/util.rb

@@ -0,0 +1,19 @@
+module ToSource
+  class Emitter
+    class Util < self
+      class DelimitedBody < self
+
+      private
+
+        def dispatch
+          max = node.length - 1
+          node.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,38 @@
+module ToSource
+  class Emitter
+    class When < self
+
+      handle(Rubinius::AST::When)
+
+    private
+
+      def dispatch
+        emit('when ')
+        emit_single
+        emit_conditions
+        emit_splat
+        indent
+        visit(node.body)
+        unindent
+      end
+
+      def emit_single
+        single = node.single
+        visit(single) if single
+      end
+
+      def emit_splat
+        splat = node.splat
+        return unless splat
+        visit(splat)
+      end
+
+      def emit_conditions
+        conditions = node.conditions 
+        return unless conditions
+        run(Util::DelimitedBody, conditions.body)
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/while.rb

@@ -0,0 +1,20 @@
+module ToSource
+  class Emitter
+    class While < self
+
+      handle(Rubinius::AST::While)
+
+    private
+
+      def dispatch
+        emit('while ')
+        visit(node.condition)
+        indent
+        visit(node.body)
+        unindent
+        emit_end
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/yield.rb

@@ -0,0 +1,19 @@
+module ToSource
+  class Emitter
+    class Yield < self
+
+      handle(Rubinius::AST::Yield)
+
+      def dispatch
+        emit('yield')
+        arguments = node.arguments
+        unless arguments.array.empty?
+          emit('(')
+          visit(node.arguments)
+          emit(')')
+        end
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/z_super.rb

@@ -0,0 +1,17 @@
+module ToSource
+  class Emitter
+    class ZSuper < self
+
+      handle(Rubinius::AST::ZSuper)
+
+    private
+
+      def dispatch
+        emit('super')
+        block = node.block
+        visit(block) if block
+      end
+
+    end
+  end
+end

data/lib/to_source/state.rb

@@ -0,0 +1,60 @@
+module ToSource
+  class State
+
+    attr_reader :last
+    attr_reader :identation
+    attr_reader :buffer
+
+    def initialize
+      @last        = Command::NULL
+      @indentation = 0
+      @buffer      = []
+    end
+
+    def execute(command)
+      command.run(self)
+      @last = command
+    end
+
+    def last_keyword?
+      last.kind_of?(Command::Token::Keyword)
+    end
+
+    def write(string)
+      @buffer << string
+    end
+
+    def space
+      write(' ')
+    end
+
+    def push(command)
+      indent
+      write(command.content)
+    end
+
+    def indent
+      return unless blank?
+      write(' ' * @indentation)
+    end
+
+    def blank?
+      buffer.last == "\n"
+    end
+
+    def new_line
+      write("\n")
+    end
+
+    def source
+      buffer.join('')
+    end
+
+    def shift(width)
+      @indentation += width
+      @indentation = 0 if @indentation < 0
+      new_line
+    end
+
+  end
+end

data/spec/unit/to_source/{visitor/class_methods → class_methods}/run_spec.rb

@@ -1,8 +1,6 @@
 require 'spec_helper'
 
-describe ToSource::Visitor,'.run' do
-  subject { described_class.run(node) }
-
+describe ToSource,'.to_source' do
   def compress(code)
     lines = code.split("\n")
     match = /\A( *)/.match(lines.first)
@@ -13,16 +11,32 @@ describe ToSource::Visitor,'.run' do
     joined = stripped.join("\n")
   end
 
+  def assert_round_trip(code)
+    node = code.to_ast
+    generated = ToSource.to_source(node)
+    generated.should eql(code)
+    # This is nonsense but I had a case where it helps?
+    second_node = generated.to_ast
+    second = ToSource.to_source(second_node)
+    second.should eql(code)
+  end
+
+  def assert_entrypoints(node)
+    node.instance_variables.each do |ivar|
+      value = node.instance_variable_get(ivar)
+      next unless value.kind_of?(Rubinius::AST::Node)
+      ToSource.to_source(value)
+      assert_entrypoints(value)
+    end
+  end
+
   shared_examples_for 'a source generation method' do
     it 'should create original source' do
-      should eql(compress(expected_source))
+      assert_round_trip(compress(expected_source))
     end
 
-    it 'should be able to round trip generated source also' do
-      generated = subject
-      ast = subject.to_ast
-      second = described_class.run(ast)
-      generated.should eql(second)
+    it 'should be able to use all wrapped nodes as entrypoints' do
+      assert_entrypoints(expected_source.to_ast)
     end
   end
 
@@ -45,6 +59,7 @@ describe ToSource::Visitor,'.run' do
     context 'simple' do
       assert_source <<-RUBY
         class TestClass
+
         end
       RUBY
     end
@@ -60,6 +75,7 @@ describe ToSource::Visitor,'.run' do
     context 'scoped' do
       assert_source <<-RUBY
         class SomeNameSpace::TestClass
+
         end
       RUBY
     end
@@ -67,6 +83,7 @@ describe ToSource::Visitor,'.run' do
     context 'deeply scoped' do
       assert_source <<-RUBY
         class Some::Name::Space::TestClass
+
         end
       RUBY
     end
@@ -74,6 +91,7 @@ describe ToSource::Visitor,'.run' do
     context 'with subclass' do
       assert_source <<-RUBY
         class TestClass < Object
+
         end
       RUBY
     end
@@ -81,6 +99,7 @@ describe ToSource::Visitor,'.run' do
     context 'with scoped superclass' do
       assert_source <<-RUBY
         class TestClass < SomeNameSpace::Object
+
         end
       RUBY
     end
@@ -98,6 +117,7 @@ describe ToSource::Visitor,'.run' do
     context 'toplevel' do
       assert_source <<-RUBY
         class ::TestClass
+
         end
       RUBY
     end
@@ -107,6 +127,7 @@ describe ToSource::Visitor,'.run' do
     context 'simple' do
       assert_source <<-RUBY 
         module TestModule
+
         end
       RUBY
     end
@@ -114,6 +135,7 @@ describe ToSource::Visitor,'.run' do
     context 'scoped' do
       assert_source <<-RUBY
         module SomeNameSpace::TestModule
+
         end
       RUBY
     end
@@ -121,6 +143,7 @@ describe ToSource::Visitor,'.run' do
     context 'deeply scoped' do
       assert_source <<-RUBY
         module Some::Name::Space::TestModule
+
         end
       RUBY
     end
@@ -594,56 +617,62 @@ describe ToSource::Visitor,'.run' do
   context 'binary operators' do
     %w(+ - * / & | && || << >> == === != <= < <=> > >= =~ !~ ^ **).each do |operator|
       context "on literals #{operator}" do
-        assert_source "((1) #{operator} (2))"
+        assert_source "(1) #{operator} (2)"
       end
 
       context "on self #{operator}" do
-        assert_source "((self) #{operator} (b))"
+        assert_source "(self) #{operator} (b)"
       end
 
       context "on calls #{operator}" do
-        assert_source "((a) #{operator} (b))"
+        assert_source "(a) #{operator} (b)"
       end
     end
 
     context 'binary operator and keywords' do
-      assert_source '((a) || (break(foo)))'
+      assert_source '(a) || (break(foo))'
     end
 
     context 'nested binary operators' do
-      assert_source '((a) || (((b) || (c))))'
+      assert_source '(a) || ((b) || (c))'
+    end
+  end
+
+  { :or => :'||', :and => :'&&' }.each do |word, symbol|
+    context "word form form equivalency of #{word} and #{symbol}" do
+      assert_converts "(a) #{symbol} (break(foo))", "a #{word} break foo"
     end
   end
 
   context 'expansion of shortcuts' do
     context 'on += operator' do
-      assert_converts 'a = ((a) + (2))', 'a += 2'
+      assert_converts 'a = (a) + (2)', 'a += 2'
     end
 
     context 'on -= operator' do
-      assert_converts 'a = ((a) - (2))', 'a -= 2'
+      assert_converts 'a = (a) - (2)', 'a -= 2'
     end
 
     context 'on **= operator' do
-      assert_converts 'a = ((a) ** (2))', 'a **= 2'
+      assert_converts 'a = (a) ** (2)', 'a **= 2'
     end
 
     context 'on *= operator' do
-      assert_converts 'a = ((a) * (2))', 'a *= 2'
+      assert_converts 'a = (a) * (2)', 'a *= 2'
     end
 
     context 'on /= operator' do
-      assert_converts 'a = ((a) / (2))', 'a /= 2'
+      assert_converts 'a = (a) / (2)', 'a /= 2'
     end
   end
 
   context 'shortcuts' do
     context 'on &&= operator' do
-      assert_source '(a &&= (b))'
+      assert_source 'a &&= (b)'
     end
 
     context 'on ||= operator' do
-      assert_source '(a ||= (2))'
+      assert_source 'a ||= (2)'
     end
   end
 
@@ -854,9 +883,19 @@ describe ToSource::Visitor,'.run' do
   end
 
   context 'rescue' do
+    context 'as block' do
+      assert_source <<-RUBY
+        begin
+          foo
+          foo
+        rescue
+          bar
+        end
+      RUBY
+    end
     context 'without rescue condition' do
       assert_source <<-RUBY
-        def foo
+        begin
           bar
         rescue
           baz
@@ -864,10 +903,22 @@ describe ToSource::Visitor,'.run' do
       RUBY
     end
 
+    context 'within a block' do
+      assert_source <<-RUBY
+        foo do
+          begin
+            bar
+          rescue
+            baz
+          end
+        end
+      RUBY
+    end
+
     context 'with rescue condition' do
       context 'without assignment' do
         assert_source <<-RUBY
-          def foo
+          begin
             bar
           rescue SomeError
             baz
@@ -877,7 +928,7 @@ describe ToSource::Visitor,'.run' do
 
       context 'with assignment' do
         assert_source <<-RUBY
-          def foo
+          begin
             bar
           rescue SomeError => exception
             baz
@@ -889,7 +940,7 @@ describe ToSource::Visitor,'.run' do
     context 'with multivalued rescue condition' do
       context 'without assignment' do
         assert_source <<-RUBY
-          def foo
+          begin
             bar
           rescue SomeError, SomeOtherError
             baz
@@ -899,7 +950,7 @@ describe ToSource::Visitor,'.run' do
 
       context 'with assignment' do
         assert_source <<-RUBY
-          def foo
+          begin
             bar
           rescue SomeError, SomeOther => exception
             baz
@@ -910,7 +961,7 @@ describe ToSource::Visitor,'.run' do
 
     context 'with multiple rescue conditions' do
       assert_source <<-RUBY
-        def foo
+        begin
           foo
         rescue SomeError
           bar
@@ -923,7 +974,7 @@ describe ToSource::Visitor,'.run' do
     context 'with normal and splat condition' do
       context 'without assignment' do
         assert_source <<-RUBY
-          def foo
+          begin
             bar
           rescue SomeError, *bar
             baz
@@ -933,7 +984,7 @@ describe ToSource::Visitor,'.run' do
 
       context 'with assignment' do
         assert_source <<-RUBY
-          def foo
+          begin
             bar
           rescue SomeError, *bar => exception
             baz
@@ -945,7 +996,7 @@ describe ToSource::Visitor,'.run' do
     context 'with splat condition' do
       context 'without assignment' do
         assert_source <<-RUBY
-          def foo
+          begin
             bar
           rescue *bar
             baz
@@ -955,7 +1006,7 @@ describe ToSource::Visitor,'.run' do
 
       context 'with assignment' do
         assert_source <<-RUBY
-          def foo
+          begin
             bar
           rescue *bar => exception
             baz
@@ -971,7 +1022,7 @@ describe ToSource::Visitor,'.run' do
 
   context 'ensure' do
     assert_source <<-RUBY
-      def foo
+      begin
         bar
       ensure
         baz
@@ -981,7 +1032,7 @@ describe ToSource::Visitor,'.run' do
 
   context 'return' do
     context 'with expression' do
-      assert_source 'return 9'
+      assert_source 'return(9)'
     end
 
     context 'without expression' do