Use Cop::Base API for Layout department [N-S]

Follow #7868.

This PR uses `Cop::Base` API for almost `Layout` department's cops.
It targets cop that names begin between N and S. And several N-S cops
will be excluded from this PR target and addressed separately.

lib/rubocop/cop/correctors/punctuation_corrector.rb

@@ -5,12 +5,12 @@ module Cop
     # This auto-corrects punctuation
     class PunctuationCorrector
       class << self
-        def remove_space(space_before)
-          ->(corrector) { corrector.remove(space_before) }
+        def remove_space(corrector, space_before)
+          corrector.remove(space_before)
         end
 
-        def add_space(token)
-          ->(corrector) { corrector.replace(token.pos, "#{token.pos.source} ") }
+        def add_space(corrector, token)
+          corrector.replace(token.pos, "#{token.pos.source} ")
         end
 
         def swap_comma(corrector, range)

lib/rubocop/cop/layout/rescue_ensure_alignment.rb

@@ -23,8 +23,9 @@ module Layout
       #   end
       #
       # @api private
-      class RescueEnsureAlignment < Cop
+      class RescueEnsureAlignment < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = '`%<kw_loc>s` at %<kw_loc_line>d, %<kw_loc_column>d is not ' \
               'aligned with `%<beginning>s` at ' \
@@ -43,19 +44,7 @@ def on_ensure(node)
           check(node)
         end
 
-        def autocorrect(node)
-          whitespace = whitespace_range(node)
-          # Some inline node is sitting before current node.
-          return nil unless whitespace.source.strip.empty?
-
-          alignment_node = alignment_node(node)
-          return false if alignment_node.nil?
-
-          new_column = alignment_node.loc.column
-          ->(corrector) { corrector.replace(whitespace, ' ' * new_column) }
-        end
-
-        def investigate(processed_source)
+        def on_new_investigation
           @modifier_locations =
             processed_source.tokens.each_with_object([]) do |token, locations|
               next unless token.rescue_modifier?
@@ -75,15 +64,23 @@ def check(node)
           alignment_loc = alignment_node.loc.expression
           kw_loc        = node.loc.keyword
 
-          return if
-            alignment_loc.column == kw_loc.column ||
-            alignment_loc.line   == kw_loc.line
+          return if alignment_loc.column == kw_loc.column || alignment_loc.line == kw_loc.line
 
           add_offense(
-            node,
-            location: kw_loc,
-            message: format_message(alignment_node, alignment_loc, kw_loc)
-          )
+            kw_loc, message: format_message(alignment_node, alignment_loc, kw_loc)
+          ) do |corrector|
+            autocorrect(corrector, node, alignment_node)
+          end
+        end
+
+        def autocorrect(corrector, node, alignment_node)
+          whitespace = whitespace_range(node)
+          # Some inline node is sitting before current node.
+          return nil unless whitespace.source.strip.empty?
+
+          new_column = alignment_node.loc.column
+
+          corrector.replace(whitespace, ' ' * new_column)
         end
 
         def format_message(alignment_node, alignment_loc, kw_loc)

lib/rubocop/cop/layout/space_after_colon.rb

@@ -15,31 +15,35 @@ module Layout
       #   def f(a:, b: 2); {a: 3}; end
       #
       # @api private
-      class SpaceAfterColon < Cop
+      class SpaceAfterColon < Base
+        extend AutoCorrector
+
         MSG = 'Space missing after colon.'
 
         def on_pair(node)
           return unless node.colon?
 
           colon = node.loc.operator
 
-          add_offense(colon, location: colon) unless followed_by_space?(colon)
+          register_offense(colon) unless followed_by_space?(colon)
         end
 
         def on_kwoptarg(node)
           # We have no direct reference to the colon source range following an
           # optional keyword argument's name, so must construct one.
           colon = node.loc.name.end.resize(1)
 
-          add_offense(colon, location: colon) unless followed_by_space?(colon)
-        end
-
-        def autocorrect(range)
-          ->(corrector) { corrector.insert_after(range, ' ') }
+          register_offense(colon) unless followed_by_space?(colon)
         end
 
         private
 
+        def register_offense(colon)
+          add_offense(colon) do |corrector|
+            corrector.insert_after(colon, ' ')
+          end
+        end
+
         def followed_by_space?(colon)
           /\s/.match?(colon.source_buffer.source[colon.end_pos])
         end

lib/rubocop/cop/layout/space_after_comma.rb

@@ -16,12 +16,9 @@ module Layout
       #   { foo:bar, }
       #
       # @api private
-      class SpaceAfterComma < Cop
+      class SpaceAfterComma < Base
         include SpaceAfterPunctuation
-
-        def autocorrect(comma)
-          PunctuationCorrector.add_space(comma)
-        end
+        extend AutoCorrector
 
         def space_style_before_rcurly
           cfg = config.for_cop('Layout/SpaceInsideHashLiteralBraces')

lib/rubocop/cop/layout/space_after_method_name.rb

@@ -16,8 +16,9 @@ module Layout
       #   def method=(y) end
       #
       # @api private
-      class SpaceAfterMethodName < Cop
+      class SpaceAfterMethodName < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Do not put a space between a method name and the opening ' \
               'parenthesis.'
@@ -31,13 +32,11 @@ def on_def(node)
                                                 expr.begin_pos)
           return unless pos_before_left_paren.source.start_with?(' ')
 
-          add_offense(pos_before_left_paren, location: pos_before_left_paren)
+          add_offense(pos_before_left_paren) do |corrector|
+            corrector.remove(pos_before_left_paren)
+          end
         end
         alias on_defs on_def
