Use Cop::Base API for Style department [R-S]

Follow #7868.

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

lib/rubocop/cop/style/raise_args.rb

@@ -32,8 +32,9 @@ module Style
       #   raise StandardError.new("message")
       #   raise MyCustomError.new(arg1, arg2, arg3)
       #   fail "message"
-      class RaiseArgs < Cop
+      class RaiseArgs < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         EXPLODED_MSG = 'Provide an exception class and message ' \
           'as arguments to `%<method>s`.'
@@ -51,16 +52,6 @@ def on_send(node)
           end
         end
 
-        def autocorrect(node)
-          replacement = if style == :compact
-                          correction_exploded_to_compact(node)
-                        else
-                          correction_compact_to_exploded(node)
-                        end
-
-          ->(corrector) { corrector.replace(node, replacement) }
-        end
-
         private
 
         def correction_compact_to_exploded(node)
@@ -91,8 +82,12 @@ def correction_exploded_to_compact(node)
 
         def check_compact(node)
           if node.arguments.size > 1
-            add_offense(node) do
-              opposite_style_detected
+            return unless opposite_style_detected
+
+            add_offense(node, message: format(COMPACT_MSG, method: node.method_name)) do |corrector|
+              replacement = correction_exploded_to_compact(node)
+
+              corrector.replace(node, replacement)
             end
           else
             correct_style_detected
@@ -105,11 +100,13 @@ def check_exploded(node)
           first_arg = node.first_argument
 
           return unless first_arg.send_type? && first_arg.method?(:new)
-
           return if acceptable_exploded_args?(first_arg.arguments)
+          return unless opposite_style_detected
 
-          add_offense(node) do
-            opposite_style_detected
+          add_offense(node, message: format(EXPLODED_MSG, method: node.method_name)) do |corrector|
+            replacement = correction_compact_to_exploded(node)
+
+            corrector.replace(node, replacement)
           end
         end
 
@@ -131,14 +128,6 @@ def requires_parens?(parent)
           parent.and_type? || parent.or_type? ||
             parent.if_type? && parent.ternary?
         end
-
-        def message(node)
-          if style == :compact
-            format(COMPACT_MSG, method: node.method_name)
-          else
-            format(EXPLODED_MSG, method: node.method_name)
-          end
-        end
       end
     end
   end

lib/rubocop/cop/style/random_with_offset.rb

@@ -23,7 +23,9 @@ module Style
       #   # good
       #   rand(1..6)
       #   rand(1...7)
-      class RandomWithOffset < Cop
+      class RandomWithOffset < Base
+        extend AutoCorrector
+
         MSG = 'Prefer ranges when generating random numbers instead of ' \
           'integers with offsets.'
 
@@ -61,21 +63,8 @@ def on_send(node)
                         rand_op_integer?(node) ||
                         rand_modified?(node)
 
-          add_offense(node)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            if integer_op_rand?(node)
-              corrector.replace(node,
-                                corrected_integer_op_rand(node))
-            elsif rand_op_integer?(node)
-              corrector.replace(node,
-                                corrected_rand_op_integer(node))
-            elsif rand_modified?(node)
-              corrector.replace(node,
-                                corrected_rand_modified(node))
-            end
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node)
           end
         end
 
@@ -86,6 +75,16 @@ def autocorrect(node)
            (send _ _ (send $_ _ $_))}
         PATTERN
 
+        def autocorrect(corrector, node)
+          if integer_op_rand?(node)
+            corrector.replace(node, corrected_integer_op_rand(node))
+          elsif rand_op_integer?(node)
+            corrector.replace(node, corrected_rand_op_integer(node))
+          elsif rand_modified?(node)
+            corrector.replace(node, corrected_rand_modified(node))
+          end
+        end
+
         def corrected_integer_op_rand(node)
           random_call(node) do |prefix_node, random_node|
             prefix = prefix_from_prefix_node(prefix_node)

lib/rubocop/cop/style/redundant_assignment.rb

@@ -37,7 +37,9 @@ module Style
       #     end
       #   end
       #
-      class RedundantAssignment < Cop
+      class RedundantAssignment < Base
+        extend AutoCorrector
+
         MSG = 'Redundant assignment before returning detected.'
 
         def_node_matcher :redundant_assignment?, <<~PATTERN
@@ -49,14 +51,6 @@ def on_def(node)
         end
         alias on_defs on_def
 
-        def autocorrect(node)
-          lambda do |corrector|
-            expression = node.children[1]
-            corrector.replace(node, expression.source)
-            corrector.remove(right_sibling_of(node))
-          end
-        end
-
         private
 
         def check_branch(node)
@@ -97,7 +91,11 @@ def check_ensure_node(node)
 
         def check_begin_node(node)
           if (assignment = redundant_assignment?(node))
-            add_offense(assignment)
+            add_offense(assignment) do |corrector|
+              expression = assignment.children[1]
+              corrector.replace(assignment, expression.source)
+              corrector.remove(right_sibling_of(assignment))
+            end
           else
             last_expr = node.children.last
             check_branch(last_expr)

lib/rubocop/cop/style/redundant_begin.rb

@@ -54,7 +54,9 @@ module Style
       #       baz
       #     end
       #   end
-      class RedundantBegin < Cop
+      class RedundantBegin < Base
+        extend AutoCorrector
+
         MSG = 'Redundant `begin` block detected.'
 
         def on_def(node)
@@ -71,19 +73,15 @@ def on_block(node)
           check(node)
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.remove(node.loc.begin)
-            corrector.remove(node.loc.end)
-          end
-        end
-
         private
 
         def check(node)
           return unless node.body&.kwbegin_type?
 
