synvert 0.0.17 → 0.1.0

data/spec/synvert/rewriter/action_spec.rb

@@ -1,225 +0,0 @@
-require 'spec_helper'
-
-module Synvert
-  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/rewriter/condition_spec.rb

@@ -1,106 +0,0 @@
-require 'spec_helper'
-
-module Synvert
-  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/rewriter/gem_spec_spec.rb

@@ -1,52 +0,0 @@
-require 'spec_helper'
-
-module Synvert
-  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::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::GemfileLockNotFound)
-    end
-  end
-end

data/spec/synvert/rewriter/instance_spec.rb

@@ -1,163 +0,0 @@
-require 'spec_helper'
-
-module Synvert
-  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

data/spec/synvert/rewriter/scope_spec.rb

@@ -1,42 +0,0 @@
-require 'spec_helper'
-
-module Synvert
-  describe Rewriter::Scope do
-    let(:source) {
-"""
-describe Post do
-  before :each do
-    @user = FactoryGirl.create :user
-  end
-
-  it 'gets posts' do
-    post1 = FactoryGirl.create :post
-    post2 = FactoryGirl.create :post
-  end
-end
-"""
-    }
-    let(:node) { Parser::CurrentRuby.parse(source) }
-    let(:instance) { double(:current_node => node, :current_node= => node, :current_source => source) }
-
-    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 '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
-end