rubocop 1.29.1 → 1.48.0

data/lib/rubocop/cop/registry.rb

@@ -19,6 +19,33 @@ module RuboCop
     class Registry
       include Enumerable
 
+      def self.all
+        global.without_department(:Test).cops
+      end
+
+      def self.qualified_cop_name(name, origin)
+        global.qualified_cop_name(name, origin)
+      end
+
+      # Changes momentarily the global registry
+      # Intended for testing purposes
+      def self.with_temporary_global(temp_global = global.dup)
+        previous = @global
+        @global = temp_global
+        yield
+      ensure
+        @global = previous
+      end
+
+      def self.reset!
+        @global = new
+      end
+
+      def self.qualified_cop?(name)
+        badge = Badge.parse(name)
+        global.qualify_badge(badge).first == badge
+      end
+
       attr_reader :options
 
       def initialize(cops = [], options = {})
@@ -28,6 +55,9 @@ module RuboCop
 
         @enrollment_queue = cops
         @options = options
+
+        @enabled_cache = {}.compare_by_identity
+        @disabled_cache = {}.compare_by_identity
       end
 
       def enlist(cop)
@@ -61,7 +91,7 @@ module RuboCop
 
       # @return [Boolean] Checks if given name is department
       def department?(name)
-        departments.include? name.to_sym
+        departments.include?(name.to_sym)
       end
 
       def contains_cop_matching?(names)
@@ -72,27 +102,27 @@ module RuboCop
       #
       # @example gives back a correctly qualified cop name
       #
-      #   cops = RuboCop::Cop::Cop.all
-      #   cops.
-      #     qualified_cop_name('Layout/EndOfLine') # => 'Layout/EndOfLine'
+      #   registry = RuboCop::Cop::Registry
+      #   registry.qualified_cop_name('Layout/EndOfLine', '') # => 'Layout/EndOfLine'
       #
       # @example fixes incorrect namespaces
       #
-      #   cops = RuboCop::Cop::Cop.all
-      #   cops.qualified_cop_name('Lint/EndOfLine') # => 'Layout/EndOfLine'
+      #   registry = RuboCop::Cop::Registry
+      #   registry.qualified_cop_name('Lint/EndOfLine', '') # => 'Layout/EndOfLine'
       #
       # @example namespaces bare cop identifiers
       #
-      #   cops = RuboCop::Cop::Cop.all
-      #   cops.qualified_cop_name('EndOfLine') # => 'Layout/EndOfLine'
+      #   registry = RuboCop::Cop::Registry
+      #   registry.qualified_cop_name('EndOfLine', '') # => 'Layout/EndOfLine'
       #
       # @example passes back unrecognized cop names
       #
-      #   cops = RuboCop::Cop::Cop.all
-      #   cops.qualified_cop_name('NotACop') # => 'NotACop'
+      #   registry = RuboCop::Cop::Registry
+      #   registry.qualified_cop_name('NotACop', '') # => 'NotACop'
       #
       # @param name [String] Cop name extracted from config
       # @param path [String, nil] Path of file that `name` was extracted from
+      # @param warn [Boolean] Print a warning if no department given for `name`
       #
       # @raise [AmbiguousCopName]
       #   if a bare identifier with two possible namespaces is provided
@@ -133,6 +163,13 @@ module RuboCop
           'RedundantCopDisableDirective'
       end
 
+      def qualify_badge(badge)
+        clear_enrollment_queue
+        @departments
+          .map { |department, _| badge.with_department(department) }
+          .select { |potential_badge| registered?(potential_badge) }
+      end
+
       # @return [Hash{String => Array<Class>}]
       def to_h
         clear_enrollment_queue
@@ -149,16 +186,24 @@ module RuboCop
         @registry.size
       end
 
-      def enabled(config, only = [], only_safe: false)
-        select { |cop| only.include?(cop.cop_name) || enabled?(cop, config, only_safe) }
+      def enabled(config)
+        @enabled_cache[config] ||= select { |cop| enabled?(cop, config) }
+      end
+
+      def disabled(config)
+        @disabled_cache[config] ||= reject { |cop| enabled?(cop, config) }
       end
 
