rubocop 1.80.2 → 1.86.1

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

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for manual counting patterns that can be replaced by `Enumerable#tally`.
+      #
+      # The cop detects the following patterns:
+      #
+      # - `each_with_object(Hash.new(0)) { |item, counts| counts[item] += 1 }`
+      # - `group_by(&:itself).transform_values(&:count)`
+      # - `group_by { |x| x }.transform_values(&:size)`
+      # - `group_by { |x| x }.transform_values { |v| v.length }`
+      #
+      # @safety
+      #   This cop is unsafe because it cannot guarantee that the receiver
+      #   is an `Enumerable` by static analysis, so the correction may
+      #   not be actually equivalent.
+      #
+      # @example
+      #   # bad
+      #   array.each_with_object(Hash.new(0)) { |item, counts| counts[item] += 1 }
+      #
+      #   # bad
+      #   array.group_by(&:itself).transform_values(&:count)
+      #
+      #   # bad
+      #   array.group_by { |item| item }.transform_values(&:size)
+      #
+      #   # bad
+      #   array.group_by { |item| item }.transform_values { |v| v.length }
+      #
+      #   # good
+      #   array.tally
+      #
+      class TallyMethod < Base
+        extend AutoCorrector
+        extend TargetRubyVersion
+        include RangeHelp
+
+        minimum_target_ruby_version 2.7
+
+        MSG_EACH_WITH_OBJECT = 'Use `tally` instead of `each_with_object`.'
+        MSG_GROUP_BY = 'Use `tally` instead of `group_by` and `transform_values`.'
+        RESTRICT_ON_SEND = %i[each_with_object transform_values].freeze
+        COUNTING_METHODS = %i[count size length].to_set.freeze
+
+        # Pattern 1: collection.each_with_object(Hash.new(0)) { |elem, hash| hash[elem] += 1 }
+        # @!method tally_each_with_object?(node)
+        def_node_matcher :tally_each_with_object?, <<~PATTERN
+          {
+            (block
+              (call _ :each_with_object
+                (send (const {nil? cbase} :Hash) :new (int 0)))
+              (args (arg _elem) (arg _hash))
+              (op_asgn
+                (send (lvar _hash) :[] (lvar _elem)) :+ (int 1)))
+            (numblock
+              (call _ :each_with_object
+                (send (const {nil? cbase} :Hash) :new (int 0)))
+              2
+              (op_asgn
+                (send (lvar :_2) :[] (lvar :_1)) :+ (int 1)))
+          }
+        PATTERN
+
+        # Pattern 2: collection.group_by(&:itself).transform_values(&:count/size/length)
+        # @!method tally_group_by_symbol?(node)
+        def_node_matcher :tally_group_by_symbol?, <<~PATTERN
+          (call
+            (call _ :group_by (block_pass (sym :itself)))
+            :transform_values
+            (block_pass (sym %COUNTING_METHODS)))
+        PATTERN
+
+        # Pattern 3: collection.group_by { |x| x }.transform_values(&:count/size/length)
+        # @!method tally_group_by_identity_block?(node)
+        def_node_matcher :tally_group_by_identity_block?, <<~PATTERN
+          (call
+            {
+              (block (call _ :group_by) (args (arg _x)) (lvar _x))
+              (numblock (call _ :group_by) 1 (lvar :_1))
+              (itblock (call _ :group_by) :it (lvar :it))
+            }
+            :transform_values
+            (block_pass (sym %COUNTING_METHODS)))
+        PATTERN
+
+        # Pattern 4: collection.group_by(&:itself).transform_values { |v| v.count/size/length }
+        #            collection.group_by { |x| x }.transform_values { |v| v.count/size/length }
+        # @!method tally_group_by_transform_block?(node)
+        def_node_matcher :tally_group_by_transform_block?, <<~PATTERN
+          {
+            (block
+              (call
+                {
+                  (call _ :group_by (block_pass (sym :itself)))
+                  (block (call _ :group_by) (args (arg _x)) (lvar _x))
+                  (numblock (call _ :group_by) 1 (lvar :_1))
+                  (itblock (call _ :group_by) :it (lvar :it))
+                }
+                :transform_values)
+              (args (arg _v))
+              (send (lvar _v) %COUNTING_METHODS))
+            (numblock
+              (call
+                {
+                  (call _ :group_by (block_pass (sym :itself)))
+                  (block (call _ :group_by) (args (arg _x)) (lvar _x))
+                  (numblock (call _ :group_by) 1 (lvar :_1))
+                  (itblock (call _ :group_by) :it (lvar :it))
+                }
+                :transform_values)
+              1
+              (send (lvar :_1) %COUNTING_METHODS))
+            (itblock
+              (call
+                {
+                  (call _ :group_by (block_pass (sym :itself)))
+                  (block (call _ :group_by) (args (arg _x)) (lvar _x))
+                  (numblock (call _ :group_by) 1 (lvar :_1))
+                  (itblock (call _ :group_by) :it (lvar :it))
+                }
+                :transform_values)
+              :it
+              (send (lvar :it) %COUNTING_METHODS))
+          }
+        PATTERN
+        def on_send(node)
+          if node.method?(:each_with_object)
+            check_each_with_object(node)
+          elsif node.method?(:transform_values)
+            check_transform_values(node)
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        def check_each_with_object(node)
+          block_node = node.block_node
+          return unless block_node
+          return unless tally_each_with_object?(block_node)
+
+          add_offense(node.loc.selector, message: MSG_EACH_WITH_OBJECT) do |corrector|
+            corrector.replace(replacement_range(node, block_node), 'tally')
+          end
+        end
+
+        def check_transform_values(node)
+          if tally_group_by_symbol?(node) || tally_group_by_identity_block?(node)
+            register_group_by_offense(node, node)
+          elsif (block_node = node.block_node) && tally_group_by_transform_block?(block_node)
+            register_group_by_offense(node, block_node)
+          end
+        end
+
+        def register_group_by_offense(transform_node, end_node)
+          group_by_node = group_by_send_node(transform_node)
+
+          add_offense(group_by_node.loc.selector, message: MSG_GROUP_BY) do |corrector|
+            corrector.replace(replacement_range(group_by_node, end_node), 'tally')
+          end
+        end
+
+        def group_by_send_node(transform_node)
+          receiver = transform_node.receiver
+          if receiver.type?(:any_block)
+            receiver.send_node
+          else
+            receiver
+          end
+        end
+
+        def replacement_range(start_node, end_node)
+          range_between(start_node.loc.selector.begin_pos, end_node.source_range.end_pos)
+        end
+      end
+    end
+  end
+end

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

