rubocop 0.76.0 → 0.79.0

data/lib/rubocop/cop/lint/redundant_cop_disable_directive.rb

@@ -19,9 +19,9 @@ module RuboCop
       #
       # @example
       #   # bad
-      #   # rubocop:disable Metrics/LineLength
+      #   # rubocop:disable Layout/LineLength
       #   x += 1
-      #   # rubocop:enable Metrics/LineLength
+      #   # rubocop:enable Layout/LineLength
       #
       #   # good
       #   x += 1
@@ -213,7 +213,7 @@ module RuboCop
         end
 
         def matching_range(haystack, needle)
-          offset = (haystack.source =~ Regexp.new(Regexp.escape(needle)))
+          offset = haystack.source.index(needle)
           return unless offset
 
           offset += haystack.begin_pos

data/lib/rubocop/cop/lint/redundant_cop_enable_directive.rb

@@ -15,20 +15,20 @@ module RuboCop
       # @example
       #   # bad
       #   foo = 1
-      #   # rubocop:enable Metrics/LineLength
+      #   # rubocop:enable Layout/LineLength
       #
       #   # good
       #   foo = 1
       # @example
       #   # bad
-      #   # rubocop:disable Metrics/LineLength
+      #   # rubocop:disable Layout/LineLength
       #   baaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaarrrrrrrrrrrrr
-      #   # rubocop:enable Metrics/LineLength
+      #   # rubocop:enable Layout/LineLength
       #   baz
       #   # rubocop:enable all
       #
       #   # good
-      #   # rubocop:disable Metrics/LineLength
+      #   # rubocop:disable Layout/LineLength
       #   baaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaarrrrrrrrrrrrr
       #   # rubocop:enable all
       #   baz

data/lib/rubocop/cop/lint/redundant_splat_expansion.rb

@@ -146,7 +146,7 @@ module RuboCop
           grandparent = node.parent.parent
 
           parent.when_type? || parent.send_type? || part_of_an_array?(node) ||
-            (grandparent&.resbody_type?)
+            grandparent&.resbody_type?
         end
 
         def remove_brackets(array)

data/lib/rubocop/cop/lint/{string_conversion_in_interpolation.rb → redundant_string_coercion.rb}

@@ -17,7 +17,7 @@ module RuboCop
       #   # good
       #
       #   "result is #{something}"
-      class StringConversionInInterpolation < Cop
+      class RedundantStringCoercion < Cop
         include Interpolation
 
         MSG_DEFAULT = 'Redundant use of `Object#to_s` in interpolation.'

data/lib/rubocop/cop/lint/redundant_with_index.rb

@@ -50,7 +50,7 @@ module RuboCop
         def autocorrect(node)
           lambda do |corrector|
             redundant_with_index?(node) do |send|
-              if send.method_name == :each_with_index
+              if send.method?(:each_with_index)
                 corrector.replace(send.loc.selector, 'each')
               else
                 corrector.remove(with_index_range(send))
@@ -63,7 +63,7 @@ module RuboCop
         private
 
         def message(node)
-          if node.method_name == :each_with_index
+          if node.method?(:each_with_index)
             MSG_EACH_WITH_INDEX
           else
             MSG_WITH_INDEX

data/lib/rubocop/cop/lint/redundant_with_object.rb

@@ -51,7 +51,7 @@ module RuboCop
         def autocorrect(node)
           lambda do |corrector|
             redundant_with_object?(node) do |send|
-              if send.method_name == :each_with_object
+              if send.method?(:each_with_object)
                 corrector.replace(with_object_range(send), 'each')
               else
                 corrector.remove(with_object_range(send))
@@ -64,7 +64,7 @@ module RuboCop
         private
 
         def message(node)
-          if node.method_name == :each_with_object
+          if node.method?(:each_with_object)
             MSG_EACH_WITH_OBJECT
           else
             MSG_WITH_OBJECT

data/lib/rubocop/cop/lint/{handle_exceptions.rb → suppressed_exception.rb}

@@ -74,7 +74,7 @@ module RuboCop
       #   rescue
       #     # do nothing but comment
       #   end
-      class HandleExceptions < Cop
+      class SuppressedException < Cop
         MSG = 'Do not suppress exceptions.'
 
         def on_resbody(node)

data/lib/rubocop/cop/lint/useless_access_modifier.rb

