rubocop 1.46.0 → 1.48.0

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

@@ -23,7 +23,7 @@ module RuboCop
       # The args node1 & node2 may represent a RuboCop::AST::Node
       # or a Parser::Source::Comment. Both respond to #loc.
       def preceding_comment?(node1, node2)
-        node1 && node2 && precede?(node2, node1) && comment_line?(node2.loc.expression.source)
+        node1 && node2 && precede?(node2, node1) && comment_line?(node2.source)
       end
 
       # The args node1 & node2 may represent a RuboCop::AST::Node

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

@@ -33,7 +33,7 @@ module RuboCop
 
         def separator_delta(pair)
           if pair.hash_rocket?
-            correct_separator_column = pair.key.loc.expression.end.column + 1
+            correct_separator_column = pair.key.source_range.end.column + 1
             actual_separator_column = pair.loc.operator.column
 
             correct_separator_column - actual_separator_column

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

@@ -95,19 +95,20 @@ module RuboCop
           use_modifier_form_without_parenthesized_method_call?(method_dispatch_node)
       end
 
-      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       def def_node_that_require_parentheses(node)
         last_pair = node.parent.pairs.last
         return unless last_pair.key.source == last_pair.value.source
         return unless (dispatch_node = find_ancestor_method_dispatch_node(node))
         return if dispatch_node.parenthesized?
+        return if dispatch_node.parent && parentheses?(dispatch_node.parent)
         return if last_expression?(dispatch_node) && !method_dispatch_as_argument?(dispatch_node)
 
         def_node = node.each_ancestor(:send, :csend, :super, :yield).first
 
         DefNode.new(def_node) unless def_node && def_node.arguments.empty?
       end
-      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
       def find_ancestor_method_dispatch_node(node)
         return unless (ancestor = node.parent.parent)

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

@@ -159,7 +159,7 @@ module RuboCop
         end
 
         def strip_prefix_and_suffix(node, corrector)
-          expression = node.loc.expression
+          expression = node.source_range
           corrector.remove_leading(expression, leading)
           corrector.remove_trailing(expression, trailing)
         end
@@ -175,11 +175,11 @@ module RuboCop
         end
 
         def set_new_arg_name(transformed_argname, corrector)
-          corrector.replace(block_node.arguments.loc.expression, "|#{transformed_argname}|")
+          corrector.replace(block_node.arguments.source_range, "|#{transformed_argname}|")
         end
 
         def set_new_body_expression(transforming_body_expr, corrector)
-          body_source = transforming_body_expr.loc.expression.source
+          body_source = transforming_body_expr.source
           if transforming_body_expr.hash_type? && !transforming_body_expr.braces?
             body_source = "{ #{body_source} }"
           end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for checking minimum branches count.
+    module MinBranchesCount
+      private
+
+      def min_branches_count?(node)
+        branches =
+          if node.case_type?
+            node.when_branches
+          elsif node.if_type?
+            if_conditional_branches(node)
+          else
+            raise ArgumentError, "Unsupported #{node.type.inspect} node type"
+          end
+
+        branches.size >= min_branches_count
+      end
+
+      def min_branches_count
+        length = cop_config['MinBranchesCount'] || 3
+        return length if length.is_a?(Integer) && length.positive?
+
+        raise 'MinBranchesCount needs to be a positive integer!'
+      end
+
+      def if_conditional_branches(node, branches = [])
+        return [] if node.nil? || !node.if_type?
+
+        branches << node.if_branch
+
+        else_branch = node.else_branch
+        if_conditional_branches(else_branch, branches) if else_branch&.if_type?
+        branches
+      end
+    end
+  end
+end

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

@@ -10,7 +10,7 @@ module RuboCop
       def get_source_range(node, comments_as_separators)
         unless comments_as_separators
           first_comment = processed_source.ast_with_comments[node].first
-          return first_comment.loc.expression unless first_comment.nil?
+          return first_comment.source_range unless first_comment.nil?
         end
         node.source_range
       end

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

@@ -132,12 +132,7 @@ module RuboCop
       end
 
       def range_with_comments(node)
-        ranges = [
-          node,
-          *@processed_source.ast_with_comments[node]
-        ].map do |element|
-          element.location.expression
-        end
+        ranges = [node, *@processed_source.ast_with_comments[node]].map(&:source_range)
         ranges.reduce do |result, range|
           add_range(result, range)
         end

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

@@ -65,14 +65,14 @@ module RuboCop
       end
 
       def method_source(if_body)
-        range_between(if_body.loc.expression.begin_pos, if_body.loc.selector.end_pos).source
+        range_between(if_body.source_range.begin_pos, if_body.loc.selector.end_pos).source
       end
 
       def first_line_comment(node)
         comment = processed_source.find_comment { |c| same_line?(c, node) }
         return unless comment
 
-        comment_source = comment.loc.expression.source
+        comment_source = comment.source
         comment_source unless comment_disables_cop?(comment_source)
       end
 

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

@@ -75,7 +75,7 @@ module RuboCop
 
       def inside_comment?(range, comma_offset)
         comment = processed_source.comment_at_line(range.line)
-        comment && comment.loc.expression.begin_pos < range.begin_pos + comma_offset
+        comment && comment.source_range.begin_pos < range.begin_pos + comma_offset
       end
 
       # Returns true if the node has round/square/curly brackets.

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

@@ -38,7 +38,7 @@ module RuboCop
           return if correct_case_delimiters?(node)
 
           add_offense(node.loc.heredoc_end) do |corrector|
-            expr = node.loc.expression
+            expr = node.source_range
 
             corrector.replace(expr, correct_delimiters(expr.source))
             corrector.replace(node.loc.heredoc_end, correct_delimiters(delimiter_string(expr)))

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

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

@@ -14,12 +14,25 @@ module RuboCop
       #   # 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
@@ -70,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 +94,14 @@ module RuboCop
 
         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?

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