rubocop 1.31.1 → 1.33.0

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

@@ -11,7 +11,8 @@ module RuboCop
       # The reason is that _unannotated_ format is very similar
       # to encoded URLs or Date/Time formatting strings.
       #
-      # This cop can be customized ignored methods with `IgnoredMethods`.
+      # This cop can be customized allowed methods with `AllowedMethods`.
+      # By default, there are no methods to allowed.
       #
       # @example EnforcedStyle: annotated (default)
       #
@@ -61,18 +62,34 @@ module RuboCop
       #   # good
       #   format('%06d', 10)
       #
-      # @example IgnoredMethods: [redirect]
+      # @example AllowedMethods: [] (default)
+      #
+      #   # bad
+      #   redirect('foo/%{bar_id}')
+      #
+      # @example AllowedMethods: [redirect]
+      #
+      #   # good
+      #   redirect('foo/%{bar_id}')
+      #
+      # @example AllowedPatterns: [] (default)
+      #
+      #   # bad
+      #   redirect('foo/%{bar_id}')
+      #
+      # @example AllowedPatterns: [/redirect/]
       #
       #   # good
       #   redirect('foo/%{bar_id}')
       #
       class FormatStringToken < Base
         include ConfigurableEnforcedStyle
-        include IgnoredMethods
+        include AllowedMethods
+        include AllowedPattern
         extend AutoCorrector
 
         def on_str(node)
-          return if format_string_token?(node) || use_ignored_method?(node)
+          return if format_string_token?(node) || use_allowed_method?(node)
 
           detections = collect_detections(node)
           return if detections.empty?
@@ -97,9 +114,11 @@ module RuboCop
           !node.value.include?('%') || node.each_ancestor(:xstr, :regexp).any?
         end
 
-        def use_ignored_method?(node)
+        def use_allowed_method?(node)
           send_parent = node.each_ancestor(:send).first
-          send_parent && ignored_method?(send_parent.method_name)
+          send_parent &&
+            (allowed_method?(send_parent.method_name) ||
+            matches_allowed_pattern?(send_parent.method_name))
         end
 
         def check_sequence(detected_sequence, token_range)

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

@@ -159,10 +159,6 @@ module RuboCop
           key_argument = node.argument_list.first.source
           body = extract_body_if_nagated(node.body)
           lhs, _method_name, rhs = *body
-
-          return lhs if body.method?('include?')
-          return lhs if body.method?('exclude?')
-          return rhs if body.method?('in?')
           return if [lhs, rhs].map(&:source).none?(key_argument)
 
           [lhs, rhs].find { |operand| operand.source != key_argument }

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

@@ -6,6 +6,8 @@ module RuboCop
       # Checks for redundant `if` with boolean literal branches.
       # It checks only conditions to return boolean value (`true` or `false`) for safe detection.
       # The conditions to be checked are comparison methods, predicate methods, and double negative.
+      # `nonzero?` method is allowed by default.
+      # These are customizable with `AllowedMethods` option.
       #
       # @safety
       #   Autocorrection is unsafe because there is no guarantee that all predicate methods

data/lib/rubocop/cop/style/method_call_with_args_parentheses/require_parentheses.rb

@@ -12,7 +12,7 @@ module RuboCop
           private
 
           def require_parentheses(node)
-            return if ignored_method?(node.method_name)
+            return if allowed_method_name?(node.method_name)
             return if matches_allowed_pattern?(node.method_name)
             return if eligible_for_parentheses_omission?(node)
             return unless node.arguments? && !node.parenthesized?
@@ -24,6 +24,10 @@ module RuboCop
             end
           end
 
+          def allowed_method_name?(name)
+            allowed_method?(name) || matches_allowed_pattern?(name)
+          end
+
           def eligible_for_parentheses_omission?(node)
             node.operator_method? || node.setter_method? || ignored_macro?(node)
           end

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

@@ -6,8 +6,8 @@ module RuboCop
       # Enforces the presence (default) or absence of parentheses in
       # method calls containing parameters.
       #