@@ -10,6 +10,9 @@ module RuboCop
       # for all parenthesized multi-line method calls with arguments.
       # * `comma`: Requires a comma after the last argument, but only for
       # parenthesized method calls where each argument is on its own line.
+      # * `diff_comma`: Requires a comma after the last argument, but only
+      # when that argument is followed by an immediate newline, even if
+      # there is an inline comment on the same line.
       # * `no_comma`: Requires that there is no comma after the last
       # argument.
       #
@@ -75,6 +78,48 @@ module RuboCop
       #     2,
       #   )
       #
+      # @example EnforcedStyleForMultiline: diff_comma
+      #   # bad
+      #   method(1, 2,)
+      #
+      #   # good
+      #   method(1, 2)
+      #
+      #   # good
+      #   method(
+      #     1, 2,
+      #     3,
+      #   )
+      #
+      #   # good
+      #   method(
+      #     1, 2, 3,
+      #   )
+      #
+      #   # good
+      #   method(
+      #     1,
+      #     2,
+      #   )
+      #
+      #   # bad
+      #   method(1, [
+      #     2,
+      #   ],)
+      #
+      #   # good
+      #   method(1, [
+      #     2,
+      #   ])
+      #
+      #   # bad
+      #   object[1, 2,
+      #          3, 4,]
+      #
+      #   # good
+      #   object[1, 2,
+      #          3, 4]
+      #
       # @example EnforcedStyleForMultiline: no_comma (default)
       #   # bad
       #   method(1, 2,)

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

