synvert 0.0.3 → 0.0.4

data/spec/synvert/rewriter/action_spec.rb

@@ -2,74 +2,174 @@ require 'spec_helper'
 
 module Synvert
   describe Rewriter::ReplaceWithAction do
-    describe '#rewrite' do
-      it 'replaces code' do
-        action = Rewriter::ReplaceWithAction.new('create_list {{self.arguments}}')
-        source = "post = FactoryGirl.create_list :post, 2"
-        send_node = Parser::CurrentRuby.parse(source).children[1]
-        output = action.rewrite(source, send_node)
-        expect(output).to eq "post = create_list :post, 2"
+    subject {
+      source = "post = FactoryGirl.create_list :post, 2"
+      send_node = Parser::CurrentRuby.parse(source).children[1]
+      instance = double(:current_node => send_node)
+      Rewriter::ReplaceWithAction.new(instance, 'create_list {{arguments}}')
+    }
+
+    it 'gets begin_pos' do
+      expect(subject.begin_pos).to eq 7
+    end
+
+    it 'gets end_pos' do
+      expect(subject.end_pos).to eq 39
+    end
+
+    it 'gets rewritten_code' do
+      expect(subject.rewritten_code).to eq 'create_list :post, 2'
+    end
+  end
+
+  describe Rewriter::AppendAction < Rewriter::Action do
+    describe 'class node' do
+      subject {
+        source = "class User\n  has_many :posts\nend"
+        class_node = Parser::CurrentRuby.parse(source)
+        instance = double(:current_node => class_node)
+        Rewriter::AppendAction.new(instance, "def as_json\n  super\nend")
+      }
+
+      it 'gets begin_pos' do
+        expect(subject.begin_pos).to eq 28
+      end
+
+      it 'gets end_pos' do
+        expect(subject.end_pos).to eq 28
+      end
+
+      it 'gets rewritten_code' do
+        expect(subject.rewritten_code).to eq "\n\n  def as_json\n    super\n  end"
       end
     end
   end
 
   describe Rewriter::InsertAction do
-    describe '#rewrite' do
-      it 'insert code to block node' do
-        action = Rewriter::InsertAction.new('{{self.arguments.first}}.include FactoryGirl::Syntax::Methods')
-        source = "RSpec.configure do |config|\nend"
+    describe 'block node without args' do
+      subject {
+        source = "Synvert::Application.configure do\nend"
         block_node = Parser::CurrentRuby.parse(source)
-        output = action.rewrite(source, block_node)
-        expect(output).to eq "RSpec.configure do |config|\n  config.include FactoryGirl::Syntax::Methods\nend"
+        instance = double(:current_node => block_node)
+        Rewriter::InsertAction.new(instance, 'config.eager_load = true')
+      }
+
+      it 'gets begin_pos' do
+        expect(subject.begin_pos).to eq 33
       end
 
-      it 'insert code to class node' do
-        action = Rewriter::InsertAction.new('include FactoryGirl::Syntax::Methods')
-        source = "class Test::Unit::TestCase\nend"
-        block_node = Parser::CurrentRuby.parse(source)
-        output = action.rewrite(source, block_node)
-        expect(output).to eq "class Test::Unit::TestCase\n  include FactoryGirl::Syntax::Methods\nend"
+      it 'gets end_pos' do
+        expect(subject.end_pos).to eq 33
       end
 
-      it 'insert code to begin node' do
-        action = Rewriter::InsertAction.new('World(FactoryGirl::Syntax::Methods)')
-        source = "require 'cucumber/rails'\nActionController::Base.allow_rescue = false"
-        block_node = Parser::CurrentRuby.parse(source)
-        output = action.rewrite(source, block_node)
-        expect(output).to eq "require 'cucumber/rails'\nActionController::Base.allow_rescue = false\nWorld(FactoryGirl::Syntax::Methods)"
+      it 'gets rewritten_code' do
+        expect(subject.rewritten_code).to eq "\n  config.eager_load = true"
       end
+    end
 