@@ -9,23 +9,64 @@ module RuboCop
       # always being defined, and thus access modifiers guarding such methods
       # are not redundant.
       #
-      # @example
+      # This cop has `ContextCreatingMethods` option. The default setting value
+      # is an empty array that means no method is specified.
+      # This setting is an array of methods which, when called, are known to
+      # create its own context in the module's current access context.
+      #
+      # It also has `MethodCreatingMethods` option. The default setting value
+      # is an empty array that means no method is specified.
+      # This setting is an array of methods which, when called, are known to
+      # create other methods in the module's current access context.
       #
+      # @example
+      #   # bad
       #   class Foo
       #     public # this is redundant (default access is public)
       #
       #     def method
       #     end
+      #   end
       #
-      #     private # this is not redundant (a method is defined)
-      #     def method2
+      #   # bad
+      #   class Foo
+      #     # The following is redundant (methods defined on the class'
+      #     # singleton class are not affected by the public modifier)
+      #     public
+      #
+      #     def self.method3
       #     end
+      #   end
       #
+      #   # bad
+      #   class Foo
+      #     protected
+      #
+      #     define_method(:method2) do
+      #     end
+      #
+      #     protected # this is redundant (repeated from previous modifier)
+      #
+      #     [1,2,3].each do |i|
+      #       define_method("foo#{i}") do
+      #       end
+      #     end
+      #   end
+      #
+      #   # bad
+      #   class Foo
       #     private # this is redundant (no following methods are defined)
       #   end
       #
-      # @example
+      #   # good
+      #   class Foo
+      #     private # this is not redundant (a method is defined)
+      #
+      #     def method2
+      #     end
+      #   end
       #
+      #   # good
       #   class Foo
       #     # The following is not redundant (conditionally defined methods are
       #     # considered as always defining a method)
@@ -35,31 +76,22 @@ module RuboCop
       #       def method
       #       end
       #     end
+      #   end
       #
-      #     protected # this is not redundant (method is defined)
+      #   # good
+      #   class Foo
+      #     protected # this is not redundant (a method is defined)
       #
       #     define_method(:method2) do
       #     end
-      #
-      #     protected # this is redundant (repeated from previous modifier)
-      #
-      #     [1,2,3].each do |i|
-      #       define_method("foo#{i}") do
-      #       end
-      #     end
-      #
-      #     # The following is redundant (methods defined on the class'
-      #     # singleton class are not affected by the public modifier)
-      #     public
-      #
-      #     def self.method3
-      #     end
       #   end
       #
-      # @example
+      # @example ContextCreatingMethods: concerning
       #   # Lint/UselessAccessModifier:
       #   #   ContextCreatingMethods:
       #   #     - concerning
+      #
+      #   # good
       #   require 'active_support/concern'
       #   class Foo
       #     concerning :Bar do
@@ -79,10 +111,12 @@ module RuboCop
       #     end
       #   end
       #
-      # @example
+      # @example MethodCreatingMethods: delegate
       #   # Lint/UselessAccessModifier:
       #   #   MethodCreatingMethods:
       #   #     - delegate
+      #
+      #   # good
       #   require 'active_support/core_ext/module/delegation'
       #   class Foo
       #     # this is not redundant because `delegate` creates methods
@@ -141,7 +175,7 @@ module RuboCop
 
         def access_modifier?(node)
           node.bare_access_modifier? ||
-            node.method_name == :private_class_method
+            node.method?(:private_class_method)
         end
 
         def check_scope(node)
@@ -169,7 +203,7 @@ module RuboCop
         def check_send_node(node, cur_vis, unused)
           if node.bare_access_modifier?
             check_new_visibility(node, unused, node.method_name, cur_vis)
-          elsif node.method_name == :private_class_method && !node.arguments?
+          elsif node.method?(:private_class_method) && !node.arguments?
             add_offense(node, message: format(MSG, current: node.method_name))
             [cur_vis, unused]
           end

data/lib/rubocop/cop/lint/useless_setter_call.rb

@@ -155,7 +155,7 @@ module RuboCop
             return true if node.literal?
             return false unless node.send_type?
 
-            node.method_name == :new
+            node.method?(:new)
           end
         end
       end

data/lib/rubocop/cop/metrics/method_length.rb

@@ -20,7 +20,7 @@ module RuboCop
         alias on_defs on_def
 
         def on_block(node)
