rubocop 1.31.1 → 1.52.1

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

@@ -3,11 +3,13 @@
 module RuboCop
   module Cop
     module Style
-      # Identifies places where `fetch(key) { value }`
-      # can be replaced by `fetch(key, value)`.
+      # 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 }`.
+      # In such cases `fetch(key, value)` method is faster than `fetch(key) { value }`.
+      #
+      # NOTE: The block string `'value'` in `hash.fetch(:key) { 'value' }` is detected
+      # when frozen string literal magic comment is enabled (i.e. `# frozen_string_literal: true`),
+      # but not when disabled.
       #
       # @safety
       #   This cop is unsafe because it cannot be guaranteed that the receiver
@@ -50,7 +52,7 @@ module RuboCop
             ${nil? #basic_literal? #const_type?})
         PATTERN
 
-        def on_block(node)
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
           redundant_fetch_block_candidate?(node) do |send, body|
             return if should_not_check?(send, body)
 

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

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Identifies usages of `any?`, `empty?` or `none?` predicate methods
+      # chained to `select`/`filter`/`find_all` and change them to use predicate method instead.
+      #
+      # @example
+      #   # bad
+      #   arr.select { |x| x > 1 }.any?
+      #
+      #   # good
+      #   arr.any? { |x| x > 1 }
+      #
+      #   # bad
+      #   arr.select { |x| x > 1 }.empty?
+      #   arr.select { |x| x > 1 }.none?
+      #
+      #   # good
+      #   arr.none? { |x| x > 1 }
+      #
+      #   # good
+      #   relation.select(:name).any?
+      #   arr.select { |x| x > 1 }.any?(&:odd?)
+      #
+      # @example AllCops:ActiveSupportExtensionsEnabled: false (default)
+      #   # good
+      #   arr.select { |x| x > 1 }.many?
+      #
+      # @example AllCops:ActiveSupportExtensionsEnabled: true
+      #   # bad
+      #   arr.select { |x| x > 1 }.many?
+      #
+      #   # good
+      #   arr.many? { |x| x > 1 }
+      #
+      class RedundantFilterChain < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<prefer>s` instead of `%<first_method>s.%<second_method>s`.'
+
+        RAILS_METHODS = %i[many?].freeze
+        RESTRICT_ON_SEND = (%i[any? empty? none? one?] + RAILS_METHODS).freeze
+
+        # @!method select_predicate?(node)
+        def_node_matcher :select_predicate?, <<~PATTERN
+          (send
+            {
+              (block $(send _ {:select :filter :find_all}) ...)
+              $(send _ {:select :filter :find_all} block_pass_type?)
+            }
+            ${:#{RESTRICT_ON_SEND.join(' :')}})
+        PATTERN
+
+        REPLACEMENT_METHODS = {
+          any?: :any?,
+          empty?: :none?,
+          none?: :none?,
+          one?: :one?,
+          many?: :many?
+        }.freeze
+        private_constant :REPLACEMENT_METHODS
+
+        def on_send(node)
+          return if node.arguments? || node.block_node
+
+          select_predicate?(node) do |select_node, filter_method|
+            return if RAILS_METHODS.include?(filter_method) && !active_support_extensions_enabled?
+
+            register_offense(select_node, node)
+          end
+        end
+
+        private
+
+        def register_offense(select_node, predicate_node)
+          replacement = REPLACEMENT_METHODS[predicate_node.method_name]
+          message = format(MSG, prefer: replacement,
+                                first_method: select_node.method_name,
+                                second_method: predicate_node.method_name)
+
+          offense_range = offense_range(select_node, predicate_node)
+
+          add_offense(offense_range, message: message) do |corrector|
+            corrector.remove(predicate_range(predicate_node))
+            corrector.replace(select_node.loc.selector, replacement)
+          end
+        end
+
+        def offense_range(select_node, predicate_node)
+          select_node.loc.selector.join(predicate_node.loc.selector)
+        end
+
+        def predicate_range(predicate_node)
+          predicate_node.receiver.source_range.end.join(predicate_node.loc.selector)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for redundant heredoc delimiter quotes.
+      #
+      # @example
+      #
+      #   # bad
+      #   do_something(<<~'EOS')
+      #     no string interpolation style text
+      #   EOS
+      #
+      #   # good
+      #   do_something(<<~EOS)
+      #     no string interpolation style text
+      #   EOS
+      #
+      #   do_something(<<~'EOS')
+      #     #{string_interpolation_style_text_not_evaluated}
+      #   EOS
+      #
+      #   do_something(<<~'EOS')
+      #     Preserve \
+      #     newlines
+      #   EOS
+      #
+      class RedundantHeredocDelimiterQuotes < Base
+        include Heredoc
+        extend AutoCorrector
+
+        MSG = 'Remove the redundant heredoc delimiter quotes, use `%<replacement>s` instead.'
+        STRING_INTERPOLATION_OR_ESCAPED_CHARACTER_PATTERN = /#(\{|@|\$)|\\/.freeze
+
+        def on_heredoc(node)
+          return if need_heredoc_delimiter_quotes?(node)
+
+          replacement = "#{heredoc_type(node)}#{delimiter_string(node)}"
+
+          add_offense(node, message: format(MSG, replacement: replacement)) do |corrector|
+            corrector.replace(node, replacement)
+          end
+        end
+
+        private
+
+        def need_heredoc_delimiter_quotes?(node)
+          heredoc_delimiter = node.source.delete(heredoc_type(node))
+          return true unless heredoc_delimiter.start_with?("'", '"')
+
+          node.loc.heredoc_end.source.strip.match?(/\W/) ||
+            node.loc.heredoc_body.source.match?(STRING_INTERPOLATION_OR_ESCAPED_CHARACTER_PATTERN)
+        end
+      end
+    end
+  end
+end

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

@@ -140,7 +140,9 @@ module RuboCop
         end
 
         def allow_comments?(node)
-          cop_config['AllowComments'] && contains_comments?(node)
+          return false unless cop_config['AllowComments']
+
+          contains_comments?(node) && !comments_contain_disables?(node, name)
         end
 
         def same_args?(super_node, args)

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

@@ -97,7 +97,7 @@ module RuboCop
         end
 
         def autocorrect_variable_interpolation(corrector, embedded_node, node)
-          replacement = "#{embedded_node.loc.expression.source}.to_s"
+          replacement = "#{embedded_node.source}.to_s"
 
           corrector.replace(node, replacement)
         end
@@ -107,7 +107,7 @@ module RuboCop
 
           source = if require_parentheses?(embedded_var)
                      receiver = range_between(
-                       embedded_var.loc.expression.begin_pos, embedded_var.loc.selector.end_pos
+                       embedded_var.source_range.begin_pos, embedded_var.loc.selector.end_pos
                      )
                      arguments = embedded_var.arguments.map(&:source).join(', ')
 

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

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Check for redundant line continuation.
+      #
+      # This cop marks a line continuation as redundant if removing the backslash
+      # does not result in a syntax error.
+      # However, a backslash at the end of a comment or
+      # for string concatenation is not redundant and is not considered an offense.
+      #
+      # @example
+      #   # bad
+      #   foo. \
+      #     bar
+      #   foo \
+      #     &.bar \
+      #       .baz
+      #
+      #   # good
+      #   foo.
+      #     bar
+      #   foo
+      #     &.bar
+      #       .baz
+      #
+      #   # bad
+      #   [foo, \
+      #     bar]
+      #   {foo: \
+      #     bar}
+      #
+      #   # good
+      #   [foo,
+      #     bar]
+      #   {foo:
+      #     bar}
+      #
+      #   # bad
+      #   foo(bar, \
+      #     baz)
+      #
+      #   # good
+      #   foo(bar,
+      #     baz)
+      #
+      #   # also good - backslash in string concatenation is not redundant
+      #   foo('bar' \
+      #     'baz')
+      #
+      #   # also good - backslash at the end of a comment is not redundant
+      #   foo(bar, # \
+      #     baz)
+      #
+      #   # also good - backslash at the line following the newline begins with a + or -,
+      #   # it is not redundant
+      #   1 \
+      #     + 2 \
+      #       - 3
+      #
+      #   # also good - backslash with newline between the method name and its arguments,
+      #   # it is not redundant.
+      #   some_method \
+      #     (argument)
+      #
+      class RedundantLineContinuation < Base
+        include MatchRange
+        extend AutoCorrector
+
+        MSG = 'Redundant line continuation.'
+        ALLOWED_STRING_TOKENS = %i[tSTRING tSTRING_CONTENT].freeze
+        ARGUMENT_TYPES = %i[
+          kFALSE kNIL kSELF kTRUE tCONSTANT tCVAR tFLOAT tGVAR tIDENTIFIER tINTEGER tIVAR
+          tLBRACK tLCURLY tLPAREN_ARG tSTRING tSTRING_BEG tSYMBOL tXSTRING_BEG
+        ].freeze
+
+        def on_new_investigation
+          return unless processed_source.ast
+
+          each_match_range(processed_source.ast.source_range, /(\\\n)/) do |range|
+            next if require_line_continuation?(range)
+            next unless redundant_line_continuation?(range)
+
+            add_offense(range) do |corrector|
+              corrector.remove_leading(range, 1)
+            end
+          end
+        end
+
+        private
+
+        def require_line_continuation?(range)
+          !ends_with_backslash_without_comment?(range.source_line) ||
+            string_concatenation?(range.source_line) ||
+            start_with_arithmetic_operator?(processed_source[range.line]) ||
+            inside_string_literal_or_method_with_argument?(range)
+        end
+
+        def ends_with_backslash_without_comment?(source_line)
+          source_line.gsub(/#.+/, '').end_with?('\\')
+        end
+
+        def string_concatenation?(source_line)
+          /["']\s*\\\z/.match?(source_line)
+        end
+
+        def inside_string_literal_or_method_with_argument?(range)
+          processed_source.tokens.each_cons(2).any? do |token, next_token|
+            inside_string_literal?(range, token) || method_with_argument?(token, next_token)
+          end
+        end
+
+        def redundant_line_continuation?(range)
+          return true unless (node = find_node_for_line(range.line))
+          return false if argument_newline?(node)
+
+          source = node.parent ? node.parent.source : node.source
+          parse(source.gsub(/\\\n/, "\n")).valid_syntax?
+        end
+
+        def inside_string_literal?(range, token)
+          ALLOWED_STRING_TOKENS.include?(token.type) && token.pos.overlaps?(range)
+        end
+
+        # A method call without parentheses such as the following cannot remove `\`:
+        #
+        #   do_something \
+        #     argument
+        def method_with_argument?(current_token, next_token)
+          current_token.type == :tIDENTIFIER && ARGUMENT_TYPES.include?(next_token.type)
+        end
+
+        def argument_newline?(node)
+          node = node.children.first if node.root? && node.begin_type?
+
+          if argument_is_method?(node)
+            argument_newline?(node.first_argument)
+          else
+            return false unless method_call_with_arguments?(node)
+
+            node.loc.selector.line != node.first_argument.loc.line
+          end
+        end
+
+        def find_node_for_line(line)
+          processed_source.ast.each_node do |node|
+            return node if same_line?(node, line)
+          end
+        end
+
+        def same_line?(node, line)
+          return unless (source_range = node.source_range)
+
+          if node.is_a?(AST::StrNode)
+            if node.heredoc?
+              (node.loc.heredoc_body.line..node.loc.heredoc_body.last_line).cover?(line)
+            else
+              (source_range.line..source_range.last_line).cover?(line)
+            end
+          else
+            source_range.line == line
+          end
+        end
+
+        def argument_is_method?(node)
+          return false unless node.send_type?
+          return false unless (first_argument = node.first_argument)
+
+          method_call_with_arguments?(first_argument)
+        end
+
+        def method_call_with_arguments?(node)
+          node.call_type? && !node.arguments.empty?
+        end
+
+        def start_with_arithmetic_operator?(source_line)
+          %r{\A\s*[+\-*/%]}.match?(source_line)
+        end
+      end
+    end
+  end
+end

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

@@ -29,6 +29,9 @@ module RuboCop
         # @!method rescue?(node)
         def_node_matcher :rescue?, '{^resbody ^^resbody}'
 
+        # @!method allowed_pin_operator?(node)
+        def_node_matcher :allowed_pin_operator?, '^(pin (begin !{lvar ivar cvar gvar}))'
+
         # @!method arg_in_call_with_block?(node)
         def_node_matcher :arg_in_call_with_block?, '^^(block (send _ _ equal?(%0) ...) ...)'
 
@@ -44,6 +47,7 @@ module RuboCop
           empty_parentheses?(node) ||
             first_arg_begins_with_hash_literal?(node) ||
             rescue?(node) ||
+            allowed_pin_operator?(node) ||
             allowed_expression?(node)
         end
 
@@ -57,8 +61,8 @@ module RuboCop
         def allowed_expression?(node)
           allowed_ancestor?(node) ||
             allowed_method_call?(node) ||
-            allowed_array_or_hash_element?(node) ||
-            allowed_multiple_expression?(node)
+            allowed_multiple_expression?(node) ||
+            allowed_ternary?(node)
         end
 
         def allowed_ancestor?(node)
@@ -80,8 +84,22 @@ module RuboCop
           !ancestor.begin_type? && !ancestor.def_type? && !ancestor.block_type?
         end
 
+        def allowed_ternary?(node)
+          return unless node&.parent&.if_type?
+
+          node.parent.ternary? && ternary_parentheses_required?
+        end
+
+        def ternary_parentheses_required?
+          config = @config.for_cop('Style/TernaryParentheses')
+          allowed_styles = %w[require_parentheses require_parentheses_when_complex]
+
+          config.fetch('Enabled') && allowed_styles.include?(config['EnforcedStyle'])
+        end
+
         def like_method_argument_parentheses?(node)
-          node.send_type? && node.arguments.size == 1 && !node.arithmetic_operation?
+          node.send_type? && node.arguments.one? && !node.parenthesized? &&
+            !node.arithmetic_operation? && node.first_argument.begin_type?
         end
 
         def empty_parentheses?(node)
@@ -135,7 +153,7 @@ module RuboCop
 
           return if node.send_type? && !method_call_with_redundant_parentheses?(node)
 
-          offense(begin_node, 'an unary operation')
+          offense(begin_node, 'a unary operation')
         end
 
         def offense(node, msg)
@@ -152,26 +170,6 @@ module RuboCop
           node.parent&.keyword?
         end
 
-        def allowed_array_or_hash_element?(node)
-          # Don't flag
-          # ```
-          # { a: (1
-          #      ), }
-          # ```
-          hash_or_array_element?(node) && only_closing_paren_before_comma?(node)
-        end
-
-        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)
-
-          /^\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)
         end

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