-      def enabled?(cop, config, only_safe)
-        cfg = config.for_cop(cop)
+      def enabled?(cop, config)
+        return true if options[:only]&.include?(cop.cop_name)
+
+        # We need to use `cop_name` in this case, because `for_cop` uses caching
+        # which expects cop names or cop classes as keys.
+        cfg = config.for_cop(cop.cop_name)
 
         cop_enabled = cfg.fetch('Enabled') == true || enabled_pending_cop?(cfg, config)
 
-        if only_safe
+        if options.fetch(:safe, false)
           cop_enabled && cfg.fetch('Safe', true)
         else
           cop_enabled
@@ -176,8 +221,12 @@ module RuboCop
         cops.map(&:cop_name)
       end
 
+      def cops_for_department(department)
+        cops.select { |cop| cop.department == department.to_sym }
+      end
+
       def names_for_department(department)
-        cops.select { |cop| cop.department == department.to_sym }.map(&:cop_name)
+        cops_for_department(department).map(&:cop_name)
       end
 
       def ==(other)
@@ -205,6 +254,14 @@ module RuboCop
         to_h[cop_name].first
       end
 
+      # When a cop name is given returns a single-element array with the cop class.
+      # When a department name is given returns an array with all the cop classes
+      # for that department.
+      def find_cops_by_directive(directive)
+        cop = find_by_cop_name(directive)
+        cop ? [cop] : cops_for_department(directive)
+      end
+
       def freeze
         clear_enrollment_queue
         unqualified_cop_names # build cache
@@ -217,28 +274,6 @@ module RuboCop
         attr_reader :global
       end
 
-      def self.all
-        global.without_department(:Test).cops
-      end
-
-      def self.qualified_cop_name(name, origin)
-        global.qualified_cop_name(name, origin)
-      end
-
-      # Changes momentarily the global registry
-      # Intended for testing purposes
-      def self.with_temporary_global(temp_global = global.dup)
-        previous = @global
-        @global = temp_global
-        yield
-      ensure
-        @global = previous
-      end
-
-      def self.reset!
-        @global = new
-      end
-
       private
 
       def initialize_copy(reg)
@@ -261,13 +296,6 @@ module RuboCop
         self.class.new(cops)
       end
 
-      def qualify_badge(badge)
-        clear_enrollment_queue
-        @departments
-          .map { |department, _| badge.with_department(department) }
-          .select { |potential_badge| registered?(potential_badge) }
-      end
-
       def resolve_badge(given_badge, real_badge, source_path)
         unless given_badge.match?(real_badge)
           path = PathUtil.smart_path(source_path)

data/lib/rubocop/cop/security/compound_hash.rb

@@ -3,13 +3,14 @@
 module RuboCop
   module Cop
     module Security
-      # This cop checks for implementations of the `hash` method which combine
+      # Checks for implementations of the `hash` method which combine
       # values using custom logic instead of delegating to `Array#hash`.
       #
       # Manually combining hashes is error prone and hard to follow, especially
       # when there are many values. Poor implementations may also introduce
       # performance or security concerns if they are prone to collisions.
-      # Delegating to `Array#hash` is clearer, faster, and safer.
+      # Delegating to `Array#hash` is clearer and safer, although it might be slower
+      # depending on the use case.
       #
       # @safety
       #   This cop may be unsafe if the application logic depends on the hash

data/lib/rubocop/cop/security/eval.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Security
-      # This cop checks for the use of `Kernel#eval` and `Binding#eval`.
+      # Checks for the use of `Kernel#eval` and `Binding#eval`.
       #
       # @example
       #

data/lib/rubocop/cop/security/json_load.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Security
-      # This cop checks for the use of JSON class methods which have potential
+      # Checks for the use of JSON class methods which have potential
       # security issues.
       #
       # @safety

data/lib/rubocop/cop/security/marshal_load.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Security
-      # This cop checks for the use of Marshal class methods which have
+      # Checks for the use of Marshal class methods which have
       # potential security issues leading to remote code execution when
       # loading from an untrusted source.
       #

data/lib/rubocop/cop/security/open.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Security
-      # This cop checks for the use of `Kernel#open` and `URI.open` with dynamic
+      # Checks for the use of `Kernel#open` and `URI.open` with dynamic
       # data.
       #
       # `Kernel#open` and `URI.open` enable not only file access but also process

data/lib/rubocop/cop/security/yaml_load.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Security
-      # This cop checks for the use of YAML class methods which have
+      # Checks for the use of YAML class methods which have
       # potential security issues leading to remote code execution when
       # loading from an untrusted source.
       #

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