@@ -64,7 +64,7 @@ module RuboCop
 
         MSG = 'Useless trailing comma present in block arguments.'
 
-        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler
           # lambda literal (`->`) never has block arguments.
           return if node.send_node.lambda_literal?
           return unless useless_trailing_comma?(node)

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

@@ -45,6 +45,7 @@ module RuboCop
             corrector.insert_before(node.loc.end, "\n#{' ' * node.loc.keyword.column}")
           end
         end
+        alias on_defs on_def
 
         private
 

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

@@ -7,26 +7,26 @@ module RuboCop
       #
       # @example
       #   # bad
-      #   a, b, _ = foo()
-      #   a, b, _, = foo()
-      #   a, _, _ = foo()
-      #   a, _, _, = foo()
+      #   a, b, _ = foo
+      #   a, b, _, = foo
+      #   a, _, _ = foo
+      #   a, _, _, = foo
       #
       #   # good
-      #   a, b, = foo()
-      #   a, = foo()
-      #   *a, b, _ = foo()
+      #   a, b, = foo
+      #   a, = foo
+      #   *a, b, _ = foo
       #   # => We need to know to not include 2 variables in a
-      #   a, *b, _ = foo()
-      #   # => The correction `a, *b, = foo()` is a syntax error
+      #   a, *b, _ = foo
+      #   # => The correction `a, *b, = foo` is a syntax error
       #
       # @example AllowNamedUnderscoreVariables: true (default)
       #   # good
-      #   a, b, _something = foo()
+      #   a, b, _something = foo
       #
       # @example AllowNamedUnderscoreVariables: false
       #   # bad
-      #   a, b, _something = foo()
+      #   a, b, _something = foo
       #
       class TrailingUnderscoreVariable < Base
         include SurroundingSpace

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

@@ -20,7 +20,6 @@ module RuboCop
       #     # do a different thing...
       #   end
       class UnlessElse < Base
-        include RangeHelp
         extend AutoCorrector
 
         MSG = 'Do not use `unless` with `else`. Rewrite these with the positive case first.'
@@ -29,25 +28,27 @@ module RuboCop
           return unless node.unless? && node.else?
 
           add_offense(node) do |corrector|
-            body_range = range_between_condition_and_else(node, node.condition)
-            else_range = range_between_else_and_end(node)
-
             next if part_of_ignored_node?(node)
 
             corrector.replace(node.loc.keyword, 'if')
-            corrector.replace(body_range, else_range.source)
-            corrector.replace(else_range, body_range.source)
+
+            body_range = range_between_condition_and_else(node)
+            else_range = range_between_else_and_end(node)
+
+            corrector.swap(body_range, else_range)
           end
 
           ignore_node(node)
         end
 
-        def range_between_condition_and_else(node, condition)
-          range_between(condition.source_range.end_pos, node.loc.else.begin_pos)
+        def range_between_condition_and_else(node)
+          range = node.loc.begin ? node.loc.begin.end : node.condition.source_range
+
+          range.end.join(node.loc.else.begin)
         end
 
         def range_between_else_and_end(node)
-          range_between(node.loc.else.end_pos, node.loc.end.begin_pos)
+          node.loc.else.end.join(node.loc.end.begin)
         end
       end
     end

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

@@ -76,7 +76,7 @@ module RuboCop
         end
 
         def supported_operators
-          Array(cop_config['SupportedOperators'])
+          @supported_operators ||= Array(cop_config['SupportedOperators']).freeze
         end
 
         def offended_ancestor?(node)

data/lib/rubocop/cop/team.rb

@@ -177,8 +177,8 @@ module RuboCop
       # @return [Array<cop>]
       def roundup_relevant_cops(processed_source)
         cops.select do |cop|
-          next true if processed_source.comment_config.cop_opted_in?(cop)
           next false if cop.excluded_file?(processed_source.file_path)
+          next true if processed_source.comment_config.cop_opted_in?(cop)
           next false unless @registry.enabled?(cop, @config)
 
           support_target_ruby_version?(cop) && support_target_rails_version?(cop)
