synvert-core 0.15.2 → 0.19.0

data/spec/synvert/core/rewriter/action/insert_action_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 module Synvert::Core
@@ -11,11 +13,11 @@ module Synvert::Core
       }
 
       it 'gets begin_pos' do
-        expect(subject.begin_pos).to eq "Synvert::Application.configure do".length
+        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
+        expect(subject.end_pos).to eq 'Synvert::Application.configure do'.length
       end
 
       it 'gets rewritten_code' do
@@ -32,11 +34,11 @@ module Synvert::Core
       }
 
       it 'gets begin_pos' do
-        expect(subject.begin_pos).to eq "RSpec.configure do |config|".length
+        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
+        expect(subject.end_pos).to eq 'RSpec.configure do |config|'.length
       end
 
       it 'gets rewritten_code' do
@@ -53,11 +55,11 @@ module Synvert::Core
       }
 
       it 'gets begin_pos' do
-        expect(subject.begin_pos).to eq "class User".length
+        expect(subject.begin_pos).to eq 'class User'.length
       end
 
       it 'gets end_pos' do
-        expect(subject.end_pos).to eq "class User".length
+        expect(subject.end_pos).to eq 'class User'.length
       end
 
       it 'gets rewritten_code' do
@@ -74,11 +76,11 @@ module Synvert::Core
       }
 
       it 'gets begin_pos' do
-        expect(subject.begin_pos).to eq "class User < ActionRecord::Base".length
+        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
+        expect(subject.end_pos).to eq 'class User < ActionRecord::Base'.length
       end
 
       it 'gets rewritten_code' do

data/spec/synvert/core/rewriter/action/insert_after_action_spec.rb

@@ -1,20 +1,22 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 module Synvert::Core
   describe Rewriter::InsertAfterAction do
     subject {
-      source = "  include Foo"
+      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
+      expect(subject.begin_pos).to eq '  include Foo'.length
     end
 
     it 'gets end_pos' do
-      expect(subject.end_pos).to eq "  include Foo".length
+      expect(subject.end_pos).to eq '  include Foo'.length
     end
 
     it 'gets rewritten_code' do

data/spec/synvert/core/rewriter/action/remove_action_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 module Synvert::Core
@@ -18,7 +20,7 @@ module Synvert::Core
     end
 
     it 'gets rewritten_code' do
-      expect(subject.rewritten_code).to eq ""
+      expect(subject.rewritten_code).to eq ''
     end
   end
 end

data/spec/synvert/core/rewriter/action/replace_erb_stmt_with_expr_action_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 module Synvert::Core

data/spec/synvert/core/rewriter/action/replace_with_action_spec.rb

@@ -1,21 +1,23 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 module Synvert::Core
   describe Rewriter::ReplaceWithAction do
-    context "replace with single line" do
+    context 'replace with single line' do
       subject {
-        source = "post = FactoryGirl.create_list :post, 2"
+        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
+        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
+        expect(subject.end_pos).to eq 'post = FactoryGirl.create_list :post, 2'.length
       end
 
       it 'gets rewritten_code' do
@@ -23,15 +25,19 @@ module Synvert::Core
       end
     end
 
-    context "#replace with multiple line" do
+    context '#replace with multiple line' do
       subject {
-        source = "  its(:size) { should == 1 }"
+        source = '  its(:size) { should == 1 }'
         send_node = Parser::CurrentRuby.parse(source)
         instance = double(current_node: send_node)
-        Rewriter::ReplaceWithAction.new(instance, """describe '#size' do
+        Rewriter::ReplaceWithAction.new(
+          instance,
+          "describe '#size' do
   subject { super().size }
   it { {{body}} }
-end""", autoindent: false)
+end",
+          autoindent: false
+        )
       }
 
       it 'gets begin_pos' do
@@ -39,14 +45,14 @@ end""", autoindent: false)
       end
 
       it 'gets end_pos' do
-        expect(subject.end_pos).to eq "  its(:size) { should == 1 }".length
+        expect(subject.end_pos).to eq '  its(:size) { should == 1 }'.length
       end
 
       it 'gets rewritten_code' do
-        expect(subject.rewritten_code).to eq """describe '#size' do
+        expect(subject.rewritten_code).to eq "describe '#size' do
   subject { super().size }
   it { should == 1 }
-end"""
+end"
       end
     end
   end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 module Synvert::Core

data/spec/synvert/core/rewriter/condition/if_exist_condition_spec.rb

@@ -1,33 +1,43 @@
+# frozen_string_literal: true
+
 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) }
+    let(:instance) { double(current_node: node) }
 
     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 =
+          Rewriter::IfExistCondition.new instance,
+                                         type: 'send',
+                                         message: 'include',
+                                         arguments: ['EmailSpec::Helpers'] do
+            run = true
+          end
         condition.process
         expect(run).to be_truthy
       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 =
+          Rewriter::IfExistCondition.new instance,
+                                         type: 'send',
+                                         message: 'include',
+                                         arguments: ['FactoryGirl::SyntaxMethods'] do
+            run = true
+          end
         condition.process
         expect(run).to be_falsey
       end

data/spec/synvert/core/rewriter/condition/if_only_exist_condition_spec.rb

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

data/spec/synvert/core/rewriter/condition/unless_exist_condition_spec.rb

@@ -1,33 +1,43 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 module Synvert::Core
   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) }
+    let(:instance) { double(current_node: node) }
 
     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 =
+          Rewriter::UnlessExistCondition.new instance,
+                                             type: 'send',
+                                             message: 'include',
+                                             arguments: ['FactoryGirl::Syntax::Methods'] do
+            run = true
+          end
         condition.process
         expect(run).to be_truthy
       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 =
+          Rewriter::UnlessExistCondition.new instance,
+                                             type: 'send',
+                                             message: 'include',
+                                             arguments: ['EmailSpec::Helpers'] do
+            run = true
+          end
         condition.process
         expect(run).to be_falsey
       end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 module Synvert::Core

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

@@ -1,8 +1,11 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 module Synvert::Core
   describe Rewriter::GemSpec do
-    let(:gemfile_lock_content) { """
+    let(:gemfile_lock_content) {
+      '
 GEM
   remote: https://rubygems.org/
   specs:
@@ -12,41 +15,41 @@ GEM
       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(:exist?).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'})
+      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(:exist?).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(:exist?).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'})
+      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(:exist?).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)
+      expect(File).to receive(:exist?).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)
+      expect(gem_spec).to be_match
     end
   end
 end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 module Synvert::Core