@@ -9,6 +9,11 @@ module RuboCop
       # Applications of visibility methods to symbols can be controlled
       # using AllowModifiersOnSymbols config.
       #
+      # @safety
+      #   Autocorrection is not safe, because the visibility of dynamically
+      #   defined methods can vary depending on the state determined by
+      #   the group access modifier.
+      #
       # @example EnforcedStyle: group (default)
       #   # bad
       #   class Foo
@@ -63,7 +68,10 @@ module RuboCop
       #
       #   end
       class AccessModifierDeclarations < Base
+        extend AutoCorrector
+
         include ConfigurableEnforcedStyle
+        include RangeHelp
 
         GROUP_STYLE_MESSAGE = [
           '`%<access_modifier>s` should not be',
@@ -77,6 +85,8 @@ module RuboCop
 
         RESTRICT_ON_SEND = %i[private protected public module_function].freeze
 
+        ALLOWED_NODE_TYPES = %i[pair block].freeze
+
         # @!method access_modifier_with_symbol?(node)
         def_node_matcher :access_modifier_with_symbol?, <<~PATTERN
           (send nil? {:private :protected :public :module_function} (sym _))
@@ -84,11 +94,14 @@ module RuboCop
 
         def on_send(node)
           return unless node.access_modifier?
-          return if node.parent&.pair_type?
+          return if ALLOWED_NODE_TYPES.include?(node.parent&.type)
           return if allow_modifiers_on_symbols?(node)
 
           if offense?(node)
-            add_offense(node.loc.selector) { opposite_style_detected }
+            add_offense(node.loc.selector) do |corrector|
+              autocorrect(corrector, node)
+            end
+            opposite_style_detected
           else
             correct_style_detected
           end
@@ -96,12 +109,28 @@ module RuboCop
 
         private
 
+        def autocorrect(corrector, node)
+          case style
+          when :group
+            def_node = find_corresponding_def_node(node)
+            return unless def_node
+
+            replace_def(corrector, node, def_node)
+          when :inline
+            remove_node(corrector, node)
+            select_grouped_def_nodes(node).each do |grouped_def_node|
+              insert_inline_modifier(corrector, grouped_def_node, node.method_name)
+            end
+          end
+        end
+
         def allow_modifiers_on_symbols?(node)
           cop_config['AllowModifiersOnSymbols'] && access_modifier_with_symbol?(node)
         end
 
         def offense?(node)
-          (group_style? && access_modifier_is_inlined?(node)) ||
+          (group_style? && access_modifier_is_inlined?(node) &&
+            !right_siblings_same_inline_method?(node)) ||
             (inline_style? && access_modifier_is_not_inlined?(node))
         end
 
@@ -121,6 +150,12 @@ module RuboCop
           !access_modifier_is_inlined?(node)
         end
 
+        def right_siblings_same_inline_method?(node)
+          node.right_siblings.any? do |sibling|
+            sibling.send_type? && sibling.method?(node.method_name) && !sibling.arguments.empty?
+          end
+        end
+
         def message(range)
           access_modifier = range.source
 
@@ -130,6 +165,60 @@ module RuboCop
             format(INLINE_STYLE_MESSAGE, access_modifier: access_modifier)
           end
         end
+
+        def find_corresponding_def_node(node)
+          if access_modifier_with_symbol?(node)
+            method_name = node.arguments.first.value
+            node.parent.each_child_node(:def).find do |child|
+              child.method?(method_name)
+            end
+          else
+            node.arguments.first
+          end
+        end
+
+        def find_argument_less_modifier_node(node)
+          return unless (parent = node.parent)
+
+          parent.each_child_node(:send).find do |child|
+            child.method?(node.method_name) && child.arguments.empty?
+          end
+        end
+
+        def select_grouped_def_nodes(node)
+          node.right_siblings.take_while do |sibling|
+            !(sibling.send_type? && sibling.bare_access_modifier_declaration?)
+          end.select(&:def_type?)
+        end
+
+        def replace_def(corrector, node, def_node)
+          source = def_source(node, def_node)
+          argument_less_modifier_node = find_argument_less_modifier_node(node)
+          if argument_less_modifier_node
+            corrector.insert_after(argument_less_modifier_node, "\n\n#{source}")
+          elsif (ancestor = node.each_ancestor(:block, :class, :module).first)
+
+            corrector.insert_before(ancestor.loc.end, "#{node.method_name}\n\n#{source}\n")
+          else
+            corrector.replace(node, "#{node.method_name}\n\n#{source}")
+            return
+          end
+
+          remove_node(corrector, def_node)
+          remove_node(corrector, node)
+        end
+
+        def insert_inline_modifier(corrector, node, modifier_name)
+          corrector.insert_before(node, "#{modifier_name} ")
+        end
+
+        def remove_node(corrector, node)
+          corrector.remove(range_with_comments_and_lines(node))
+        end
+
+        def def_source(node, def_node)
+          [*processed_source.ast_with_comments[node].map(&:text), def_node.source].join("\n")
+        end
       end
     end
   end

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

@@ -3,23 +3,36 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for grouping of accessors in `class` and `module` bodies.
+      # Checks for grouping of accessors in `class` and `module` bodies.
       # By default it enforces accessors to be placed in grouped declarations,
       # but it can be configured to enforce separating them in multiple declarations.
       #
-      # NOTE: `Sorbet` is not compatible with "grouped" style. Consider "separated" style
-      # or disabling this cop.
+      # NOTE: If there is a method call before the accessor method it is always allowed
+      # as it might be intended like Sorbet.
       #
       # @example EnforcedStyle: grouped (default)
       #   # bad
       #   class Foo
       #     attr_reader :bar
+      #     attr_reader :bax
       #     attr_reader :baz
       #   end
       #
       #   # good
       #   class Foo
-      #     attr_reader :bar, :baz
+      #     attr_reader :bar, :bax, :baz
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     # may be intended comment for bar.
+      #     attr_reader :bar
+      #
+      #     sig { returns(String) }
+      #     attr_reader :bax
+      #
+      #     may_be_intended_annotation :baz
+      #     attr_reader :baz
       #   end
       #
       # @example EnforcedStyle: separated
@@ -43,11 +56,9 @@ module RuboCop
         GROUPED_MSG = 'Group together all `%<accessor>s` attributes.'
         SEPARATED_MSG = 'Use one attribute per `%<accessor>s`.'
 
-        ACCESSOR_METHODS = %i[attr_reader attr_writer attr_accessor attr].freeze
-
         def on_class(node)
           class_send_elements(node).each do |macro|
-            next unless accessor?(macro)
+            next unless macro.attribute_accessor?
 
             check(macro)
           end
@@ -58,7 +69,7 @@ module RuboCop
         private
 
         def check(send_node)
-          return if previous_line_comment?(send_node)
+          return if previous_line_comment?(send_node) || !groupable_accessor?(send_node)
           return unless (grouped_style? && sibling_accessors(send_node).size > 1) ||
                         (separated_style? && send_node.arguments.size > 1)
 
@@ -72,7 +83,7 @@ module RuboCop
           if (preferred_accessors = preferred_accessors(node))
             corrector.replace(node, preferred_accessors)
           else
-            range = range_with_surrounding_space(range: node.loc.expression, side: :left)
+            range = range_with_surrounding_space(node.source_range, side: :left)
             corrector.remove(range)
           end
         end
@@ -81,6 +92,21 @@ module RuboCop
           comment_line?(processed_source[node.first_line - 2])
         end
 
+        def groupable_accessor?(node)
+          return true unless (previous_expression = node.left_siblings.last)
+
+          # Accessors with Sorbet `sig { ... }` blocks shouldn't be groupable.
+          if previous_expression.block_type?
+            previous_expression.child_nodes.each do |child_node|
+              break previous_expression = child_node if child_node.send_type?
+            end
+          end
+
+          return true unless previous_expression.send_type?
+
+          previous_expression.attribute_accessor? || previous_expression.access_modifier?
+        end
+
         def class_send_elements(class_node)
           class_def = class_node.body
 
@@ -93,10 +119,6 @@ module RuboCop
           end
         end
 
-        def accessor?(send_node)
-          send_node.macro? && ACCESSOR_METHODS.include?(send_node.method_name)
-        end
-
         def grouped_style?
           style == :grouped
         end
@@ -107,7 +129,7 @@ module RuboCop
 
         def sibling_accessors(send_node)
           send_node.parent.each_child_node(:send).select do |sibling|
-            accessor?(sibling) &&
+            sibling.attribute_accessor? &&
               sibling.method?(send_node.method_name) &&
               node_visibility(sibling) == node_visibility(send_node) &&
               !previous_line_comment?(sibling)
@@ -122,25 +144,29 @@ module RuboCop
         def preferred_accessors(node)
           if grouped_style?
             accessors = sibling_accessors(node)
-            group_accessors(node, accessors) if node == accessors.first
+            group_accessors(node, accessors) if node.loc == accessors.first.loc
           else
             separate_accessors(node)
           end
         end
 
         def group_accessors(node, accessors)
-          accessor_names = accessors.flat_map { |accessor| accessor.arguments.map(&:source) }
+          accessor_names = accessors.flat_map { |accessor| accessor.arguments.map(&:source) }.uniq
 
           "#{node.method_name} #{accessor_names.join(', ')}"
         end
 
         def separate_accessors(node)
-          node.arguments.map do |arg|
-            if arg == node.arguments.first
+          node.arguments.flat_map do |arg|
+            lines = [
+              *processed_source.ast_with_comments[arg].map(&:text),
               "#{node.method_name} #{arg.source}"
+            ]
+            if arg == node.arguments.first
+              lines
             else
               indent = ' ' * node.loc.column
-              "#{indent}#{node.method_name} #{arg.source}"
+              lines.map { |line| "#{indent}#{line}" }
             end
           end.join("\n")
         end

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

@@ -3,10 +3,15 @@
 module RuboCop
   module Cop
     module Style
-      # This cop enforces the use of either `#alias` or `#alias_method`
+      # Enforces the use of either `#alias` or `#alias_method`
       # depending on configuration.
       # It also flags uses of `alias :symbol` rather than `alias bareword`.
       #
+      # However, it will always enforce `method_alias` when used `alias`
+      # in an instance method definition and in a singleton method definition.
+      # If used in a block, always enforce `alias_method`
+      # unless it is an `instance_eval` block.
+      #
       # @example EnforcedStyle: prefer_alias (default)
       #   # bad
       #   alias_method :bar, :foo
@@ -22,6 +27,7 @@ module RuboCop
       #
       #   # good
       #   alias_method :bar, :foo
+      #
       class Alias < Base
         include ConfigurableEnforcedStyle
         extend AutoCorrector
@@ -71,7 +77,9 @@ module RuboCop
         end
 
         def alias_method_possible?(node)
-          scope_type(node) != :instance_eval && node.children.none?(&:gvar_type?)
+          scope_type(node) != :instance_eval &&
+            node.children.none?(&:gvar_type?) &&
+            node&.parent&.type != :def
         end
 
         def add_offense_for_args(node, &block)

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

@@ -3,19 +3,16 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for uses of `and` and `or`, and suggests using `&&` and
+      # Checks for uses of `and` and `or`, and suggests using `&&` and
       # `||` instead. It can be configured to check only in conditions or in
       # all contexts.
       #
       # @safety
-      #   Auto-correction is unsafe because there is a different operator precedence
+      #   Autocorrection is unsafe because there is a different operator precedence
       #   between logical operators (`&&` and `||`) and semantic operators (`and` and `or`),
       #   and that might change the behavior.
       #
-      # @example EnforcedStyle: always
-      #   # bad
-      #   foo.save and return
-      #
+      # @example EnforcedStyle: conditionals (default)
       #   # bad
       #   if foo and bar
       #   end
@@ -24,10 +21,16 @@ module RuboCop
       #   foo.save && return
       #
       #   # good
+      #   foo.save and return
+      #
+      #   # good
       #   if foo && bar
       #   end
       #
-      # @example EnforcedStyle: conditionals (default)
+      # @example EnforcedStyle: always
+      #   # bad
+      #   foo.save and return
+      #
       #   # bad
       #   if foo and bar
       #   end
@@ -36,9 +39,6 @@ module RuboCop
       #   foo.save && return
       #
       #   # good
-      #   foo.save and return
-      #
-      #   # good
       #   if foo && bar
       #   end
       class AndOr < Base
@@ -111,7 +111,7 @@ module RuboCop
         end
 
         # ! is a special case:
-        # 'x and !obj.method arg' can be auto-corrected if we
+        # 'x and !obj.method arg' can be autocorrected if we
         # recurse down a level and add parens to 'obj.method arg'
         # however, 'not x' also parses as (send x :!)
         def correct_not(node, receiver, corrector)