rubocop 1.63.0 → 1.64.1

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

@@ -8,6 +8,17 @@ module RuboCop
       # EnforcedStyle config covers only method definitions.
       # Applications of visibility methods to symbols can be controlled
       # using AllowModifiersOnSymbols config.
+      # Also, the visibility of `attr*` methods can be controlled using
+      # AllowModifiersOnAttrs config.
+      #
+      # In Ruby 3.0, `attr*` methods now return an array of defined method names
+      # as symbols. So we can write the modifier and `attr*` in inline style.
+      # AllowModifiersOnAttrs config allows `attr*` methods to be written in
+      # inline style without modifying applications that have been maintained
+      # for a long time in group style. Furthermore, developers who are not very
+      # familiar with Ruby may know that the modifier applies to `def`, but they
+      # may not know that it also applies to `attr*` methods. It would be easier
+      # to understand if we could write `attr*` methods in inline style.
       #
       # @safety
       #   Autocorrection is not safe, because the visibility of dynamically
@@ -67,6 +78,34 @@ module RuboCop
       #     private :bar, :baz
       #
       #   end
+      #
+      # @example AllowModifiersOnAttrs: true (default)
+      #   # good
+      #   class Foo
+      #
+      #     public attr_reader :bar
+      #     protected attr_writer :baz
+      #     private attr_accessor :qux
+      #     private attr :quux
+      #
+      #     def public_method; end
+      #
+      #     private
+      #
+      #     def private_method; end
+      #
+      #   end
+      #
+      # @example AllowModifiersOnAttrs: false
+      #   # bad
+      #   class Foo
+      #
+      #     public attr_reader :bar
+      #     protected attr_writer :baz
+      #     private attr_accessor :qux
+      #     private attr :quux
+      #
+      #   end
       class AccessModifierDeclarations < Base
         extend AutoCorrector
 
@@ -92,10 +131,17 @@ module RuboCop
           (send nil? {:private :protected :public :module_function} (sym _))
         PATTERN
 
+        # @!method access_modifier_with_attr?(node)
+        def_node_matcher :access_modifier_with_attr?, <<~PATTERN
+          (send nil? {:private :protected :public :module_function}
+            (send nil? {:attr :attr_reader :attr_writer :attr_accessor} _))
+        PATTERN
+
         def on_send(node)
           return unless node.access_modifier?
           return if ALLOWED_NODE_TYPES.include?(node.parent&.type)
           return if allow_modifiers_on_symbols?(node)
+          return if allow_modifiers_on_attrs?(node)
 
           if offense?(node)
             add_offense(node.loc.selector) do |corrector|
@@ -128,6 +174,10 @@ module RuboCop
           cop_config['AllowModifiersOnSymbols'] && access_modifier_with_symbol?(node)
         end
 
+        def allow_modifiers_on_attrs?(node)
+          cop_config['AllowModifiersOnAttrs'] && access_modifier_with_attr?(node)
+        end
+
         def offense?(node)
           (group_style? && access_modifier_is_inlined?(node) &&
             !right_siblings_same_inline_method?(node)) ||

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

@@ -29,6 +29,8 @@ module RuboCop
       #
       # Names not on this list are likely to be meaningful and are allowed by default.
       #
+      # This cop handles not only method forwarding but also forwarding to `super`.
+      #
       # @example
       #   # bad
       #   def foo(*args, &block)
@@ -146,7 +148,7 @@ module RuboCop
 
           restarg, kwrestarg, blockarg = extract_forwardable_args(node.arguments)
           forwardable_args = redundant_forwardable_named_args(restarg, kwrestarg, blockarg)