-          add_offense(node.body, location: :begin)
+          add_offense(node.body.loc.begin) do |corrector|
+            corrector.remove(node.body.loc.begin)
+            corrector.remove(node.body.loc.end)
+          end
         end
       end
     end

lib/rubocop/cop/style/redundant_condition.rb

@@ -30,8 +30,9 @@ module Style
       #     c
       #   end
       #
-      class RedundantCondition < Cop
+      class RedundantCondition < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Use double pipes `||` instead.'
         REDUNDANT_CONDITION = 'This condition is not needed.'
@@ -40,11 +41,9 @@ def on_if(node)
           return if node.elsif_conditional?
           return unless offense?(node)
 
-          add_offense(node, location: range_of_offense(node))
-        end
+          message = message(node)
 
-        def autocorrect(node)
-          lambda do |corrector|
+          add_offense(range_of_offense(node), message: message) do |corrector|
             if node.ternary?
               correct_ternary(corrector, node)
             elsif node.modifier_form? || !node.else_branch
@@ -68,7 +67,7 @@ def message(node)
         end
 
         def range_of_offense(node)
-          return :expression unless node.ternary?
+          return node.loc.expression unless node.ternary?
 
           range_between(node.loc.question.begin_pos, node.loc.colon.end_pos)
         end

lib/rubocop/cop/style/redundant_fetch_block.rb

@@ -31,9 +31,10 @@ module Style
       #   # good
       #   ENV.fetch(:key, VALUE)
       #
-      class RedundantFetchBlock < Cop
+      class RedundantFetchBlock < Base
         include FrozenStringLiteral
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Use `%<good>s` instead of `%<bad>s`.'
 
@@ -52,17 +53,7 @@ def on_block(node)
             good = build_good_method(send, body)
             bad = build_bad_method(send, body)
 
-            add_offense(
-              node,
-              location: range,
-              message: format(MSG, good: good, bad: bad)
-            )
-          end
-        end
-
-        def autocorrect(node)
-          redundant_fetch_block_candidate?(node) do |send, body|
-            lambda do |corrector|
+            add_offense(range, message: format(MSG, good: good, bad: bad)) do |corrector|
               receiver, _, key = send.children
               default_value = body ? body.source : 'nil'
 

lib/rubocop/cop/style/redundant_file_extension_in_require.rb

@@ -24,7 +24,9 @@ module Style
       #   require_relative '../foo'
       #   require_relative '../foo.so'
       #
-      class RedundantFileExtensionInRequire < Cop
+      class RedundantFileExtensionInRequire < Base
+        extend AutoCorrector
+
         MSG = 'Redundant `.rb` file extension detected.'
 
         def_node_matcher :require_call?, <<~PATTERN
@@ -33,15 +35,13 @@ class RedundantFileExtensionInRequire < Cop
 
         def on_send(node)
           require_call?(node) do |name_node|
-            add_offense(name_node) if name_node.value.end_with?('.rb')
-          end
-        end
+            return unless name_node.value.end_with?('.rb')
 
-        def autocorrect(node)
-          correction = node.value.sub(/\.rb\z/, '')
+            add_offense(name_node) do |corrector|
+              correction = name_node.value.sub(/\.rb\z/, '')
 
-          lambda do |corrector|
-            corrector.replace(node, "'#{correction}'")
+              corrector.replace(name_node, "'#{correction}'")
+            end
           end
         end
       end

lib/rubocop/cop/style/redundant_freeze.rb

@@ -11,7 +11,8 @@ module Style
       #
       #   # good
       #   CONST = 1
-      class RedundantFreeze < Cop
+      class RedundantFreeze < Base
+        extend AutoCorrector
         include FrozenStringLiteral
 
         MSG = 'Do not freeze immutable objects, as freezing them has no ' \
@@ -22,11 +23,7 @@ def on_send(node)
                         (immutable_literal?(node.receiver) ||
                          operation_produces_immutable_object?(node.receiver))
 
-          add_offense(node)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
+          add_offense(node) do |corrector|
             corrector.remove(node.loc.dot)
             corrector.remove(node.loc.selector)
           end

lib/rubocop/cop/style/regexp_literal.rb

@@ -81,42 +81,31 @@ module Style
       # @example AllowInnerSlashes: true
       #   # good
       #   x =~ /home\//
-      class RegexpLiteral < Cop
+      class RegexpLiteral < Base
         include ConfigurableEnforcedStyle
         include RangeHelp
+        extend AutoCorrector
 
         MSG_USE_SLASHES = 'Use `//` around regular expression.'
         MSG_USE_PERCENT_R = 'Use `%r` around regular expression.'
 
         def on_regexp(node)
-          if slash_literal?(node)
-            check_slash_literal(node)
-          else
-            check_percent_r_literal(node)
-          end
-        end
+          message = if slash_literal?(node)
+                      MSG_USE_PERCENT_R unless allowed_slash_literal?(node)
+                    else
+                      MSG_USE_SLASHES unless allowed_percent_r_literal?(node)
+                    end
+
+          return unless message
 
-        def autocorrect(node)
-          lambda do |corrector|
+          add_offense(node, message: message) do |corrector|
             correct_delimiters(node, corrector)
             correct_inner_slashes(node, corrector)
           end
         end
 
         private
 
-        def check_slash_literal(node)
-          return if allowed_slash_literal?(node)
-
-          add_offense(node, message: MSG_USE_PERCENT_R)
-        end
-
-        def check_percent_r_literal(node)
-          return if allowed_percent_r_literal?(node)
-
-          add_offense(node, message: MSG_USE_SLASHES)
-        end
-
         def allowed_slash_literal?(node)
           style == :slashes && !contains_disallowed_slash?(node) ||
             allowed_mixed_slash?(node)