@@ -93,7 +93,7 @@ module RuboCop
 
           return true if STRING_INTERPOLATION_REGEXP.match?(src)
 
-          src.scan(/\\./).any? { |s| ESCAPED_NON_BACKSLASH.match?(s) }
+          src.scan(/\\./).any?(ESCAPED_NON_BACKSLASH)
         end
 
         def acceptable_capital_q?(node)

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

@@ -63,7 +63,7 @@ module RuboCop
             next if expr.type != :set || expr.expressions.size != 1
             next if expr.negative?
             next if %i[set posixclass nonposixclass].include?(expr.expressions.first.type)
-            next if multiple_codepoins?(expr.expressions.first)
+            next if multiple_codepoints?(expr.expressions.first)
 
             yield expr
           end
@@ -74,13 +74,13 @@ module RuboCop
 
           non_redundant =
             whitespace_in_free_space_mode?(node, class_elem) ||
-            backslash_b?(class_elem) ||
+            backslash_b?(class_elem) || octal_requiring_char_class?(class_elem) ||
             requires_escape_outside_char_class?(class_elem)
 
           !non_redundant
         end
 
-        def multiple_codepoins?(expression)
+        def multiple_codepoints?(expression)
           expression.respond_to?(:codepoints) && expression.codepoints.count >= 2
         end
 
