rubocop 1.45.1 → 1.48.1

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

@@ -10,8 +10,8 @@ module RuboCop
       #
       #   Naming/MethodName:
       #     AllowedPatterns:
-      #       - '\A\s*onSelectionBulkChange\s*'
-      #       - '\A\s*onSelectionCleared\s*'
+      #       - '\AonSelectionBulkChange\z'
+      #       - '\AonSelectionCleared\z'
       #
       # Method names matching patterns are always allowed.
       #
@@ -67,7 +67,7 @@ module RuboCop
 
         def range_position(node)
           selector_end_pos = node.loc.selector.end_pos + 1
-          expr_end_pos = node.loc.expression.end_pos
+          expr_end_pos = node.source_range.end_pos
 
           range_between(selector_end_pos, expr_end_pos)
         end

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

@@ -72,7 +72,7 @@ module RuboCop
               next if allowed_method_name?(method_name.to_s, prefix)
 
               add_offense(
-                node.first_argument.loc.expression,
+                node.first_argument.source_range,
                 message: message(method_name, expected_name(method_name.to_s, prefix))
               )
             end

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

@@ -92,7 +92,7 @@ module RuboCop
 
         def offense_range(resbody)
           variable = resbody.exception_variable
-          variable.loc.expression
+          variable.source_range
         end
 
         def variable_name_matches?(node, name)

data/lib/rubocop/cop/registry.rb

@@ -197,7 +197,9 @@ module RuboCop
       def enabled?(cop, config)
         return true if options[:only]&.include?(cop.cop_name)
 
-        cfg = config.for_cop(cop)
+        # 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)
 

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

@@ -7,19 +7,32 @@ module RuboCop
       # 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,8 +69,8 @@ module RuboCop
         private
 
         def check(send_node)
-          return if previous_line_comment?(send_node)
-          return unless (grouped_style? && sibling_accessors(send_node).size > 1) ||
+          return if previous_line_comment?(send_node) || !groupable_accessor?(send_node)
+          return unless (grouped_style? && groupable_sibling_accessors(send_node).size > 1) ||
                         (separated_style? && send_node.arguments.size > 1)
 
           message = message(send_node)
@@ -72,7 +83,7 @@ module RuboCop
           if (preferred_accessors = preferred_accessors(node))
             corrector.replace(node, preferred_accessors)
           else
-            range = range_with_surrounding_space(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
@@ -105,12 +127,12 @@ module RuboCop
           style == :separated
         end
 
-        def sibling_accessors(send_node)
+        def groupable_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)
+              groupable_accessor?(sibling) && !previous_line_comment?(sibling)
           end
         end
 
@@ -121,7 +143,7 @@ module RuboCop
 
         def preferred_accessors(node)
           if grouped_style?
-            accessors = sibling_accessors(node)
+            accessors = groupable_sibling_accessors(node)
             group_accessors(node, accessors) if node.loc == accessors.first.loc
           else
             separate_accessors(node)

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

@@ -124,9 +124,9 @@ module RuboCop
 
         def register_offense_to_forwarding_method_arguments(forwarding_method)
           add_offense(arguments_range(forwarding_method)) do |corrector|
-            range = range_between(
-              forwarding_method.loc.selector.end_pos, forwarding_method.source_range.end_pos
-            )
+            begin_pos = forwarding_method.loc.selector&.end_pos || forwarding_method.loc.dot.end_pos
+            range = range_between(begin_pos, forwarding_method.source_range.end_pos)
+
             corrector.replace(range, '(...)')
           end
         end

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

@@ -12,7 +12,7 @@ module RuboCop
       # `(array1 & array2).any?` and is more readable.
       #
       # @safety
-      #   This cop cannot guarantee that array1 and array2 are
+      #   This cop cannot guarantee that `array1` and `array2` are
       #   actually arrays while method `intersect?` is for arrays only.
       #
       # @example

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

@@ -30,7 +30,7 @@ module RuboCop
         private
 
         def first_offense_range(comment)
-          expression    = comment.loc.expression
+          expression    = comment.source_range
           first_offense = first_non_ascii_chars(comment.text)
 
           start_position = expression.begin_pos + comment.text.index(first_offense)

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

@@ -55,7 +55,7 @@ module RuboCop
         def after_class(class_node)
           @macros_to_rewrite[class_node].each do |macro|
             node = macro.node
-            range = range_by_whole_lines(node.loc.expression, include_final_newline: true)
+            range = range_by_whole_lines(node.source_range, include_final_newline: true)
 
             correct(range) do |corrector|
               if macro.writer?

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

@@ -46,7 +46,7 @@ module RuboCop
         private
 
         def parts(comment)
