synvert-core 0.15.2 → 0.19.0

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 module Synvert::Core
@@ -10,66 +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', &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', &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 {}
+      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 {}
+      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
@@ -91,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)
@@ -117,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)
@@ -141,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)
@@ -166,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)
@@ -194,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)
@@ -205,10 +257,10 @@ end
         instance.instance_variable_set :@actions, [action1, action2, action3]
         conflict_actions = instance.send(:get_conflict_actions)
         expect(conflict_actions).to eq []
-        expect(instance.instance_variable_get :@actions).to eq [action1, action2, action3]
+        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)
@@ -216,14 +268,14 @@ end
         instance.instance_variable_set :@actions, [action1, action2, action3]
         conflict_actions = instance.send(:get_conflict_actions)
         expect(conflict_actions).to eq [action2, action1]
-        expect(instance.instance_variable_get :@actions).to eq [action3]
+        expect(instance.instance_variable_get(:@actions)).to eq [action3]
       end
     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
@@ -234,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

data/spec/synvert/core/rewriter/scope/goto_scope_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 module Synvert::Core
@@ -6,10 +8,11 @@ module Synvert::Core
       rewriter = Rewriter.new('foo', 'bar')
       Rewriter::Instance.new(rewriter, 'file pattern')
     }
-    let(:source) {'''
+    let(:source) {
+      '
 Factory.define :user do |user|
 end
-    '''
+    '
     }
     let(:node) { Parser::CurrentRuby.parse(source) }
     before do
@@ -21,10 +24,11 @@ end
       it 'call block with child node' do
         run = false
         type_in_scope = nil
-        scope = Rewriter::GotoScope.new instance, :caller do
-          run = true
-          type_in_scope = node.type
-        end
+        scope =
+          Rewriter::GotoScope.new instance, :caller do
+            run = true
+            type_in_scope = node.type
+          end
         scope.process
         expect(run).to be_truthy
         expect(type_in_scope).to eq :send

data/spec/synvert/core/rewriter/scope/within_scope.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 module Synvert::Core
@@ -6,13 +8,14 @@ module Synvert::Core
       rewriter = Rewriter.new('foo', 'bar')
       Rewriter::Instance.new(rewriter, 'file pattern')
     }
-    let(:source) {"""
+    let(:source) {
+      "
 describe Post do
   it 'gets post' do
     FactoryGirl.create :post
   end
 end
-    """
+    "
     }
     let(:node) { Parser::CurrentRuby.parse(source) }
     before do
@@ -23,9 +26,10 @@ end
     describe '#process' do
       it 'not call block if no matching node' do
         run = false
-        scope = Rewriter::WithinScope.new instance, type: 'send', message: 'missing' do
-          run = true
-        end
+        scope =
+          Rewriter::WithinScope.new instance, type: 'send', message: 'missing' do
+            run = true
+          end
         scope.process
         expect(run).to be_falsey
       end
@@ -33,10 +37,15 @@ end
       it 'call block if there is matching node' do
         run = false
         type_in_scope = nil
-        scope = Rewriter::WithinScope.new instance, type: 'send', receiver: 'FactoryGirl', message: 'create', arguments: [':post'] do
-          run = true
-          type_in_scope = node.type
-        end
+        scope =
+          Rewriter::WithinScope.new instance,
+                                    type: 'send',
+                                    receiver: 'FactoryGirl',
+                                    message: 'create',
+                                    arguments: [':post'] do
+            run = true
+            type_in_scope = node.type
+          end
         scope.process
         expect(run).to be_truthy
         expect(type_in_scope).to eq :send

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

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

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

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

data/spec/synvert/core/rewriter_spec.rb

@@ -1,28 +1,39 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 module Synvert::Core
   describe Rewriter do
+    it '.execute' do
+      run = false
+      Rewriter.execute { run = true }
+      expect(run).to be_truthy
+    end
+
     it 'parses description' do
-      rewriter = Rewriter.new 'group', 'name' do
-        description 'rewriter description'
-      end
+      rewriter =
+        Rewriter.new 'group', 'name' do
+          description 'rewriter description'
+        end
       rewriter.process
       expect(rewriter.description).to eq 'rewriter description'
     end
 
     it 'parses if_ruby' do
-      #stub_const("RUBY_VERSION", '2.0.0')
-      rewriter = Rewriter.new 'group', 'name' do
-        if_ruby '2.0.0'
-      end
+      expect(Rewriter::RubyVersion).to receive(:new).with('2.0.0')
+      rewriter =
+        Rewriter.new 'group', 'name' do
+          if_ruby '2.0.0'
+        end
       rewriter.process
     end
 
     it 'parses if_gem' do
-      expect(Rewriter::GemSpec).to receive(:new).with('synvert', {gte: '1.0.0'})
-      rewriter = Rewriter.new 'group', 'name' do
-        if_gem 'synvert', {gte: '1.0.0'}
-      end
+      expect(Rewriter::GemSpec).to receive(:new).with('synvert', { gte: '1.0.0' })
+      rewriter =
+        Rewriter.new 'group', 'name' do
+          if_gem 'synvert', { gte: '1.0.0' }
+        end
       rewriter.process
     end
 