@@ -5,74 +7,77 @@ module Synvert::Core
     let(:dummy_instance) { Class.new { include Rewriter::Helper }.new }
     let(:instance) do
       rewriter = Rewriter.new('foo', 'bar')
-      Rewriter::Instance.new rewriter, 'spec/**/*_spec.rb' do; end
+      Rewriter::Instance.new rewriter, 'spec/**/*_spec.rb' do
+      end
     end
 
-    describe "add_receiver_if_necessary" do
-      context "with receiver" do
-        let(:node) { parse("User.save(false)") }
+    describe 'add_receiver_if_necessary' do
+      context 'with receiver' do
+        let(:node) { parse('User.save(false)') }
 
-        it "adds reciever" do
+        it 'adds reciever' do
           allow(dummy_instance).to receive(:node).and_return(node)
-          expect(dummy_instance.add_receiver_if_necessary("save(validate: false)")).to eq "{{receiver}}.save(validate: false)"
+          expect(
+            dummy_instance.add_receiver_if_necessary('save(validate: false)')
+          ).to eq '{{receiver}}.save(validate: false)'
         end
       end
 
-      context "without receiver" do
-        let(:node) { parse("save(false)") }
+      context 'without receiver' do
+        let(:node) { parse('save(false)') }
 
         it "doesn't add reciever" do
           allow(dummy_instance).to receive(:node).and_return(node)
-          expect(dummy_instance.add_receiver_if_necessary("save(validate: false)")).to eq "save(validate: false)"
+          expect(dummy_instance.add_receiver_if_necessary('save(validate: false)')).to eq 'save(validate: false)'
         end
       end
     end
 
-    describe "add_arguments_with_parenthesis_if_necessary" do
-      context "with arguments" do
-        let(:node) { parse("user.save(false)") }
+    describe 'add_arguments_with_parenthesis_if_necessary' do
+      context 'with arguments' do
+        let(:node) { parse('user.save(false)') }
 
-        it "gets arguments with parenthesis" do
+        it 'gets arguments with parenthesis' do
           allow(dummy_instance).to receive(:node).and_return(node)
-          expect(dummy_instance.add_arguments_with_parenthesis_if_necessary).to eq "({{arguments}})"
+          expect(dummy_instance.add_arguments_with_parenthesis_if_necessary).to eq '({{arguments}})'
         end
       end
 
-      context "without argument" do
-        let(:node) { parse("user.save") }
+      context 'without argument' do
+        let(:node) { parse('user.save') }
 
-        it "gets nothing" do
+        it 'gets nothing' do
           allow(dummy_instance).to receive(:node).and_return(node)
-          expect(dummy_instance.add_arguments_with_parenthesis_if_necessary).to eq ""
+          expect(dummy_instance.add_arguments_with_parenthesis_if_necessary).to eq ''
         end
       end
     end
 
-    describe "add_curly_brackets_if_necessary" do
-      it "add {} if code does not have" do
-        expect(dummy_instance.add_curly_brackets_if_necessary("foo: bar")).to eq "{ foo: bar }"
+    describe 'add_curly_brackets_if_necessary' do
+      it 'add {} if code does not have' do
+        expect(dummy_instance.add_curly_brackets_if_necessary('foo: bar')).to eq '{ foo: bar }'
       end
 
       it "doesn't add {} if code already has" do
-        expect(dummy_instance.add_curly_brackets_if_necessary("{foo: bar}")).to eq "{foo: bar}"
+        expect(dummy_instance.add_curly_brackets_if_necessary('{foo: bar}')).to eq '{foo: bar}'
       end
     end
 
-    describe "strip_brackets" do
-      it "strip ()" do
-        expect(dummy_instance.strip_brackets("(123)")).to eq "123"
+    describe 'strip_brackets' do
+      it 'strip ()' do
+        expect(dummy_instance.strip_brackets('(123)')).to eq '123'
       end
 
-      it "strip {}" do
-        expect(dummy_instance.strip_brackets("{123}")).to eq "123"
+      it 'strip {}' do
+        expect(dummy_instance.strip_brackets('{123}')).to eq '123'
       end
 
-      it "strip []" do
-        expect(dummy_instance.strip_brackets("[123]")).to eq "123"
+      it 'strip []' do
+        expect(dummy_instance.strip_brackets('[123]')).to eq '123'
       end
 
-      it "not strip unmatched (]" do
-        expect(dummy_instance.strip_brackets("(123]")).to eq "(123]"
+      it 'not strip unmatched (]' do
+        expect(dummy_instance.strip_brackets('(123]')).to eq '(123]'
       end
     end
   end