-          expr = comment.loc.expression
+          expr = comment.source_range
           eq_begin = expr.resize(BEGIN_LENGTH)
           eq_end = eq_end_part(comment, expr)
           contents = range_between(eq_begin.end_pos, eq_end.begin_pos)

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

@@ -299,7 +299,7 @@ module RuboCop
 
         def move_comment_before_block(corrector, comment, block_node, closing_brace)
           range = block_node.chained? ? end_of_chain(block_node.parent).source_range : closing_brace
-          corrector.remove(range_with_surrounding_space(comment.loc.expression, side: :right))
+          corrector.remove(range_with_surrounding_space(comment.source_range, side: :right))
           remove_trailing_whitespace(corrector, range, comment)
           corrector.insert_after(range, "\n")
 
@@ -314,7 +314,7 @@ module RuboCop
         end
 
         def remove_trailing_whitespace(corrector, range, comment)
-          range_of_trailing = range.end.join(comment.loc.expression.begin)
+          range_of_trailing = range.end.join(comment.source_range.begin)
 
           corrector.remove(range_of_trailing) if range_of_trailing.source.match?(/\A\s+\z/)
         end
@@ -342,6 +342,7 @@ module RuboCop
         end
 
         def proper_block_style?(node)
+          return true if require_braces?(node)
           return special_method_proper_block_style?(node) if special_method?(node.method_name)
 
           case style
@@ -352,6 +353,14 @@ module RuboCop
           end
         end
 
+        def require_braces?(node)
+          return false unless node.braces?
+
+          node.each_ancestor(:send).any? do |send|
+            send.arithmetic_operation? && node.source_range.end_pos < send.loc.selector.begin_pos
+          end
+        end
+
         def special_method?(method_name)
           allowed_method?(method_name) ||
             matches_allowed_pattern?(method_name) ||

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

@@ -11,12 +11,14 @@ module RuboCop
       #   so if the original conditional used a different equality operator, the
       #   behavior may be different.
       #
-      # @example
+      # @example MinBranchesCount: 3 (default)
       #   # bad
       #   if status == :active
       #     perform_action
       #   elsif status == :inactive || status == :hibernating
       #     check_timeout
+      #   elsif status == :invalid
+      #     report_invalid
       #   else
       #     final_action
       #   end
@@ -27,12 +29,27 @@ module RuboCop
       #     perform_action
       #   when :inactive, :hibernating
       #     check_timeout
+      #   when :invalid
+      #     report_invalid
+      #   else
+      #     final_action
+      #   end
+      #
+      # @example MinBranchesCount: 4
+      #   # good
+      #   if status == :active
+      #     perform_action
+      #   elsif status == :inactive || status == :hibernating
+      #     check_timeout
+      #   elsif status == :invalid
+      #     report_invalid
       #   else
       #     final_action
       #   end
       #
       class CaseLikeIf < Base
         include RangeHelp
+        include MinBranchesCount
         extend AutoCorrector
 
         MSG = 'Convert `if-elsif` to `case-when`.'
@@ -78,7 +95,7 @@ module RuboCop
 
         def should_check?(node)
           !node.unless? && !node.elsif? && !node.modifier_form? && !node.ternary? &&
-            node.elsif_conditional?
+            node.elsif_conditional? && min_branches_count?(node)
         end
 
         # rubocop:disable Metrics/MethodLength
@@ -239,7 +256,7 @@ module RuboCop
         end
 
         def correction_range(node)
-          range_between(node.parent.loc.keyword.begin_pos, node.loc.expression.end_pos)
+          range_between(node.parent.loc.keyword.begin_pos, node.source_range.end_pos)
         end
 
         # Named captures work with `=~` (if regexp is on lhs) and with `match` (both sides)

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

@@ -112,7 +112,7 @@ module RuboCop
         end
 
         def range(begin_pos_node, end_pos_node)
-          range_between(begin_pos_node.loc.selector.begin_pos, end_pos_node.loc.expression.end_pos)
+          range_between(begin_pos_node.loc.selector.begin_pos, end_pos_node.source_range.end_pos)
         end
       end
     end

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

@@ -104,7 +104,7 @@ module RuboCop
         end
 
         def inline_comment?(comment)
-          !comment_line?(comment.loc.expression.source_line)
+          !comment_line?(comment.source_range.source_line)
         end
 
         def annotation_range(annotation)

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

@@ -66,7 +66,7 @@ module RuboCop
 
         def register_offense(comment, matched_keyword)
           add_offense(comment, message: format(MSG, keyword: matched_keyword)) do |corrector|
-            range = range_with_surrounding_space(comment.loc.expression, newlines: false)
+            range = range_with_surrounding_space(comment.source_range, newlines: false)
             corrector.remove(range)
 
             unless matched_keyword == 'end'