@@ -30,76 +41,90 @@ module Synvert::Core
       it 'does nothing if if_ruby does not match' do
         stub_const('RUBY_VERSION', '2.0.0')
         expect_any_instance_of(Rewriter::Instance).not_to receive(:process)
-        rewriter = Rewriter.new 'group', 'name' do
-          if_ruby '2.2.3'
-          within_file 'config/routes.rb' do; end
-        end
+        rewriter =
+          Rewriter.new 'group', 'name' do
+            if_ruby '2.2.3'
+            within_file 'config/routes.rb' do
+            end
+          end
         rewriter.process
       end
 
       it 'delegates process to instances if if_ruby matches' do
         stub_const('RUBY_VERSION', '2.0.0')
         expect_any_instance_of(Rewriter::Instance).to receive(:process)
-        rewriter = Rewriter.new 'group', 'name' do
-          if_ruby '1.9.3'
-          within_file 'config/routes.rb' do; end
-        end
+        rewriter =
+          Rewriter.new 'group', 'name' do
+            if_ruby '1.9.3'
+            within_file 'config/routes.rb' do
+            end
+          end
         rewriter.process
       end
 
       it 'does nothing if if_gem does not match' do
         expect_any_instance_of(Rewriter::GemSpec).to receive(:match?).and_return(false)
         expect_any_instance_of(Rewriter::Instance).not_to receive(:process)
-        rewriter = Rewriter.new 'group', 'name' do
-          if_gem 'synvert', '1.0.0'
-          within_file 'config/routes.rb' do; end
-        end
+        rewriter =
+          Rewriter.new 'group', 'name' do
+            if_gem 'synvert', '1.0.0'
+            within_file 'config/routes.rb' do
+            end
+          end
         rewriter.process
       end
 
       it 'delegates process to instances if if_gem matches' do
         expect_any_instance_of(Rewriter::GemSpec).to receive(:match?).and_return(true)
         expect_any_instance_of(Rewriter::Instance).to receive(:process)
-        rewriter = Rewriter.new 'group', 'name' do
-          if_gem 'synvert', '1.0.0'
-          within_file 'config/routes.rb' do; end
-        end
+        rewriter =
+          Rewriter.new 'group', 'name' do
+            if_gem 'synvert', '1.0.0'
+            within_file 'config/routes.rb' do
+            end
+          end
         rewriter.process
       end
 
       it 'delegates process to instances if if_ruby and if_gem do not exist' do
         expect_any_instance_of(Rewriter::Instance).to receive(:process)
-        rewriter = Rewriter.new 'group', 'name' do
-          within_file 'config/routes.rb' do; end
-        end
+        rewriter =
+          Rewriter.new 'group', 'name' do
+            within_file 'config/routes.rb' do
+            end
+          end
         rewriter.process
       end
 
       it 'does nothing in sandbox mode' do
         expect_any_instance_of(Rewriter::GemSpec).not_to receive(:match?)
         expect_any_instance_of(Rewriter::Instance).not_to receive(:process)
-        rewriter = Rewriter.new 'group', 'name' do
-          if_gem 'synvert', '1.0.0'
-          within_file 'config/routes.rb' do; end
-        end
+        rewriter =
+          Rewriter.new 'group', 'name' do
+            if_gem 'synvert', '1.0.0'
+            within_file 'config/routes.rb' do
+            end
+          end
         rewriter.process_with_sandbox
       end
     end
 
     describe 'parses add_file' do
       it 'creates a new file' do
-        rewriter = Rewriter.new 'group', 'rewriter2' do
-          add_file 'foo.bar', 'FooBar'
-        end
+        rewriter =
+          Rewriter.new 'group', 'rewriter2' do
+            add_file 'foo.bar', 'FooBar'
+          end
         rewriter.process
-        expect(File.read './foo.bar').to eq 'FooBar'
+        expect(File.read('./foo.bar')).to eq 'FooBar'
         FileUtils.rm './foo.bar'
       end
 
       it 'does nothing in sandbox mode' do
-        rewriter = Rewriter.new 'group', 'rewriter2' do
-          add_file 'foo.bar', 'FooBar'
-        end
+        rewriter =
+          Rewriter.new 'group', 'rewriter2' do
+            add_file 'foo.bar', 'FooBar'
+          end
         rewriter.process_with_sandbox
         expect(File.exist?('./foo.bar')).to be_falsey
       end
@@ -108,26 +133,29 @@ module Synvert::Core
     describe 'parses remove_file' do
       it 'removes a file' do
         FileUtils.touch './foo.bar'
-        rewriter = Rewriter.new 'group', 'rewriter2' do
-          remove_file 'foo.bar'
-        end
+        rewriter =
+          Rewriter.new 'group', 'rewriter2' do
+            remove_file 'foo.bar'
+          end
         rewriter.process