@@ -211,10 +211,10 @@ module RuboCop
 
         each_corrector(report) do |to_merge|
           suppress_clobbering do
-            if offset.positive?
-              corrector.import!(to_merge, offset: offset)
-            else
+            if corrector.source_buffer == to_merge.source_buffer
               corrector.merge!(to_merge)
+            else
+              corrector.import!(to_merge, offset: offset)
             end
           end
         end

data/lib/rubocop/cop/util.rb

@@ -117,10 +117,9 @@ module RuboCop
       # with calls chained to the end of it.
       def first_part_of_call_chain(node)
         while node
-          case node.type
-          when :send
+          if node.call_type?
             node = node.receiver
-          when :block
+          elsif node.any_block_type?
             node = node.send_node
           else
             break

data/lib/rubocop/cop/utils/format_string.rb

@@ -71,6 +71,16 @@ module RuboCop
             name && @source.include?('{')
           end
 
+          def variable_width?
+            !!width&.start_with?('*')
+          end
+
+          def variable_width_argument_number
+            return unless variable_width?
+
+            width == '*' ? 1 : width.match(DIGIT_DOLLAR)['arg_number'].to_i
+          end
+
           # Number of arguments required for the format sequence
           def arity
             @source.scan('*').count + 1

data/lib/rubocop/cop/variable_force/branch.rb

@@ -254,8 +254,8 @@ module RuboCop
           end
         end
 
-        # Mix-in module for logical operator control structures.
-        module LogicalOperator
+        # Mix-in module for operator control structures.
+        module Operator
           def always_run?
             left_body?
           end
@@ -263,7 +263,15 @@ module RuboCop
 
         # left_body && right_body
         class And < Base
-          include LogicalOperator
+          include Operator
+
+          define_predicate :left_body?,  child_index: 0
+          define_predicate :right_body?, child_index: 1
+        end
+
+        # left_body &&= right_body
+        class AndAsgn < Base
+          include Operator
 
           define_predicate :left_body?,  child_index: 0
           define_predicate :right_body?, child_index: 1
@@ -271,7 +279,23 @@ module RuboCop
 
         # left_body || right_body
         class Or < Base
-          include LogicalOperator
+          include Operator
+
+          define_predicate :left_body?,  child_index: 0
+          define_predicate :right_body?, child_index: 1
+        end
+
+        # left_body ||= right_body
+        class OrAsgn < Base
+          include Operator
+
+          define_predicate :left_body?,  child_index: 0
+          define_predicate :right_body?, child_index: 1
+        end
+
+        # e.g. left_body += right_body
+        class OpAsgn < Base
+          include Operator
 
           define_predicate :left_body?,  child_index: 0
           define_predicate :right_body?, child_index: 1
@@ -322,8 +346,8 @@ module RuboCop
           end
         end
 
-        CLASSES_BY_TYPE = Base.classes.each_with_object({}) do |klass, classes|
-          classes[klass.type] = klass
+        CLASSES_BY_TYPE = Base.classes.to_h do |klass|
+          [klass.type, klass]
         end
       end
     end

data/lib/rubocop/cops_documentation_generator.rb

@@ -194,10 +194,10 @@ class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
 
   def configurations(department, cop, cop_config)
     header = ['Name', 'Default value', 'Configurable values']
-    configs = cop_config
-              .each_key
-              .reject { |key| key.start_with?('Supported') }
-              .reject { |key| key.start_with?('AllowMultipleStyles') }
+    configs = cop_config.each_key.reject do |key|
+      key == 'AllowMultipleStyles' ||
+        (key != 'SupportedTypes' && key.start_with?('Supported'))
+    end
     return '' if configs.empty?
 
     content = configs.map do |name|

data/lib/rubocop/directive_comment.rb

@@ -14,11 +14,17 @@ module RuboCop
     # @api private
     COP_NAME_PATTERN = '([A-Za-z]\w+/)*(?:[A-Za-z]\w+)'
     # @api private
