rubocop 0.76.0 → 0.83.0

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

@@ -0,0 +1,89 @@
+# 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/IndentationStyle')['IndentationWidth'] ||
+          config.for_cop('Layout/IndentationWidth')['Width']
+      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/method_complexity.rb

@@ -5,15 +5,20 @@ module RuboCop
     # This module handles measurement and reporting of complexity in methods.
     module MethodComplexity
       include ConfigurableMax
+      include IgnoredMethods
       extend NodePattern::Macros
 
       def on_def(node)
+        return if ignored_method?(node.method_name)
+
         check_complexity(node, node.method_name)
       end
       alias on_defs on_def
 
       def on_block(node)
         define_method?(node) do |name|
+          return if ignored_method?(name)
+
           check_complexity(node, name)
         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/parser_diagnostic.rb

@@ -26,7 +26,7 @@ module RuboCop
                       d.message.capitalize
                     end
 
-          add_offense(nil,
+          add_offense(find_offense_node_by(d),
                       location: d.location,
                       message: message,
                       severity: d.level)

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

@@ -4,6 +4,8 @@ module RuboCop
   module Cop
     # Common functionality for modifier cops.
     module StatementModifier
+      include LineLengthHelp
+
       private
 
       def single_line_as_modifier?(node)
@@ -34,37 +36,20 @@ module RuboCop
       def modifier_fits_on_single_line?(node)
         return true unless max_line_length
 
-        modifier_length = length_in_modifier_form(node, node.condition,
-                                                  node.body.source_length)
-
-        modifier_length <= max_line_length
+        length_in_modifier_form(node, node.condition) <= max_line_length
       end
 
-      def length_in_modifier_form(node, cond, body_length)
+      def length_in_modifier_form(node, cond)
         keyword = node.loc.keyword
-
-        indentation = keyword.column * indentation_multiplier
-        kw_length = keyword.size
-        cond_length = cond.source_range.size
-        space = 1
-
-        indentation + body_length + space + kw_length + space + cond_length
+        indentation = keyword.source_line[/^\s*/]
+        line_length("#{indentation}#{node.body.source} #{keyword.source} " \
+                    "#{cond.source}")
       end
 
       def max_line_length
-        return unless config.for_cop('Metrics/LineLength')['Enabled']
-
-        config.for_cop('Metrics/LineLength')['Max']
-      end
-
-      def indentation_multiplier
-        return 1 if config.for_cop('Layout/Tab')['Enabled']
+        return unless config.for_cop('Layout/LineLength')['Enabled']
 
-        default_configuration = RuboCop::ConfigLoader.default_configuration
-        config.for_cop('Layout/Tab')['IndentationWidth'] ||
-          config.for_cop('Layout/IndentationWidth')['Width'] ||
-          default_configuration.for_cop('Layout/Tab')['IndentationWidth'] ||
-          default_configuration.for_cop('Layout/IndentationWidth')['Width']
+        config.for_cop('Layout/LineLength')['Max']
       end
     end
   end

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

@@ -4,12 +4,16 @@ module RuboCop
   module Cop
     # Common functionality for checking target ruby version.
     module TargetRubyVersion
+      def required_minimum_ruby_version
+        @minimum_target_ruby_version
+      end
+
       def minimum_target_ruby_version(version)
         @minimum_target_ruby_version = version
       end
 
       def support_target_ruby_version?(version)
-        @minimum_target_ruby_version <= version
+        required_minimum_ruby_version <= version
       end
     end
   end

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

@@ -23,7 +23,7 @@ module RuboCop
         if comma_offset && !inside_comment?(after_last_item, comma_offset)
           check_comma(node, kind, after_last_item.begin_pos + comma_offset)
         elsif should_have_comma?(style, node)
-          put_comma(node, items, kind)
+          put_comma(items, kind)
         end
       end
 
@@ -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
@@ -132,7 +135,7 @@ module RuboCop
 
       def avoid_comma(kind, comma_begin_pos, extra_info)
         range = range_between(comma_begin_pos, comma_begin_pos + 1)
-        article = kind =~ /array/ ? 'an' : 'a'
+        article = /array/.match?(kind) ? 'an' : 'a'
         msg = format(
           MSG,
           command: 'Avoid',
@@ -142,9 +145,7 @@ module RuboCop
         add_offense(range, location: range, message: msg)
       end
 
-      def put_comma(node, items, kind)
-        return if avoid_autocorrect?(elements(node))
-
+      def put_comma(items, kind)
         last_item = items.last
         return if last_item.block_pass_type?
 
@@ -166,11 +167,6 @@ module RuboCop
         range_between(expr.begin_pos + ix, expr.end_pos)
       end
 
-      # By default, there's no reason to avoid auto-correct.
-      def avoid_autocorrect?(_nodes)
-        false
-      end
-
       def any_heredoc?(items)
         items.any? { |item| heredoc?(item) }
       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/class_and_module_camel_case.rb

@@ -22,7 +22,7 @@ module RuboCop
         MSG = 'Use CamelCase for classes and modules.'
 
         def on_class(node)
-          return unless node.loc.name.source =~ /_/
+          return unless /_/.match?(node.loc.name.source)
 
           add_offense(node, location: :name)
         end

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

@@ -45,8 +45,9 @@ module RuboCop
           # SomeClass = Class.new(...)
           # SomeClass = Struct.new(...)
           return if allowed_assignment?(value)
+          return if SNAKE_CASE.match?(const_name)
 
-          add_offense(node, location: :name) if const_name !~ SNAKE_CASE
+          add_offense(node, location: :name)
         end
 
         private

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
       #
@@ -39,15 +39,15 @@ module RuboCop
         def meaningful_delimiters?(node)
           delimiters = delimiter_string(node)
 
-          return false unless delimiters =~ /\w/
+          return false unless /\w/.match?(delimiters)
 
-          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/memoized_instance_variable_name.rb

@@ -10,7 +10,7 @@ module RuboCop
       # directive. It can be configured to allow for memoized instance variables
       # prefixed with an underscore. Prefixing ivars with an underscore is a
       # convention that is used to implicitly indicate that an ivar should not
-      # be set or referencd outside of the memoization method.
+      # be set or referenced outside of the memoization method.
       #
       # @example EnforcedStyleForLeadingUnderscores: disallowed (default)
       #   # bad

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

@@ -31,9 +31,24 @@ module RuboCop
       class MethodName < Cop
         include ConfigurableNaming
         include IgnoredPattern
+        include RangeHelp
 
         MSG = 'Use %<style>s for method names.'
 
+        def_node_matcher :sym_name, '(sym $_name)'
+        def_node_matcher :str_name, '(str $_name)'
+
+        def on_send(node)
+          return unless (attrs = node.attribute_accessor?)
+
+          attrs.last.each do |name_item|
+            name = attr_name(name_item)
+            next if !name || matches_ignored_pattern?(name)
+
+            check_name(node, name, range_position(node))
+          end
+        end
+
         def on_def(node)
           return if node.operator_method? ||
                     matches_ignored_pattern?(node.method_name)
@@ -44,6 +59,17 @@ module RuboCop
 
         private
 
+        def attr_name(name_item)
+          sym_name(name_item) || str_name(name_item)
+        end
+
+        def range_position(node)
+          selector_end_pos = node.loc.selector.end_pos + 1
+          expr_end_pos = node.loc.expression.end_pos
+
+          range_between(selector_end_pos, expr_end_pos)
+        end
+
         def message(style)
           format(MSG, style: style)
         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/naming/rescued_exceptions_variable_name.rb

@@ -73,7 +73,7 @@ module RuboCop
             node.body&.each_descendant(:lvar) do |var|
               next unless var.children.first == offending_name
 
-              corrector.replace(var.loc.expression, preferred_name)
+              corrector.replace(var, preferred_name)
             end
           end
         end

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

@@ -22,12 +22,13 @@ module RuboCop
 
     # Registry that tracks all cops by their badge and department.
     class Registry
-      def initialize(cops = [])
+      def initialize(cops = [], options = {})
         @registry = {}
         @departments = {}
         @cops_by_cop_name = Hash.new { |hash, key| hash[key] = [] }
 
         cops.each { |cop| enlist(cop) }
+        @options = options
       end
 
       def enlist(cop)
@@ -146,13 +147,24 @@ module RuboCop
 
       def enabled?(cop, config, only_safe)
         cfg = config.for_cop(cop)
+
+        cop_enabled = cfg.fetch('Enabled') == true ||
+                      enabled_pending_cop?(cfg, config)
+
         if only_safe
-          cfg.fetch('Enabled') && cfg.fetch('Safe', true)
+          cop_enabled && cfg.fetch('Safe', true)
         else
-          cfg.fetch('Enabled')
+          cop_enabled
         end
       end
 
+      def enabled_pending_cop?(cop_cfg, config)
+        return false if @options[:disable_pending_cops]
+
+        cop_cfg.fetch('Enabled') == 'pending' &&
+          (@options[:enable_pending_cops] || config.enabled_new_cops?)
+      end
+
       def names
         cops.map(&:cop_name)
       end

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

@@ -5,11 +5,12 @@ module RuboCop
     module Style
       # Access modifiers should be declared to apply to a group of methods
       # or inline before each method, depending on configuration.
+      # EnforcedStyle config covers only method definitions.
+      # Applications of visibility methods to symbols can be controlled
+      # using AllowModifiersOnSymbols config.
       #
       # @example EnforcedStyle: group (default)
-      #
       #   # bad
-      #
       #   class Foo
       #
       #     private def bar; end
@@ -18,7 +19,6 @@ module RuboCop
       #   end
       #
       #   # good
-      #
       #   class Foo
       #
       #     private
@@ -27,10 +27,9 @@ module RuboCop
       #     def baz; end
       #
       #   end
-      # @example EnforcedStyle: inline
       #
+      # @example EnforcedStyle: inline
       #   # bad
-      #
       #   class Foo
       #
       #     private
@@ -41,13 +40,28 @@ module RuboCop
       #   end
       #
       #   # good
-      #
       #   class Foo
       #
       #     private def bar; end
       #     private def baz; end
       #
       #   end
+      #
+      # @example AllowModifiersOnSymbols: true
+      #   # good
+      #   class Foo
+      #
+      #     private :bar, :baz
+      #
+      #   end
+      #
+      # @example AllowModifiersOnSymbols: false
+      #   # bad
+      #   class Foo
+      #
+      #     private :bar, :baz
+      #
+      #   end
       class AccessModifierDeclarations < Cop
         include ConfigurableEnforcedStyle
 
@@ -61,9 +75,15 @@ module RuboCop
           'inlined in method definitions.'
         ].join(' ')
 
+        def_node_matcher :access_modifier_with_symbol?, <<~PATTERN
+          (send nil? {:private :protected :public} (sym _))
+        PATTERN
+
         def on_send(node)
           return unless node.access_modifier?
           return if node.parent.pair_type?
+          return if cop_config['AllowModifiersOnSymbols'] &&
+                    access_modifier_with_symbol?(node)
 
           if offense?(node)
             add_offense(node, location: :selector) do

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
@@ -115,7 +115,7 @@ module RuboCop
           lambda do |corrector|
             new, old = *send_node.arguments
             replacement = "alias #{identifier(new)} #{identifier(old)}"
-            corrector.replace(send_node.source_range, replacement)
+            corrector.replace(send_node, replacement)
           end
         end
 
@@ -125,15 +125,15 @@ module RuboCop
               'alias_method ' \
               ":#{identifier(node.new_identifier)}, " \
               ":#{identifier(node.old_identifier)}"
-            corrector.replace(node.source_range, replacement)
+            corrector.replace(node, replacement)
           end
         end
 
         def correct_alias_with_symbol_args(node)
           lambda do |corrector|
-            corrector.replace(node.new_identifier.source_range,
+            corrector.replace(node.new_identifier,
                               node.new_identifier.source[1..-1])
-            corrector.replace(node.old_identifier.source_range,
+            corrector.replace(node.old_identifier,
                               node.old_identifier.source[1..-1])
           end
         end