-      # In the default style (require_parentheses), macro methods are ignored.
-      # Additional methods can be added to the `IgnoredMethods`
+      # In the default style (require_parentheses), macro methods are allowed.
+      # Additional methods can be added to the `AllowedMethods`
       # or `AllowedPatterns` list. These options are
       # valid only in the default style. Macros can be included by
       # either setting `IgnoreMacros` to false or adding specific macros to
@@ -15,13 +15,13 @@ module RuboCop
       #
       # Precedence of options is all follows:
       #
-      # 1. `IgnoredMethods`
+      # 1. `AllowedMethods`
       # 2. `AllowedPatterns`
       # 3. `IncludedMacros`
       #
       # eg. If a method is listed in both
-      # `IncludedMacros` and `IgnoredMethods`, then the latter takes
-      # precedence (that is, the method is ignored).
+      # `IncludedMacros` and `AllowedMethods`, then the latter takes
+      # precedence (that is, the method is allowed).
       #
       # In the alternative style (omit_parentheses), there are three additional
       # options.
@@ -65,7 +65,7 @@ module RuboCop
       #   # Setter methods don't need parens
       #   foo.bar = baz
       #
-      #   # okay with `puts` listed in `IgnoredMethods`
+      #   # okay with `puts` listed in `AllowedMethods`
       #   puts 'test'
       #
       #   # okay with `^assert` listed in `AllowedPatterns`
@@ -197,7 +197,7 @@ module RuboCop
         require_relative 'method_call_with_args_parentheses/require_parentheses'
 
         include ConfigurableEnforcedStyle
-        include IgnoredMethods
+        include AllowedMethods
         include AllowedPattern
         include RequireParentheses
         include OmitParentheses

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

@@ -5,14 +5,27 @@ module RuboCop
     module Style
       # Checks for unwanted parentheses in parameterless method calls.
       #
+      # This cop can be customized allowed methods with `AllowedMethods`.
+      # By default, there are no methods to allowed.
+      #
       # @example
       #   # bad
       #   object.some_method()
       #
       #   # good
       #   object.some_method
+      #
+      # @example AllowedMethods: [] (default)
+      #   # bad
+      #   object.foo()
+      #
+      # @example AllowedMethods: [foo]
+      #   # good
+      #   object.foo()
+      #
       class MethodCallWithoutArgsParentheses < Base
-        include IgnoredMethods
+        include AllowedMethods
+        include AllowedPattern
         extend AutoCorrector
 
         MSG = 'Do not use parentheses for method calls with no arguments.'
@@ -21,7 +34,7 @@ module RuboCop
           return unless !node.arguments? && node.parenthesized?
           return if ineligible_node?(node)
           return if default_argument?(node)
-          return if ignored_method?(node.method_name)
+          return if allowed_method_name?(node.method_name)
           return if same_name_assignment?(node)
 
           register_offense(node)
@@ -44,6 +57,10 @@ module RuboCop
           node.parent&.optarg_type?
         end
 
+        def allowed_method_name?(name)
+          allowed_method?(name) || matches_allowed_pattern?(name)
+        end
+
         def same_name_assignment?(node)
           any_assignment?(node) do |asgn_node|
             next variable_in_mass_assignment?(node.method_name, asgn_node) if asgn_node.masgn_type?

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

@@ -117,10 +117,10 @@ module RuboCop
         end
 
         def check_module_function(nodes)
-          private_directive = nodes.any? { |node| private_directive?(node) }
+          return if nodes.any? { |node| private_directive?(node) }
 
           nodes.each do |node|
-            yield node if extend_self_node?(node) && !private_directive
+            yield node if extend_self_node?(node)
           end
         end
 

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

@@ -5,6 +5,10 @@ module RuboCop
     module Style
       # Checks for unparenthesized method calls in the argument list
       # of a parenthesized method call.