+    COP_NAME_PATTERN_NC = '(?:[A-Za-z]\w+/)*[A-Za-z]\w+'
+    # @api private
+    COP_NAMES_PATTERN_NC = "(?:#{COP_NAME_PATTERN_NC} , )*#{COP_NAME_PATTERN_NC}"
+    # @api private
     COP_NAMES_PATTERN = "(?:#{COP_NAME_PATTERN} , )*#{COP_NAME_PATTERN}"
     # @api private
     COPS_PATTERN = "(all|#{COP_NAMES_PATTERN})"
     # @api private
-    AVAILABLE_MODES = %w[disable enable todo].freeze
+    PUSH_POP_ARGS_PATTERN = "([+\\-]#{COP_NAME_PATTERN_NC}(?:\\s+[+\\-]#{COP_NAME_PATTERN_NC})*)"
+    # @api private
+    AVAILABLE_MODES = %w[disable enable todo push pop].freeze
     # @api private
     DIRECTIVE_MARKER_PATTERN = '# rubocop : '
     # @api private
@@ -27,7 +33,7 @@ module RuboCop
     DIRECTIVE_HEADER_PATTERN = "#{DIRECTIVE_MARKER_PATTERN}((?:#{AVAILABLE_MODES.join('|')}))\\b"
     # @api private
     DIRECTIVE_COMMENT_REGEXP = Regexp.new(
-      "#{DIRECTIVE_HEADER_PATTERN} #{COPS_PATTERN}"
+      "#{DIRECTIVE_HEADER_PATTERN}(?:\\s+#{COPS_PATTERN}|\\s+#{PUSH_POP_ARGS_PATTERN})?"
         .gsub(' ', '\s*')
     )
     # @api private
@@ -46,7 +52,8 @@ module RuboCop
     def initialize(comment, cop_registry = Cop::Registry.global)
       @comment = comment
       @cop_registry = cop_registry
