rubocop 0.89.1 → 0.93.0

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

@@ -28,6 +28,14 @@ module RuboCop
       #   end
       #
       #   # bad
+      #   begin
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   do_something
+      #
+      #   # bad
       #   # When using Ruby 2.5 or later.
       #   do_something do
       #     begin
@@ -54,11 +62,15 @@ module RuboCop
       #       baz
       #     end
       #   end
-      class RedundantBegin < Cop
+      class RedundantBegin < Base
+        extend AutoCorrector
+
         MSG = 'Redundant `begin` block detected.'
 
         def on_def(node)
-          check(node)
+          return unless node.body&.kwbegin_type?
+
+          register_offense(node.body)
         end
         alias on_defs on_def
 
@@ -67,23 +79,27 @@ module RuboCop
 
           return if node.send_node.lambda_literal?
           return if node.braces?
+          return unless node.body&.kwbegin_type?
 
-          check(node)
+          register_offense(node.body)
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.remove(node.loc.begin)
-            corrector.remove(node.loc.end)
-          end
+        def on_kwbegin(node)
+          return if node.parent&.assignment?
+
+          first_child = node.children.first
+          return if first_child.rescue_type? || first_child.ensure_type?
+
+          register_offense(node)
         end
 
         private
 
-        def check(node)
-          return unless node.body&.kwbegin_type?
-
-          add_offense(node.body, location: :begin)
+        def register_offense(node)
+          add_offense(node.loc.begin) do |corrector|
+            corrector.remove(node.loc.begin)
+            corrector.remove(node.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
@@ -76,7 +75,7 @@ module RuboCop
         def offense?(node)
           condition, if_branch, else_branch = *node
 
-          return false if use_if_branch?(else_branch)
+          return false if use_if_branch?(else_branch) || use_hash_key_assignment?(else_branch)
 
           condition == if_branch && !node.elsif? && (
             node.ternary? ||
@@ -89,6 +88,10 @@ module RuboCop
           else_branch&.if_type?
         end
 
+        def use_hash_key_assignment?(else_branch)
+          else_branch&.send_type? && else_branch&.method?(:[]=)
+        end
+
         def else_source(else_branch)
           if require_parentheses?(else_branch)
             "(#{else_branch.source})"

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

@@ -24,8 +24,9 @@ module RuboCop
       #
       #   # good
       #   x != y
-      class RedundantConditional < Cop
+      class RedundantConditional < Base
         include Alignment
+        extend AutoCorrector
 
         operators = RuboCop::AST::Node::COMPARISON_OPERATORS.to_a
         COMPARISON_OPERATOR_MATCHER = "{:#{operators.join(' :')}}"
@@ -36,11 +37,9 @@ module RuboCop
         def on_if(node)
           return unless offense?(node)
 
-          add_offense(node)
-        end
+          message = message(node)
 
-        def autocorrect(node)
-          lambda do |corrector|
+          add_offense(node, message: message) do |corrector|
             corrector.replace(node, replacement_condition(node))
           end
         end

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

@@ -23,13 +23,11 @@ module RuboCop
         MSG_2 = 'Redundant `RuntimeError.new` call can be replaced with ' \
                 'just the message.'
 
-        RAISE_METHODS = %i[raise fail].freeze
+        RESTRICT_ON_SEND = %i[raise fail].freeze
 
         # Switch `raise RuntimeError, 'message'` to `raise 'message'`, and
         # `raise RuntimeError.new('message')` to `raise 'message'`.
         def on_send(node)
-          return unless RAISE_METHODS.include?(node.method_name)
-
           fix_exploded(node) || fix_compact(node)
         end
 

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

@@ -31,9 +31,10 @@ module RuboCop
       #   # 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 @@ module RuboCop
             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'
 

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

@@ -24,8 +24,11 @@ module RuboCop
       #   require_relative '../foo'
       #   require_relative '../foo.so'
       #
-      class RedundantFileExtensionInRequire < Cop
+      class RedundantFileExtensionInRequire < Base
+        extend AutoCorrector
+
         MSG = 'Redundant `.rb` file extension detected.'
+        RESTRICT_ON_SEND = %i[require require_relative].freeze
 
         def_node_matcher :require_call?, <<~PATTERN
           (send nil? {:require :require_relative} $str_type?)
@@ -33,15 +36,13 @@ module RuboCop
 
         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

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

@@ -11,22 +11,20 @@ module RuboCop
       #
       #   # good
       #   CONST = 1
-      class RedundantFreeze < Cop
+      class RedundantFreeze < Base
+        extend AutoCorrector
         include FrozenStringLiteral
 
         MSG = 'Do not freeze immutable objects, as freezing them has no ' \
               'effect.'
+        RESTRICT_ON_SEND = %i[freeze].freeze
 
         def on_send(node)
-          return unless node.receiver && node.method?(:freeze) &&
+          return unless node.receiver &&
                         (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

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

@@ -15,8 +15,9 @@ module RuboCop
       #
       #   # good if @var is already a String
       #   @var
-      class RedundantInterpolation < Cop
+      class RedundantInterpolation < Base
         include PercentLiteral
+        extend AutoCorrector
 
         MSG = 'Prefer `to_s` over string interpolation.'
 
@@ -25,18 +26,18 @@ module RuboCop
         end
 
         def on_dstr(node)
-          add_offense(node) if single_interpolation?(node)
-        end
-
-        def autocorrect(node)
-          embedded_node = node.children.first
-
-          if variable_interpolation?(embedded_node)
-            autocorrect_variable_interpolation(embedded_node, node)
-          elsif single_variable_interpolation?(embedded_node)
-            autocorrect_single_variable_interpolation(embedded_node, node)
-          else
-            autocorrect_other(embedded_node, node)
+          return unless single_interpolation?(node)
+
+          add_offense(node) do |corrector|
+            embedded_node = node.children.first
+
+            if variable_interpolation?(embedded_node)
+              autocorrect_variable_interpolation(corrector, embedded_node, node)
+            elsif single_variable_interpolation?(embedded_node)
+              autocorrect_single_variable_interpolation(corrector, embedded_node, node)
+            else
+              autocorrect_other(corrector, embedded_node, node)
+            end
           end
         end
 
@@ -50,7 +51,12 @@ module RuboCop
         end
 
         def single_variable_interpolation?(node)
-          node.children.one? && variable_interpolation?(node.children.first)
+          return false unless node.children.one?
+
+          first_child = node.children.first
+
+          variable_interpolation?(first_child) ||
+            first_child.send_type? && !first_child.operator_method?
         end
 
         def interpolation?(node)
@@ -70,27 +76,27 @@ module RuboCop
             percent_literal?(node.parent)
         end
 
-        def autocorrect_variable_interpolation(embedded_node, node)
+        def autocorrect_variable_interpolation(corrector, embedded_node, node)
           replacement = "#{embedded_node.loc.expression.source}.to_s"
-          ->(corrector) { corrector.replace(node, replacement) }
+
+          corrector.replace(node, replacement)
         end
 
-        def autocorrect_single_variable_interpolation(embedded_node, node)
+        def autocorrect_single_variable_interpolation(corrector, embedded_node, node)
           variable_loc = embedded_node.children.first.loc
           replacement = "#{variable_loc.expression.source}.to_s"
-          ->(corrector) { corrector.replace(node, replacement) }
+
+          corrector.replace(node, replacement)
         end
 
-        def autocorrect_other(embedded_node, node)
+        def autocorrect_other(corrector, embedded_node, node)
           loc = node.loc
           embedded_loc = embedded_node.loc
 
-          lambda do |corrector|
-            corrector.replace(loc.begin, '')
-            corrector.replace(loc.end, '')
-            corrector.replace(embedded_loc.begin, '(')
-            corrector.replace(embedded_loc.end, ').to_s')
-          end
+          corrector.replace(loc.begin, '')
+          corrector.replace(loc.end, '')
+          corrector.replace(embedded_loc.begin, '(')
+          corrector.replace(embedded_loc.end, ').to_s')
         end
       end
     end