+      # `be`, `be_a`, `be_an`, `be_between`, `be_falsey`, `be_kind_of`, `be_instance_of`,
+      # `be_truthy`, `be_within`, `eq`, `eql`, `end_with`, `include`, `match`, `raise_error`,
+      # `respond_to`, and `start_with` methods are allowed by default.
+      # These are customizable with `AllowedMethods` option.
       #
       # @example
       #   # good
@@ -12,6 +16,11 @@ module RuboCop
       #
       #   # bad
       #   method1(method2 arg)
+      #
+      # @example AllowedMethods: [foo]
+      #   # good
+      #   method1(foo arg)
+      #
       class NestedParenthesizedCalls < Base
         include RangeHelp
         include AllowedMethods

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

@@ -6,13 +6,16 @@ module RuboCop
       # Checks for usage of comparison operators (`==`,
       # `>`, `<`) to test numbers as zero, positive, or negative.
       # These can be replaced by their respective predicate methods.
-      # The cop can also be configured to do the reverse.
+      # This cop can also be configured to do the reverse.
       #
-      # The cop disregards `#nonzero?` as its value is truthy or falsey,
+      # This cop can be customized allowed methods with `AllowedMethods`.
+      # By default, there are no methods to allowed.
+      #
+      # This cop disregards `#nonzero?` as its value is truthy or falsey,
       # but not `true` and `false`, and thus not always interchangeable with
       # `!= 0`.
       #
-      # The cop ignores comparisons to global variables, since they are often
+      # This cop allows comparisons to global variables, since they are often
       # populated with objects which can be compared with integers, but are
       # not themselves `Integer` polymorphic.
       #
@@ -23,32 +26,59 @@ module RuboCop
       #
       # @example EnforcedStyle: predicate (default)
       #   # bad
-      #
       #   foo == 0
       #   0 > foo
       #   bar.baz > 0
       #
       #   # good
-      #
       #   foo.zero?
       #   foo.negative?
       #   bar.baz.positive?
       #
       # @example EnforcedStyle: comparison
       #   # bad
-      #
       #   foo.zero?
       #   foo.negative?
       #   bar.baz.positive?
       #
       #   # good
+      #   foo == 0
+      #   0 > foo
+      #   bar.baz > 0
+      #
+      # @example AllowedMethods: [] (default) with EnforcedStyle: predicate
+      #   # bad
+      #   foo == 0
+      #   0 > foo
+      #   bar.baz > 0
       #
+      # @example AllowedMethods: [==] with EnforcedStyle: predicate
+      #   # good
       #   foo == 0
+      #
+      #   # bad
       #   0 > foo
       #   bar.baz > 0
+      #
+      # @example AllowedPatterns: [] (default) with EnforcedStyle: comparison
+      #   # bad
+      #   foo.zero?
+      #   foo.negative?
+      #   bar.baz.positive?
+      #
+      # @example AllowedPatterns: [/zero/] with EnforcedStyle: predicate
+      #   # good
+      #   # bad
+      #   foo.zero?
+      #
+      #   # bad
+      #   foo.negative?
+      #   bar.baz.positive?
+      #
       class NumericPredicate < Base
         include ConfigurableEnforcedStyle
-        include IgnoredMethods
+        include AllowedMethods
+        include AllowedPattern
         extend AutoCorrector
 
         MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
@@ -61,9 +91,9 @@ module RuboCop
           numeric, replacement = check(node)
           return unless numeric
 
-          return if ignored_method?(node.method_name) ||
+          return if allowed_method_name?(node.method_name) ||
                     node.each_ancestor(:send, :block).any? do |ancestor|
-                      ignored_method?(ancestor.method_name)
+                      allowed_method_name?(ancestor.method_name)
                     end
 
           message = format(MSG, prefer: replacement, current: node.source)
@@ -74,6 +104,10 @@ module RuboCop
 
         private
 
+        def allowed_method_name?(name)
+          allowed_method?(name) || matches_allowed_pattern?(name)
+        end
+
         def check(node)
           numeric, operator =
             if style == :predicate

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

@@ -154,16 +154,22 @@ module RuboCop
           if_branch.method?(else_branch.method_name) && if_branch.receiver == else_branch.receiver
         end
 