@@ -84,7 +84,7 @@ module RuboCop
         end
 
         def source_line(comment)
-          comment.location.expression.source_line
+          comment.source_range.source_line
         end
       end
     end

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

@@ -38,7 +38,7 @@ module RuboCop
           offense = offense_range(node)
           current = offense.source
 
-          if node.arguments.any?(&:percent_literal?)
+          if (use_percent_literal = node.arguments.any?(&:percent_literal?))
             if percent_literals_includes_only_basic_literals?(node)
               prefer = preferred_method(node)
               message = format(MSG, prefer: prefer, current: current)
@@ -51,7 +51,15 @@ module RuboCop
           end
 
           add_offense(offense, message: message) do |corrector|
-            corrector.replace(offense, prefer)
+            if use_percent_literal
+              corrector.replace(offense, prefer)
+            else
+              corrector.replace(node.loc.selector, 'push')
+              node.arguments.each do |argument|
+                corrector.remove(argument.loc.begin)
+                corrector.remove(argument.loc.end)
+              end
+            end
           end
         end
         # rubocop:enable Metrics

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

@@ -450,7 +450,7 @@ module RuboCop
         end
 
         def white_space_range(node, column)
-          expression = node.loc.expression
+          expression = node.source_range
           begin_pos = expression.begin_pos - (expression.column - column - 2)
 
           Parser::Source::Range.new(expression.source_buffer, begin_pos, expression.begin_pos)
@@ -458,9 +458,9 @@ module RuboCop
 
         def assignment(node)
           *_, condition = *node
-          Parser::Source::Range.new(node.loc.expression.source_buffer,
-                                    node.loc.expression.begin_pos,
-                                    condition.loc.expression.begin_pos)
+          Parser::Source::Range.new(node.source_range.source_buffer,
+                                    node.source_range.begin_pos,
+                                    condition.source_range.begin_pos)
         end
 
         def correct_if_branches(corrector, cop, node)
@@ -565,7 +565,7 @@ module RuboCop
           end
 
           def move_assignment_inside_condition(corrector, node)
-            column = node.loc.expression.column
+            column = node.source_range.column
             *_var, condition = *node
             assignment = assignment(node)
 
@@ -616,7 +616,7 @@ module RuboCop
           end
 
           def move_assignment_inside_condition(corrector, node)
-            column = node.loc.expression.column
+            column = node.source_range.column
             *_var, condition = *node
             assignment = assignment(node)
 

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Prefer to use `Dir.empty?('path/to/dir')` when checking if a directory is empty.
+      #
+      # @example
+      #   # bad
+      #   Dir.entries('path/to/dir').size == 2
+      #   Dir.children('path/to/dir').empty?
+      #   Dir.children('path/to/dir').size == 0
+      #   Dir.each_child('path/to/dir').none?
+      #
+      #   # good
+      #   Dir.empty?('path/to/dir')
+      #
+      class DirEmpty < Base
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        MSG = 'Use `Dir.empty?(%<arg>s)` instead.'
+        RESTRICT_ON_SEND = %i[== > empty? none?].freeze
+
+        minimum_target_ruby_version 2.4
+
+        # @!method offensive?(node)
+        def_node_matcher :offensive?, <<~PATTERN
+          {
+            (send (send (send $(const {nil? cbase} :Dir) :entries $_) :size) {:== :>} (int 2))
+            (send (send (send $(const {nil? cbase} :Dir) :children $_) :size) {:== :>} (int 0))
+            (send (send (send (send $(const {nil? cbase} :Dir) :entries $_) :size) :!) {:== :>} (int 2))
+            (send (send (send (send $(const {nil? cbase} :Dir) :children $_) :size) :!) {:== :>} (int 0))
+            (send (send $(const {nil? cbase} :Dir) :children $_) :empty?)
+            (send (send $(const {nil? cbase} :Dir) :each_child $_) :none?)
+          }
+        PATTERN
+
+        def on_send(node)
+          offensive?(node) do |const_node, arg_node|
+            add_offense(node, message: format(MSG, arg: arg_node.source)) do |corrector|
+              bang(node)
+              corrector.replace(node,
+                                "#{bang(node)}#{const_node.source}.empty?(#{arg_node.source})")
+            end
+          end
+        end
+
+        private
+
+        def bang(node)
+          if (node.method?(:==) && node.child_nodes.first.method?(:!)) ||
+             (node.method?(:>) && !node.child_nodes.first.method?(:!))
+            '!'
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -116,7 +116,7 @@ module RuboCop
 
         def preceding_comment_blocks(node)
           # Collect comments in the method call, but outside the heredoc