-        expect(File.exist? './foo.bar').to be_falsey
+        expect(File.exist?('./foo.bar')).to be_falsey
       end
 
       it 'does nothing if file not exist' do
-        rewriter = Rewriter.new 'group', 'rewriter2' do
-          remove_file 'foo.bar'
-        end
+        rewriter =
+          Rewriter.new 'group', 'rewriter2' do
+            remove_file 'foo.bar'
+          end
         rewriter.process
-        expect(File.exist? './foo.bar').to be_falsey
+        expect(File.exist?('./foo.bar')).to be_falsey
       end
 
       it 'does nothing in sandbox mode' do
         FileUtils.touch './foo.bar'
-        rewriter = Rewriter.new 'group', 'rewriter2' do
-          add_file 'foo.bar', 'FooBar'
-        end
+        rewriter =
+          Rewriter.new 'group', 'rewriter2' do
+            add_file 'foo.bar', 'FooBar'
+          end
         rewriter.process_with_sandbox
         expect(File.exist?('./foo.bar')).to be_truthy
         FileUtils.rm './foo.bar'
@@ -137,46 +165,51 @@ module Synvert::Core
     describe 'parses add_snippet' do
       it 'processes the rewritter' do
         rewriter1 = Rewriter.new 'group', 'rewriter1'
-        rewriter2 = Rewriter.new 'group', 'rewriter2' do
-          add_snippet :group, :rewriter1
-        end
+        rewriter2 =
+          Rewriter.new 'group', 'rewriter2' do
+            add_snippet :group, :rewriter1
+          end
         expect(rewriter1).to receive(:process)
         rewriter2.process
       end
 
       it 'adds sub_snippets' do
         rewriter1 = Rewriter.new 'group', 'rewriter1'
-        rewriter2 = Rewriter.new 'group', 'rewriter2' do
-          add_snippet :group, :rewriter1
-        end
+        rewriter2 =
+          Rewriter.new 'group', 'rewriter2' do
+            add_snippet :group, :rewriter1
+          end
         expect(rewriter1).to receive(:process)
         rewriter2.process
         expect(rewriter2.sub_snippets).to eq [rewriter1]
       end
 
       it 'raises RewriterNotFound' do
-        rewriter = Rewriter.new 'group', 'name' do
-          add_snippet :group, :not_exist
-        end
+        rewriter =
+          Rewriter.new 'group', 'name' do
+            add_snippet :group, :not_exist
+          end
         expect { rewriter.process }.to raise_error(RewriterNotFound)
       end
     end
 
     it 'parses helper_method' do
-      rewriter = Rewriter.new 'group', 'name' do
-        helper_method 'dynamic_helper' do |arg1, arg2|
-          'dynamic result'
+      rewriter =
+        Rewriter.new 'group', 'name' do
+          helper_method 'dynamic_helper' do |_arg1, _arg2|
+            'dynamic result'
+          end
         end
-      end
       rewriter.process
       instance = Rewriter::Instance.new(rewriter, '*.rb')
       expect(instance.dynamic_helper('arg1', 'arg2')).to eq 'dynamic result'
     end
 
     it 'parses todo' do
-      rewriter = Rewriter.new 'group', 'name' do
-        todo "this rewriter doesn't do blah blah blah"
-      end
+      rewriter =
+        Rewriter.new 'group', 'name' do
+          todo "this rewriter doesn't do blah blah blah"
+        end
       rewriter.process
       expect(rewriter.todo).to eq "this rewriter doesn't do blah blah blah"
     end
@@ -201,18 +234,18 @@ module Synvert::Core
         expect { Rewriter.call 'group', 'rewriter' }.to raise_error(RewriterNotFound)
       end
 
-      context "exist?" do
+      context 'exist?' do
         it 'returns true if rewriter exists' do
           Rewriter.new 'group', 'rewriter'
-          expect(Rewriter.exist? 'group', 'rewriter').to be_truthy
+          expect(Rewriter.exist?('group', 'rewriter')).to be_truthy
         end
 
         it 'returns false if rewriter does not exist' do
-          expect(Rewriter.exist? 'group', 'rewriter').to be_falsey
+          expect(Rewriter.exist?('group', 'rewriter')).to be_falsey
         end
       end
 
-      context "available" do
+      context 'available' do
         it 'lists empty rewriters' do
           expect(Rewriter.availables).to eq({})
         end
@@ -220,7 +253,7 @@ module Synvert::Core
         it 'registers and lists all available rewriters' do
           rewriter1 = Rewriter.new 'group', 'rewriter1'
           rewriter2 = Rewriter.new 'group', 'rewriter2'
-          expect(Rewriter.availables).to eq({'group' => {'rewriter1' => rewriter1, 'rewriter2' => rewriter2}})
+          expect(Rewriter.availables).to eq({ 'group' => { 'rewriter1' => rewriter1, 'rewriter2' => rewriter2 } })
         end
       end
     end