-        def if_source(if_branch)
+        def if_source(if_branch, arithmetic_operation)
           if branches_have_method?(if_branch.parent) && if_branch.parenthesized?
             if_branch.source.delete_suffix(')')
+          elsif arithmetic_operation
+            argument_source = if_branch.first_argument.source
+
+            "#{if_branch.receiver.source} #{if_branch.method_name} (#{argument_source}"
           else
             if_branch.source
           end
         end
 
-        def else_source(else_branch)
-          if branches_have_method?(else_branch.parent)
+        def else_source(else_branch, arithmetic_operation) # rubocop:disable Metrics/AbcSize
+          if arithmetic_operation
+            "#{else_branch.first_argument.source})"
+          elsif branches_have_method?(else_branch.parent)
             else_source_if_has_method(else_branch)
           elsif require_parentheses?(else_branch)
             "(#{else_branch.source})"
@@ -198,7 +204,12 @@ module RuboCop
 
         def make_ternary_form(node)
           _condition, if_branch, else_branch = *node
-          ternary_form = [if_source(if_branch), else_source(else_branch)].join(' || ')
+          arithmetic_operation = use_arithmetic_operation?(if_branch)
+
+          ternary_form = [
+            if_source(if_branch, arithmetic_operation),
+            else_source(else_branch, arithmetic_operation)
+          ].join(' || ')
           ternary_form += ')' if branches_have_method?(node) && if_branch.parenthesized?
 
           if node.parent&.send_type?
@@ -227,6 +238,10 @@ module RuboCop
           node.hash_type? && !node.braces?
         end
 
+        def use_arithmetic_operation?(node)
+          node.respond_to?(:arithmetic_operation?) && node.arithmetic_operation?
+        end
+
         def without_argument_parentheses_method?(node)
           node.send_type? && !node.arguments.empty? &&
             !node.parenthesized? && !node.operator_method? && !node.assignment_method?

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

@@ -81,7 +81,8 @@ module RuboCop
         end
 
         def like_method_argument_parentheses?(node)
-          node.send_type? && node.arguments.size == 1 && !node.arithmetic_operation?
+          node.send_type? && node.arguments.one? &&
+            !node.arithmetic_operation? && node.first_argument.begin_type?
         end
 
         def empty_parentheses?(node)

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

@@ -123,13 +123,8 @@ module RuboCop
 
         def register_offense(node, sort_node, sorter, accessor)
           message = message(node, sorter, accessor)
-
           add_offense(offense_range(sort_node, node), message: message) do |corrector|
-            # Remove accessor, e.g. `first` or `[-1]`.
-            corrector.remove(range_between(accessor_start(node), node.loc.expression.end_pos))
-
-            # Replace "sort" or "sort_by" with the appropriate min/max method.
-            corrector.replace(sort_node.loc.selector, suggestion(sorter, accessor, arg_value(node)))
+            autocorrect(corrector, node, sort_node, sorter, accessor)
           end
         end
 
@@ -149,6 +144,20 @@ module RuboCop
                  accessor_source: accessor_source)
         end
 
+        def autocorrect(corrector, node, sort_node, sorter, accessor)
+          # Remove accessor, e.g. `first` or `[-1]`.
+          corrector.remove(range_between(accessor_start(node), node.loc.expression.end_pos))
+          # Replace "sort" or "sort_by" with the appropriate min/max method.
+          corrector.replace(sort_node.loc.selector, suggestion(sorter, accessor, arg_value(node)))
+          # Replace to avoid syntax errors when followed by a logical operator.
+          replace_with_logical_operator(corrector, node) if with_logical_operator?(node)
+        end
+
+        def replace_with_logical_operator(corrector, node)
+          corrector.insert_after(node.child_nodes.first, " #{node.parent.loc.operator.source}")
+          corrector.remove(node.parent.loc.operator)
+        end
+
         def suggestion(sorter, accessor, arg)
           base(accessor, arg) + suffix(sorter)
         end