-          comments = processed_source.each_comment_in_lines(node.loc.expression.line_span)
+          comments = processed_source.each_comment_in_lines(node.source_range.line_span)
 
           comments.each_with_object({}) do |comment, hash|
             merge_adjacent_comments(comment.text, comment.loc.line, hash)

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

@@ -110,7 +110,7 @@ module RuboCop
           return if nodoc_self_or_outer_module?(node)
           return if include_statement_only?(body)
 
-          range = range_between(node.loc.expression.begin_pos, node.loc.name.end_pos)
+          range = range_between(node.source_range.begin_pos, node.loc.name.end_pos)
           message = format(MSG, type: node.type, identifier: identifier(node))
           add_offense(range, message: message)
         end
@@ -178,13 +178,19 @@ module RuboCop
         def identifier(node)
           # Get the fully qualified identifier for a class/module
           nodes = [node, *node.each_ancestor(:class, :module)]
-          nodes.reverse_each.flat_map { |n| qualify_const(n.identifier) }.join('::')
+          identifier = nodes.reverse_each.flat_map { |n| qualify_const(n.identifier) }.join('::')
+
+          identifier.sub('::::', '::')
         end
 
         def qualify_const(node)
-          return if node.nil? || node.cbase_type? || node.self_type? || node.send_type?
+          return if node.nil?
 
-          [qualify_const(node.namespace), node.short_name].compact
+          if node.cbase_type? || node.self_type? || node.call_type? || node.variable?
+            node.source
+          else
+            [qualify_const(node.namespace), node.short_name].compact
+          end
         end
       end
     end

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

@@ -101,16 +101,16 @@ module RuboCop
 
         MSG = 'Missing method documentation comment.'
 
-        # @!method module_function_node?(node)
-        def_node_matcher :module_function_node?, <<~PATTERN
-          (send nil? :module_function ...)
+        # @!method modifier_node?(node)
+        def_node_matcher :modifier_node?, <<~PATTERN
+          (send nil? {:module_function :ruby2_keywords} ...)
         PATTERN
 
         def on_def(node)
           return if node.method?(:initialize)
 
           parent = node.parent
-          module_function_node?(parent) ? check(parent) : check(node)
+          modifier_node?(parent) ? check(parent) : check(node)
         end
         alias on_defs on_def
 

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

@@ -131,7 +131,7 @@ module RuboCop
         end
 
         def whole_line_expression(node)
-          range_by_whole_lines(node.loc.expression, include_final_newline: true)
+          range_by_whole_lines(node.source_range, include_final_newline: true)
         end
       end
     end

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

@@ -37,7 +37,7 @@ module RuboCop
 
         def autocorrect(corrector, node)
           block = node.parent
-          range = range_between(block.loc.begin.end_pos, node.loc.expression.end_pos)
+          range = range_between(block.loc.begin.end_pos, node.source_range.end_pos)
 
           corrector.remove(range)
         end

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

@@ -34,7 +34,7 @@ module RuboCop
 
         def autocorrect(corrector, node)
           send_node = node.parent.send_node
-          range = range_between(send_node.loc.expression.end_pos, node.loc.expression.end_pos)
+          range = range_between(send_node.source_range.end_pos, node.source_range.end_pos)
 
           corrector.remove(range)
         end

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

@@ -146,7 +146,7 @@ module RuboCop
                            actual: line_node.source,
                            expected: expected)
 
-          add_offense(line_node.loc.expression, message: message) do |corrector|
+          add_offense(line_node.source_range, message: message) do |corrector|
             corrector.replace(line_node, expected)
           end
         end
@@ -175,14 +175,14 @@ module RuboCop
         end
 
         def line_difference(line_node, code)
-          string_first_line(code) - line_node.loc.expression.first_line
+          string_first_line(code) - line_node.source_range.first_line
         end
 
         def string_first_line(str_node)
           if str_node.heredoc?
             str_node.loc.heredoc_body.first_line
           else
-            str_node.loc.expression.first_line
+            str_node.source_range.first_line
           end
         end
 
@@ -210,7 +210,7 @@ module RuboCop
         def add_offense_for_missing_line(node, code)
           register_offense(node) do |corrector|
             line_str = missing_line(node, code)
-            corrector.insert_after(node.loc.expression.end, ", #{line_str}")
+            corrector.insert_after(node.source_range.end, ", #{line_str}")
           end
         end
 

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

@@ -145,7 +145,7 @@ module RuboCop
         end
 
         def block_body_range(block_node, send_node)
-          range_between(send_node.loc.expression.end_pos, block_node.loc.end.end_pos)
+          range_between(send_node.source_range.end_pos, block_node.loc.end.end_pos)
         end
       end
     end