-      it 'insert code to other node' do
-        action = Rewriter::InsertAction.new('World(FactoryGirl::Syntax::Methods)')
-        source = "require 'cucumber/rails'"
+    describe 'block node with args' do
+      subject {
+        source = "RSpec.configure do |config|\nend"
         block_node = Parser::CurrentRuby.parse(source)
-        output = action.rewrite(source, block_node)
-        expect(output).to eq "require 'cucumber/rails'\nWorld(FactoryGirl::Syntax::Methods)"
+        instance = double(:current_node => block_node)
+        Rewriter::InsertAction.new(instance, '{{arguments.first}}.include FactoryGirl::Syntax::Methods')
+      }
+
+      it 'gets begin_pos' do
+        expect(subject.begin_pos).to eq 27
+      end
+
+      it 'gets end_pos' do
+        expect(subject.end_pos).to eq 27
+      end
+
+      it 'gets rewritten_code' do
+        expect(subject.rewritten_code).to eq "\n  config.include FactoryGirl::Syntax::Methods"
+      end
+    end
+
+    describe 'class node without superclass' do
+      subject {
+        source = "class User\n  has_many :posts\nend"
+        class_node = Parser::CurrentRuby.parse(source)
+        instance = double(:current_node => class_node)
+        Rewriter::InsertAction.new(instance, 'include Deletable')
+      }
+
+      it 'gets begin_pos' do
+        expect(subject.begin_pos).to eq 10
+      end
+
+      it 'gets end_pos' do
+        expect(subject.end_pos).to eq 10
+      end
+
+      it 'gets rewritten_code' do
+        expect(subject.rewritten_code).to eq "\n  include Deletable"
+      end
+    end
+
+    describe 'class node with superclass' do
+      subject {
+        source = "class User < ActiveRecord::Base\n  has_many :posts\nend"
+        class_node = Parser::CurrentRuby.parse(source)
+        instance = double(:current_node => class_node)
+        Rewriter::InsertAction.new(instance, 'include Deletable')
+      }
+
+      it 'gets begin_pos' do
+        expect(subject.begin_pos).to eq 31
+      end
+
+      it 'gets end_pos' do
+        expect(subject.end_pos).to eq 31
+      end
+
+      it 'gets rewritten_code' do
+        expect(subject.rewritten_code).to eq "\n  include Deletable"
       end
     end
   end
 
   describe Rewriter::InsertAfterAction do
-    describe '#rewrite' do
-      it 'insert_after code' do
-        action = Rewriter::InsertAfterAction.new('include Bar')
-        source = "  include Foo"
-        node = Parser::CurrentRuby.parse(source)
-        output = action.rewrite(source, node)
-        expect(output).to eq "  include Foo\n  include Bar"
-      end
+    subject {
+      source = "  include Foo"
+      node = Parser::CurrentRuby.parse(source)
+      instance = double(:current_node => node)
+      Rewriter::InsertAfterAction.new(instance, 'include Bar')
+    }
+
+    it 'gets begin_pos' do
+      expect(subject.begin_pos).to eq 13
+    end
+
+    it 'gets end_pos' do
+      expect(subject.end_pos).to eq 13
+    end
+
+    it 'gets rewritten_code' do
+      expect(subject.rewritten_code).to eq "\n  include Bar"
     end
   end
 
   describe Rewriter::RemoveAction do
-    describe '#rewrite' do
-      it 'remove code' do
-        action = Rewriter::RemoveAction.new
-        source = "user = User.new params[:user]\nuser.save\nrender\n"
-        send_node = Parser::CurrentRuby.parse(source).children[1]
-        output = action.rewrite(source, send_node)
-        expect(output).to eq "user = User.new params[:user]\nrender\n"
-      end
+    subject {
+      source = "user = User.new params[:user]\nuser.save\nrender\n"
+      send_node = Parser::CurrentRuby.parse(source).children[1]
+      instance = double(:current_node => send_node)
+      Rewriter::RemoveAction.new(instance)
+    }
+
+    it 'gets begin_pos' do
+      expect(subject.begin_pos).to eq 30
+    end
+
+    it 'gets end_pos' do
+      expect(subject.end_pos).to eq 39
+    end
+
+    it 'gets rewritten_code' do
+      expect(subject.rewritten_code).to eq ""
     end
   end
 end