-          return unless node.send_node.method_name == :define_method
+          return unless node.send_node.method?(:define_method)
 
           check_code_length(node)
         end

data/lib/rubocop/cop/migration/department_name.rb

@@ -10,13 +10,24 @@ module RuboCop
 
         MSG = 'Department name is missing.'
 
+        DISABLE_COMMENT_FORMAT =
+          /\A(# *rubocop *: *((dis|en)able|todo) +)(.*)/.freeze
+
+        # The token that makes up a disable comment.
+        # The token used after `# rubocop: disable` are `A-z`, `/`, and `,`.
+        # Also `A-z` includes `all`.
+        DISABLING_COPS_CONTENT_TOKEN = %r{[A-z/,]+}.freeze
+
         def investigate(processed_source)
           processed_source.each_comment do |comment|
-            next if comment.text !~ /\A(# *rubocop:((dis|en)able|todo) +)(.*)/
+            next if comment.text !~ DISABLE_COMMENT_FORMAT
 
             offset = Regexp.last_match(1).length
             Regexp.last_match(4).scan(%r{[\w/]+|\W+}) do |name|
+              break unless valid_content_token?(name.strip)
+
               check_cop_name(name, comment, offset)
+
               offset += name.length
             end
           end
@@ -38,6 +49,10 @@ module RuboCop
           range = range_between(start, start + name.length)
           add_offense(range, location: range)
         end
+
+        def valid_content_token?(content_token)
+          !DISABLING_COPS_CONTENT_TOKEN.match(content_token).nil?
+        end
       end
     end
   end

data/lib/rubocop/cop/mixin/alignment.rb

@@ -35,7 +35,7 @@ module RuboCop
             # If this offense is within a line range that is already being
             # realigned by autocorrect, we report the offense without
             # autocorrecting it. Two rewrites in the same area by the same
-            # cop can not be handled. The next iteration will find the
+            # cop cannot be handled. The next iteration will find the
             # offense again and correct it.
             add_offense(nil, location: expr)
           else

data/lib/rubocop/cop/mixin/frozen_string_literal.rb

@@ -40,13 +40,7 @@ module RuboCop
       end
 
       def leading_comment_lines
-        comments = processed_source.comments
-
-        comments.each_with_object([]) do |comment, leading_comments|
-          next if comment.loc.line > 3
-
-          leading_comments << comment.text
-        end
+        processed_source.comments.first(3).map(&:text)
       end
     end
   end

data/lib/rubocop/cop/mixin/{hash_alignment.rb → hash_alignment_styles.rb}

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     # Common functionality for checking hash alignment.
-    module HashAlignment
+    module HashAlignmentStyles
       # Handles calculation of deltas when the enforced style is 'key'.
       class KeyAlignment
         def checkable_layout?(_node)

data/lib/rubocop/cop/mixin/line_length_help.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Help methods for determining if a line is too long.
+    module LineLengthHelp
+      private
+
+      def ignore_cop_directives?
+        config.for_cop('Layout/LineLength')['IgnoreCopDirectives']
+      end
+
+      def directive_on_source_line?(line_index)
+        source_line_number = line_index + processed_source.buffer.first_line
+        comment =
+          processed_source.comments
+                          .detect { |e| e.location.line == source_line_number }
+
+        return false unless comment
+
+        comment.text.match(CommentConfig::COMMENT_DIRECTIVE_REGEXP)
+      end
+
+      def allow_uri?
+        config.for_cop('Layout/LineLength')['AllowURI']
+      end
+
+      def allowed_uri_position?(line, uri_range)
+        uri_range.begin < max_line_length &&
+          (uri_range.end == line_length(line) ||
+           uri_range.end == line_length(line) - 1)
+      end
+
+      def line_length(line)
+        line.length + indentation_difference(line)
+      end
+
+      def find_excessive_uri_range(line)
+        last_uri_match = match_uris(line).last
+        return nil unless last_uri_match
+
+        begin_position, end_position = last_uri_match.offset(0).map do |pos|
+          pos + indentation_difference(line)
+        end
+        return nil if begin_position < max_line_length &&
+                      end_position < max_line_length
+
+        begin_position...end_position
+      end
+
+      def match_uris(string)
+        matches = []
+        string.scan(uri_regexp) do
+          matches << $LAST_MATCH_INFO if valid_uri?($LAST_MATCH_INFO[0])
+        end
+        matches
+      end
+
+      def indentation_difference(line)
+        return 0 unless tab_indentation_width
+
+        line.match(/^\t*/)[0].size * (tab_indentation_width - 1)
+      end
+
+      def tab_indentation_width
+        config.for_cop('Layout/Tab')['IndentationWidth']
+      end
+
+      def uri_regexp
+        @uri_regexp ||=
+          URI::DEFAULT_PARSER
+          .make_regexp(config.for_cop('Layout/LineLength')['URISchemes'])
+      end
+
+      def valid_uri?(uri_ish_string)
+        URI.parse(uri_ish_string)
+        true
+      rescue URI::InvalidURIError, NoMethodError
+        false
+      end
+
+      def line_length_without_directive(line)
+        before_comment, = line.split(CommentConfig::COMMENT_DIRECTIVE_REGEXP)
+        before_comment.rstrip.length
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/nil_methods.rb

@@ -5,20 +5,20 @@ module RuboCop
     # This module provides a list of methods that are:
     # 1. In the NilClass by default
     # 2. Added to NilClass by explicitly requiring any standard libraries
-    # 3. Cop's configuration parameter Whitelist.
+    # 3. Cop's configuration parameter AllowedMethods.
     module NilMethods
       private
 
       def nil_methods
-        nil.methods + other_stdlib_methods + whitelist
+        nil.methods + other_stdlib_methods + allowed_methods
       end
 
       def other_stdlib_methods
         [:to_d]
       end
 
-      def whitelist
-        cop_config['Whitelist'].map(&:to_sym)
+      def allowed_methods
+        cop_config['AllowedMethods'].map(&:to_sym)
       end
     end
   end

data/lib/rubocop/cop/mixin/rational_literal.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for handling Rational literals.
+    module RationalLiteral
+      extend NodePattern::Macros
+
+      private
+
+      def_node_matcher :rational_literal?, <<~PATTERN
+        (send
+          (int _) :/
+          (rational _))
+      PATTERN
+    end
+  end
+end

data/lib/rubocop/cop/mixin/statement_modifier.rb

@@ -52,9 +52,9 @@ module RuboCop
       end
 
       def max_line_length
-        return unless config.for_cop('Metrics/LineLength')['Enabled']
+        return unless config.for_cop('Layout/LineLength')['Enabled']
 
-        config.for_cop('Metrics/LineLength')['Max']
+        config.for_cop('Layout/LineLength')['Max']
       end
 
       def indentation_multiplier

data/lib/rubocop/cop/mixin/trailing_comma.rb

@@ -93,9 +93,12 @@ module RuboCop
       end
 
       def method_name_and_arguments_on_same_line?(node)
-        %i[send csend].include?(node.type) &&
-          node.loc.selector.line == node.arguments.last.last_line &&
-          node.last_line == node.arguments.last.last_line
+        return false unless node.call_type?
+
+        line = node.loc.selector.nil? ? node.loc.line : node.loc.selector.line
+
+        line == node.last_argument.last_line &&
+          node.last_line == node.last_argument.last_line
       end
 
       # A single argument with the closing bracket on the same line as the end

data/lib/rubocop/cop/naming/{uncommunicative_block_param_name.rb → block_parameter_name.rb}

@@ -11,9 +11,9 @@ module RuboCop
       # The `AllowNamesEndingInNumbers` config option takes a boolean. When
       # set to false, this cop will register offenses for names ending with
       # numbers. Its default is false. The `AllowedNames` config option
-      # takes an array of whitelisted names that will never register an
+      # takes an array of permitted names that will never register an
       # offense. The `ForbiddenNames` config option takes an array of
-      # blacklisted names that will always register an offense.
+      # restricted names that will always register an offense.
       #
       # @example
       #   # bad
@@ -35,7 +35,7 @@ module RuboCop
       #   foo { |speed, distance| speed * distance }
       #
       #   baz { |age, height, gender| do_stuff(age, height, gender) }
-      class UncommunicativeBlockParamName < Cop
+      class BlockParameterName < Cop
         include UncommunicativeName
 
         def on_block(node)

data/lib/rubocop/cop/naming/heredoc_delimiter_naming.rb

@@ -5,7 +5,7 @@ module RuboCop
     module Naming
       # This cop checks that your heredocs are using meaningful delimiters.
       # By default it disallows `END` and `EO*`, and can be configured through
-      # blacklisting additional delimiters.
+      # forbidden listing additional delimiters.
       #
       # @example
       #
@@ -41,13 +41,13 @@ module RuboCop
 
           return false unless delimiters =~ /\w/
 
-          blacklisted_delimiters.none? do |blacklisted_delimiter|
-            delimiters =~ Regexp.new(blacklisted_delimiter)
+          forbidden_delimiters.none? do |forbidden_delimiter|
+            delimiters =~ Regexp.new(forbidden_delimiter)
           end
         end
 
-        def blacklisted_delimiters
-          cop_config['Blacklist'] || []
+        def forbidden_delimiters
+          cop_config['ForbiddenDelimiters'] || []
         end
       end
     end

data/lib/rubocop/cop/naming/{uncommunicative_method_param_name.rb → method_parameter_name.rb}

@@ -11,9 +11,9 @@ module RuboCop
       # The `AllowNamesEndingInNumbers` config option takes a boolean. When
       # set to false, this cop will register offenses for names ending with
       # numbers. Its default is false. The `AllowedNames` config option
-      # takes an array of whitelisted names that will never register an
+      # takes an array of permitted names that will never register an
       # offense. The `ForbiddenNames` config option takes an array of
-      # blacklisted names that will always register an offense.
+      # restricted names that will always register an offense.
       #
       # @example
       #   # bad
@@ -43,13 +43,13 @@ module RuboCop
       #   def baz(age_a, height_b, gender_c)
       #     do_stuff(age_a, height_b, gender_c)
       #   end
-      class UncommunicativeMethodParamName < Cop
+      class MethodParameterName < Cop
         include UncommunicativeName
 
         def on_def(node)
           return unless node.arguments?
 
-          check(node, node.arguments)
+          check(node, node.arguments.reject(&:forward_args_type?))
         end
         alias on_defs on_def
       end

data/lib/rubocop/cop/naming/predicate_name.rb

@@ -70,11 +70,11 @@ module RuboCop
           !method_name.match(/^#{prefix}[^0-9]/) ||
             method_name == expected_name(method_name, prefix) ||
             method_name.end_with?('=') ||
-            predicate_whitelist.include?(method_name)
+            allowed_methods.include?(method_name)
         end
 
         def expected_name(method_name, prefix)
-          new_name = if prefix_blacklist.include?(prefix)
+          new_name = if forbidden_prefixes.include?(prefix)
                        method_name.sub(prefix, '')
                      else
                        method_name.dup
@@ -87,16 +87,16 @@ module RuboCop
           "Rename `#{method_name}` to `#{new_name}`."
         end
 
-        def prefix_blacklist
-          cop_config['NamePrefixBlacklist']
+        def forbidden_prefixes
+          cop_config['ForbiddenPrefixes']
         end
 
         def predicate_prefixes
           cop_config['NamePrefix']
         end
 
-        def predicate_whitelist
-          cop_config['NameWhitelist']
+        def allowed_methods
+          cop_config['AllowedMethods']
         end
 
         def method_definition_macros(macro_name)

data/lib/rubocop/cop/offense.rb

@@ -65,6 +65,17 @@ module RuboCop
         freeze
       end
 
+      # @api public
+      #
+      # @!attribute [r] correctable?
+      #
+      # @return [Boolean]
+      #   whether this offense can be automatically corrected via
+      #   autocorrect or a todo.
+      def correctable?
+        @status != :unsupported
+      end
+
       # @api public
       #
       # @!attribute [r] corrected?

data/lib/rubocop/cop/registry.rb

@@ -146,10 +146,15 @@ module RuboCop
 
       def enabled?(cop, config, only_safe)
         cfg = config.for_cop(cop)
+
+        # cfg['Enabled'] might be a string `pending`, which is considered
+        # disabled
+        cop_enabled = cfg.fetch('Enabled') == true
+
         if only_safe
-          cfg.fetch('Enabled') && cfg.fetch('Safe', true)
+          cop_enabled && cfg.fetch('Safe', true)
         else
-          cfg.fetch('Enabled')
+          cop_enabled
         end
       end
 

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

@@ -91,7 +91,7 @@ module RuboCop
             when :def, :defs
               return :dynamic
             when :block
-              return :instance_eval if parent.method_name == :instance_eval
+              return :instance_eval if parent.method?(:instance_eval)
 
               return :dynamic
             end