@@ -187,6 +196,12 @@ module RuboCop
             node.loc.selector.begin_pos
           end
         end
+
+        def with_logical_operator?(node)
+          return unless (parent = node.parent)
+
+          parent.or_type? || parent.and_type?
+        end
       end
     end
   end

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

@@ -64,12 +64,14 @@ module RuboCop
           # Make the obvious check first
           return unless processed_source.raw_source.include?(';')
 
-          each_semicolon { |line, column| register_semicolon(line, column, false) }
+          each_semicolon do |line, column, token_before_semicolon|
+            register_semicolon(line, column, false, token_before_semicolon)
+          end
         end
 
         def each_semicolon
           tokens_for_lines.each do |line, tokens|
-            yield line, tokens.last.column if tokens.last.semicolon?
+            yield line, tokens.last.column, tokens[-2] if tokens.last.semicolon?
             yield line, tokens.first.column if tokens.first.semicolon?
           end
         end
@@ -78,13 +80,21 @@ module RuboCop
           processed_source.tokens.group_by(&:line)
         end
 
-        def register_semicolon(line, column, after_expression)
+        def register_semicolon(line, column, after_expression, token_before_semicolon = nil)
           range = source_range(processed_source.buffer, line, column)
 
           add_offense(range) do |corrector|
             if after_expression
               corrector.replace(range, "\n")
             else
+              # Prevents becoming one range instance with subsequent line when endless range
+              # without parentheses.
+              # See: https://github.com/rubocop/rubocop/issues/10791
+              if token_before_semicolon&.regexp_dots?
+                range_node = find_range_node(token_before_semicolon)
+                corrector.wrap(range_node, '(', ')') if range_node
+              end
+
               corrector.remove(range)
             end
           end
@@ -103,6 +113,20 @@ module RuboCop
             yield Regexp.last_match.begin(0)
           end
         end
+
+        def find_range_node(token_before_semicolon)
+          range_nodes.detect do |range_node|
+            range_node.source_range.contains?(token_before_semicolon.pos)
+          end
+        end
+
+        def range_nodes
+          return @range_nodes if instance_variable_defined?(:@range_nodes)
+
+          ast = processed_source.ast
+          @range_nodes = ast.range_type? ? [ast] : []
+          @range_nodes.concat(ast.each_descendant(:irange, :erange).to_a)
+        end
       end
     end
   end

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

@@ -39,7 +39,7 @@ module RuboCop
         minimum_target_ruby_version 2.0
 
         PERCENT_MSG = 'Use `%i` or `%I` for an array of symbols.'
-        ARRAY_MSG = 'Use `%<prefer>s` for an array of symbols.'
+        ARRAY_MSG = 'Use %<prefer>s for an array of symbols.'
 
         class << self
           attr_accessor :largest_brackets
@@ -74,8 +74,7 @@ module RuboCop
               to_symbol_literal(c.value.to_s)
             end
           end
-
-          "[#{syms.join(', ')}]"
+          build_bracketed_array_with_appropriate_whitespace(elements: syms, node: node)
         end
 
         def to_symbol_literal(string)

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

@@ -7,11 +7,13 @@ module RuboCop
       #
       # If you prefer a style that allows block for method with arguments,
       # please set `true` to `AllowMethodsWithArguments`.
+      # respond_to , and `define_method?` methods are allowed by default.
+      # These are customizable with `AllowedMethods` option.
       #
       # @safety
       #   This cop is unsafe because `proc`s and blocks work differently
       #   when additional arguments are passed in. A block will silently
-      #   ignore additional arguments, but a `proc` will raise
+      #   allow additional arguments, but a `proc` will raise
       #   an `ArgumentError`.
       #
       #   For example:
@@ -68,10 +70,26 @@ module RuboCop
       #     s.upcase # some comment
       #     # some comment
       #   end