data/spec/synvert/rewriter/condition_spec.rb

@@ -11,22 +11,31 @@ module Synvert
       """
     }
     let(:node) { Parser::CurrentRuby.parse(source) }
+    let(:instance) { double(:current_node => node, :current_source => source) }
 
-    describe '#matching_nodes' do
-      it 'gets empty array if does not matchi anything' do
-        condition = Rewriter::UnlessExistCondition.new type: 'send', message: 'include', arguments: {first: {to_s: 'FactoryGirl::Syntax::Methods'} }
-        expect(condition.matching_nodes([node]).size).to eq 1
+    describe '#process' do
+      it 'call block if match anything' do
+        run = false
+        condition = Rewriter::UnlessExistCondition.new instance, type: 'send', message: 'include', arguments: ['FactoryGirl::Syntax::Methods'] do
+          run = true
+        end
+        condition.process
+        expect(run).to be_true
       end
 
-      it 'gets matching nodes' do
-        condition = Rewriter::UnlessExistCondition.new type: 'send', message: 'include', arguments: {first: {to_s: 'EmailSpec::Helpers'} }
-        expect(condition.matching_nodes([node])).to eq []
+      it 'not call block if not match anything' do
+        run = false
+        condition = Rewriter::UnlessExistCondition.new instance, type: 'send', message: 'include', arguments: ['EmailSpec::Helpers'] do
+          run = true
+        end
+        condition.process
+        expect(run).to be_false
       end
     end
   end
 
   describe Rewriter::IfOnlyExistCondition do
-    describe '#matching_nodes' do
+    describe '#process' do
       it 'gets matching nodes' do
         source = """
           RSpec.configure do |config|
@@ -34,12 +43,16 @@ module Synvert
           end
         """
         node = Parser::CurrentRuby.parse(source)
-
-        condition = Rewriter::IfOnlyExistCondition.new type: 'send', message: 'include', arguments: {first: 'EmailSpec::Helpers'}
-        expect(condition.matching_nodes([node])).to eq [node]
+        instance = double(:current_node => node, :current_source => source)
+        run = false
+        condition = Rewriter::IfOnlyExistCondition.new instance, type: 'send', message: 'include', arguments: ['EmailSpec::Helpers'] do
+          run = true
+        end
+        condition.process
+        expect(run).to be_true
       end
 
-      it 'gets empty array if does not match' do
+      it 'not call block if does not match' do
         source = """
           RSpec.configure do |config|
             config.include EmailSpec::Helpers