-      @match_data = comment.text.match(DIRECTIVE_COMMENT_REGEXP)
+      match_data = comment.text.match(DIRECTIVE_COMMENT_REGEXP)
+      @match_data = match_data&.pre_match&.match?(/\A#\s*\z/) ? nil : match_data
       @mode, @cops = match_captures
     end
 
@@ -58,6 +65,7 @@ module RuboCop
     # Checks if the comment is malformed as a `# rubocop:` directive
     def malformed?
       return true if !start_with_marker? || @match_data.nil?
+      return true if missing_cop_name?
 
       tail = @match_data.post_match.lstrip
       !(tail.empty? || tail.start_with?(TRAILING_COMMENT_MARKER))
@@ -65,6 +73,8 @@ module RuboCop
 
     # Checks if the directive comment is missing a cop name
     def missing_cop_name?
+      return false if push? || pop?
+
       MALFORMED_DIRECTIVE_WITHOUT_COP_NAME_REGEXP.match?(comment.text)
     end
 
@@ -88,7 +98,13 @@ module RuboCop
 
     # Returns match captures to directive comment pattern
     def match_captures
-      @match_captures ||= @match_data&.captures
+      @match_captures ||= @match_data && begin
+        captures = @match_data.captures
+        mode = captures[0]
+        # COPS_PATTERN is at captures[1], PUSH_POP_ARGS_PATTERN is at captures[4]
+        cops = captures[1] || captures[4]
+        [mode, cops]
+      end
     end
 
     # Checks if this directive disables cops
@@ -101,6 +117,21 @@ module RuboCop
       mode == 'enable'
     end
 
+    # Checks if this directive is a push
+    def push?
+      mode == 'push'
+    end
+
+    # Checks if this directive is a pop
+    def pop?
+      mode == 'pop'
+    end
+
+    # Returns the push arguments as a hash of cop names with their operations
+    def push_args
+      @push_args ||= parse_push_args
+    end
+
     # Checks if this directive enables all cops
     def enabled_all?
       !disabled? && all_cops?
@@ -176,5 +207,18 @@ module RuboCop
     def exclude_lint_department_cops(cops)
       cops - [LINT_REDUNDANT_DIRECTIVE_COP, LINT_SYNTAX_COP]
     end
+
+    def parse_push_args
+      return {} unless push? && cops
+
+      args = {}
+      cops.split.each do |cop_spec|
+        op = cop_spec[0]
+        cop_name = cop_spec[1..]
+        args[op] ||= []
+        args[op] << cop_name
+      end
+      args
+    end
   end
 end

data/lib/rubocop/formatter/clang_style_formatter.rb

@@ -47,8 +47,11 @@ module RuboCop
       def report_highlighted_area(highlighted_area)
         space_area  = highlighted_area.source_buffer.slice(0...highlighted_area.begin_pos)
         source_area = highlighted_area.source
-        output.puts("#{' ' * Unicode::DisplayWidth.of(space_area)}" \
-                    "#{'^' * Unicode::DisplayWidth.of(source_area)}")
+        output.puts("#{to_whitespace(space_area)}#{'^' * Unicode::DisplayWidth.of(source_area)}")
+      end
+
+      def to_whitespace(string)
+        "#{string.delete("^\t")}#{' ' * Unicode::DisplayWidth.of(string.delete("\t"))}"
       end
     end
   end

data/lib/rubocop/formatter/disabled_config_formatter.rb

@@ -27,6 +27,7 @@ module RuboCop
         References
         Safe
         SafeAutoCorrect
+        Severity
         StyleGuide
         VersionAdded
         VersionChanged
@@ -232,7 +233,7 @@ module RuboCop
 
       def output_exclude_list(output_buffer, offending_files, cop_name)
         require 'pathname'
-        parent = Pathname.new(Dir.pwd)
+        parent = Pathname.new(PathUtil.pwd)
 
         output_buffer.puts '  Exclude:'
         excludes(offending_files, cop_name, parent).each do |exclude_path|

data/lib/rubocop/formatter/formatter_set.rb

@@ -57,7 +57,7 @@ module RuboCop
         if output_path
           dir_path = File.dirname(output_path)
           FileUtils.mkdir_p(dir_path)
-          output = File.open(output_path, 'w')
+          output = File.open(output_path, 'w') # rubocop:disable Style/FileOpen
         else
           output = $stdout
         end
@@ -86,7 +86,7 @@ module RuboCop
 
       def builtin_formatter_class(specified_key)
         matching_keys = BUILTIN_FORMATTERS_FOR_KEYS.keys.select do |key|
-          /^\[#{specified_key}\]/.match?(key) || specified_key == key.delete('[]')
+          key.start_with?("[#{specified_key}]") || specified_key == key.delete('[]')
         end
 
         if matching_keys.empty?

data/lib/rubocop/formatter/junit_formatter.rb

@@ -93,7 +93,7 @@ module RuboCop
 
       def classname_attribute_value(file)
         @classname_attribute_value_cache ||= Hash.new do |hash, key|
-          hash[key] = key.delete_suffix('.rb').gsub("#{Dir.pwd}/", '').tr('/', '.')
+          hash[key] = key.delete_suffix('.rb').gsub("#{PathUtil.pwd}/", '').tr('/', '.')
         end
         @classname_attribute_value_cache[file]
       end

data/lib/rubocop/formatter/simple_text_formatter.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative 'colorizable'
-
 module RuboCop
   module Formatter
     # A basic formatter that displays only files with offenses.

data/lib/rubocop/formatter/tap_formatter.rb

@@ -39,8 +39,11 @@ module RuboCop
       def report_highlighted_area(highlighted_area)
         space_area  = highlighted_area.source_buffer.slice(0...highlighted_area.begin_pos)
         source_area = highlighted_area.source
-        output.puts("# #{' ' * Unicode::DisplayWidth.of(space_area)}" \
-                    "#{'^' * Unicode::DisplayWidth.of(source_area)}")
+        output.puts("# #{to_whitespace(space_area)}#{'^' * Unicode::DisplayWidth.of(source_area)}")
+      end
+
+      def to_whitespace(string)
+        "#{string.delete("^\t")}#{' ' * Unicode::DisplayWidth.of(string.delete("\t"))}"
       end
 
       def report_offense(file, offense)