rubocop 0.78.0 → 1.13.0

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.loc.expression, 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.loc.expression, 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

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

@@ -13,29 +13,31 @@ module RuboCop
       #   # good
       #   x if y.z.nil?
       #
-      class RedundantParentheses < Cop
+      class RedundantParentheses < Base
         include Parentheses
+        extend AutoCorrector
 
-        def_node_matcher :square_brackets?,
-                         '(send {(send _recv _msg) str array hash} :[] ...)'
+        # @!method square_brackets?(node)
+        def_node_matcher :square_brackets?, '(send {(send _recv _msg) str array hash} :[] ...)'
+
+        # @!method range_end?(node)
         def_node_matcher :range_end?, '^^{irange erange}'
+
+        # @!method method_node_and_args(node)
         def_node_matcher :method_node_and_args, '$(call _recv _msg $...)'
+
+        # @!method rescue?(node)
         def_node_matcher :rescue?, '{^resbody ^^resbody}'
-        def_node_matcher :arg_in_call_with_block?,
-                         '^^(block (send _ _ equal?(%0) ...) ...)'
+
+        # @!method arg_in_call_with_block?(node)
+        def_node_matcher :arg_in_call_with_block?, '^^(block (send _ _ equal?(%0) ...) ...)'
 
         def on_begin(node)
-          return if !parentheses?(node) || parens_allowed?(node)
-          return if node.parent && (node.parent.while_post_type? ||
-                                    node.parent.until_post_type?)
+          return if !parentheses?(node) || parens_allowed?(node) || ignore_syntax?(node)
 
           check(node)
         end
 
-        def autocorrect(node)
-          ParenthesesCorrector.correct(node)
-        end
-
         private
 
         def parens_allowed?(node)
@@ -45,6 +47,13 @@ module RuboCop
             allowed_expression?(node)
         end
 
+        def ignore_syntax?(node)
+          return false unless (parent = node.parent)
+
+          parent.while_post_type? || parent.until_post_type? ||
+            like_method_argument_parentheses?(parent)
+        end
+
         def allowed_expression?(node)
           allowed_ancestor?(node) ||
             allowed_method_call?(node) ||
@@ -71,6 +80,10 @@ module RuboCop
           !ancestor.begin_type? && !ancestor.def_type? && !ancestor.block_type?
         end
 
+        def like_method_argument_parentheses?(node)
+          node.send_type? && node.arguments.size == 1 && !node.arithmetic_operation?
+        end
+
         def empty_parentheses?(node)
           # Don't flag `()`
           node.children.empty?
@@ -93,18 +106,19 @@ module RuboCop
 
         def check(begin_node)
           node = begin_node.children.first
-          if keyword_with_redundant_parentheses?(node)
-            return offense(begin_node, 'a keyword')
-          end
-          if disallowed_literal?(begin_node, node)
-            return offense(begin_node, 'a literal')
-          end
+          return offense(begin_node, 'a keyword') if keyword_with_redundant_parentheses?(node)
+          return offense(begin_node, 'a literal') if disallowed_literal?(begin_node, node)
           return offense(begin_node, 'a variable') if node.variable?
           return offense(begin_node, 'a constant') if node.const_type?
 
+          return offense(begin_node, 'an interpolated expression') if interpolation?(begin_node)
+
           check_send(begin_node, node) if node.call_type?
         end
 
+        # @!method interpolation?(node)
+        def_node_matcher :interpolation?, '[^begin ^^dstr]'
+
         def check_send(begin_node, node)
           return check_unary(begin_node, node) if node.unary_operation?
 
@@ -119,15 +133,15 @@ module RuboCop
 
           node = node.children.first while suspect_unary?(node)
 
-          if node.send_type?
-            return unless method_call_with_redundant_parentheses?(node)
-          end
+          return if node.send_type? && !method_call_with_redundant_parentheses?(node)
 
           offense(begin_node, 'an unary operation')
         end
 
         def offense(node, msg)
-          add_offense(node, message: "Don't use parentheses around #{msg}.")
+          add_offense(node, message: "Don't use parentheses around #{msg}.") do |corrector|
+            ParenthesesCorrector.correct(corrector, node)
+          end
         end
 
         def suspect_unary?(node)
@@ -144,38 +158,30 @@ module RuboCop
           # { a: (1
           #      ), }
           # ```
-          (hash_element?(node) || array_element?(node)) &&
-            only_closing_paren_before_comma?(node)
-        end
-
-        def hash_element?(node)
-          node.parent&.pair_type?
+          hash_or_array_element?(node) && only_closing_paren_before_comma?(node)
         end
 