-
-        def autocorrect(pos_before_left_paren)
-          ->(corrector) { corrector.remove(pos_before_left_paren) }
-        end
       end
     end
   end

lib/rubocop/cop/layout/space_after_not.rb

@@ -13,29 +13,27 @@ module Layout
       #   !something
       #
       # @api private
-      class SpaceAfterNot < Cop
+      class SpaceAfterNot < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Do not leave space between `!` and its argument.'
 
         def on_send(node)
           return unless node.prefix_bang? && whitespace_after_operator?(node)
 
-          add_offense(node)
+          add_offense(node) do |corrector|
+            corrector.remove(
+              range_between(node.loc.selector.end_pos, node.receiver.source_range.begin_pos)
+            )
+          end
         end
 
+        private
+
         def whitespace_after_operator?(node)
           node.receiver.loc.column - node.loc.column > 1
         end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.remove(
-              range_between(node.loc.selector.end_pos,
-                            node.receiver.source_range.begin_pos)
-            )
-          end
-        end
       end
     end
   end

lib/rubocop/cop/layout/space_after_semicolon.rb

@@ -13,12 +13,9 @@ module Layout
       #   x = 1; y = 2
       #
       # @api private
-      class SpaceAfterSemicolon < Cop
+      class SpaceAfterSemicolon < Base
         include SpaceAfterPunctuation
-
-        def autocorrect(semicolon)
-          PunctuationCorrector.add_space(semicolon)
-        end
+        extend AutoCorrector
 
         def space_style_before_rcurly
           cfg = config.for_cop('Layout/SpaceInsideBlockBraces')

lib/rubocop/cop/layout/space_around_equals_in_parameter_default.rb

@@ -29,10 +29,11 @@ module Layout
       #   end
       #
       # @api private
-      class SpaceAroundEqualsInParameterDefault < Cop
+      class SpaceAroundEqualsInParameterDefault < Base
         include SurroundingSpace
         include ConfigurableEnforcedStyle
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Surrounding space %<type>s in default value assignment.'
 
@@ -42,13 +43,6 @@ def on_optarg(node)
           check_optarg(arg, equals, value)
         end
 
-        def autocorrect(range)
-          m = range.source.match(/=\s*(\S+)/)
-          rest = m ? m.captures[0] : ''
-          replacement = style == :space ? ' = ' : '='
-          ->(corrector) { corrector.replace(range, replacement + rest) }
-        end
-
         private
 
         def check_optarg(arg, equals, value)
@@ -67,14 +61,25 @@ def check_optarg(arg, equals, value)
         def incorrect_style_detected(arg, value, space_on_both_sides,
                                      no_surrounding_space)
           range = range_between(arg.end_pos, value.begin_pos)
-          add_offense(range, location: range) do
-            if style == :space && no_surrounding_space ||
-               style == :no_space && space_on_both_sides
-              opposite_style_detected
-            else
-              unrecognized_style_detected
-            end
+
+          if style == :space && no_surrounding_space ||
+             style == :no_space && space_on_both_sides
+            return unless opposite_style_detected
+          else
+            return unless unrecognized_style_detected
           end
+
+          add_offense(range) do |corrector|
+            autocorrect(corrector, range)
+          end
+        end
+
+        def autocorrect(corrector, range)
+          m = range.source.match(/=\s*(\S+)/)
+          rest = m ? m.captures[0] : ''
+          replacement = style == :space ? ' = ' : '='
+
+          corrector.replace(range, replacement + rest)
         end
 
         def space_on_both_sides?(arg, equals)

lib/rubocop/cop/layout/space_around_keyword.rb

@@ -26,7 +26,9 @@ module Layout
       #   something = 123 if test
       #
       # @api private
-      class SpaceAroundKeyword < Cop
+      class SpaceAroundKeyword < Base
+        extend AutoCorrector
+
         MSG_BEFORE = 'Space before keyword `%<range>s` is missing.'
         MSG_AFTER = 'Space after keyword `%<range>s` is missing.'
 
@@ -131,14 +133,6 @@ def on_defined?(node)
           check(node, [:keyword].freeze)
         end
 
-        def autocorrect(range)
-          if space_before_missing?(range)
-            ->(corrector) { corrector.insert_before(range, ' ') }
-          else
-            ->(corrector) { corrector.insert_after(range, ' ') }
-          end
-        end
-
         private
 
         def check(node, locations, begin_keyword = DO)
@@ -164,24 +158,29 @@ def check_begin(node, range, begin_keyword)
 
         def check_end(node, range, begin_keyword)
           return if begin_keyword == DO && !do?(node)
+          return unless space_before_missing?(range)
 
-          offense(range, MSG_BEFORE) if space_before_missing?(range)
+          add_offense(range, message: format(MSG_BEFORE, range: range.source)) do |corrector|
+            corrector.insert_before(range, ' ')
+          end
         end
 
         def do?(node)
           node.loc.begin&.is?(DO)
         end
 
         def check_keyword(node, range)
-          offense(range, MSG_BEFORE) if space_before_missing?(range) &&
-                                        !preceded_by_operator?(node, range)
-          offense(range, MSG_AFTER) if space_after_missing?(range)
-        end
+          if space_before_missing?(range) && !preceded_by_operator?(node, range)
+            add_offense(range, message: format(MSG_BEFORE, range: range.source)) do |corrector|
+              corrector.insert_before(range, ' ')
+            end
+          end
 
-        def offense(range, msg)
-          add_offense(range,
-                      location: range,
-                      message: format(msg, range: range.source))
+          return unless space_after_missing?(range)
+
+          add_offense(range, message: format(MSG_AFTER, range: range.source)) do |corrector|
+            corrector.insert_after(range, ' ')
+          end
         end
 
         def space_before_missing?(range)