synvert-core 0.16.0 → 0.20.0

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

@@ -20,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_with_action_spec.rb

@@ -4,20 +4,20 @@ 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
@@ -25,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
@@ -41,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/condition/if_exist_condition_spec.rb

@@ -5,31 +5,39 @@ 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

@@ -5,38 +5,47 @@ 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

@@ -5,31 +5,39 @@ 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/gem_spec_spec.rb

@@ -4,7 +4,8 @@ require 'spec_helper'
 
 module Synvert::Core
   describe Rewriter::GemSpec do
-    let(:gemfile_lock_content) { """
+    let(:gemfile_lock_content) {
+      '
 GEM
   remote: https://rubygems.org/
   specs:
@@ -14,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

@@ -7,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

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

@@ -12,82 +12,104 @@ module Synvert::Core
     }
 
     it 'parses within_node' do
-      scope = double()
-      block = Proc.new {}
-      expect(Rewriter::WithinScope).to receive(:new).with(instance, { type: 'send', message: 'create' }, { recursive: true }, &block).and_return(scope)
+      scope = double
+      block = proc {}
+      expect(Rewriter::WithinScope).to receive(:new)
+        .with(instance, { type: 'send', message: 'create' }, { recursive: true }, &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::WithinScope).to receive(:new).with(instance, { type: 'send', message: 'create' }, { recursive: true }, &block).and_return(scope)
+      scope = double
+      block = proc {}
+      expect(Rewriter::WithinScope).to receive(:new)
+        .with(instance, { type: 'send', message: 'create' }, { recursive: true }, &block)
+        .and_return(scope)
       expect(scope).to receive(:process)
       instance.with_node(type: 'send', message: 'create', &block)
     end
 
     it 'parses within_direct_node' do
-      scope = double()
-      block = Proc.new {}
-      expect(Rewriter::WithinScope).to receive(:new).with(instance, { type: 'send', message: 'create' }, { recursive: false }, &block).and_return(scope)
+      scope = double
+      block = proc {}
+      expect(Rewriter::WithinScope).to receive(:new)
+        .with(instance, { type: 'send', message: 'create' }, { recursive: false }, &block)
+        .and_return(scope)
       expect(scope).to receive(:process)
       instance.within_direct_node(type: 'send', message: 'create', &block)
     end
 
     it 'parses with_direct_node' do
-      scope = double()
-      block = Proc.new {}
-      expect(Rewriter::WithinScope).to receive(:new).with(instance, { type: 'send', message: 'create' }, { recursive: false }, &block).and_return(scope)
+      scope = double
+      block = proc {}
+      expect(Rewriter::WithinScope).to receive(:new)
+        .with(instance, { type: 'send', message: 'create' }, { recursive: false }, &block)
+        .and_return(scope)
       expect(scope).to receive(:process)
       instance.with_direct_node(type: 'send', message: 'create', &block)
     end
 
     it 'parses goto_node' do
-      scope = double()
-      block = Proc.new {}
+      scope = double
+      block = proc {}
       expect(Rewriter::GotoScope).to receive(:new).with(instance, :caller, &block).and_return(scope)
       expect(scope).to receive(:process)
       instance.goto_node(:caller, &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)
+      condition = double
+      block = proc {}
+      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)
+      condition = double
+      block = proc {}
+      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)
+      condition = double
+      block = proc {}
+      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"
+      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"
+      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"
+      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
@@ -109,25 +131,28 @@ module Synvert::Core
       let(:rewriter) { Rewriter.new('foo', 'bar') }
 
       it 'writes new code to file' do
-        instance = Rewriter::Instance.new rewriter, 'spec/**/*_spec.rb' do
-          with_node type: 'send', receiver: 'FactoryGirl', message: 'create' do
-            replace_with 'create {{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
-        end
-        input = """
+        input =
+          "
 it 'uses factory_girl' do
   user = FactoryGirl.create :user
   post = FactoryGirl.create :post, user: user
   assert post.valid?
 end
-"""
-        output = """
+"
+        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)
@@ -135,23 +160,26 @@ end
       end
 
       it 'does not write if file content is not changed' do
-        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"
+        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
-        end
-        input = """
+        input =
+          '
         RSpec.configure do |config|
           config.include FactoryGirl::Syntax::Methods
         end
-        """
-        output = """
+        '
+        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).not_to receive(:write).with('spec/spec_helper.rb', output)
@@ -159,23 +187,26 @@ end
       end
 
       it 'does not read file if already read' do
-        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"
+        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
-        end
-        input = """
+        input =
+          '
         RSpec.configure do |config|
           config.include FactoryGirl::Syntax::Methods
         end
-        """
-        output = """
+        '
+        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']).twice
         expect(File).to receive(:read).with('spec/spec_helper.rb').and_return(input).once
         expect(File).not_to receive(:write).with('spec/spec_helper.rb', output)
@@ -184,25 +215,28 @@ end
       end
 
       it 'updates file_source and file_ast when writing a file' do
-        instance = Rewriter::Instance.new rewriter, 'spec/**/*_spec.rb' do
-          with_node type: 'send', receiver: 'FactoryGirl', message: 'create' do
-            replace_with 'create {{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
-        end
-        input = """
+        input =
+          "
 it 'uses factory_girl' do
   user = FactoryGirl.create :user
   post = FactoryGirl.create :post, user: user
   assert post.valid?
 end
-"""
-        output = """
+"
+        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']).twice
         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)
@@ -212,10 +246,10 @@ end
       end
     end
 
-    describe "#get_conflict_actions" do
+    describe '#get_conflict_actions' do
       let(:rewriter) { Rewriter.new('foo', 'bar') }
 
-      it "has no conflict" do
+      it 'has no conflict' do
         action1 = double(begin_pos: 10, end_pos: 20)
         action2 = double(begin_pos: 30, end_pos: 40)
         action3 = double(begin_pos: 50, end_pos: 60)
@@ -226,7 +260,7 @@ end
         expect(instance.instance_variable_get(:@actions)).to eq [action1, action2, action3]
       end
 
-      it "has no conflict" do
+      it 'has no conflict' do
         action1 = double(begin_pos: 30, end_pos: 40)
         action2 = double(begin_pos: 50, end_pos: 60)
         action3 = double(begin_pos: 10, end_pos: 20)
@@ -240,8 +274,8 @@ end
 
     describe '#process_with_node' do
       it 'resets current_node' do
-        node1 = double()
-        node2 = double()
+        node1 = double
+        node2 = double
         instance.process_with_node(node1) do
           instance.current_node = node2
           expect(instance.current_node).to eq node2
@@ -252,9 +286,9 @@ end
 
     describe '#process_with_other_node' do
       it 'resets current_node' do
-        node1 = double()
-        node2 = double()
-        node3 = double()
+        node1 = double
+        node2 = double
+        node3 = double
         instance.current_node = node1
         instance.process_with_other_node(node2) do
           instance.current_node = node3