to_source 0.2.16 → 0.2.17

data/lib/to_source/emitter/send.rb

@@ -11,6 +11,7 @@ module ToSource
     private
 
       delegate(:block, :name, :receiver)
+      predicate(:block)
 
       # Perform dispatch
       #
@@ -19,14 +20,32 @@ module ToSource
       # @api private
       #
       def dispatch
-        if unary_operator_method?
-          run(UnaryOperatorMethod, node)
+        case
+        when unary_operator_method?
+          run(UnaryOperatorMethod)
+          return
+        when for?
+          run(For)
           return
         end
 
         normal_dispatch
       end
 
+      # Test for for node
+      #
+      # @return [true]
+      #   if for node is detected
+      #
+      # @return [false]
+      #   otherwise
+      #
+      # @api private
+      #
+      def for?
+        block.kind_of?(Rubinius::AST::For19)
+      end
+
       # Test for unary operator method
       #
       # @return [true]
@@ -54,20 +73,6 @@ module ToSource
         emit_block
       end
 
-      # Test for block
-      #
-      # @return [true]
-      #   if block is present
-      #
-      # @return [false]
-      #   otherwise
-      #
-      # @api private
-      #
-      def block?
-        !!block
-      end
-
       # Test for block pass
       #
       # @return [true]

data/lib/to_source/emitter/splat.rb

@@ -8,6 +8,8 @@ module ToSource
 
     private
 
+      delegate(:value)
+
       # Perform dispatch
       #
       # @return [undefined]
@@ -16,9 +18,46 @@ module ToSource
       #
       def dispatch
         emit('*')
-        visit(node.value)
+        emit_value
+      end
+
+      # Emit value
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_value
+        visit(value)
       end
 
+      # Emitter for empty splat
+      class Empty < self
+
+        handle(Rubinius::AST::EmptySplat)
+
+      private
+
+        # Perform dispatch
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def dispatch
+          emit('*')
+        end
+
+        # Return value
+        #
+        # @return [nil]
+        #
+        # @api private
+        #
+        def value
+        end
+
+      end
     end
   end
 end

data/lib/to_source/emitter/static.rb

@@ -39,6 +39,14 @@ module ToSource
 
       end
 
+      # Emitter for encoding node
+      class Encoding < self
+
+        handle(Rubinius::AST::Encoding)
+        SYMBOL = :__ENCODING__
+
+      end
+
       # Emitter for file node
       class File < self
 
@@ -47,6 +55,30 @@ module ToSource
 
       end
 
+      # Emitter for redo node
+      class Redo < self
+
+        handle(Rubinius::AST::Redo)
+        SYMBOL = :redo
+
+      end
+
+      # Emitter for retry node
+      class Retry < self
+
+        handle(Rubinius::AST::Retry)
+        SYMBOL = :retry
+
+      end
+
+      # Emitter for rubinius specific type constant
+      class TypeConstant < self
+
+        handle(Rubinius::AST::TypeConstant)
+        SYMBOL = 'Rubinius::Type'
+
+      end
+
     end
   end
 end

data/lib/to_source/emitter/toplevel.rb

@@ -1,9 +1,10 @@
 module ToSource
   class Emitter
-    # Emitter for toplevel constants or classes
+    # Emitter for toplevel constants, classes and modules
     class Toplevel < self
 
       handle(Rubinius::AST::ToplevelClassName)
+      handle(Rubinius::AST::ToplevelModuleName)
       handle(Rubinius::AST::ToplevelConstant)
 
     private

data/lib/to_source/emitter/undef.rb

@@ -0,0 +1,26 @@
+module ToSource
+  class Emitter
+
+    # Emitter for undef nodes
+    class Undef < self
+
+      handle(Rubinius::AST::Undef)
+      SYMBOL = :undef
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        emit(:undef)
+        space
+        visit(node.name)
+      end
+
+    end
+  end
+end

data/spec/unit/to_source/class_methods/run_spec.rb

@@ -48,10 +48,10 @@ describe ToSource,'.to_source' do
     it_should_behave_like 'a source generation method'
   end
 
-  def self.assert_converts(converted, source)
-    let(:node)            { source.to_ast }
-    let(:source)          { source        }
-    let(:expected_source) { converted     }
+  def self.assert_converts(target, original)
+    let(:node)            { original.to_ast }
+    let(:source)          { original        }
+    let(:expected_source) { target          }
     it_should_behave_like 'a source generation method'
   end
 
@@ -192,7 +192,27 @@ describe ToSource,'.to_source' do
 
 
   context 'element assignment' do
-    assert_source 'array[index] = value'
+    context 'simpe' do
+      assert_source 'array[index] = value'
+    end
+
+    context 'splat index' do
+      assert_source 'array[*index] = value'
+    end
+
+    context 'with assignment operator' do
+      %w(+ - * / % & | || &&).each do |operator|
+        context "with #{operator}" do
+          context 'explicit index' do
+            assert_source "array[index] #{operator}= 2"
+          end
+
+          context 'implicit index' do
+            assert_source "array[] #{operator}= 2"
+          end
+        end
+      end
+    end
   end
 
   context 'multiple assignment' do
