rubocop 0.89.0 → 0.92.0

data/lib/rubocop/cop/style/percent_q_literals.rb

@@ -25,9 +25,10 @@ module RuboCop
       #   # good
       #   %Q/Mix the foo into the baz./
       #   %Q{They all said: 'Hooray!'}
-      class PercentQLiterals < Cop
+      class PercentQLiterals < Base
         include PercentLiteral
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         LOWER_CASE_Q_MSG = 'Do not use `%Q` unless interpolation is ' \
                            'needed. Use `%q`.'
@@ -37,12 +38,6 @@ module RuboCop
           process(node, '%Q', '%q')
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node, corrected(node.source))
-          end
-        end
-
         private
 
         def on_percent_literal(node)
@@ -50,9 +45,12 @@ module RuboCop
 
           # Report offense only if changing case doesn't change semantics,
           # i.e., if the string would become dynamic or has special characters.
-          return if node.children != parse(corrected(node.source)).ast.children
+          ast = ProcessedSource.new(corrected(node.source), target_ruby_version).ast
+          return if node.children != ast.children
 
-          add_offense(node, location: :begin)
+          add_offense(node.loc.begin) do |corrector|
+            corrector.replace(node, corrected(node.source))
+          end
         end
 
         def correct_literal_style?(node)
@@ -60,7 +58,7 @@ module RuboCop
             style == :upper_case_q && type(node) == '%Q'
         end
 
-        def message(_node)
+        def message(_range)
           style == :lower_case_q ? LOWER_CASE_Q_MSG : UPPER_CASE_Q_MSG
         end
 

data/lib/rubocop/cop/style/perl_backrefs.rb

@@ -12,23 +12,21 @@ module RuboCop
       #
       #   # good
       #   puts Regexp.last_match(1)
-      class PerlBackrefs < Cop
+      class PerlBackrefs < Base
+        extend AutoCorrector
+
         MSG = 'Avoid the use of Perl-style backrefs.'
 
         def on_nth_ref(node)
-          add_offense(node)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
+          add_offense(node) do |corrector|
             backref, = *node
             parent_type = node.parent ? node.parent.type : nil
+
             if %i[dstr xstr regexp].include?(parent_type)
-              corrector.replace(node,
-                                "{Regexp.last_match(#{backref})}")
+              corrector.replace(node, "{Regexp.last_match(#{backref})}")
+
             else
-              corrector.replace(node,
-                                "Regexp.last_match(#{backref})")
+              corrector.replace(node, "Regexp.last_match(#{backref})")
             end
           end
         end

data/lib/rubocop/cop/style/preferred_hash_methods.rb

@@ -25,8 +25,9 @@ module RuboCop
       #  # good
       #  Hash#has_key?
       #  Hash#has_value?
-      class PreferredHashMethods < Cop
+      class PreferredHashMethods < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         MSG = 'Use `Hash#%<prefer>s` instead of `Hash#%<current>s`.'
 
@@ -35,27 +36,23 @@ module RuboCop
           verbose: %i[key? value?]
         }.freeze
 
+        RESTRICT_ON_SEND = OFFENDING_SELECTORS.values.flatten.freeze
+
         def on_send(node)
-          return unless node.arguments.one? &&
-                        offending_selector?(node.method_name)
+          return unless node.arguments.one? && offending_selector?(node.method_name)
 
-          add_offense(node, location: :selector)
-        end
-        alias on_csend on_send
+          message = message(node.method_name)
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.loc.selector,
-                              proper_method_name(node.loc.selector.source))
+          add_offense(node.loc.selector, message: message) do |corrector|
+            corrector.replace(node.loc.selector, proper_method_name(node.loc.selector.source))
           end
         end
+        alias on_csend on_send
 
         private
 
-        def message(node)
-          format(MSG,
-                 prefer: proper_method_name(node.method_name),
-                 current: node.method_name)
+        def message(method_name)
+          format(MSG, prefer: proper_method_name(method_name), current: method_name)
         end
 
         def proper_method_name(method_name)

data/lib/rubocop/cop/style/proc.rb

@@ -13,7 +13,9 @@ module RuboCop
       #   # good
       #   p = proc { |n| puts n }
       #
-      class Proc < Cop
+      class Proc < Base
+        extend AutoCorrector
+
         MSG = 'Use `proc` instead of `Proc.new`.'
 
         def_node_matcher :proc_new?,
@@ -21,13 +23,11 @@ module RuboCop
 
         def on_block(node)
           proc_new?(node) do |block_method|
-            add_offense(block_method)
+            add_offense(block_method) do |corrector|
+              corrector.replace(block_method, 'proc')
+            end
           end
         end
