diff --git a/lib/synvert/core.rb b/lib/synvert/core.rb
index e1cecdb6..fe8fe6ab 100644
--- a/lib/synvert/core.rb
+++ b/lib/synvert/core.rb
@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "synvert/core/version"
+require 'synvert/core/version'
 require 'bundler'
 require 'parser'
 require 'parser/current'
diff --git a/lib/synvert/core/engine/erb.rb b/lib/synvert/core/engine/erb.rb
index 34dcadf7..68b0a972 100644
--- a/lib/synvert/core/engine/erb.rb
+++ b/lib/synvert/core/engine/erb.rb
@@ -4,17 +4,17 @@
 
 module Synvert::Core
   module Engine
-    ERUBY_EXPR_SPLITTER = ";  ;"
-    ERUBY_STMT_SPLITTER = ";   ;"
+    ERUBY_EXPR_SPLITTER = ';  ;'
+    ERUBY_STMT_SPLITTER = ';   ;'
 
     class ERB
-      class <<self
+      class << self
         # convert erb to ruby code.
         #
         # @param source [String] erb source code.
         # @return [String] ruby source code.
         def encode(source)
-          Erubis.new(source.gsub("-%>", "%>"), :escape => false, :trim => false).src
+          Erubis.new(source.gsub('-%>', '%>'), escape: false, trim: false).src
         end
 
         # convert ruby code to erb.
@@ -28,25 +28,30 @@ def decode(source)
           source = remove_erubis_buf(source)
         end
 