@@ -47,9 +60,13 @@ module Synvert
           end
         """
         node = Parser::CurrentRuby.parse(source)
-
-        condition = Rewriter::IfOnlyExistCondition.new type: 'send', message: 'include', arguments: {first: {to_s: 'EmailSpec::Helpers'} }
-        expect(condition.matching_nodes([node])).to eq []
+        instance = double(:current_node => node, :current_source => source)
+        run = false
+        condition = Rewriter::IfOnlyExistCondition.new instance, type: 'send', message: 'include', arguments: ['EmailSpec::Helpers'] do
+          run = true
+        end
+        condition.process
+        expect(run).to be_false
       end
     end
   end

data/spec/synvert/rewriter/instance_spec.rb

@@ -2,43 +2,79 @@ require 'spec_helper'
 
 module Synvert
   describe Rewriter::Instance do
-    let(:instance) { Rewriter::Instance.new('file pattern') }
+    let(:rewriter) { Rewriter.new 'description' do; end }
+    let(:instance) { Rewriter::Instance.new(rewriter, 'file pattern') }
 
-    describe '#insert' do
-      it 'sets an action' do
-        expect(Rewriter::InsertAction).to receive(:new).with('{{self.arguments.first}}.include FactoryGirl::Syntax::Methods')
-        instance.insert "{{self.arguments.first}}.include FactoryGirl::Syntax::Methods"
-      end
+    it 'parses within_node' do
+      scope = double()
+      block = Proc.new {}
+      expect(Rewriter::Scope).to receive(:new).with(instance, type: 'send', message: 'create', &block).and_return(scope)
+      expect(scope).to receive(:process)
+      instance.within_node(type: 'send', message: 'create', &block)
     end
 
-    describe '#insert_after' do
-      it 'sets an action' do
-        expect(Rewriter::InsertAfterAction).to receive(:new).with('{{self.arguments.first}}.include FactoryGirl::Syntax::Methods')
-        instance.insert_after "{{self.arguments.first}}.include FactoryGirl::Syntax::Methods"
-      end
+    it 'parses with_node' do
+      scope = double()
+      block = Proc.new {}
+      expect(Rewriter::Scope).to receive(:new).with(instance, type: 'send', message: 'create', &block).and_return(scope)
+      expect(scope).to receive(:process)
+      instance.with_node(type: 'send', message: 'create', &block)
     end
 
-    describe '#replace_with' do
-      it 'sets an action' do
-        expect(Rewriter::ReplaceWithAction).to receive(:new).with('create {{self.arguments}}')
-        instance.replace_with 'create {{self.arguments}}'
-      end
+    it 'parses unless_exist_node' do
+      condition = double()
+      block = Proc.new {}
+      expect(Rewriter::UnlessExistCondition).to receive(:new).with(instance, type: 'send', message: 'create', &block).and_return(condition)
+      expect(condition).to receive(:process)
+      instance.unless_exist_node(type: 'send', message: 'create', &block)
     end
 
-    describe '#remove' do
-      it 'sets an action' do
-        expect(Rewriter::RemoveAction).to receive(:new)
-        instance.remove
-      end
+    it 'parses if_only_exist_node' do
+      condition = double()
+      block = Proc.new {}
+      expect(Rewriter::IfOnlyExistCondition).to receive(:new).with(instance, type: 'send', message: 'create', &block).and_return(condition)
+      expect(condition).to receive(:process)
+      instance.if_only_exist_node(type: 'send', message: 'create', &block)
+    end
+
+    it 'parses append' do
+      expect(Rewriter::AppendAction).to receive(:new).with(instance, 'include FactoryGirl::Syntax::Methods')
+      instance.append "include FactoryGirl::Syntax::Methods"
+    end
+
+    it 'parses insert' do
+      expect(Rewriter::InsertAction).to receive(:new).with(instance, '{{arguments.first}}.include FactoryGirl::Syntax::Methods')
+      instance.insert "{{arguments.first}}.include FactoryGirl::Syntax::Methods"
+    end
+
+    it 'parses insert_after' do
+      expect(Rewriter::InsertAfterAction).to receive(:new).with(instance, '{{arguments.first}}.include FactoryGirl::Syntax::Methods')
+      instance.insert_after "{{arguments.first}}.include FactoryGirl::Syntax::Methods"
+    end
+
+    it 'parses replace_with' do
+      expect(Rewriter::ReplaceWithAction).to receive(:new).with(instance, 'create {{arguments}}')
+      instance.replace_with 'create {{arguments}}'
+    end
+
+    it 'parses remove' do
+      expect(Rewriter::RemoveAction).to receive(:new).with(instance)
+      instance.remove
+    end
+
+    it 'parses assign / fetch' do
+      instance.assign 'parameters', 'user', 'email'
+      expect(instance.fetch 'parameters', 'user').to eq 'email'
     end
 
     describe '#process' do
       before { Configuration.instance.set :path, '.' }
 
       it 'FactoryGirl uses short syntax' do
-        instance = Rewriter::Instance.new('spec/**/*_spec.rb')
-        instance.with_node type: 'send', receiver: 'FactoryGirl', message: 'create' do
-          replace_with 'create {{self.arguments}}'
+        instance = Rewriter::Instance.new rewriter, 'spec/**/*_spec.rb' do
+          with_node type: 'send', receiver: 'FactoryGirl', message: 'create' do
+            replace_with 'create {{arguments}}'
+          end
         end
         input = """
 it 'uses factory_girl' do