+      #
+      # @example AllowedMethods: [respond_to, define_method] (default)
+      #   # good
+      #   respond_to { |foo| foo.bar }
+      #   define_method(:foo) { |foo| foo.bar }
+      #
+      #
+      # @example AllowedPatterns: [] (default)
+      #   # bad
+      #   something.map { |s| s.upcase }
+      #
+      # @example AllowedPatterns: [/map/] (default)
+      #   # good
+      #   something.map { |s| s.upcase }
+      #
       class SymbolProc < Base
         include CommentsHelp
         include RangeHelp
-        include IgnoredMethods
+        include AllowedMethods
+        include AllowedPattern
         extend AutoCorrector
 
         MSG = 'Pass `&:%<method>s` as an argument to `%<block_method>s` instead of a block.'
@@ -81,7 +99,7 @@ module RuboCop
         def_node_matcher :proc_node?, '(send (const {nil? cbase} :Proc) :new)'
 
         # @!method symbol_proc_receiver?(node)
-        def_node_matcher :symbol_proc_receiver?, '{(send ...) (super ...) zsuper}'
+        def_node_matcher :symbol_proc_receiver?, '{(call ...) (super ...) zsuper}'
 
         # @!method symbol_proc?(node)
         def_node_matcher :symbol_proc?, <<~PATTERN
@@ -95,15 +113,16 @@ module RuboCop
           [Layout::SpaceBeforeBlockBraces]
         end
 
-        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def on_block(node)
           symbol_proc?(node) do |dispatch_node, arguments_node, method_name|
             # TODO: Rails-specific handling that we should probably make
             # configurable - https://github.com/rubocop/rubocop/issues/1485
-            # we should ignore lambdas & procs
+            # we should allow lambdas & procs
             return if proc_node?(dispatch_node)
+            return if unsafe_hash_usage?(dispatch_node)
             return if %i[lambda proc].include?(dispatch_node.method_name)
-            return if ignored_method?(dispatch_node.method_name)
+            return if allowed_method_name?(dispatch_node.method_name)
             return if allow_if_method_has_argument?(node.send_node)
             return if node.block_type? && destructuring_block_argument?(arguments_node)
             return if allow_comments? && contains_comments?(node)
@@ -111,7 +130,7 @@ module RuboCop
             register_offense(node, method_name, dispatch_node.method_name)
           end
         end
-        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         alias on_numblock on_block
 
         def destructuring_block_argument?(argument_node)
@@ -120,6 +139,15 @@ module RuboCop
 
         private
 
+        # See: https://github.com/rubocop/rubocop/issues/10864
+        def unsafe_hash_usage?(node)
+          node.receiver&.hash_type? && %i[reject select].include?(node.method_name)
+        end
+
+        def allowed_method_name?(name)
+          allowed_method?(name) || matches_allowed_pattern?(name)
+        end
+
         def register_offense(node, method_name, block_method_name)
           block_start = node.loc.begin.begin_pos
           block_end = node.loc.end.end_pos

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

@@ -5,6 +5,9 @@ module RuboCop
     module Style
       # Looks for trivial reader/writer methods, that could
       # have been created with the attr_* family of functions automatically.
+      # `to_ary`, `to_a`, `to_c`, `to_enum`, `to_h`, `to_hash`, `to_i`, `to_int`, `to_io`,
+      # `to_open`, `to_path`, `to_proc`, `to_r`, `to_regexp`, `to_str`, `to_s`, and `to_sym` methods
+      # are allowed by default. These are customizable with `AllowedMethods` option.
       #
       # @example
       #   # bad

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

@@ -44,7 +44,7 @@ module RuboCop
         extend AutoCorrector
 
         PERCENT_MSG = 'Use `%w` or `%W` for an array of words.'
-        ARRAY_MSG = 'Use `%<prefer>s` for an array of words.'
+        ARRAY_MSG = 'Use %<prefer>s for an array of words.'
 
         class << self
           attr_accessor :largest_brackets
@@ -92,8 +92,7 @@ module RuboCop
               to_string_literal(word.children[0])
             end
           end
-
-          "[#{words.join(', ')}]"
+          build_bracketed_array_with_appropriate_whitespace(elements: words, node: node)
         end
       end
     end