rubocop 0.79.0 → 0.83.0

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

@@ -63,7 +63,8 @@ module RuboCop
       end
 
       def tab_indentation_width
-        config.for_cop('Layout/Tab')['IndentationWidth']
+        config.for_cop('Layout/IndentationStyle')['IndentationWidth'] ||
+          config.for_cop('Layout/IndentationWidth')['Width']
       end
 
       def uri_regexp

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/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/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,21 +36,14 @@ 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
@@ -56,16 +51,6 @@ module RuboCop
 
         config.for_cop('Layout/LineLength')['Max']
       end
-
-      def indentation_multiplier
-        return 1 if config.for_cop('Layout/Tab')['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']
-      end
     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
 
@@ -135,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',
@@ -145,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?
 
@@ -169,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/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

@@ -39,7 +39,7 @@ module RuboCop
         def meaningful_delimiters?(node)
           delimiters = delimiter_string(node)
 
-          return false unless delimiters =~ /\w/
+          return false unless /\w/.match?(delimiters)
 
           forbidden_delimiters.none? do |forbidden_delimiter|
             delimiters =~ Regexp.new(forbidden_delimiter)

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/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/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)
@@ -147,9 +148,8 @@ 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
+        cop_enabled = cfg.fetch('Enabled') == true ||
+                      enabled_pending_cop?(cfg, config)
 
         if only_safe
           cop_enabled && cfg.fetch('Safe', true)
@@ -158,6 +158,13 @@ module RuboCop
         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

@@ -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

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

@@ -97,12 +97,12 @@ module RuboCop
           return unless correctable_send?(node)
 
           corrector.replace(whitespace_before_arg(node), '(')
-          corrector.insert_after(node.last_argument.source_range, ')')
+          corrector.insert_after(node.last_argument, ')')
         end
 
         def correct_setter(node, corrector)
-          corrector.insert_before(node.receiver.source_range, '(')
-          corrector.insert_after(node.last_argument.source_range, ')')
+          corrector.insert_before(node.receiver, '(')
+          corrector.insert_after(node.last_argument, ')')
         end
 
         # ! is a special case:
@@ -124,8 +124,7 @@ module RuboCop
         def correct_other(node, corrector)
           return if node.source_range.begin.is?('(')
 
-          corrector.insert_before(node.source_range, '(')
-          corrector.insert_after(node.source_range, ')')
+          corrector.wrap(node, '(', ')')
         end
 
         def correctable_send?(node)
@@ -137,7 +136,7 @@ module RuboCop
           end_paren = begin_paren
           # Increment position of parenthesis, unless message is a predicate
           # method followed by a non-whitespace char (e.g. is_a?String).
-          end_paren += 1 unless node.source =~ /\?\S/
+          end_paren += 1 unless /\?\S/.match?(node.source)
           range_between(begin_paren, end_paren)
         end
       end

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

@@ -30,7 +30,7 @@ module RuboCop
           array, join_arg = join_candidate?(node).map(&:source)
 
           lambda do |corrector|
-            corrector.replace(node.source_range, "#{array}.join(#{join_arg})")
+            corrector.replace(node, "#{array}.join(#{join_arg})")
           end
         end
       end

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

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+# rubocop:disable Metrics/ClassLength
 module RuboCop
   module Cop
     module Style
@@ -106,12 +107,41 @@ module RuboCop
       #     word.flip.flop
       #   }
       #
+      # @example BracesRequiredMethods: ['sig']
+      #
+      #   # Methods listed in the BracesRequiredMethods list, such as 'sig'
+      #   # in this example, will require `{...}` braces. This option takes
+      #   # precedence over all other configurations except IgnoredMethods.
+      #
+      #   # bad
+      #   sig do
+      #     params(
+      #       foo: string,
+      #     ).void
+      #   end
+      #   def bar(foo)
+      #     puts foo
+      #   end
+      #
+      #   # good
+      #   sig {
+      #     params(
+      #       foo: string,
+      #     ).void
+      #   }
+      #   def bar(foo)
+      #     puts foo
+      #   end
+      #
       class BlockDelimiters < Cop
         include ConfigurableEnforcedStyle
         include IgnoredMethods
 
         ALWAYS_BRACES_MESSAGE = 'Prefer `{...}` over `do...end` for blocks.'
 
+        BRACES_REQUIRED_MESSAGE = 'Brace delimiters `{...}` required for ' \
+          "'%<method_name>s' method."
+
         def on_send(node)
           return unless node.arguments?
           return if node.parenthesized?
@@ -175,7 +205,15 @@ module RuboCop
           end
         end
 
+        def braces_required_message(node)
+          format(BRACES_REQUIRED_MESSAGE, method_name: node.method_name.to_s)
+        end
+
         def message(node)
+          if braces_required_method?(node.method_name)
+            return braces_required_message(node)
+          end
+
           case style
           when :line_count_based    then line_count_based_message(node)
           when :semantic            then semantic_message(node)
@@ -238,7 +276,9 @@ module RuboCop
         # rubocop:enable Metrics/CyclomaticComplexity
 
         def proper_block_style?(node)
-          return true if ignored_method?(node.method_name)
+          if special_method?(node.method_name)
+            return special_method_proper_block_style?(node)
+          end
 
           case style
           when :line_count_based    then line_count_based_block_style?(node)
@@ -248,6 +288,24 @@ module RuboCop
           end
         end
 
+        def special_method?(method_name)
+          ignored_method?(method_name) || braces_required_method?(method_name)
+        end
+
+        def special_method_proper_block_style?(node)
+          method_name = node.method_name
+          return true if ignored_method?(method_name)
+          return node.braces? if braces_required_method?(method_name)
+        end
+
+        def braces_required_method?(method_name)
+          braces_required_methods.include?(method_name.to_s)
+        end
+
+        def braces_required_methods
+          cop_config.fetch('BracesRequiredMethods', [])
+        end
+
         def line_count_based_block_style?(node)
           node.multiline? ^ node.braces?
         end
@@ -329,3 +387,4 @@ module RuboCop
     end
   end
 end
+# rubocop:enable Metrics/ClassLength