@@ -104,6 +104,12 @@ module RuboCop
           elem == '\b'
         end
 
+        def octal_requiring_char_class?(elem)
+          # The octal escapes \1 to \7 only work inside a character class
+          # because they would be a backreference outside it.
+          elem.match?(/\A\\[1-7]\z/)
+        end
+
         def requires_escape_outside_char_class?(elem)
           REQUIRES_ESCAPE_OUTSIDE_CHAR_CLASS_CHARS.include?(elem)
         end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for the instantiation of regexp using redundant `Regexp.new` or `Regexp.compile`.
+      # Autocorrect replaces to regexp literal which is the simplest and fastest.
+      #
+      # @example
+      #
+      #   # bad
+      #   Regexp.new(/regexp/)
+      #   Regexp.compile(/regexp/)
+      #
+      #   # good
+      #   /regexp/
+      #   Regexp.new('regexp')
+      #   Regexp.compile('regexp')
+      #
+      class RedundantRegexpConstructor < Base
+        extend AutoCorrector
+
+        MSG = 'Remove the redundant `Regexp.%<method>s`.'
+        RESTRICT_ON_SEND = %i[new compile].freeze
+
+        # @!method redundant_regexp_constructor(node)
+        def_node_matcher :redundant_regexp_constructor, <<~PATTERN
+          (send
+            (const {nil? cbase} :Regexp) {:new :compile}
+            (regexp $... (regopt $...)))
+        PATTERN
+
+        def on_send(node)
+          return unless (regexp, regopt = redundant_regexp_constructor(node))
+
+          add_offense(node, message: format(MSG, method: node.method_name)) do |corrector|
+            pattern = regexp.map(&:source).join
+            regopt = regopt.join
+
+            corrector.replace(node, "/#{pattern}/#{regopt}")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -44,7 +44,7 @@ module RuboCop
 
         def on_regexp(node)
           each_escape(node) do |char, index, within_character_class|