-      private
+        private
 
         def decode_ruby_stmt(source)
           source.gsub(/#{ERUBY_STMT_SPLITTER}(.+?)#{ERUBY_STMT_SPLITTER}/m) { "<%#{$1}%>" }
         end
 
         def decode_ruby_output(source)
-          source.gsub(/@output_buffer.append=\((.+?)\);#{ERUBY_EXPR_SPLITTER}/m) { "<%=#{$1}%>" }
-            .gsub(/@output_buffer.append= (.+?)\s+(do|\{)(\s*\|[^|]*\|)?\s*#{ERUBY_EXPR_SPLITTER}/m) { |m| "<%=#{m.sub("@output_buffer.append= ", "").sub(ERUBY_EXPR_SPLITTER, "")}%>" }
+          source.gsub(/@output_buffer.append=\((.+?)\);#{ERUBY_EXPR_SPLITTER}/m) { "<%=#{$1}%>" }.gsub(
+            /@output_buffer.append= (.+?)\s+(do|\{)(\s*\|[^|]*\|)?\s*#{ERUBY_EXPR_SPLITTER}/m
+          ) { |m| "<%=#{m.sub('@output_buffer.append= ', '').sub(ERUBY_EXPR_SPLITTER, '')}%>" }
         end
 
         def decode_html_output(source)
-          source.gsub(/@output_buffer.safe_append='(.+?)'.freeze;/m) { reverse_escape_text($1) }
-            .gsub(/@output_buffer.safe_append=\((.+?)\);#{ERUBY_EXPR_SPLITTER}/m) { reverse_escape_text($1) }
-            .gsub(/@output_buffer.safe_append=(.+?)\s+(do|\{)(\s*\|[^|]*\|)?\s*#{ERUBY_EXPR_SPLITTER}/m) { reverse_escape_text($1) }
+          source.gsub(/@output_buffer.safe_append='(.+?)'.freeze;/m) { reverse_escape_text($1) }.gsub(
+            /@output_buffer.safe_append=\((.+?)\);#{ERUBY_EXPR_SPLITTER}/m
+          ) { reverse_escape_text($1) }.gsub(
+            /@output_buffer.safe_append=(.+?)\s+(do|\{)(\s*\|[^|]*\|)?\s*#{ERUBY_EXPR_SPLITTER}/m
+          ) { reverse_escape_text($1) }
         end
 
         def remove_erubis_buf(source)
-          source.sub("@output_buffer = output_buffer || ActionView::OutputBuffer.new;", "").sub("@output_buffer.to_s", "")
+          source
+            .sub('@output_buffer = output_buffer || ActionView::OutputBuffer.new;', '')
+            .sub('@output_buffer.to_s', '')
         end
 
         def reverse_escape_text(source)
@@ -59,7 +64,7 @@ def reverse_escape_text(source)
     class Erubis < ::Erubis::Eruby
       def add_preamble(src)
         @newline_pending = 0
-        src << "@output_buffer = output_buffer || ActionView::OutputBuffer.new;"
+        src << '@output_buffer = output_buffer || ActionView::OutputBuffer.new;'
       end
 
       def add_text(src, text)
@@ -102,22 +107,23 @@ def add_expr_literal(src, code)
       def add_expr_escaped(src, code)
         flush_newline_if_pending(src)
         if code =~ BLOCK_EXPR
-          src << "@output_buffer.safe_append= " << code << ERUBY_EXPR_SPLITTER
+          src << '@output_buffer.safe_append= ' << code << ERUBY_EXPR_SPLITTER
         else
-          src << "@output_buffer.safe_append=(" << code << ");" << ERUBY_EXPR_SPLITTER
+          src << '@output_buffer.safe_append=(' << code << ');' << ERUBY_EXPR_SPLITTER
         end
       end
 
       def add_stmt(src, code)
         flush_newline_if_pending(src)
-        if code != "\n" && code != ""
-          index = if code =~ /\A(\s*)\r?\n/
-                    $1.length
-                  elsif code =~ /\A(\s+)/
-                    $1.end_with?(' ') ? $1.length - 1 : $1.length
-                  else
-                    0
-                  end
+        if code != "\n" && code != ''
+          index =
+            if code =~ /\A(\s*)\r?\n/
+              $1.length
+            elsif code =~ /\A(\s+)/
+              $1.end_with?(' ') ? $1.length - 1 : $1.length
+            else
+              0
+            end
           code.insert(index, ERUBY_STMT_SPLITTER)
           code.insert(-1, ERUBY_STMT_SPLITTER[0...-1])
         end
diff --git a/lib/synvert/core/exceptions.rb b/lib/synvert/core/exceptions.rb
index 8e1867f6..97926644 100644
--- a/lib/synvert/core/exceptions.rb
+++ b/lib/synvert/core/exceptions.rb
@@ -2,14 +2,11 @@
 
 module Synvert::Core
   # Rewriter not found exception.
-  class RewriterNotFound < RuntimeError
-  end
+  class RewriterNotFound < RuntimeError; end
 
   # Gemfile.lock not found exception.
-  class GemfileLockNotFound < RuntimeError
-  end
+  class GemfileLockNotFound < RuntimeError; end
 
   # Method not supported exception.
-  class MethodNotSupported < RuntimeError
-  end
+  class MethodNotSupported < RuntimeError; end
 end
diff --git a/lib/synvert/core/node_ext.rb b/lib/synvert/core/node_ext.rb
index 046adbfb..5c2262f5 100644
--- a/lib/synvert/core/node_ext.rb
+++ b/lib/synvert/core/node_ext.rb
@@ -281,27 +281,24 @@ def to_value
     end
 
     def to_s
-      if :mlhs == self.type
-        "(#{self.children.map(&:name).join(', ')})"
-      end
+      "(#{self.children.map(&:name).join(', ')})" if :mlhs == self.type
     end
 
     def debug_info
-      "\n" + [
-        "file: #{self.loc.expression.source_buffer.name}",
-        "line: #{self.loc.expression.line}",
-        "source: #{self.to_source}",
-        "node: #{self.inspect}"
-      ].join("\n")
+      "\n" +
+        [
+          "file: #{self.loc.expression.source_buffer.name}",
+          "line: #{self.loc.expression.line}",
+          "source: #{self.to_source}",
+          "node: #{self.inspect}"
+        ].join("\n")
     end
 
     # Get the source code of current node.
     #
     # @return [String] source code.
     def to_source
-      if self.loc.expression
-        self.loc.expression.source
-      end
+      self.loc.expression.source if self.loc.expression
     end
 
     # Get the indent of current node.
@@ -336,21 +333,23 @@ def recursive_children
     # @param rules [Hash] rules to match.
     # @return true if matches.
     def match?(rules)
-      flat_hash(rules).keys.all? do |multi_keys|
-        if multi_keys.last == :any
-          actual_values = actual_value(self, multi_keys[0...-1])
-          expected = expected_value(rules, multi_keys)
-          actual_values.any? { |actual| match_value?(actual, expected) }
-        elsif multi_keys.last == :not
-          actual = actual_value(self, multi_keys[0...-1])
-          expected = expected_value(rules, multi_keys)
-          !match_value?(actual, expected)
-        else
-          actual = actual_value(self, multi_keys)
-          expected = expected_value(rules, multi_keys)
-          match_value?(actual, expected)
+      flat_hash(rules)
+        .keys
+        .all? do |multi_keys|
+          if multi_keys.last == :any
+            actual_values = actual_value(self, multi_keys[0...-1])
+            expected = expected_value(rules, multi_keys)
+            actual_values.any? { |actual| match_value?(actual, expected) }
+          elsif multi_keys.last == :not
+            actual = actual_value(self, multi_keys[0...-1])
+            expected = expected_value(rules, multi_keys)
+            !match_value?(actual, expected)
+          else
+            actual = actual_value(self, multi_keys)
+            expected = expected_value(rules, multi_keys)
+            match_value?(actual, expected)
+          end
         end
-      end
     end
 
     # Get rewritten source code.
@@ -376,9 +375,9 @@ def rewritten_source(code)
               lines_count = lines.length
               if lines_count > 1 && lines_count == evaluated.size
                 new_code = []
-                lines.each_with_index { |line, index|
-                  new_code << (index == 0 ? line : line[evaluated.first.indent-2..-1])
-                }
+                lines.each_with_index do |line, index|
+                  new_code << (index == 0 ? line : line[evaluated.first.indent - 2..-1])
+                end
                 new_code.join("\n")
               else
                 source
@@ -397,7 +396,7 @@ def rewritten_source(code)
       end
     end
 
-  private
+    private
 
     # Compare actual value with expected value.
     #
@@ -408,15 +407,10 @@ def rewritten_source(code)
     def match_value?(actual, expected)
       case expected
       when Symbol
-        if Parser::AST::Node === actual
-          actual.to_source == ":#{expected}"
-        else
-          actual.to_sym == expected
-        end
+        Parser::AST::Node === actual ? actual.to_source == ":#{expected}" : actual.to_sym == expected
       when String
         if Parser::AST::Node === actual
-          actual.to_source == expected ||
-            (actual.to_source[0] == ':' && actual.to_source[1..-1] == expected) ||
+          actual.to_source == expected || (actual.to_source[0] == ':' && actual.to_source[1..-1] == expected) ||
             actual.to_source[1...-1] == expected
         else
           actual.to_s == expected
@@ -434,11 +428,7 @@ def match_value?(actual, expected)
       when NilClass
         actual.nil?
       when Numeric
-        if Parser::AST::Node === actual
-          actual.children[0] == expected
-        else
-          actual == expected
-        end
+        Parser::AST::Node === actual ? actual.children[0] == expected : actual == expected
       when TrueClass
         :true == actual.type
       when FalseClass
@@ -475,11 +465,7 @@ def flat_hash(h, k = [])
     # @param multi_keys [Array<Symbol>]
     # @return [Object] actual value.
     def actual_value(node, multi_keys)
-      multi_keys.inject(node) { |n, key|
-        if n
-          key == :source ? n.send(key) : n.send(key)
-        end
-      }
+      multi_keys.inject(node) { |n, key| key == :source ? n.send(key) : n.send(key) if n }
     end
 
     # Get expected value from rules.
diff --git a/lib/synvert/core/rewriter.rb b/lib/synvert/core/rewriter.rb
index f436d843..01b8ffc7 100644
--- a/lib/synvert/core/rewriter.rb
+++ b/lib/synvert/core/rewriter.rb
@@ -42,7 +42,7 @@ class Rewriter
     autoload :RubyVersion, 'synvert/core/rewriter/ruby_version'
     autoload :GemSpec, 'synvert/core/rewriter/gem_spec'
 
-    class <<self
+    class << self
       # Register a rewriter with its group and name.
       #
       # @param group [String] the rewriter group.
@@ -93,11 +93,7 @@ def call(group, name)
       # @return [Boolean] true if the rewriter exist.
       def exist?(group, name)
         group, name = group.to_s, name.to_s
-        if rewriters[group] && rewriters[group][name]
-          true
-        else
-          false
-        end
+        rewriters[group] && rewriters[group][name] ? true : false
       end
 
       # Get all available rewriters
@@ -112,7 +108,7 @@ def clear
         rewriters.clear
       end
 
-    private
+      private
 
       def rewriters
         @rewriters ||= {}
@@ -178,7 +174,7 @@ def add_warning(warning)
     #
     # @param description [String] rewriter description.
     # @return rewriter description.
-    def description(description=nil)
+    def description(description = nil)
       if description
         @description = description
       else
@@ -208,11 +204,10 @@ def if_gem(name, comparator)
     # @param file_pattern [String] pattern to find files, e.g. spec/**/*_spec.rb
     # @param options [Hash] instance options.
     # @param block [Block] the block to rewrite code in the matching files.
-    def within_files(file_pattern, options={}, &block)
+    def within_files(file_pattern, options = {}, &block)
       return if @sandbox
 
-      if (!@ruby_version || @ruby_version.match?) &&
-        (!@gem_spec || @gem_spec.match?)
+      if (!@ruby_version || @ruby_version.match?) && (!@gem_spec || @gem_spec.match?)
         Rewriter::Instance.new(self, file_pattern, options, &block).process
       end
     end
@@ -262,7 +257,7 @@ def add_snippet(group, name)
     # @param name [String] helper method name.
     # @param block [Block] helper method block.
     def helper_method(name, &block)
-      @helpers << {name: name, block: block}
+      @helpers << { name: name, block: block }
     end
 
     # Parse todo dsl, it sets todo of the rewriter.
@@ -270,7 +265,7 @@ def helper_method(name, &block)
     #
     # @param todo_list [String] rewriter todo.
     # @return [String] rewriter todo.
-    def todo(todo=nil)
+    def todo(todo = nil)
       if todo
         @todo = todo
       else
diff --git a/lib/synvert/core/rewriter/action.rb b/lib/synvert/core/rewriter/action.rb
index 2cc27dc0..a2bddd16 100644
--- a/lib/synvert/core/rewriter/action.rb
+++ b/lib/synvert/core/rewriter/action.rb
@@ -11,7 +11,7 @@ class Rewriter::Action
     # @param instance [Synvert::Core::Rewriter::Instance]
     # @param code [String] new code to add, replace or remove.
     # @param options [Hash] action options, it includes :autoindent.
-    def initialize(instance, code, options={})
+    def initialize(instance, code, options = {})
       @instance = instance
       @code = code
       @options = DEFAULT_OPTIONS.merge(options)
@@ -30,9 +30,7 @@ def line
     # @return [String] rewritten code.
     def rewritten_code
       if rewritten_source.split("\n").length > 1
-        "\n\n" + rewritten_source.split("\n").map { |line|
-          indent(@node) + line
-        }.join("\n")
+        "\n\n" + rewritten_source.split("\n").map { |line| indent(@node) + line }.join("\n")
       else
         "\n" + indent(@node) + rewritten_source
       end
diff --git a/lib/synvert/core/rewriter/action/append_action.rb b/lib/synvert/core/rewriter/action/append_action.rb
index a3dc820d..e2e94659 100644
--- a/lib/synvert/core/rewriter/action/append_action.rb
+++ b/lib/synvert/core/rewriter/action/append_action.rb
@@ -9,11 +9,7 @@ class Rewriter::AppendAction < Rewriter::Action
     #
     # @return [Integer] begin position.
     def begin_pos
-      if :begin == @node.type
-        @node.loc.expression.end_pos
-      else
-        @node.loc.expression.end_pos - @node.indent - END_LENGTH
-      end
+      :begin == @node.type ? @node.loc.expression.end_pos : @node.loc.expression.end_pos - @node.indent - END_LENGTH
     end
 
     # End position, always same to begin position.
@@ -23,7 +19,7 @@ def end_pos
       begin_pos
     end
 
-  private
+    private
 
     # Indent of the node.
     #
diff --git a/lib/synvert/core/rewriter/action/insert_action.rb b/lib/synvert/core/rewriter/action/insert_action.rb
index 56edad63..f1de8981 100644
--- a/lib/synvert/core/rewriter/action/insert_action.rb
+++ b/lib/synvert/core/rewriter/action/insert_action.rb
@@ -3,7 +3,7 @@
 module Synvert::Core
   # InsertAction to insert code to the top of node body.
   class Rewriter::InsertAction < Rewriter::Action
-    DO_LENGTH = " do".length
+    DO_LENGTH = ' do'.length
 
     # Begin position to insert code.
     #
@@ -11,7 +11,11 @@ class Rewriter::InsertAction < Rewriter::Action
     def begin_pos
       case @node.type
       when :block
-        @node.children[1].children.empty? ? @node.children[0].loc.expression.end_pos + DO_LENGTH : @node.children[1].loc.expression.end_pos
+        if @node.children[1].children.empty?
+          @node.children[0].loc.expression.end_pos + DO_LENGTH
+        else
+          @node.children[1].loc.expression.end_pos
+        end
       when :class
         @node.children[1] ? @node.children[1].loc.expression.end_pos : @node.children[0].loc.expression.end_pos
       else
@@ -26,7 +30,7 @@ def end_pos
       begin_pos
     end
 
-  private
+    private
 
     # Indent of the node.
     #
diff --git a/lib/synvert/core/rewriter/action/insert_after_action.rb b/lib/synvert/core/rewriter/action/insert_after_action.rb
index 10d73ed8..8737d1b4 100644
--- a/lib/synvert/core/rewriter/action/insert_after_action.rb
+++ b/lib/synvert/core/rewriter/action/insert_after_action.rb
@@ -17,7 +17,7 @@ def end_pos
       begin_pos
     end
 
-  private
+    private
 
     # Indent of the node.
     #
diff --git a/lib/synvert/core/rewriter/action/remove_action.rb b/lib/synvert/core/rewriter/action/remove_action.rb
index 36eb8744..cda308aa 100644
--- a/lib/synvert/core/rewriter/action/remove_action.rb
+++ b/lib/synvert/core/rewriter/action/remove_action.rb
@@ -3,7 +3,7 @@
 module Synvert::Core
   # RemoveAction to remove code.
   class Rewriter::RemoveAction < Rewriter::Action
-    def initialize(instance, code=nil)
+    def initialize(instance, code = nil)
       super
     end
 
diff --git a/lib/synvert/core/rewriter/action/replace_erb_stmt_with_expr_action.rb b/lib/synvert/core/rewriter/action/replace_erb_stmt_with_expr_action.rb
index 84489277..4ad5330f 100644
--- a/lib/synvert/core/rewriter/action/replace_erb_stmt_with_expr_action.rb
+++ b/lib/synvert/core/rewriter/action/replace_erb_stmt_with_expr_action.rb
@@ -4,7 +4,7 @@ module Synvert::Core
   # ReplaceErbStmtWithExprAction to replace erb stmt code to expr,
   #   e.g. <% form_for ... %> => <%= form_for ... %>.
   class Rewriter::ReplaceErbStmtWithExprAction < Rewriter::Action
-    def initialize(instance, code=nil)
+    def initialize(instance, code = nil)
       super
     end
 
@@ -13,8 +13,7 @@ def initialize(instance, code=nil)
     # @return [Integer] begin position.
     def begin_pos
       node_begin_pos = @node.loc.expression.begin_pos
-      while @node.loc.expression.source_buffer.source[node_begin_pos -= 1] == ' '
-      end
+      while @node.loc.expression.source_buffer.source[node_begin_pos -= 1] == ' '; end
       node_begin_pos - Engine::ERUBY_STMT_SPLITTER.length + 1
     end
 
@@ -23,9 +22,8 @@ def begin_pos
     # @return [Integer] end position.
     def end_pos
       node_begin_pos = @node.loc.expression.begin_pos
-      node_begin_pos += @node.loc.expression.source.index "do"
-      while @node.loc.expression.source_buffer.source[node_begin_pos += 1] != '@'
-      end
+      node_begin_pos += @node.loc.expression.source.index 'do'
+      while @node.loc.expression.source_buffer.source[node_begin_pos += 1] != '@'; end
       node_begin_pos
     end
 
@@ -33,7 +31,8 @@ def end_pos
     #
     # @return [String] rewritten code.
     def rewritten_code
-      @node.loc.expression.source_buffer.source[begin_pos...end_pos].sub(Engine::ERUBY_STMT_SPLITTER, "@output_buffer.append= ")
+      @node.loc.expression.source_buffer.source[begin_pos...end_pos]
+        .sub(Engine::ERUBY_STMT_SPLITTER, '@output_buffer.append= ')
         .sub(Engine::ERUBY_STMT_SPLITTER, Engine::ERUBY_EXPR_SPLITTER)
     end
   end
diff --git a/lib/synvert/core/rewriter/action/replace_with_action.rb b/lib/synvert/core/rewriter/action/replace_with_action.rb
index f40a4e71..ad7f755e 100644
--- a/lib/synvert/core/rewriter/action/replace_with_action.rb
+++ b/lib/synvert/core/rewriter/action/replace_with_action.rb
@@ -23,16 +23,18 @@ def end_pos
     def rewritten_code
       if rewritten_source.split("\n").length > 1
         new_code = []
-        rewritten_source.split("\n").each_with_index { |line, index|
-          new_code << (index == 0 || !@options[:autoindent] ? line : indent(@node) + line)
-        }
+        rewritten_source
+          .split("\n")
+          .each_with_index do |line, index|
+            new_code << (index == 0 || !@options[:autoindent] ? line : indent(@node) + line)
+          end
         new_code.join("\n")
       else
         rewritten_source
       end
     end
 
-  private
+    private
 
     # Indent of the node
     #
diff --git a/lib/synvert/core/rewriter/condition/if_only_exist_condition.rb b/lib/synvert/core/rewriter/condition/if_only_exist_condition.rb
index 1407d623..22a9a7b7 100644
--- a/lib/synvert/core/rewriter/condition/if_only_exist_condition.rb
+++ b/lib/synvert/core/rewriter/condition/if_only_exist_condition.rb
@@ -5,8 +5,7 @@ module Synvert::Core
   class Rewriter::IfOnlyExistCondition < Rewriter::Condition
     # check if only have one child node and the child node matches rules.
     def match?
-      @instance.current_node.body.size == 1 &&
-        @instance.current_node.body.first.match?(@rules)
+      @instance.current_node.body.size == 1 && @instance.current_node.body.first.match?(@rules)
     end
   end
 end
diff --git a/lib/synvert/core/rewriter/gem_spec.rb b/lib/synvert/core/rewriter/gem_spec.rb
index 6d5ad45c..da96abf7 100644
--- a/lib/synvert/core/rewriter/gem_spec.rb
+++ b/lib/synvert/core/rewriter/gem_spec.rb
@@ -3,7 +3,7 @@
 module Synvert::Core
   # GemSpec checks and compares gem version.
   class Rewriter::GemSpec
-    OPERATORS = {eq: '==', lt: '<', gt: '>', lte: '<=', gte: '>=', ne: '!='}
+    OPERATORS = { eq: '==', lt: '<', gt: '>', lte: '<=', gte: '>=', ne: '!=' }
 
     # Initialize a gem_spec.
     #
diff --git a/lib/synvert/core/rewriter/helper.rb b/lib/synvert/core/rewriter/helper.rb
index 98da9e68..a9e96e7c 100644
--- a/lib/synvert/core/rewriter/helper.rb
+++ b/lib/synvert/core/rewriter/helper.rb
@@ -15,11 +15,7 @@ module Rewriter::Helper
     #   if current_node doesn't have a receiver, it returns "{{message}} {{arguments}}"
     #   if current_node has a receiver, it returns "{{receiver}}.{{message}} {{arguments}}"
     def add_receiver_if_necessary(code)
-      if node.receiver
-        "{{receiver}}.#{code}"
-      else
-        code
-      end
+      node.receiver ? "{{receiver}}.#{code}" : code
     end
 
     # Add arguments with parenthesis if necessary.
@@ -33,11 +29,7 @@ def add_receiver_if_necessary(code)
     #   if current_node doesn't have an argument, it returns ""
     #   if current_node has argument, it returns "({{arguments}})"
     def add_arguments_with_parenthesis_if_necessary
-      if node.arguments.size > 0
-        "({{arguments}})"
-      else
-        ""
-      end
+      node.arguments.size > 0 ? '({{arguments}})' : ''
     end
 
     # Add curly brackets to code if necessary.
@@ -49,11 +41,7 @@ def add_arguments_with_parenthesis_if_necessary
     #
     #   add_curly_brackets_if_necessary("{{arguments}}")
     def add_curly_brackets_if_necessary(code)
-      if code.start_with?('{') && code.end_with?('}')
-        code
-      else
-        "{ #{code} }"
-      end
+      code.start_with?('{') && code.end_with?('}') ? code : "{ #{code} }"
     end
 
     # Remove leading and trailing brackets.
@@ -65,9 +53,7 @@ def add_curly_brackets_if_necessary(code)
     #
     #   strip_brackets("(1..100)") #=> "1..100"
     def strip_brackets(code)
-      code.sub(/^\((.*)\)$/) { $1 }
-          .sub(/^\[(.*)\]$/) { $1 }
-          .sub(/^{(.*)}$/) { $1 }
+      code.sub(/^\((.*)\)$/) { $1 }.sub(/^\[(.*)\]$/) { $1 }.sub(/^{(.*)}$/) { $1 }
     end
   end
 end
diff --git a/lib/synvert/core/rewriter/instance.rb b/lib/synvert/core/rewriter/instance.rb
index 9125b72c..986088d2 100644
--- a/lib/synvert/core/rewriter/instance.rb
+++ b/lib/synvert/core/rewriter/instance.rb
@@ -8,7 +8,7 @@ module Synvert::Core
   class Rewriter::Instance
     include Rewriter::Helper
 
-    class <<self
+    class << self
       # Cached file source.
       #
       # @param file_path [String] file path
@@ -46,7 +46,7 @@ def file_ast(file_path)
       # @param source [String] file source
       def write_file(file_path, source)
         source = Engine::ERB.decode(source) if file_path =~ /\.erb/
-        File.write file_path, source.gsub(/ +\n/, "\n")
+        File.write file_path, source.gsub(%r{ +\n}, "\n")
         @file_source[file_path] = nil
         @file_ast[file_path] = nil
       end
@@ -73,7 +73,7 @@ def reset
     # @param options [Hash] instance options, it includes :sort_by.
     # @param block [Block] block code to find nodes, match conditions and rewrite code.
     # @return [Synvert::Core::Rewriter::Instance]
-    def initialize(rewriter, file_pattern, options={}, &block)
+    def initialize(rewriter, file_pattern, options = {}, &block)
       @rewriter = rewriter
       @actions = []
       @file_pattern = file_pattern
@@ -87,41 +87,43 @@ def initialize(rewriter, file_pattern, options={}, &block)
     # and rewrite source code back to original file.
     def process
       file_pattern = File.join(Configuration.instance.get(:path), @file_pattern)
-      Dir.glob(file_pattern).each do |file_path|
-        unless Configuration.instance.get(:skip_files).include? file_path
-          begin
-            conflict_actions = []
-            source = +self.class.file_source(file_path)
-            ast = self.class.file_ast(file_path)
-
-            @current_file = file_path
-
-            self.process_with_node ast do
-              begin
-                instance_eval &@block
-              rescue NoMethodError
-                puts @current_node.debug_info
-                raise
+      Dir
+        .glob(file_pattern)
+        .each do |file_path|
+          unless Configuration.instance.get(:skip_files).include? file_path
+            begin
+              conflict_actions = []
+              source = +self.class.file_source(file_path)
+              ast = self.class.file_ast(file_path)
+
+              @current_file = file_path
+
+              self.process_with_node ast do
+                begin
+                  instance_eval &@block
+                rescue NoMethodError
+                  puts @current_node.debug_info
+                  raise
+                end
               end
-            end
-
-            if @actions.length > 0
-              @actions.sort_by! { |action| action.send(@options[:sort_by]) }
-              conflict_actions = get_conflict_actions
-              @actions.reverse_each do |action|
-                source[action.begin_pos...action.end_pos] = action.rewritten_code
-                source = remove_code_or_whole_line(source, action.line)
+
+              if @actions.length > 0
+                @actions.sort_by! { |action| action.send(@options[:sort_by]) }
+                conflict_actions = get_conflict_actions
+                @actions.reverse_each do |action|
+                  source[action.begin_pos...action.end_pos] = action.rewritten_code
+                  source = remove_code_or_whole_line(source, action.line)
+                end
+                @actions = []
+
+                self.class.write_file(file_path, source)
               end
-              @actions = []
-
-              self.class.write_file(file_path, source)
-            end
-          rescue Parser::SyntaxError
-            puts "[Warn] file #{file_path} was not parsed correctly."
-            # do nothing, iterate next file
-          end while !conflict_actions.empty?
+            rescue Parser::SyntaxError
+              puts "[Warn] file #{file_path} was not parsed correctly."
+              # do nothing, iterate next file
+            end while !conflict_actions.empty?
+          end
         end
-      end
     end
 
     # Gets current node, it allows to get current node in block code.
@@ -220,7 +222,7 @@ def if_only_exist_node(rules, &block)
     #
     # @param code [String] code need to be appended.
     # @param options [Hash] action options.
-    def append(code, options={})
+    def append(code, options = {})
       @actions << Rewriter::AppendAction.new(self, code, options)
     end
 
@@ -229,7 +231,7 @@ def append(code, options={})
     #
     # @param code [String] code need to be inserted.
     # @param options [Hash] action options.
-    def insert(code, options={})
+    def insert(code, options = {})
       @actions << Rewriter::InsertAction.new(self, code, options)
     end
 
@@ -238,7 +240,7 @@ def insert(code, options={})
     #
     # @param code [String] code need to be inserted.
     # @param options [Hash] action options.
-    def insert_after(node, options={})
+    def insert_after(node, options = {})
       @actions << Rewriter::InsertAfterAction.new(self, node, options)
     end
 
@@ -247,7 +249,7 @@ def insert_after(node, options={})
     #
     # @param code [String] code need to be replaced with.
     # @param options [Hash] action options.
-    def replace_with(code, options={})
+    def replace_with(code, options = {})
       @actions << Rewriter::ReplaceWithAction.new(self, code, options)
     end
 
@@ -269,7 +271,7 @@ def warn(message)
       @rewriter.add_warning Rewriter::Warning.new(self, message)
     end
 
-  private
+    private
 
     # It changes source code from bottom to top, and it can change source code twice at the same time,
     # So if there is an overlap between two actions, it removes the conflict actions and operate them in the next loop.
@@ -301,7 +303,8 @@ def remove_code_or_whole_line(source, line)
       source_arr = source.split("\n")
       if source_arr[line - 1] && source_arr[line - 1].strip.empty?
         source_arr.delete_at(line - 1)
-        if source_arr[line - 2] && source_arr[line - 2].strip.empty? && source_arr[line - 1] && source_arr[line - 1].strip.empty?
+        if source_arr[line - 2] && source_arr[line - 2].strip.empty? && source_arr[line - 1] &&
+             source_arr[line - 1].strip.empty?
           source_arr.delete_at(line - 1)
         end
         source_arr.join("\n") + (newline_at_end_of_line ? "\n" : '')
diff --git a/lib/synvert/core/rewriter/scope.rb b/lib/synvert/core/rewriter/scope.rb
index 493975f0..e26a4a50 100644
--- a/lib/synvert/core/rewriter/scope.rb
+++ b/lib/synvert/core/rewriter/scope.rb
@@ -2,6 +2,5 @@
 
 module Synvert::Core
   # Scope finds out nodes which match rules.
-  class Rewriter::Scope
-  end
+  class Rewriter::Scope; end
 end
diff --git a/lib/synvert/core/rewriter/scope/within_scope.rb b/lib/synvert/core/rewriter/scope/within_scope.rb
index fec5703e..8e40a170 100644
--- a/lib/synvert/core/rewriter/scope/within_scope.rb
+++ b/lib/synvert/core/rewriter/scope/within_scope.rb
@@ -38,13 +38,9 @@ def find_matching_nodes(current_node)
       matching_nodes = []
       if @options[:recursive]
         matching_nodes << current_node if current_node.match? @rules
-        current_node.recursive_children do |child_node|
-          matching_nodes << child_node if child_node.match? @rules
-        end
+        current_node.recursive_children { |child_node| matching_nodes << child_node if child_node.match? @rules }
       else
-        current_node.each do |child_node|
-          matching_nodes << child_node if child_node.match? @rules
-        end
+        current_node.each { |child_node| matching_nodes << child_node if child_node.match? @rules }
       end
       matching_nodes
     end
diff --git a/lib/synvert/core/version.rb b/lib/synvert/core/version.rb
index a695ba58..8dc9f166 100644
--- a/lib/synvert/core/version.rb
+++ b/lib/synvert/core/version.rb
@@ -2,6 +2,6 @@
 
 module Synvert
   module Core
-    VERSION = "0.16.1"
+    VERSION = '0.16.1'
   end
 end
diff --git a/spec/spec_helper.rb b/spec/spec_helper.rb
index d0fda429..4e6ce400 100644
--- a/spec/spec_helper.rb
+++ b/spec/spec_helper.rb
@@ -1,15 +1,13 @@
 # frozen_string_literal: true
 
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 
 require 'synvert/core'
 
 require 'coveralls'
 Coveralls.wear!
 
-Dir[File.join(File.dirname(__FILE__), 'support', '*')].each do |path|
-  require path
-end
+Dir[File.join(File.dirname(__FILE__), 'support', '*')].each { |path| require path }
 
 RSpec.configure do |config|
   config.include ParserHelper
diff --git a/spec/synvert/core/engine/erb_spec.rb b/spec/synvert/core/engine/erb_spec.rb
index ddcde4bf..1ff8304d 100644
--- a/spec/synvert/core/engine/erb_spec.rb
+++ b/spec/synvert/core/engine/erb_spec.rb
@@ -4,8 +4,8 @@
 
 module Synvert::Core
   describe Engine::ERB do
-    it "encodes / decodes" do
-      source =<<-EOF
+    it 'encodes / decodes' do
+      source = <<-EOF
 <%content_for :head do%>
   <style>
     body {
@@ -35,7 +35,7 @@ module Synvert::Core
 <% end %>
       EOF
       encoded_source = Engine::ERB.encode(source)
-      buffer = Parser::Source::Buffer.new "(test)"
+      buffer = Parser::Source::Buffer.new '(test)'
       buffer.source = encoded_source
       parser = Parser::CurrentRuby.new
       parser.reset
diff --git a/spec/synvert/core/node_ext_spec.rb b/spec/synvert/core/node_ext_spec.rb
index 0f2e3829..0ed93cf6 100644
--- a/spec/synvert/core/node_ext_spec.rb
+++ b/spec/synvert/core/node_ext_spec.rb
@@ -103,12 +103,12 @@
 
   describe '#arguments' do
     it 'gets for def node' do
-      node = parse("def test(foo, bar); foo + bar; end")
+      node = parse('def test(foo, bar); foo + bar; end')
       expect(node.arguments.map { |argument| argument.to_source }).to eq %w[foo bar]
     end
 
     it 'gets for defs node' do
-      node = parse("def self.test(foo, bar); foo + bar; end")
+      node = parse('def self.test(foo, bar); foo + bar; end')
       expect(node.arguments.map { |argument| argument.to_source }).to eq %w[foo bar]
     end
 
@@ -172,129 +172,129 @@
     end
   end
 
-  describe "#keys" do
+  describe '#keys' do
     it 'gets for hash node' do
       node = parse("{:foo => :bar, 'foo' => 'bar'}")
       expect(node.keys).to eq [parse(':foo'), parse("'foo'")]
     end
   end
 
-  describe "#values" do
+  describe '#values' do
     it 'gets for hash node' do
       node = parse("{:foo => :bar, 'foo' => 'bar'}")
       expect(node.values).to eq [parse(':bar'), parse("'bar'")]
     end
   end
 
-  describe "#has_key?" do
-    it "gets true if key exists" do
-      node = parse("{:foo => :bar}")
+  describe '#has_key?' do
+    it 'gets true if key exists' do
+      node = parse('{:foo => :bar}')
       expect(node.has_key?(:foo)).to be_truthy
     end
 
-    it "gets false if key does not exist" do
-      node = parse("{:foo => :bar}")
+    it 'gets false if key does not exist' do
+      node = parse('{:foo => :bar}')
       expect(node.has_key?('foo')).to be_falsey
     end
   end
 
-  describe "#hash_value" do
-    it "gets value of specified key" do
-      node = parse("{:foo => :bar}")
+  describe '#hash_value' do
+    it 'gets value of specified key' do
+      node = parse('{:foo => :bar}')
       expect(node.hash_value(:foo)).to eq parse(':bar')
     end
 
-    it "gets nil if key does not exist" do
-      node = parse("{:foo => :bar}")
+    it 'gets nil if key does not exist' do
+      node = parse('{:foo => :bar}')
       expect(node.hash_value(:bar)).to be_nil
     end
   end
 
-  describe "#key" do
+  describe '#key' do
     it 'gets for pair node' do
       node = parse("{:foo => 'bar'}").children[0]
       expect(node.key).to eq parse(':foo')
     end
   end
 
-  describe "#value" do
+  describe '#value' do
     it 'gets for hash node' do
       node = parse("{:foo => 'bar'}").children[0]
       expect(node.value).to eq parse("'bar'")
     end
   end
 
-  describe "#condition" do
+  describe '#condition' do
     it 'gets for if node' do
       node = parse('if defined?(Bundler); end')
       expect(node.condition).to eq parse('defined?(Bundler)')
     end
   end
 
-  describe "#left_value" do
+  describe '#left_value' do
     it 'gets for masgn' do
-      node = parse("a, b = 1, 2")
+      node = parse('a, b = 1, 2')
       expect(node.left_value.to_source).to eq 'a, b'
     end
 
     it 'gets for lvasgn' do
-      node = parse("a = 1")
+      node = parse('a = 1')
       expect(node.left_value).to eq :a
     end
 
     it 'gets for ivasgn' do
-      node = parse("@a = 1")
+      node = parse('@a = 1')
       expect(node.left_value).to eq :@a
     end
   end
 
-  describe "#right_value" do
+  describe '#right_value' do
     it 'gets for masgn' do
-      node = parse("a, b = 1, 2")
+      node = parse('a, b = 1, 2')
       expect(node.right_value).to eq parse('[1, 2]')
     end
 
     it 'gets for masgn' do
-      node = parse("a, b = params")
-      expect(node.right_value).to eq parse("params")
+      node = parse('a, b = params')
+      expect(node.right_value).to eq parse('params')
     end
 
     it 'gets for lvasgn' do
-      node = parse("a = 1")
-      expect(node.right_value).to eq parse("1")
+      node = parse('a = 1')
+      expect(node.right_value).to eq parse('1')
     end
 
     it 'gets for ivasgn' do
-      node = parse("@a = 1")
-      expect(node.right_value).to eq parse("1")
+      node = parse('@a = 1')
+      expect(node.right_value).to eq parse('1')
     end
   end
 
-  describe "#to_value" do
+  describe '#to_value' do
     it 'gets for int' do
-      node = parse("1")
+      node = parse('1')
       expect(node.to_value).to eq 1
     end
 
     it 'gets for string' do
       node = parse("'str'")
-      expect(node.to_value).to eq "str"
+      expect(node.to_value).to eq 'str'
     end
 
     it 'gets for symbol' do
-      node = parse(":str")
+      node = parse(':str')
       expect(node.to_value).to eq :str
     end
 
     it 'get for boolean' do
-      node = parse("true")
+      node = parse('true')
       expect(node.to_value).to be_truthy
-      node = parse("false")
+      node = parse('false')
       expect(node.to_value).to be_falsey
     end
 
     it 'get for range' do
-      node = parse("(1..10)")
+      node = parse('(1..10)')
       expect(node.to_value).to eq (1..10)
     end
 
@@ -346,10 +346,10 @@
   end
 
   describe '#match?' do
-    let(:instance) {
+    let(:instance) do
       rewriter = Synvert::Rewriter.new('foo', 'bar')
       Synvert::Rewriter::Instance.new(rewriter, 'file pattern')
-    }
+    end
 
     it 'matches class name' do
       source = 'class Synvert; end'
@@ -384,21 +384,21 @@
     it 'matches arguments any' do
       source = 'config.middleware.insert_after ActiveRecord::QueryCache, Lifo::Cache, page_cache: false'
       node = parse(source)
-      expect(node).to be_match(type: 'send', arguments: {any: 'Lifo::Cache'})
+      expect(node).to be_match(type: 'send', arguments: { any: 'Lifo::Cache' })
     end
 
     it 'matches not' do
       source = 'class Synvert; end'
       node = parse(source)
-      expect(node).not_to be_match(type: 'class', name: {not: 'Synvert'})
+      expect(node).not_to be_match(type: 'class', name: { not: 'Synvert' })
     end
   end
 
   describe '#rewritten_source' do
-    let(:instance) {
+    let(:instance) do
       rewriter = Synvert::Rewriter.new('foo', 'bar')
       Synvert::Rewriter::Instance.new(rewriter, 'file pattern')
-    }
+    end
 
     it 'does not rewrite with unknown method' do
       source = 'class Synvert; end'
@@ -415,10 +415,10 @@
     it 'rewrites for ArgumentsNode' do
       source = 'test { |a, b| }'
       node = parse(source)
-      expect(node.rewritten_source('{{arguments}}')).to eq %(a, b)
+      expect(node.rewritten_source('{{arguments}}')).to eq 'a, b'
     end
 
-    it 'rewrites array with multi line given as argument for method'do
+    it 'rewrites array with multi line given as argument for method' do
       source = <<-EOS.strip
 long_name_method([
   1,
@@ -426,6 +426,7 @@
   3
 ])
       EOS
+
       node = parse(source)
       expect(node.rewritten_source('{{arguments}}')).to eq <<-EOS.strip
 [
diff --git a/spec/synvert/core/rewriter/action/insert_action_spec.rb b/spec/synvert/core/rewriter/action/insert_action_spec.rb
index ca833198..64d4794a 100644
--- a/spec/synvert/core/rewriter/action/insert_action_spec.rb
+++ b/spec/synvert/core/rewriter/action/insert_action_spec.rb
@@ -5,19 +5,19 @@
 module Synvert::Core
   describe Rewriter::InsertAction do
     describe 'block node without args' do
-      subject {
+      subject do
         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')
-      }
+      end
 
       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
@@ -26,19 +26,19 @@ module Synvert::Core
     end
 
     describe 'block node with args' do
-      subject {
+      subject do
         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')
-      }
+      end
 
       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
@@ -47,19 +47,19 @@ module Synvert::Core
     end
 
     describe 'class node without superclass' do
-      subject {
+      subject do
         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')
-      }
+      end
 
       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
@@ -68,19 +68,19 @@ module Synvert::Core
     end
 
     describe 'class node with superclass' do
-      subject {
+      subject do
         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')
-      }
+      end
 
       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
diff --git a/spec/synvert/core/rewriter/action/insert_after_action_spec.rb b/spec/synvert/core/rewriter/action/insert_after_action_spec.rb
index 71f2915e..182a11ff 100644
--- a/spec/synvert/core/rewriter/action/insert_after_action_spec.rb
+++ b/spec/synvert/core/rewriter/action/insert_after_action_spec.rb
@@ -4,19 +4,19 @@
 
 module Synvert::Core
   describe Rewriter::InsertAfterAction do
-    subject {
-      source = "  include Foo"
+    subject do
+      source = '  include Foo'
       node = Parser::CurrentRuby.parse(source)
       instance = double(current_node: node)
       Rewriter::InsertAfterAction.new(instance, 'include Bar')
-    }
+    end
 
     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
diff --git a/spec/synvert/core/rewriter/action/remove_action_spec.rb b/spec/synvert/core/rewriter/action/remove_action_spec.rb
index 27c97c48..01742d33 100644
--- a/spec/synvert/core/rewriter/action/remove_action_spec.rb
+++ b/spec/synvert/core/rewriter/action/remove_action_spec.rb
@@ -4,12 +4,12 @@
 
 module Synvert::Core
   describe Rewriter::RemoveAction do
-    subject {
+    subject do
       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)
-    }
+    end
 
     it 'gets begin_pos' do
       expect(subject.begin_pos).to eq "user = User.new params[:user]\n".length
@@ -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
diff --git a/spec/synvert/core/rewriter/action/replace_with_action_spec.rb b/spec/synvert/core/rewriter/action/replace_with_action_spec.rb
index 9f782a06..63f9b8e6 100644
--- a/spec/synvert/core/rewriter/action/replace_with_action_spec.rb
+++ b/spec/synvert/core/rewriter/action/replace_with_action_spec.rb
@@ -4,20 +4,20 @@
 
 module Synvert::Core
   describe Rewriter::ReplaceWithAction do
-    context "replace with single line" do
-      subject {
-        source = "post = FactoryGirl.create_list :post, 2"
+    context 'replace with single line' do
+      subject do
+        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}}')
-      }
+      end
 
       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,30 +25,38 @@ module Synvert::Core
       end
     end
 
-    context "#replace with multiple line" do
-      subject {
-        source = "  its(:size) { should == 1 }"
+    context '#replace with multiple line' do
+      subject do
+        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
+        )
+      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
+        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
diff --git a/spec/synvert/core/rewriter/action_spec.rb b/spec/synvert/core/rewriter/action_spec.rb
index 9f6d8755..73e49f62 100644
--- a/spec/synvert/core/rewriter/action_spec.rb
+++ b/spec/synvert/core/rewriter/action_spec.rb
@@ -4,12 +4,12 @@
 
 module Synvert::Core
   describe Rewriter::Action do
-    subject {
+    subject do
       source = "before_save do\n  return false\nend"
       block_node = Parser::CurrentRuby.parse(source).body.first
       instance = double(current_node: block_node)
       Rewriter::Action.new(instance, source)
-    }
+    end
 
     it 'gets line' do
       expect(subject.line).to eq 2
diff --git a/spec/synvert/core/rewriter/condition/if_exist_condition_spec.rb b/spec/synvert/core/rewriter/condition/if_exist_condition_spec.rb
index f1cc795e..edfd4435 100644
--- a/spec/synvert/core/rewriter/condition/if_exist_condition_spec.rb
+++ b/spec/synvert/core/rewriter/condition/if_exist_condition_spec.rb
@@ -4,32 +4,42 @@
 
 module Synvert::Core
   describe Rewriter::IfExistCondition do
-    let(:source) {
-      """
+    let(:source) do
+      '' \
+        '
       RSpec.configure do |config|
         config.include EmailSpec::Helpers
         config.include EmailSpec::Methods
       end
-      """
-    }
+      ' \
+        ''
+    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
diff --git a/spec/synvert/core/rewriter/condition/if_only_exist_condition_spec.rb b/spec/synvert/core/rewriter/condition/if_only_exist_condition_spec.rb
index 90a5f83c..38901da8 100644
--- a/spec/synvert/core/rewriter/condition/if_only_exist_condition_spec.rb
+++ b/spec/synvert/core/rewriter/condition/if_only_exist_condition_spec.rb
@@ -4,39 +4,52 @@
 
 module Synvert::Core
   describe Rewriter::IfOnlyExistCondition do
-    let(:source) {
-      """
+    let(:source) do
+      '' \
+        '
       RSpec.configure do |config|
         config.include EmailSpec::Helpers
         config.include EmailSpec::Methods
       end
-      """
-    }
+      ' \
+        ''
+    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
diff --git a/spec/synvert/core/rewriter/condition/unless_exist_condition_spec.rb b/spec/synvert/core/rewriter/condition/unless_exist_condition_spec.rb
index a27fd6b4..e12e8de4 100644
--- a/spec/synvert/core/rewriter/condition/unless_exist_condition_spec.rb
+++ b/spec/synvert/core/rewriter/condition/unless_exist_condition_spec.rb
@@ -4,32 +4,42 @@
 
 module Synvert::Core
   describe Rewriter::UnlessExistCondition do
-    let(:source) {
-      """
+    let(:source) do
+      '' \
+        '
       RSpec.configure do |config|
         config.include EmailSpec::Helpers
         config.include EmailSpec::Methods
       end
-      """
-    }
+      ' \
+        ''
+    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
diff --git a/spec/synvert/core/rewriter/gem_spec_spec.rb b/spec/synvert/core/rewriter/gem_spec_spec.rb
index 6fcf69fc..6686666f 100644
--- a/spec/synvert/core/rewriter/gem_spec_spec.rb
+++ b/spec/synvert/core/rewriter/gem_spec_spec.rb
@@ -4,7 +4,9 @@
 
 module Synvert::Core
   describe Rewriter::GemSpec do
-    let(:gemfile_lock_content) { """
+    let(:gemfile_lock_content) do
+      '' \
+        '
 GEM
   remote: https://rubygems.org/
   specs:
@@ -14,13 +16,14 @@ module Synvert::Core
       slop (~> 3.4, >= 3.4.5)
     rake (10.1.1)
     slop (3.4.7)
-      """
-    }
+      ' \
+        ''
+    end
 
     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'})
+      gem_spec = Rewriter::GemSpec.new('ast', { gte: '1.0.0' })
       expect(gem_spec).to be_match
     end
 
@@ -34,7 +37,7 @@ module Synvert::Core
     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'})
+      gem_spec = Rewriter::GemSpec.new('ast', { gt: '1.2.0' })
       expect(gem_spec).not_to be_match
     end
 
diff --git a/spec/synvert/core/rewriter/helper_spec.rb b/spec/synvert/core/rewriter/helper_spec.rb
index bac2737d..5d298aa2 100644
--- a/spec/synvert/core/rewriter/helper_spec.rb
+++ b/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
diff --git a/spec/synvert/core/rewriter/instance_spec.rb b/spec/synvert/core/rewriter/instance_spec.rb
index b3e1e8e0..a5e038f9 100644
--- a/spec/synvert/core/rewriter/instance_spec.rb
+++ b/spec/synvert/core/rewriter/instance_spec.rb
@@ -6,45 +6,53 @@ module Synvert::Core
   describe Rewriter::Instance do
     before { Rewriter::Instance.reset }
 
-    let(:instance) {
+    let(:instance) do
       rewriter = Rewriter.new('foo', 'bar')
       Rewriter::Instance.new(rewriter, 'file pattern')
-    }
+    end
 
     it 'parses within_node' do
-      scope = double()
+      scope = double
       block = Proc.new {}
-      expect(Rewriter::WithinScope).to receive(:new).with(instance, { type: 'send', message: 'create' }, { recursive: true }, &block).and_return(scope)
+      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()
+      scope = double
       block = Proc.new {}
-      expect(Rewriter::WithinScope).to receive(:new).with(instance, { type: 'send', message: 'create' }, { recursive: true }, &block).and_return(scope)
+      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()
+      scope = double
       block = Proc.new {}
-      expect(Rewriter::WithinScope).to receive(:new).with(instance, { type: 'send', message: 'create' }, { recursive: false }, &block).and_return(scope)
+      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()
+      scope = double
       block = Proc.new {}
-      expect(Rewriter::WithinScope).to receive(:new).with(instance, { type: 'send', message: 'create' }, { recursive: false }, &block).and_return(scope)
+      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()
+      scope = double
       block = Proc.new {}
       expect(Rewriter::GotoScope).to receive(:new).with(instance, :caller, &block).and_return(scope)
       expect(scope).to receive(:process)
@@ -52,42 +60,56 @@ module Synvert::Core
     end
 
     it 'parses if_exist_node' do
-      condition = double()
+      condition = double
       block = Proc.new {}
-      expect(Rewriter::IfExistCondition).to receive(:new).with(instance, type: 'send', message: 'create', &block).and_return(condition)
+      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()
+      condition = double
       block = Proc.new {}
-      expect(Rewriter::UnlessExistCondition).to receive(:new).with(instance, type: 'send', message: 'create', &block).and_return(condition)
+      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()
+      condition = double
       block = Proc.new {}
-      expect(Rewriter::IfOnlyExistCondition).to receive(:new).with(instance, type: 'send', message: 'create', &block).and_return(condition)
+      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,32 @@ 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 +164,30 @@ module Synvert::Core
       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 +195,30 @@ module Synvert::Core
       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 +227,32 @@ module Synvert::Core
       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 +262,10 @@ module Synvert::Core
       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 +276,7 @@ module Synvert::Core
         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 +290,8 @@ module Synvert::Core
 
     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 +302,9 @@ module Synvert::Core
 
     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
diff --git a/spec/synvert/core/rewriter/scope/goto_scope_spec.rb b/spec/synvert/core/rewriter/scope/goto_scope_spec.rb
index 5fe37744..1c1f43bd 100644
--- a/spec/synvert/core/rewriter/scope/goto_scope_spec.rb
+++ b/spec/synvert/core/rewriter/scope/goto_scope_spec.rb
@@ -4,15 +4,18 @@
 
 module Synvert::Core
   describe Rewriter::GotoScope do
-    let(:instance) {
+    let(:instance) do
       rewriter = Rewriter.new('foo', 'bar')
       Rewriter::Instance.new(rewriter, 'file pattern')
-    }
-    let(:source) {'''
+    end
+    let(:source) do
+      '' \
+        '
 Factory.define :user do |user|
 end
-    '''
-    }
+    ' \
+        ''
+    end
     let(:node) { Parser::CurrentRuby.parse(source) }
     before do
       Rewriter::Instance.reset
@@ -23,10 +26,11 @@ module Synvert::Core
       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
diff --git a/spec/synvert/core/rewriter/scope/within_scope.rb b/spec/synvert/core/rewriter/scope/within_scope.rb
index 2c9d4d5b..8cb5547b 100644
--- a/spec/synvert/core/rewriter/scope/within_scope.rb
+++ b/spec/synvert/core/rewriter/scope/within_scope.rb
@@ -4,18 +4,21 @@
 
 module Synvert::Core
   describe Rewriter::WithinScope do
-    let(:instance) {
+    let(:instance) do
       rewriter = Rewriter.new('foo', 'bar')
       Rewriter::Instance.new(rewriter, 'file pattern')
-    }
-    let(:source) {"""
+    end
+    let(:source) do
+      '' \
+        "
 describe Post do
   it 'gets post' do
     FactoryGirl.create :post
   end
 end
-    """
-    }
+    " \
+        ''
+    end
     let(:node) { Parser::CurrentRuby.parse(source) }
     before do
       Rewriter::Instance.reset
@@ -25,9 +28,10 @@ module Synvert::Core
     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
@@ -35,10 +39,15 @@ module Synvert::Core
       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
diff --git a/spec/synvert/core/rewriter/warning_spec.rb b/spec/synvert/core/rewriter/warning_spec.rb
index d4bc87ac..5c7ecb26 100644
--- a/spec/synvert/core/rewriter/warning_spec.rb
+++ b/spec/synvert/core/rewriter/warning_spec.rb
@@ -4,12 +4,12 @@
 
 module Synvert::Core
   describe Rewriter::Warning do
-    subject {
+    subject do
       source = "def test\n  debugger\nend"
       send_node = Parser::CurrentRuby.parse(source).body.first
       instance = double(current_node: send_node, current_file: 'app/test.rb')
       Rewriter::Warning.new(instance, 'remove debugger')
-    }
+    end
 
     it 'gets message with filename and line number' do
       expect(subject.message).to eq 'app/test.rb#2: remove debugger'
diff --git a/spec/synvert/core/rewriter_spec.rb b/spec/synvert/core/rewriter_spec.rb
index b42ede54..facd121a 100644
--- a/spec/synvert/core/rewriter_spec.rb
+++ b/spec/synvert/core/rewriter_spec.rb
@@ -5,26 +5,29 @@
 module Synvert::Core
   describe Rewriter do
     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
+      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
 
@@ -32,76 +35,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'
         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
@@ -110,26 +127,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
       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
       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'
@@ -139,46 +159,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
@@ -203,7 +228,7 @@ 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
@@ -214,7 +239,7 @@ module Synvert::Core
         end
       end
 
-      context "available" do
+      context 'available' do
         it 'lists empty rewriters' do
           expect(Rewriter.availables).to eq({})
         end
@@ -222,7 +247,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