@@ -200,10 +220,34 @@ describe ToSource,'.to_source' do
       assert_source 'a, b = 1, 2'
     end
 
+    context 'to local and splat var' do
+      assert_source 'a, *foo = 1, 2'
+    end
+
+    context 'with empty splat' do
+      assert_source 'a, * = 1, 2'
+    end
+
+    context 'to splat var' do
+      assert_source '*foo = 1, 2'
+    end
+
     context 'to instance variable' do
       assert_source '@a, @b = 1, 2'
     end
 
+    context 'to attribute reference' do
+      assert_source 'a.foo, a.bar = 1, 2'
+    end
+
+    context 'to element' do
+      assert_source 'a[0], a[1] = 1, 2'
+    end
+
+    context 'to spat element' do
+      assert_source 'a[*foo], a[1] = 1, 2'
+    end
+
     context 'to class variable' do
       assert_source '@@a, @@b = 1, 2'
     end
@@ -247,6 +291,10 @@ describe ToSource,'.to_source' do
       assert_source '$1'
     end
 
+    context 'on back ref global variable' do
+      assert_source '$`'
+    end
+
     context 'on global variable' do
       assert_source '$foo'
     end
@@ -269,6 +317,10 @@ describe ToSource,'.to_source' do
   end
 
   context 'literal' do
+    context 'number' do
+      assert_source '12379813738877118345'
+    end
+
     context 'fixnum' do
       assert_source '1' 
     end
@@ -314,9 +366,17 @@ describe ToSource,'.to_source' do
         assert_source '[1, 2, 3]'
       end
 
-      context 'with splat' do
+      context 'with splat in the end' do
         assert_source '[1, *foo]'
       end
+
+      context 'with splat in the beginning' do
+        assert_source '[*foo, 1]'
+      end
+
+      context 'with splat in the beginning and end' do
+        assert_source '[*foo, *baz]'
+      end
     end
 
     context 'empty hash' do
@@ -340,6 +400,42 @@ describe ToSource,'.to_source' do
         assert_source '/.*/'
       end
 
