rubocop 0.85.0 → 0.88.0

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

@@ -18,7 +18,7 @@ module RuboCop
               'name its argument `other`.'
 
         OP_LIKE_METHODS = %i[eql? equal?].freeze
-        BLACKLISTED = %i[+@ -@ [] []= << === `].freeze
+        EXCLUDED = %i[+@ -@ [] []= << === `].freeze
 
         def_node_matcher :op_method_candidate?, <<~PATTERN
           (def [#op_method? $_] (args $(arg [!:other !:_other])) _)
@@ -33,9 +33,9 @@ module RuboCop
         private
 
         def op_method?(name)
-          return false if BLACKLISTED.include?(name)
+          return false if EXCLUDED.include?(name)
 
-          name !~ /\A\w/ || OP_LIKE_METHODS.include?(name)
+          !/\A\w/.match?(name) || OP_LIKE_METHODS.include?(name)
         end
       end
     end

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

@@ -123,10 +123,9 @@ module RuboCop
           # special handling for Action Pack Variants file names like
           # some_file.xlsx+mobile.axlsx
           basename = basename.sub('+', '_')
-          basename =~ (regex || SNAKE_CASE)
+          basename.match?(regex || SNAKE_CASE)
         end
 
-        # rubocop:disable Metrics/CyclomaticComplexity
         def find_class_or_module(node, namespace)
           return nil unless node
 
@@ -145,7 +144,6 @@ module RuboCop
 
           nil
         end
-        # rubocop:enable Metrics/CyclomaticComplexity
 
         def match_namespace(node, namespace, expected)
           match_partial = partial_matcher!(expected)

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

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

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

@@ -28,7 +28,7 @@ module RuboCop
       #
       #   # good
       #   def fooBar; end
-      class MethodName < Cop
+      class MethodName < Base
         include ConfigurableNaming
         include IgnoredPattern
         include RangeHelp

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

@@ -49,7 +49,7 @@ module RuboCop
         def on_def(node)
           return unless node.arguments?
 
-          check(node, node.arguments.reject(&:forward_args_type?))
+          check(node, node.arguments)
         end
         alias on_defs on_def
       end

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

@@ -28,6 +28,8 @@ module RuboCop
       #   def value?
       #   end
       class PredicateName < Cop
+        include AllowedMethods
+
         def_node_matcher :dynamic_method_define, <<~PATTERN
           (send nil? #method_definition_macros
             (sym $_)
@@ -70,7 +72,7 @@ module RuboCop
           !method_name.match?(/^#{prefix}[^0-9]/) ||
             method_name == expected_name(method_name, prefix) ||
             method_name.end_with?('=') ||
-            allowed_methods.include?(method_name)
+            allowed_method?(method_name)
         end
 
         def expected_name(method_name, prefix)
@@ -95,10 +97,6 @@ module RuboCop
           cop_config['NamePrefix']
         end
 
-        def allowed_methods
-          cop_config['AllowedMethods']
-        end
-
         def method_definition_macros(macro_name)
           cop_config['MethodDefinitionMacros'].include?(macro_name.to_s)
         end

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

@@ -19,7 +19,7 @@ module RuboCop
       #
       #   # good
       #   fooBar = 1
-      class VariableName < Cop
+      class VariableName < Base
         include ConfigurableNaming
 
         MSG = 'Use %<style>s for variable names.'

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

@@ -37,7 +37,7 @@ module RuboCop
       #   variableone = 1
       #
       #   variable_one = 1
-      class VariableNumber < Cop
+      class VariableNumber < Base
         include ConfigurableNumbering
 
         MSG = 'Use %<style>s for variable numbers.'

data/lib/rubocop/cop/offense.rb

@@ -54,14 +54,28 @@ module RuboCop
       # @api private
       attr_reader :status
 
+      # @api public
+      #
+      # @!attribute [r] corrector
+      #
+      # @return [Corrector | nil]
+      #   the autocorrection for this offense, or `nil` when not available
+      attr_reader :corrector
+
+      PseudoSourceRange = Struct.new(:line, :column, :source_line, :begin_pos,
+                                     :end_pos)
+
+      NO_LOCATION = PseudoSourceRange.new(1, 0, '', 0, 1).freeze
+
       # @api private
-      def initialize(severity, location, message, cop_name,
-                     status = :uncorrected)
+      def initialize(severity, location, message, cop_name, # rubocop:disable Metrics/ParameterLists
+                     status = :uncorrected, corrector = nil)
         @severity = RuboCop::Cop::Severity.new(severity)
         @location = location
         @message = message.freeze
         @cop_name = cop_name.freeze
         @status = status
+        @corrector = corrector
         freeze
       end
 

data/lib/rubocop/cop/registry.rb

@@ -22,34 +22,42 @@ module RuboCop
 
     # Registry that tracks all cops by their badge and department.
     class Registry
+      include Enumerable
+
+      attr_reader :options
+
       def initialize(cops = [], options = {})
         @registry = {}
         @departments = {}
         @cops_by_cop_name = Hash.new { |hash, key| hash[key] = [] }
 
-        cops.each { |cop| enlist(cop) }
+        @enrollment_queue = cops
         @options = options
       end
 
       def enlist(cop)
-        @registry[cop.badge] = cop
-        @departments[cop.department] ||= []
-        @departments[cop.department] << cop
-        @cops_by_cop_name[cop.cop_name] << cop
+        @enrollment_queue << cop
+      end
+
+      def dismiss(cop)
+        raise "Cop #{cop} could not be dismissed" unless @enrollment_queue.delete(cop)
       end
 
       # @return [Array<Symbol>] list of departments for current cops.
       def departments
+        clear_enrollment_queue
         @departments.keys
       end
 
       # @return [Registry] Cops for that specific department.
       def with_department(department)
+        clear_enrollment_queue
         with(@departments.fetch(department, []))
       end
 
       # @return [Registry] Cops not for a specific department.
       def without_department(department)
+        clear_enrollment_queue
         without_department = @departments.dup
         without_department.delete(department)
 
@@ -119,6 +127,7 @@ module RuboCop
       end
 
       def unqualified_cop_names
+        clear_enrollment_queue
         @unqualified_cop_names ||=
           Set.new(@cops_by_cop_name.keys.map { |qn| File.basename(qn) }) <<
           'RedundantCopDisableDirective'
@@ -126,18 +135,21 @@ module RuboCop
 
       # @return [Hash{String => Array<Class>}]
       def to_h
+        clear_enrollment_queue
         @cops_by_cop_name
       end
 
       def cops
+        clear_enrollment_queue
         @registry.values
       end
 
       def length
+        clear_enrollment_queue
         @registry.size
       end
 
-      def enabled(config, only, only_safe = false)
+      def enabled(config, only = [], only_safe = false)
         select do |cop|
           only.include?(cop.cop_name) || enabled?(cop, config, only_safe)
         end
@@ -172,6 +184,7 @@ module RuboCop
       end
 
       def sort!
+        clear_enrollment_queue
         @registry = Hash[@registry.sort_by { |badge, _| badge.cop_name }]
 
         self
@@ -188,16 +201,57 @@ module RuboCop
       # @param [String] cop_name
       # @return [Class, nil]
       def find_by_cop_name(cop_name)
-        @cops_by_cop_name[cop_name].first
+        to_h[cop_name].first
+      end
+
+      @global = new
+
+      class << self
+        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
 
       private
 
+      def initialize_copy(reg)
+        initialize(reg.cops, reg.options)
+      end
+
+      def clear_enrollment_queue
+        return if @enrollment_queue.empty?
+
+        @enrollment_queue.each do |cop|
+          @registry[cop.badge] = cop
+          @departments[cop.department] ||= []
+          @departments[cop.department] << cop
+          @cops_by_cop_name[cop.cop_name] << cop
+        end
+        @enrollment_queue = []
+      end
+
       def with(cops)
         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) }
@@ -214,6 +268,7 @@ module RuboCop
       end
 
       def registered?(badge)
+        clear_enrollment_queue
         @registry.key?(badge)
       end
     end

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

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop 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.
+      #
+      # @example EnforcedStyle: grouped (default)
+      #   # bad
+      #   class Foo
+      #     attr_reader :bar
+      #     attr_reader :baz
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     attr_reader :bar, :baz
+      #   end
+      #
+      # @example EnforcedStyle: separated
+      #   # bad
+      #   class Foo
+      #     attr_reader :bar, :baz
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     attr_reader :bar
+      #     attr_reader :baz
+      #   end
+      #
+      class AccessorGrouping < Cop
+        include ConfigurableEnforcedStyle
+        include VisibilityHelp
+
+        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)
+
+            check(macro)
+          end
+        end
+        alias on_sclass on_class
+        alias on_module on_class
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node, correction(node))
+          end
+        end
+
+        private
+
+        def previous_line_comment?(node)
+          comment_line?(processed_source[node.first_line - 2])
+        end
+
+        def class_send_elements(class_node)
+          class_def = class_node.body
+
+          if !class_def || class_def.def_type?
+            []
+          elsif class_def.send_type?
+            [class_def]
+          else
+            class_def.each_child_node(:send).to_a
+          end
+        end
+
+        def accessor?(send_node)
+          send_node.macro? && ACCESSOR_METHODS.include?(send_node.method_name)
+        end
+
+        def check(send_node)
+          return if previous_line_comment?(send_node)
+
+          if grouped_style? && sibling_accessors(send_node).size > 1
+            add_offense(send_node)
+          elsif separated_style? && send_node.arguments.size > 1
+            add_offense(send_node)
+          end
+        end
+
+        def grouped_style?
+          style == :grouped
+        end
+
+        def separated_style?
+          style == :separated
+        end
+
+        def sibling_accessors(send_node)
+          send_node.parent.each_child_node(:send).select do |sibling|
+            accessor?(sibling) &&
+              sibling.method?(send_node.method_name) &&
+              node_visibility(sibling) == node_visibility(send_node) &&
+              !previous_line_comment?(sibling)
+          end
+        end
+
+        def message(send_node)
+          msg = grouped_style? ? GROUPED_MSG : SEPARATED_MSG
+          format(msg, accessor: send_node.method_name)
+        end
+
+        def correction(node)
+          if grouped_style?
+            accessors = sibling_accessors(node)
+            if node == accessors.first
+              group_accessors(node, accessors)
+            else
+              ''
+            end
+          else
+            separate_accessors(node)
+          end
+        end
+
+        def group_accessors(node, accessors)
+          accessor_names = accessors.flat_map do |accessor|
+            accessor.arguments.map(&:source)
+          end
+
+          "#{node.method_name} #{accessor_names.join(', ')}"
+        end
+
+        def separate_accessors(node)
+          node.arguments.map do |arg|
+            if arg == node.arguments.first
+              "#{node.method_name} #{arg.source}"
+            else
+              indent = ' ' * node.loc.column
+              "#{indent}#{node.method_name} #{arg.source}"
+            end
+          end.join("\n")
+        end
+      end
+    end
+  end
+end