-            next if allowed_escape?(node, char, within_character_class)
+            next if allowed_escape?(node, char, index, within_character_class)
 
             location = escape_range_at_index(node, index)
 
@@ -56,7 +56,7 @@ module RuboCop
 
         private
 
-        def allowed_escape?(node, char, within_character_class)
+        def allowed_escape?(node, char, index, within_character_class)
           # Strictly speaking a few single-letter metachars are currently
           # unnecessary to "escape", e.g. i, E, F, but enumerating them is
           # rather difficult, and their behavior could change over time with
@@ -65,12 +65,29 @@ module RuboCop
           return true if ALLOWED_ALWAYS_ESCAPES.include?(char) || delimiter?(node, char)
 
           if within_character_class
-            ALLOWED_WITHIN_CHAR_CLASS_METACHAR_ESCAPES.include?(char)
+            ALLOWED_WITHIN_CHAR_CLASS_METACHAR_ESCAPES.include?(char) &&
+              !char_class_begins_or_ends_with_escaped_hyphen?(node, index)
           else
             ALLOWED_OUTSIDE_CHAR_CLASS_METACHAR_ESCAPES.include?(char)
           end
         end
 
+        def char_class_begins_or_ends_with_escaped_hyphen?(node, index)
+          # The hyphen character is allowed to be escaped within a character class
+          # but it's not necessary to escape hyphen if it's the first or last character
+          # within the character class. This method checks if that's the case.
+          # e.g. "[0-9\\-]" or "[\\-0-9]" would return true
+          content = contents_range(node).source
+
+          if content[index + 2] == ']'
+            true
+          elsif content[index - 1] == '['
+            index < 2 || content[index - 2] != '\\'
+          else
+            false
+          end
+        end
+
         def delimiter?(node, char)
           delimiters = [node.loc.begin.source[-1], node.loc.end.source[0]]
 
@@ -90,7 +107,7 @@ module RuboCop
             end
           end
         # Please remove this `else` branch when support for regexp_parser 1.8 will be dropped.
-        # It's for compatibility with regexp_arser 1.8 and will never be maintained.
+        # It's for compatibility with regexp_parser 1.8 and will never be maintained.
         else
           def each_escape(node)
             node.parsed_tree&.traverse&.reduce(0) do |char_class_depth, (event, expr)|

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

@@ -53,6 +53,13 @@ module RuboCop
 
         MSG = 'Redundant `return` detected.'
         MULTI_RETURN_MSG = 'To return multiple values, use an array.'
+        RESTRICT_ON_SEND = %i[define_method define_singleton_method].freeze
+
+        def on_send(node)
+          return unless (parent = node.parent) && parent.block_type?
+
+          check_branch(parent.body)
+        end
 
         def on_def(node)
           check_branch(node.body)

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

@@ -120,6 +120,8 @@ module RuboCop
           add_scope(node, @local_variables_scopes[node])
         end
 
+        alias on_numblock on_block
+
         def on_if(node)
           # Allow conditional nodes to use `self` in the condition if that variable
           # name is used in an `lvasgn` or `masgn` within the `if`.