@@ -61,10 +97,11 @@ end
       end
 
       it 'includes FactoryGirl::Syntax::Methods' do
-        instance = Rewriter::Instance.new('spec/spec_helper.rb')
-        instance.with_node type: 'block', caller: {receiver: 'RSpec', message: 'configure'} do
-          unless_exist_node type: 'send', message: 'include', arguments: {first: {to_s: 'FactoryGirl::Syntax::Methods'}} do
-            insert "{{self.arguments.first}}.include FactoryGirl::Syntax::Methods"
+        instance = Rewriter::Instance.new rewriter, 'spec/spec_helper.rb'  do
+          with_node type: 'block', caller: {receiver: 'RSpec', message: 'configure'} do
+            unless_exist_node type: 'send', message: 'include', arguments: ['FactoryGirl::Syntax::Methods'] do
+              insert "{{arguments.first}}.include FactoryGirl::Syntax::Methods"
+            end
           end
         end
         input = """
@@ -83,10 +120,11 @@ end
       end
 
       it 'does not include FactoryGirl::Syntax::Methods' do
-        instance = Rewriter::Instance.new('spec/spec_helper.rb')
-        instance.with_node type: 'block', caller: {receiver: 'RSpec', message: 'configure'} do
-          unless_exist_node type: 'send', message: 'include', arguments: {first: {to_s: 'FactoryGirl::Syntax::Methods'}} do
-            insert "{{self.arguments.first}}.include FactoryGirl::Syntax::Methods"
+        instance = Rewriter::Instance.new rewriter, 'spec/spec_helper.rb' do
+          with_node type: 'block', caller: {receiver: 'RSpec', message: 'configure'} do
+            unless_exist_node type: 'send', message: 'include', arguments: ['FactoryGirl::Syntax::Methods'] do
+              insert "{{arguments.first}}.include FactoryGirl::Syntax::Methods"
+            end
           end
         end
         input = """
@@ -106,9 +144,10 @@ end
       end
 
       it 'process nested send nodes' do
-        instance = Rewriter::Instance.new('config/*.rb')
-        instance.with_node type: 'send', receiver: {type: 'send', receiver: {type: 'send', message: 'config'}, message: 'active_record'}, message: 'identity_map=' do
-          remove
+        instance = Rewriter::Instance.new rewriter, 'config/*.rb'  do
+          with_node type: 'send', receiver: {type: 'send', receiver: {type: 'send', message: 'config'}, message: 'active_record'}, message: 'identity_map=' do
+            remove
+          end
         end
         input = 'config.active_record.identity_map = true'
         output = ''

data/spec/synvert/rewriter/scope_spec.rb

@@ -17,21 +17,25 @@ end
 """
     }
     let(:node) { Parser::CurrentRuby.parse(source) }
+    let(:instance) { double(:current_node => node, :current_node= => node, :current_source => source) }
 
-    describe '#matching_nodes' do
-      it 'gets empty array if does not match anything' do
-        scope = Rewriter::Scope.new type: 'send', message: 'missing'
-        expect(scope.matching_nodes([node])).to eq []
+    describe '#process' do
+      it 'not call block if no matching node' do
+        run = false
+        scope = Rewriter::Scope.new instance, type: 'send', message: 'missing' do
+          run = true
+        end
+        scope.process
+        expect(run).to be_false
       end
 
-      it 'gets matching nodes' do
-        scope = Rewriter::Scope.new type: 'send', receiver: 'FactoryGirl', message: 'create', arguments: [':post']
-        expect(scope.matching_nodes([node]).size).to eq 2
-      end
-
-      it 'gets matching nodes witch block caller' do
-        scope = Rewriter::Scope.new type: 'block', caller: {message: 'it', arguments: ['gets posts']}
-        expect(scope.matching_nodes([node]).size).to eq 1
+      it 'call block if there is matching node' do
+        run = false
+        scope = Rewriter::Scope.new instance, type: 'send', receiver: 'FactoryGirl', message: 'create', arguments: [':post'] do
+          run = true
+        end
+        scope.process
+        expect(run).to be_true
       end
     end
   end