+      context 'with character classes' do
+        assert_source %q(/[^-+',.\/:@[:alnum:]\[\]\x80-\xff]+/)
+      end
+
+      context 'with options' do
+
+        context 'case insensitive' do
+          assert_source '//i'
+        end
+
+        context 'ignore comments and whitespace' do
+          assert_source '//x'
+        end
+
+        context 'assci encoding' do
+          assert_source '//n'
+        end
+
+        context 'windows-31j encoding' do
+          assert_source '//s'
+        end
+
+        context 'euc-jp encoding' do
+          assert_source '//e'
+        end
+
+        context 'utf-8 encoding' do
+          assert_source '//u'
+        end
+
+        context 'multiline' do
+          assert_source '//m'
+        end
+
+      end
+
       context 'with escapes' do
         assert_source '/\//'
       end
@@ -408,6 +504,14 @@ describe ToSource,'.to_source' do
         assert_source '/foo#{bar}baz/'
       end
 
+      context 'with flags' do
+        assert_source '/foo#{bar}/i'
+        assert_source '/foo#{bar}/m'
+        assert_source '/foo#{bar}/im'
+        assert_source '/foo#{bar}/imx'
+        assert_source '/foo#{bar}/x'
+      end
+
       context 'split groups' do
         assert_source '/(#{foo})*/'
       end
@@ -423,14 +527,42 @@ describe ToSource,'.to_source' do
       context 'with dynamic segment in the end' do
         assert_source '/foo#{bar}/'
       end
+
+      context 'with o flag' do
+        assert_source '/foo#{bar}/o'
+      end
+
+      context 'with o and other flags' do
+        assert_source '/foo#{bar}/oim'
+      end
     end
   end
 
+  context 'END' do
+    original = <<-RUBY
+      END { 
+        foo 
+      }
+    RUBY
+
+    target = <<-RUBY
+      at_exit do
+        foo
+      end
+    RUBY
+
+    assert_converts target, original
+  end
+
   context 'send' do
     context 'as element reference' do
       assert_source 'foo[index]'
     end
 
+    context 'as element reference with splat' do
+      assert_source 'self[*foo]'
+    end
+
     context 'as element reference on self' do
       assert_source 'self[foo]'
     end
@@ -515,6 +647,14 @@ describe ToSource,'.to_source' do
       assert_source 'foo.bar(*args)'
     end
 
+    context 'with formal splat and formal argument' do
+      assert_source 'foo.bar(*arga, foo, *argb)'
+    end
+
+    context 'with splat and formal argument' do
+      assert_source 'foo.bar(*args, foo)'
+    end
+
     context 'with formal and splat argument' do
       assert_source 'foo.bar(foo, *args)'
     end
@@ -545,11 +685,11 @@ describe ToSource,'.to_source' do
 
     context 'attribute assignment' do
       context 'on foreign object' do
-        assert_source 'foo.bar= :baz'
+        assert_source 'foo.bar = :baz'
       end
 
       context 'on self' do
-        assert_source 'self.foo= :bar'
+        assert_source 'self.foo = :bar'
       end
     end
   end
@@ -628,16 +768,54 @@ describe ToSource,'.to_source' do
     assert_source 'break(a)'
   end
 
+  context 'retry' do
+    assert_source 'retry'
+  end
+
+  context 'redo' do
+    assert_source 'redo'
+  end
+
   context 'next' do
     assert_source 'next'
   end
 
-  context 'match operator' do
+  context 'match2 operator' do
+    assert_source <<-RUBY
+      /bar/ =~ foo
+    RUBY
+  end
+
+  context 'match3 operator' do
     assert_source <<-RUBY
       foo =~ /bar/
     RUBY
   end
 
+  context 'flip flops' do
+    context 'flip2' do
+      assert_source <<-RUBY
+        if (((i) == (4)))..(((i) == (4)))
+          foo
+        end
+      RUBY
+    end
+
+    context 'flip3' do
+      assert_source <<-RUBY
+        if (((i) == (4)))...(((i) == (4)))
+          foo
+        end
+      RUBY
+    end
+  end
+
+  context 'valias' do
+    assert_source <<-RUBY
+      alias $foo $bar
+    RUBY
+  end
+
   context 'alias' do
     assert_source <<-RUBY
       alias foo bar
@@ -659,11 +837,15 @@ describe ToSource,'.to_source' do
   end
 
   context 'binary operators methods' do
-    %w(+ - * / & | && || << >> == === != <= < <=> > >= =~ !~ ^ **).each do |operator|
+    %w(+ - * / & | << >> == === != <= < <=> > >= =~ !~ ^ **).each do |operator|
       context "on literals #{operator}" do
         assert_source "((1) #{operator} (2))"
       end
 
+      context "#{operator} with splat args" do
+        assert_source "((left).#{operator}(*foo))"
+      end
+
       context "on self #{operator}" do
         assert_source "((self) #{operator} (b))"
       end
@@ -672,19 +854,21 @@ describe ToSource,'.to_source' do
         assert_source "((a) #{operator} (b))"
       end
     end
+  end
 
-    context 'binary operator and keywords' do
-      assert_source '((a) || (break(foo)))'
-    end
+   context 'binary operator' do
+     context 'and keywords' do
+       assert_source '((a) || (break(foo)))'
+     end
 
-    context 'sending methods to result of binary operator' do
-      assert_source '((a) || (b)).foo'
-    end
+     context 'sending methods to result' do
+       assert_source '((a) || (b)).foo'
+     end
 
-    context 'nested binary operators' do
-      assert_source '((a) || (((b) || (c))))'
-    end
-  end
+     context 'nested' do
+       assert_source '((a) || (((b) || (c))))'
+     end
+   end
 
   { :or => :'||', :and => :'&&' }.each do |word, symbol|
     context "word form form equivalency of #{word} and #{symbol}" do
@@ -751,6 +935,13 @@ describe ToSource,'.to_source' do
   end
 
   context 'if statement' do
+    context 'when matching regexp' do
+      assert_source <<-RUBY
+        if /foo/
+          bar
+        end
+      RUBY
+    end
     context 'without else branch' do
       context 'single statement in branch' do
         assert_source <<-RUBY
@@ -868,6 +1059,32 @@ describe ToSource,'.to_source' do
     end
   end
 
+  context 'for' do
+    context 'single assignment' do
+      assert_source <<-RUBY
+        for a in bar do
+          baz
+        end
+      RUBY
+    end
+
+    context 'splat assignment' do
+      assert_source <<-RUBY
+        for a, *b in bar do
+          baz
+        end
+      RUBY
+    end
+
+    context 'multiple assignment' do
+      assert_source <<-RUBY
+        for a, b in bar do
+          baz
+        end
+      RUBY
+    end
+  end
+
   context 'loop' do
     assert_source <<-RUBY
       loop do
@@ -1089,6 +1306,10 @@ describe ToSource,'.to_source' do
     end
   end
 
+  context '__ENCODING__' do
+    assert_source '__ENCODING__'
+  end
+
   context '__FILE__' do
     assert_source '__FILE__'
   end
@@ -1113,6 +1334,10 @@ describe ToSource,'.to_source' do
     end
   end
 
+  context 'undef' do
+    assert_source 'undef :foo'
+  end
+
   context 'define' do
     context 'on instance' do
       context 'without arguments' do