-          send_nodes = node.each_descendant(:send).to_a
+          send_nodes = node.each_descendant(:send, :csend, :super).to_a
 
           send_classifications = classify_send_nodes(
             node, send_nodes, non_splat_or_block_pass_lvar_references(node.body), forwardable_args
@@ -312,7 +314,8 @@ module RuboCop
         end
 
         def register_forward_block_arg_offense(add_parens, def_arguments_or_send, block_arg)
-          return if target_ruby_version <= 3.0 || block_arg.source == '&' || explicit_block_name?
+          return if target_ruby_version <= 3.0 ||
+                    block_arg.nil? || block_arg.source == '&' || explicit_block_name?
 
           add_offense(block_arg, message: BLOCK_MSG) do |corrector|
             add_parens_if_missing(def_arguments_or_send, corrector) if add_parens

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

@@ -214,7 +214,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Use the return of the conditional for variable assignment and comparison.'
-        ASSIGN_TO_CONDITION_MSG = 'Assign variables inside of conditionals'
+        ASSIGN_TO_CONDITION_MSG = 'Assign variables inside of conditionals.'
         VARIABLE_ASSIGNMENT_TYPES = %i[casgn cvasgn gvasgn ivasgn lvasgn].freeze
         ASSIGNMENT_TYPES = VARIABLE_ASSIGNMENT_TYPES + %i[and_asgn or_asgn op_asgn masgn].freeze
         LINE_LENGTH = 'Layout/LineLength'

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

@@ -58,12 +58,15 @@ module RuboCop
         end
 
         def verify_autocorrect_notice!
-          raise Warning, AUTOCORRECT_EMPTY_WARNING if autocorrect_notice.empty?
+          if autocorrect_notice.nil? || autocorrect_notice.empty?
+            raise Warning, "#{cop_name}: #{AUTOCORRECT_EMPTY_WARNING}"
+          end
 
           regex = Regexp.new(notice)
-          return if autocorrect_notice&.match?(regex)
+          return if autocorrect_notice.gsub(/^# */, '').match?(regex)
 
-          raise Warning, "AutocorrectNotice '#{autocorrect_notice}' must match Notice /#{notice}/"
+          message = "AutocorrectNotice '#{autocorrect_notice}' must match Notice /#{notice}/"
+          raise Warning, "#{cop_name}: #{message}"
         end
 
         def insert_notice_before(processed_source)
@@ -77,26 +80,28 @@ module RuboCop
           return false if token_index >= processed_source.tokens.size
 
           token = processed_source.tokens[token_index]
-          token.comment? && /^#!.*$/.match?(token.text)
+          token.comment? && /\A#!.*\z/.match?(token.text)
         end
 
         def encoding_token?(processed_source, token_index)
           return false if token_index >= processed_source.tokens.size
 
           token = processed_source.tokens[token_index]
-          token.comment? && /^#.*coding\s?[:=]\s?(?:UTF|utf)-8/.match?(token.text)
+          token.comment? && /\A#.*coding\s?[:=]\s?(?:UTF|utf)-8/.match?(token.text)
         end
 
         def notice_found?(processed_source)
-          notice_found = false
-          notice_regexp = Regexp.new(notice)
+          notice_regexp = Regexp.new(notice.lines.map(&:strip).join)
+          multiline_notice = +''
           processed_source.tokens.each do |token|
             break unless token.comment?
 
-            notice_found = notice_regexp.match?(token.text)
-            break if notice_found
+            multiline_notice << token.text.sub(/\A# */, '')
+
+            break if notice_regexp.match?(token.text)
           end
-          notice_found
+
+          multiline_notice.match?(notice_regexp)
         end
       end
     end

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

@@ -29,36 +29,36 @@ module RuboCop
       #   end
       #
       #   # allowed
-      #     # Class without body
+      #   # Class without body
+      #   class Person
+      #   end
+      #
+      #   # Namespace - A namespace can be a class or a module
+      #   # Containing a class
+      #   module Namespace
+      #     # Description/Explanation of Person class
       #     class Person
+      #       # ...
       #     end
+      #   end
       #
-      #     # Namespace - A namespace can be a class or a module
-      #     # Containing a class
-      #     module Namespace
-      #       # Description/Explanation of Person class
-      #       class Person
-      #         # ...
-      #       end
+      #   # Containing constant visibility declaration
+      #   module Namespace
+      #     class Private
       #     end
       #
-      #     # Containing constant visibility declaration
-      #     module Namespace
-      #       class Private
-      #       end
-      #
-      #       private_constant :Private
-      #     end
+      #     private_constant :Private
+      #   end
       #
-      #     # Containing constant definition
-      #     module Namespace
-      #       Public = Class.new
-      #     end
+      #   # Containing constant definition
+      #   module Namespace
+      #     Public = Class.new
+      #   end
       #
-      #     # Macro calls
-      #     module Namespace
-      #       extend Foo
-      #     end
+      #   # Macro calls
+      #   module Namespace
+      #     extend Foo
+      #   end
       #
       # @example AllowedConstants: ['ClassMethods']
       #
@@ -67,7 +67,7 @@ module RuboCop
       #      module ClassMethods
       #        # ...
       #      end
-      #     end
+      #    end
       #
       class Documentation < Base
         include DocumentationComment

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

@@ -95,6 +95,17 @@ module RuboCop
       #     end
       #   end
       #
+      # @example AllowedMethods: ['method_missing', 'respond_to_missing?']
+      #
+      #    # good
+      #    class Foo
+      #      def method_missing(name, *args)
+      #      end
+      #
+      #      def respond_to_missing?(symbol, include_private)
+      #      end
+      #    end
+      #
       class DocumentationMethod < Base
         include DocumentationComment
         include DefNode
@@ -119,6 +130,7 @@ module RuboCop
         def check(node)
           return if non_public?(node) && !require_for_non_public_methods?
           return if documentation_comment?(node)
+          return if method_allowed?(node)
 
           add_offense(node)
         end
@@ -126,6 +138,14 @@ module RuboCop
         def require_for_non_public_methods?
           cop_config['RequireForNonPublicMethods']
         end
+
+        def method_allowed?(node)
+          allowed_methods.include?(node.method_name)
+        end
+
+        def allowed_methods
+          @allowed_methods ||= cop_config.fetch('AllowedMethods', []).map(&:to_sym)
+        end
       end
     end
   end

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

@@ -141,7 +141,7 @@ module RuboCop
         end
 
         def check_file(node, file_node)
-          return true if special_file_keyword?(file_node)
+          return if special_file_keyword?(file_node)
 
           message = format(MSG_INCORRECT_FILE,
                            method_name: node.method_name,

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

@@ -29,6 +29,8 @@ module RuboCop
       # * never - forces use of explicit hash literal value
       # * either - accepts both shorthand and explicit use of hash literal value
       # * consistent - forces use of the 3.1 syntax only if all values can be omitted in the hash
+      # * either_consistent - accepts both shorthand and explicit use of hash literal value,
+      #                       but they must be consistent
       #
       # @example EnforcedStyle: ruby19 (default)
       #   # bad
@@ -110,6 +112,22 @@ module RuboCop
       #   # good - can't omit `baz`
       #   {foo: foo, bar: baz}
       #
+      # @example EnforcedShorthandSyntax: either_consistent
+      #
+      #   # good - `foo` and `bar` values can be omitted, but they are consistent, so it's accepted
+      #   {foo: foo, bar: bar}
+      #
+      #   # bad - `bar` value can be omitted
+      #   {foo:, bar: bar}
+      #
+      #   # bad - mixed syntaxes
+      #   {foo:, bar: baz}
+      #
+      #   # good
+      #   {foo:, bar:}
+      #
+      #   # good - can't omit `baz`
+      #   {foo: foo, bar: baz}
       class HashSyntax < Base
         include ConfigurableEnforcedStyle
         include HashShorthandSyntax

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

@@ -112,9 +112,11 @@ module RuboCop
         end
 
         def message(node, keyword)
-          message_template = node.elsif? ? MSG_FOR_ELSIF : MSG
-
-          format(message_template, keyword: keyword)
+          if node.elsif?
+            MSG_FOR_ELSIF
+          else
+            format(MSG, keyword: keyword)
+          end
         end
 
         def return_boolean_value?(condition)

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

@@ -20,8 +20,8 @@ module RuboCop
       #
       # [source,ruby]
       # ----
-      # @dest = []
-      # src.each { |e| @dest << e * 2 } # `src` method may mutate `@dest`
+      # ret = []
+      # src.each { |e| ret << e * 2 } # `<<` method may mutate `ret`
       #
       # dest = []
       # src.each { |e| dest << transform(e, dest) } # `transform` method may mutate `dest`
@@ -57,7 +57,7 @@ module RuboCop
         def_node_matcher :each_block_with_push?, <<-PATTERN
           [
             ^({begin kwbegin} ...)
-            ({block numblock} (send _ :each) _
+            ({block numblock} (send !{nil? self} :each) _
               (send (lvar _) {:<< :push :append} _))
           ]
         PATTERN

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

@@ -118,12 +118,14 @@ module RuboCop
 
           return unless numeric && operator && replacement_supported?(operator)
 
-          [numeric, replacement(numeric, operator)]
+          [numeric, replacement(node, numeric, operator)]
         end
 
-        def replacement(numeric, operation)
+        def replacement(node, numeric, operation)
           if style == :predicate
             [parenthesized_source(numeric), REPLACEMENTS.invert[operation.to_s]].join('.')
+          elsif negated?(node)
+            "(#{numeric.source} #{REPLACEMENTS[operation.to_s]} 0)"
           else
             [numeric.source, REPLACEMENTS[operation.to_s], 0].join(' ')
           end
@@ -157,6 +159,12 @@ module RuboCop
           end
         end
 
+        def negated?(node)
+          return false unless (parent = node.parent)
+
+          parent.send_type? && parent.method?(:!)
+        end
+
         # @!method predicate(node)
         def_node_matcher :predicate, <<~PATTERN
           (send $(...) ${:zero? :positive? :negative?})

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

@@ -75,7 +75,7 @@ module RuboCop
         end
 
         def always_multiline?
-          @config.for_cop('Style/OneLineConditional')['AlwaysCorrectToMultiline']
+          cop_config['AlwaysCorrectToMultiline']
         end
 
         def cannot_replace_to_ternary?(node)

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

@@ -74,6 +74,7 @@ module RuboCop
           kFALSE kNIL kSELF kTRUE tCONSTANT tCVAR tFLOAT tGVAR tIDENTIFIER tINTEGER tIVAR
           tLBRACK tLCURLY tLPAREN_ARG tSTRING tSTRING_BEG tSYMBOL tXSTRING_BEG
         ].freeze
+        ARGUMENT_TAKING_FLOW_TOKEN_TYPES = %i[tIDENTIFIER kRETURN kBREAK kNEXT kYIELD].freeze
 
         def on_new_investigation
           return unless processed_source.ast
@@ -137,7 +138,9 @@ module RuboCop
         #   do_something \
         #     argument
         def method_with_argument?(current_token, next_token)
-          current_token.type == :tIDENTIFIER && ARGUMENT_TYPES.include?(next_token.type)
+          return false unless ARGUMENT_TAKING_FLOW_TOKEN_TYPES.include?(current_token.type)
+
+          ARGUMENT_TYPES.include?(next_token.type)
         end
 
         # rubocop:disable Metrics/AbcSize

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

@@ -131,7 +131,7 @@ module RuboCop
         end
 
         def in_same_section?(node1, node2)
-          !node1.source_range.with(end_pos: node2.source_range.end_pos).source.include?("\n\n")
+          !node1.source_range.join(node2.source_range.end).source.include?("\n\n")
         end
       end
     end

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

@@ -7,12 +7,12 @@ module RuboCop
       #
       # @example
       #   # bad
-      #   Foo.send(:bar)
-      #   quuz.send(:fred)
+      #   Foo.send(bar)
+      #   quuz.send(fred)
       #
       #   # good
-      #   Foo.__send__(:bar)
-      #   quuz.public_send(:fred)
+      #   Foo.__send__(bar)
+      #   quuz.public_send(fred)
       class Send < Base
         MSG = 'Prefer `Object#__send__` or `Object#public_send` to `send`.'
         RESTRICT_ON_SEND = %i[send].freeze

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Detects the use of the `public_send` method with a literal method name argument.
+      # Since the `send` method can be used to call private methods, by default,
+      # only the `public_send` method is detected.
+      #
+      # @safety
+      #   This cop is not safe because it can incorrectly detect based on the receiver.
+      #   Additionally, when `AllowSend` is set to `true`, it cannot determine whether
+      #   the `send` method being detected is calling a private method.
+      #
+      # @example
+      #   # bad
+      #   obj.public_send(:method_name)
+      #   obj.public_send('method_name')
+      #
+      #   # good
+      #   obj.method_name
+      #
+      # @example AllowSend: true (default)
+      #   # good
+      #   obj.send(:method_name)
+      #   obj.send('method_name')
+      #   obj.__send__(:method_name)
+      #   obj.__send__('method_name')
+      #
+      # @example AllowSend: false
+      #   # bad
+      #   obj.send(:method_name)
+      #   obj.send('method_name')
+      #   obj.__send__(:method_name)
+      #   obj.__send__('method_name')
+      #
+      #   # good
+      #   obj.method_name
+      #
+      class SendWithLiteralMethodName < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<method_name>s` method call directly instead.'
+        RESTRICT_ON_SEND = %i[public_send send __send__].freeze
+        STATIC_METHOD_NAME_NODE_TYPES = %i[sym str].freeze
+        METHOD_NAME_PATTERN = /\A[a-zA-Z_][a-zA-Z0-9_]*[!?=]?\z/.freeze
+        RESERVED_WORDS = %i[
+          BEGIN END alias and begin break case class def defined? do else elsif end ensure
+          false for if in module next nil not or redo rescue retry return self super then true
+          undef unless until when while yield
+        ].freeze
+
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def on_send(node)
+          return if allow_send? && !node.method?(:public_send)
+          return unless (first_argument = node.first_argument)
+          return unless STATIC_METHOD_NAME_NODE_TYPES.include?(first_argument.type)
+
+          offense_range = offense_range(node)
+          method_name = first_argument.value
+          return if !METHOD_NAME_PATTERN.match?(method_name) || RESERVED_WORDS.include?(method_name)
+
+          add_offense(offense_range, message: format(MSG, method_name: method_name)) do |corrector|
+            if node.arguments.one?
+              corrector.replace(offense_range, method_name)
+            else
+              corrector.replace(node.loc.selector, method_name)
+              corrector.remove(removal_argument_range(first_argument, node.arguments[1]))
+            end
+          end
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+        private
+
+        def allow_send?
+          !!cop_config['AllowSend']
+        end
+
+        def offense_range(node)
+          node.loc.selector.join(node.source_range.end)
+        end
+
+        def removal_argument_range(first_argument, second_argument)
+          first_argument.source_range.begin.join(second_argument.source_range.begin)
+        end
+      end
+    end
+  end
+end

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

@@ -58,9 +58,8 @@ module RuboCop
       #
       # @example EnforcedStyle: use_builtin_english_names
       #
-      # Like `use_perl_names` but allows builtin global vars.
-      #
       #   # good
+      #   # Like `use_perl_names` but allows builtin global vars.
       #   puts $LOAD_PATH
       #   puts $LOADED_FEATURES
       #   puts $PROGRAM_NAME