rubocop 0.82.0 → 1.18.4

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

@@ -24,22 +24,21 @@ module RuboCop
       #
       #   # good
       #   x != y
-      class RedundantConditional < Cop
+      class RedundantConditional < Base
         include Alignment
+        extend AutoCorrector
 
-        COMPARISON_OPERATORS = RuboCop::AST::Node::COMPARISON_OPERATORS
+        operators = RuboCop::AST::Node::COMPARISON_OPERATORS.to_a
+        COMPARISON_OPERATOR_MATCHER = "{:#{operators.join(' :')}}"
 
-        MSG = 'This conditional expression can just be replaced ' \
-              'by `%<msg>s`.'
+        MSG = 'This conditional expression can just be replaced by `%<msg>s`.'
 
         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
@@ -53,12 +52,14 @@ module RuboCop
           format(MSG, msg: msg)
         end
 
+        # @!method redundant_condition?(node)
         def_node_matcher :redundant_condition?, <<~RUBY
-          (if (send _ {:#{COMPARISON_OPERATORS.join(' :')}} _) true false)
+          (if (send _ #{COMPARISON_OPERATOR_MATCHER} _) true false)
         RUBY
 
+        # @!method redundant_condition_inverted?(node)
         def_node_matcher :redundant_condition_inverted?, <<~RUBY
-          (if (send _ {:#{COMPARISON_OPERATORS.join(' :')}} _) false true)
+          (if (send _ #{COMPARISON_OPERATOR_MATCHER} _) false true)
         RUBY
 
         def offense?(node)
@@ -76,11 +77,9 @@ module RuboCop
 
         def invert_expression?(node)
           (
-            (node.if? || node.elsif? || node.ternary?) &&
-            redundant_condition_inverted?(node)
+            (node.if? || node.elsif? || node.ternary?) && redundant_condition_inverted?(node)
           ) || (
-            node.unless? &&
-            redundant_condition?(node)
+            node.unless? && redundant_condition?(node)
           )
         end
 

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

@@ -16,43 +16,48 @@ module RuboCop
       #
       #   # Good
       #   raise 'message'
-      class RedundantException < Cop
+      class RedundantException < Base
+        extend AutoCorrector
+
         MSG_1 = 'Redundant `RuntimeError` argument can be removed.'
-        MSG_2 = 'Redundant `RuntimeError.new` call can be replaced with ' \
-                'just the message.'
+        MSG_2 = 'Redundant `RuntimeError.new` call can be replaced with just the message.'
 
-        def on_send(node)
-          exploded?(node) { return add_offense(node, message: MSG_1) }
-          compact?(node) { add_offense(node, message: MSG_2) }
-        end
+        RESTRICT_ON_SEND = %i[raise fail].freeze
 
         # Switch `raise RuntimeError, 'message'` to `raise 'message'`, and
         # `raise RuntimeError.new('message')` to `raise 'message'`.
-        def autocorrect(node) # rubocop:disable Metrics/MethodLength
+        def on_send(node)
+          fix_exploded(node) || fix_compact(node)
+        end
+
+        def fix_exploded(node)
           exploded?(node) do |command, message|
-            return lambda do |corrector|
+            add_offense(node, message: MSG_1) do |corrector|
               if node.parenthesized?
-                corrector.replace(node,
-                                  "#{command}(#{message.source})")
+                corrector.replace(node, "#{command}(#{message.source})")
               else
-                corrector.replace(node,
-                                  "#{command} #{message.source}")
+                corrector.replace(node, "#{command} #{message.source}")
               end
             end
           end
+        end
+
+        def fix_compact(node)
           compact?(node) do |new_call, message|
-            lambda do |corrector|
+            add_offense(node, message: MSG_2) do |corrector|
               corrector.replace(new_call, message.source)
             end
           end
         end
 
+        # @!method exploded?(node)
         def_node_matcher :exploded?, <<~PATTERN
-          (send nil? ${:raise :fail} (const nil? :RuntimeError) $_)
+          (send nil? ${:raise :fail} (const {nil? cbase} :RuntimeError) $_)
         PATTERN
 
+        # @!method compact?(node)
         def_node_matcher :compact?, <<~PATTERN
-          (send nil? {:raise :fail} $(send (const nil? :RuntimeError) :new $_))
+          (send nil? {:raise :fail} $(send (const {nil? cbase} :RuntimeError) :new $_))
         PATTERN
       end
     end

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

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop identifies places where `fetch(key) { value }`
+      # can be replaced by `fetch(key, value)`.
+      #
+      # In such cases `fetch(key, value)` method is faster
+      # than `fetch(key) { value }`.
+      #
+      # @example SafeForConstants: false (default)
+      #   # bad
+      #   hash.fetch(:key) { 5 }
+      #   hash.fetch(:key) { true }
+      #   hash.fetch(:key) { nil }
+      #   array.fetch(5) { :value }
+      #   ENV.fetch(:key) { 'value' }
+      #
+      #   # good
+      #   hash.fetch(:key, 5)
+      #   hash.fetch(:key, true)
+      #   hash.fetch(:key, nil)
+      #   array.fetch(5, :value)
+      #   ENV.fetch(:key, 'value')
+      #
+      # @example SafeForConstants: true
+      #   # bad
+      #   ENV.fetch(:key) { VALUE }
+      #
+      #   # good
+      #   ENV.fetch(:key, VALUE)
+      #
+      class RedundantFetchBlock < Base
+        include FrozenStringLiteral
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Use `%<good>s` instead of `%<bad>s`.'
+
+        # @!method redundant_fetch_block_candidate?(node)
+        def_node_matcher :redundant_fetch_block_candidate?, <<~PATTERN
+          (block
+            $(send _ :fetch _)
+            (args)
+            ${nil? #basic_literal? #const_type?})
+        PATTERN
+
+        def on_block(node)
+          redundant_fetch_block_candidate?(node) do |send, body|
+            return if should_not_check?(send, body)
+
+            range = fetch_range(send, node)
+            good = build_good_method(send, body)
+            bad = build_bad_method(send, body)
+
+            add_offense(range, message: format(MSG, good: good, bad: bad)) do |corrector|
+              receiver, _, key = send.children
+              default_value = body ? body.source : 'nil'
+
+              corrector.replace(node, "#{receiver.source}.fetch(#{key.source}, #{default_value})")
+            end
+          end
+        end
+
+        private
+
+        def basic_literal?(node)
+          node&.basic_literal?
+        end
+
+        def const_type?(node)
+          node&.const_type?
+        end
+
+        def should_not_check?(send, body)
+          (body&.const_type? && !check_for_constant?) ||
+            (body&.str_type? && !check_for_string?) ||
+            rails_cache?(send.receiver)
+        end
+
+        # @!method rails_cache?(node)
+        def_node_matcher :rails_cache?, <<~PATTERN
+          (send (const _ :Rails) :cache)
+        PATTERN
+
+        def fetch_range(send, node)
+          range_between(send.loc.selector.begin_pos, node.loc.end.end_pos)
+        end
+
+        def build_good_method(send, body)
+          key = send.children[2].source
+          default_value = body ? body.source : 'nil'
+
+          "fetch(#{key}, #{default_value})"
+        end
+
+        def build_bad_method(send, body)
+          key = send.children[2].source
+          block = body ? "{ #{body.source} }" : '{}'
+
+          "fetch(#{key}) #{block}"
+        end
+
+        def check_for_constant?
+          cop_config['SafeForConstants']
+        end
+
+        def check_for_string?
+          frozen_string_literals_enabled?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for the presence of superfluous `.rb` extension in
+      # the filename provided to `require` and `require_relative`.
+      #
+      # Note: If the extension is omitted, Ruby tries adding '.rb', '.so',
+      #       and so on to the name until found. If the file named cannot be found,
+      #       a `LoadError` will be raised.
+      #       There is an edge case where `foo.so` file is loaded instead of a `LoadError`
+      #       if `foo.so` file exists when `require 'foo.rb'` will be changed to `require 'foo'`,
+      #       but that seems harmless.
+      #
+      # @example
+      #   # bad
+      #   require 'foo.rb'
+      #   require_relative '../foo.rb'
+      #
+      #   # good
+      #   require 'foo'
+      #   require 'foo.so'
+      #   require_relative '../foo'
+      #   require_relative '../foo.so'
+      #
+      class RedundantFileExtensionInRequire < Base
+        extend AutoCorrector
+
+        MSG = 'Redundant `.rb` file extension detected.'
+        RESTRICT_ON_SEND = %i[require require_relative].freeze
+
+        # @!method require_call?(node)
+        def_node_matcher :require_call?, <<~PATTERN
+          (send nil? {:require :require_relative} $str_type?)
+        PATTERN
+
+        def on_send(node)
+          require_call?(node) do |name_node|
+            return unless name_node.value.end_with?('.rb')
+
+            add_offense(name_node) do |corrector|
+              correction = name_node.value.delete_suffix('.rb')
+
+              corrector.replace(name_node, "'#{correction}'")
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,7 +3,9 @@
 module RuboCop
   module Cop
     module Style
-      # This cop check for uses of Object#freeze on immutable objects.
+      # This cop check for uses of `Object#freeze` on immutable objects.
+      #
+      # NOTE: Regexp and Range literals are frozen objects since Ruby 3.0.
       #
       # @example
       #   # bad
@@ -11,22 +13,19 @@ 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.'
+        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
@@ -39,8 +38,10 @@ module RuboCop
 
           return true if node.immutable_literal?
 
-          FROZEN_STRING_LITERAL_TYPES.include?(node.type) &&
-            frozen_string_literals_enabled?
+          return true if FROZEN_STRING_LITERAL_TYPES.include?(node.type) &&
+                         frozen_string_literals_enabled?
+
+          target_ruby_version >= 3.0 && (node.regexp_type? || node.range_type?)
         end
 
         def strip_parenthesis(node)
@@ -51,12 +52,13 @@ module RuboCop
           end
         end
 
+        # @!method operation_produces_immutable_object?(node)
         def_node_matcher :operation_produces_immutable_object?, <<~PATTERN
           {
             (begin (send {float int} {:+ :- :* :** :/ :% :<<} _))
-            (begin (send !(str _) {:+ :- :* :** :/ :%} {float int}))
+            (begin (send !{(str _) array} {:+ :- :* :** :/ :%} {float int}))
             (begin (send _ {:== :=== :!= :<= :>= :< :>} _))
-            (send (const nil? :ENV) :[] _)
+            (send (const {nil? cbase} :ENV) :[] _)
             (send _ {:count :length :size} ...)
             (block (send _ {:count :length :size} ...) ...)
           }

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)
@@ -66,31 +72,30 @@ module RuboCop
         end
 
         def embedded_in_percent_array?(node)
-          node.parent&.array_type? &&
-            percent_literal?(node.parent)
+          node.parent&.array_type? && 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