-
-        def autocorrect(node)
-          ->(corrector) { corrector.replace(node, 'proc') }
-        end
       end
     end
   end

data/lib/rubocop/cop/style/raise_args.rb

@@ -32,14 +32,17 @@ module RuboCop
       #   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`.'
         COMPACT_MSG = 'Provide an exception object ' \
           'as an argument to `%<method>s`.'
 
+        RESTRICT_ON_SEND = %i[raise fail].freeze
+
         def on_send(node)
           return unless node.command?(:raise) || node.command?(:fail)
 
@@ -51,16 +54,6 @@ module RuboCop
           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 +84,12 @@ module RuboCop
 
         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 +102,13 @@ module RuboCop
           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, message: format(EXPLODED_MSG, method: node.method_name)) do |corrector|
+            replacement = correction_compact_to_exploded(node)
 
-          add_offense(node) do
-            opposite_style_detected
+            corrector.replace(node, replacement)
           end
         end
 
@@ -131,14 +130,6 @@ module RuboCop
           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

data/lib/rubocop/cop/style/random_with_offset.rb

@@ -23,9 +23,12 @@ module RuboCop
       #   # 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.'
+        RESTRICT_ON_SEND = %i[+ - succ pred next].freeze
 
         def_node_matcher :integer_op_rand?, <<~PATTERN
           (send
@@ -33,7 +36,7 @@ module RuboCop
             (send
               {nil? (const {nil? cbase} :Random) (const {nil? cbase} :Kernel)}
               :rand
-              {int irange erange}))
+              {int (irange int int) (erange int int)}))
         PATTERN
 
         def_node_matcher :rand_op_integer?, <<~PATTERN
@@ -41,7 +44,7 @@ module RuboCop
             (send
               {nil? (const {nil? cbase} :Random) (const {nil? cbase} :Kernel)}
               :rand
-              {int irange erange})
+              {int (irange int int) (erange int int)})
             {:+ :-}
             int)
         PATTERN
@@ -51,7 +54,7 @@ module RuboCop
             (send
               {nil? (const {nil? cbase} :Random) (const {nil? cbase} :Kernel)}
               :rand
-              {int irange erange})
+              {int (irange int int) (erange int int)})
             {:succ :pred :next})
         PATTERN
 
@@ -61,21 +64,8 @@ module RuboCop
                         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 +76,16 @@ module RuboCop
            (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)

data/lib/rubocop/cop/style/redundant_assignment.rb

@@ -37,7 +37,9 @@ module RuboCop
       #     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 @@ module RuboCop
         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,20 +91,16 @@ module RuboCop
 
         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(assignment.right_sibling)
+            end
           else
             last_expr = node.children.last
             check_branch(last_expr)
           end
         end
-
-        def right_sibling_of(node)
-          siblings_of(node)[node.sibling_index + 1]
-        end
-
-        def siblings_of(node)
-          node.parent.children
-        end
       end
     end
   end

data/lib/rubocop/cop/style/redundant_begin.rb

@@ -54,7 +54,9 @@ module RuboCop
       #       baz
       #     end
       #   end
-      class RedundantBegin < Cop
+      class RedundantBegin < Base
+        extend AutoCorrector
+
         MSG = 'Redundant `begin` block detected.'
 
         def on_def(node)
@@ -71,19 +73,15 @@ module RuboCop
           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

data/lib/rubocop/cop/style/redundant_capital_w.rb

@@ -14,8 +14,9 @@ module RuboCop
       #   %w/swim run bike/
       #   %w[shirt pants shoes]
       #   %W(apple #{fruit} grape)
-      class RedundantCapitalW < Cop
+      class RedundantCapitalW < Base
         include PercentLiteral
+        extend AutoCorrector
 
         MSG = 'Do not use `%W` unless interpolation is needed. ' \
               'If not, use `%w`.'
@@ -24,19 +25,15 @@ module RuboCop
           process(node, '%W')
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            src = node.loc.begin.source
-            corrector.replace(node.loc.begin, src.tr('W', 'w'))
-          end
-        end
-
         private
 
         def on_percent_literal(node)
           return if requires_interpolation?(node)
 
-          add_offense(node)
+          add_offense(node) do |corrector|
+            src = node.loc.begin.source
+            corrector.replace(node.loc.begin, src.tr('W', 'w'))
+          end
         end
 
         def requires_interpolation?(node)

data/lib/rubocop/cop/style/redundant_condition.rb

@@ -30,8 +30,9 @@ module RuboCop
       #     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 @@ module RuboCop
           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 @@ module RuboCop
         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