-        def array_element?(node)
-          node.parent&.array_type?
+        def hash_or_array_element?(node)
+          node.each_ancestor(:array, :hash).any?
         end
 
         def only_closing_paren_before_comma?(node)
           source_buffer = node.source_range.source_buffer
           line_range = source_buffer.line_range(node.loc.end.line)
 
-          line_range.source =~ /^\s*\)\s*,/
+          /^\s*\)\s*,/.match?(line_range.source)
         end
 
         def disallowed_literal?(begin_node, node)
-          node.literal? &&
-            !node.range_type? &&
-            !raised_to_power_negative_numeric?(begin_node, node)
+          node.literal? && !node.range_type? && !raised_to_power_negative_numeric?(begin_node, node)
         end
 
         def raised_to_power_negative_numeric?(begin_node, node)
           return false unless node.numeric_type?
 
-          siblings = begin_node.parent&.children
-          return false if siblings.nil?
+          next_sibling = begin_node.right_sibling
+          return false unless next_sibling
 
-          next_sibling = siblings[begin_node.sibling_index + 1]
           base_value = node.children.first
 
           base_value.negative? && next_sibling == :**
@@ -209,17 +215,24 @@ module RuboCop
         end
 
         def first_argument?(node)
-          first_send_argument?(node) || first_super_argument?(node)
+          first_send_argument?(node) || first_super_argument?(node) || first_yield_argument?(node)
         end
 
+        # @!method first_send_argument?(node)
         def_node_matcher :first_send_argument?, <<~PATTERN
           ^(send _ _ equal?(%0) ...)
         PATTERN
 
+        # @!method first_super_argument?(node)
         def_node_matcher :first_super_argument?, <<~PATTERN
           ^(super equal?(%0) ...)
         PATTERN
 
+        # @!method first_yield_argument?(node)
+        def_node_matcher :first_yield_argument?, <<~PATTERN
+          ^(yield equal?(%0) ...)
+        PATTERN
+
         def call_chain_starts_with_int?(begin_node, send_node)
           recv = first_part_of_call_chain(send_node)
           recv&.int_type? && (parent = begin_node.parent) &&

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

@@ -17,17 +17,18 @@ module RuboCop
       #   time = "8 o'clock"
       #   question = '"What did you say?"'
       #
-      class RedundantPercentQ < Cop
+      class RedundantPercentQ < Base
+        extend AutoCorrector
+
         MSG = 'Use `%<q_type>s` only for strings that contain both ' \
               'single quotes and double quotes%<extra>s.'
-        DYNAMIC_MSG = ', or for dynamic strings that contain ' \
-                      'double quotes'
+        DYNAMIC_MSG = ', or for dynamic strings that contain double quotes'
         SINGLE_QUOTE = "'"
         QUOTE = '"'
         EMPTY = ''
         PERCENT_Q = '%q'
         PERCENT_CAPITAL_Q = '%Q'
-        STRING_INTERPOLATION_REGEXP = /#\{.+}/.freeze
+        STRING_INTERPOLATION_REGEXP = /#\{.+\}/.freeze
         ESCAPED_NON_BACKSLASH = /\\[^\\]/.freeze
 
         def on_dstr(node)
@@ -45,22 +46,18 @@ module RuboCop
           check(node)
         end
 
-        def autocorrect(node)
-          delimiter =
-            node.source =~ /^%Q[^"]+$|'/ ? QUOTE : SINGLE_QUOTE
-          lambda do |corrector|
-            corrector.replace(node.loc.begin, delimiter)
-            corrector.replace(node.loc.end, delimiter)
-          end
-        end
-
         private
 
         def check(node)
           return unless start_with_percent_q_variant?(node)
           return if interpolated_quotes?(node) || allowed_percent_q?(node)
 
-          add_offense(node)
+          add_offense(node) do |corrector|
+            delimiter = /^%Q[^"]+$|'/.match?(node.source) ? QUOTE : SINGLE_QUOTE
+
+            corrector.replace(node.loc.begin, delimiter)
+            corrector.replace(node.loc.end, delimiter)
+          end
         end
 
         def interpolated_quotes?(node)
@@ -95,15 +92,15 @@ module RuboCop
         def acceptable_q?(node)
           src = node.source
 
-          return true if src =~ STRING_INTERPOLATION_REGEXP
+          return true if STRING_INTERPOLATION_REGEXP.match?(src)
 
-          src.scan(/\\./).any? { |s| s =~ ESCAPED_NON_BACKSLASH }
+          src.scan(/\\./).any? { |s| ESCAPED_NON_BACKSLASH.match?(s) }
         end
 
         def acceptable_capital_q?(node)
           src = node.source
           src.include?(QUOTE) &&
-            (src =~ STRING_INTERPOLATION_REGEXP ||
+            (STRING_INTERPOLATION_REGEXP.match?(src) ||
             (node.str_type? && double_quotes_required?(src)))
         end
       end