synvert-core 0.1.0

data/spec/synvert/core/rewriter/action_spec.rb

@@ -0,0 +1,225 @@
+require 'spec_helper'
+
+module Synvert::Core
+  describe Rewriter::ReplaceWithAction do
+    context "replace with single line" do
+      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 "post = ".length
+      end
+
+      it 'gets end_pos' do
+        expect(subject.end_pos).to eq "post = FactoryGirl.create_list :post, 2".length
+      end
+
+      it 'gets rewritten_code' do
+        expect(subject.rewritten_code).to eq 'create_list :post, 2'
+      end
+    end
+
+    context "#replace with multiple line" do
+      subject {
+        source = "  its(:size) { should == 1 }"
+        send_node = Parser::CurrentRuby.parse(source)
+        instance = double(:current_node => send_node)
+        Rewriter::ReplaceWithAction.new(instance, """describe '#size' do
+  subject { super().size }
+  it { {{body}} }
+end""")
+      }
+
+      it 'gets begin_pos' do
+        expect(subject.begin_pos).to eq 2
+      end
+
+      it 'gets end_pos' do
+        expect(subject.end_pos).to eq "  its(:size) { should == 1 }".length
+      end
+
+      it 'gets rewritten_code' do
+        expect(subject.rewritten_code).to eq """\n\n  describe '#size' do
+    subject { super().size }
+    it { should == 1 }
+  end"""
+      end
+    end
+  end
+
+  describe Rewriter::AppendAction < Rewriter::Action do
+    describe 'class node' do
+      subject do
+        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")
+      end
+
+      it 'gets begin_pos' do
+        expect(subject.begin_pos).to eq "calss User\n  has_many :posts".length
+      end
+
+      it 'gets end_pos' do
+        expect(subject.end_pos).to eq "class User\n  has_many :posts".length
+      end
+
+      it 'gets rewritten_code' do
+        expect(subject.rewritten_code).to eq "\n\n  def as_json\n    super\n  end"
+      end
+    end
+
+    describe 'begin node' do
+      subject do
+        source = "gem 'rails'\ngem 'mysql2'"
+        begin_node = Parser::CurrentRuby.parse(source)
+        instance = double(:current_node => begin_node)
+        Rewriter::AppendAction.new(instance, "gem 'twitter'")
+      end
+
+      it 'gets begin_pos' do
+        expect(subject.begin_pos).to eq "gem 'rails'\ngem 'mysql2'".length
+      end
+
+      it 'gets end_pos' do
+        expect(subject.end_pos).to eq "gem 'rails'\ngem 'mysql2'".length
+      end
+
+      it 'gets rewritten_code' do
+        expect(subject.rewritten_code).to eq "\ngem 'twitter'"
+      end
+    end
+  end
+
+  describe Rewriter::InsertAction do
+    describe 'block node without args' do
+      subject {
+        source = "Synvert::Application.configure do\nend"
+        block_node = Parser::CurrentRuby.parse(source)
+        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 "Synvert::Application.configure do".length
+      end
+
+      it 'gets end_pos' do
+        expect(subject.end_pos).to eq "Synvert::Application.configure do".length
+      end
+
+      it 'gets rewritten_code' do
+        expect(subject.rewritten_code).to eq "\n  config.eager_load = true"
+      end
+    end
+
+    describe 'block node with args' do
+      subject {
+        source = "RSpec.configure do |config|\nend"
+        block_node = Parser::CurrentRuby.parse(source)
+        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 "RSpec.configure do |config|".length
+      end
+
+      it 'gets end_pos' do
+        expect(subject.end_pos).to eq "RSpec.configure do |config|".length
+      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 "class User".length
+      end
+
+      it 'gets end_pos' do
+        expect(subject.end_pos).to eq "class User".length
+      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 "class User < ActionRecord::Base".length
+      end
+
+      it 'gets end_pos' do
+        expect(subject.end_pos).to eq "class User < ActionRecord::Base".length
+      end
+
+      it 'gets rewritten_code' do
+        expect(subject.rewritten_code).to eq "\n  include Deletable"
+      end
+    end
+  end
+
+  describe Rewriter::InsertAfterAction do
+    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 "  include Foo".length
+    end
+
+    it 'gets end_pos' do
+      expect(subject.end_pos).to eq "  include Foo".length
+    end
+
+    it 'gets rewritten_code' do
+      expect(subject.rewritten_code).to eq "\n  include Bar"
+    end
+  end
+
+  describe Rewriter::RemoveAction do
+    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 "user = User.new params[:user]\n".length
+    end
+
+    it 'gets end_pos' do
+      expect(subject.end_pos).to eq "user = User.new params[:user]\nuser.save".length
+    end
+
+    it 'gets rewritten_code' do
+      expect(subject.rewritten_code).to eq ""
+    end
+  end
+end

data/spec/synvert/core/rewriter/condition_spec.rb

@@ -0,0 +1,106 @@
+require 'spec_helper'
+
+module Synvert::Core
+  describe Rewriter::IfExistCondition do
+    let(:source) {
+      """
+      RSpec.configure do |config|
+        config.include EmailSpec::Helpers
+        config.include EmailSpec::Methods
+      end
+      """
+    }
+    let(:node) { Parser::CurrentRuby.parse(source) }
+    let(:instance) { double(:current_node => node, :current_source => source) }
+
+    describe '#process' do
+      it 'call block if match anything' do
+        run = false
+        condition = Rewriter::IfExistCondition.new instance, type: 'send', message: 'include', arguments: ['EmailSpec::Helpers'] do
+          run = true
+        end
+        condition.process
+        expect(run).to be_true
+      end
+
+      it 'not call block if not match anything' do
+        run = false
+        condition = Rewriter::IfExistCondition.new instance, type: 'send', message: 'include', arguments: ['FactoryGirl::SyntaxMethods'] do
+          run = true
+        end
+        condition.process
+        expect(run).to be_false
+      end
+    end
+  end
+
+  describe Rewriter::UnlessExistCondition do
+    let(:source) {
+      """
+      RSpec.configure do |config|
+        config.include EmailSpec::Helpers
+        config.include EmailSpec::Methods
+      end
+      """
+    }
+    let(:node) { Parser::CurrentRuby.parse(source) }
+    let(:instance) { double(:current_node => node, :current_source => source) }
+
+    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 '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 '#process' do
+      it 'gets matching nodes' do
+        source = """
+          RSpec.configure do |config|
+            config.include EmailSpec::Helpers
+          end
+        """
+        node = Parser::CurrentRuby.parse(source)
+        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 'not call block if does not match' do
+        source = """
+          RSpec.configure do |config|
+            config.include EmailSpec::Helpers
+            config.include EmailSpec::Methods
+          end
+        """
+        node = Parser::CurrentRuby.parse(source)
+        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
+end

data/spec/synvert/core/rewriter/gem_spec_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+module Synvert::Core
+  describe Rewriter::GemSpec do
+    before { Configuration.instance.set :path, '.' }
+    let(:gemfile_lock_content) { """
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (1.1.0)
+    parser (2.1.7)
+      ast (~> 1.1)
+      slop (~> 3.4, >= 3.4.5)
+    rake (10.1.1)
+    slop (3.4.7)
+      """}
+
+    it 'returns true if version in Gemfile.lock is greater than definition' do
+      expect(File).to receive(:exists?).with('./Gemfile.lock').and_return(true)
+      expect(File).to receive(:read).with('./Gemfile.lock').and_return(gemfile_lock_content)
+      gem_spec = Rewriter::GemSpec.new('ast', {gte: '1.0.0'})
+      expect(gem_spec).to be_match
+    end
+
+    it 'returns true if version in Gemfile.lock is equal to definition' do
+      expect(File).to receive(:exists?).with('./Gemfile.lock').and_return(true)
+      expect(File).to receive(:read).with('./Gemfile.lock').and_return(gemfile_lock_content)
+      gem_spec = Rewriter::GemSpec.new('ast', '1.1.0')
+      expect(gem_spec).to be_match
+    end
+
+    it 'returns false if version in Gemfile.lock is less than definition' do
+      expect(File).to receive(:exists?).with('./Gemfile.lock').and_return(true)
+      expect(File).to receive(:read).with('./Gemfile.lock').and_return(gemfile_lock_content)
+      gem_spec = Rewriter::GemSpec.new('ast', {gt: '1.2.0'})
+      expect(gem_spec).not_to be_match
+    end
+
+    it 'returns false if gem does not exist in Gemfile.lock' do
+      expect(File).to receive(:exists?).with('./Gemfile.lock').and_return(true)
+      expect(File).to receive(:read).with('./Gemfile.lock').and_return(gemfile_lock_content)
+      gem_spec = Rewriter::GemSpec.new('synvert', '1.0.0')
+      expect(gem_spec).not_to be_match
+    end
+
+    it 'raise Synvert::Core::GemfileLockNotFound if Gemfile.lock does not exist' do
+      expect(File).to receive(:exists?).with('./Gemfile.lock').and_return(false)
+      gem_spec = Rewriter::GemSpec.new('ast', '1.1.0')
+      expect { gem_spec.match? }.to raise_error(Synvert::Core::GemfileLockNotFound)
+    end
+  end
+end

data/spec/synvert/core/rewriter/instance_spec.rb

@@ -0,0 +1,163 @@
+require 'spec_helper'
+
+module Synvert::Core
+  describe Rewriter::Instance do
+    let(:instance) { Rewriter::Instance.new('file pattern') }
+
+    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
+
+    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
+
+    it 'parses if_exist_node' do
+      condition = double()
+      block = Proc.new {}
+      expect(Rewriter::IfExistCondition).to receive(:new).with(instance, type: 'send', message: 'create', &block).and_return(condition)
+      expect(condition).to receive(:process)
+      instance.if_exist_node(type: 'send', message: 'create', &block)
+    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
+
+    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
+
+    describe '#process' do
+      before { Configuration.instance.set :path, '.' }
+
+      it 'FactoryGirl uses short syntax' do
+        instance = Rewriter::Instance.new '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
+  user = FactoryGirl.create :user
+  post = FactoryGirl.create :post, user: user
+  assert post.valid?
+end
+"""
+        output = """
+it 'uses factory_girl' do
+  user = create :user
+  post = create :post, user: user
+  assert post.valid?
+end
+"""
+        expect(Dir).to receive(:glob).with('./spec/**/*_spec.rb').and_return(['spec/models/post_spec.rb'])
+        expect(File).to receive(:read).with('spec/models/post_spec.rb').and_return(input)
+        expect(File).to receive(:write).with('spec/models/post_spec.rb', output)
+        instance.process
+      end
+
+      it 'includes FactoryGirl::Syntax::Methods' do
+        instance = Rewriter::Instance.new '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 = """
+        RSpec.configure do |config|
+        end
+        """
+        output = """
+        RSpec.configure do |config|
+          config.include FactoryGirl::Syntax::Methods
+        end
+        """
+        expect(Dir).to receive(:glob).with('./spec/spec_helper.rb').and_return(['spec/spec_helper.rb'])
+        expect(File).to receive(:read).with('spec/spec_helper.rb').and_return(input)
+        expect(File).to receive(:write).with('spec/spec_helper.rb', output)
+        instance.process
+      end
+
+      it 'does not include FactoryGirl::Syntax::Methods' do
+        instance = Rewriter::Instance.new '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 = """
+        RSpec.configure do |config|
+          config.include FactoryGirl::Syntax::Methods
+        end
+        """
+        output = """
+        RSpec.configure do |config|
+          config.include FactoryGirl::Syntax::Methods
+        end
+        """
+        expect(Dir).to receive(:glob).with('./spec/spec_helper.rb').and_return(['spec/spec_helper.rb'])
+        expect(File).to receive(:read).with('spec/spec_helper.rb').and_return(input)
+        expect(File).to receive(:write).with('spec/spec_helper.rb', output)
+        instance.process
+      end
+
+      it 'process nested send nodes' do
+        instance = Rewriter::Instance.new '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 = ''
+        expect(Dir).to receive(:glob).with('./config/*.rb').and_return(['config/environments/production.rb'])
+        expect(File).to receive(:read).with('config/environments/production.rb').and_return(input)
+        expect(File).to receive(:write).with('config/environments/production.rb', output)
+        instance.process
+      end
+    end
+  end
+end