rubocop 1.43.0 → 1.50.2

data/lib/rubocop/cop/registry.rb

@@ -41,6 +41,11 @@ module RuboCop
         @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 = {})
@@ -158,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
@@ -185,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)
 
@@ -282,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/style/access_modifier_declarations.rb

@@ -115,9 +115,7 @@ module RuboCop
             def_node = find_corresponding_def_node(node)
             return unless def_node
 
-            remove_node(corrector, def_node)
-            remove_node(corrector, node)
-            insert_def(corrector, node, def_node.source)
+            replace_def(corrector, node, def_node)
           when :inline
             remove_node(corrector, node)
             select_grouped_def_nodes(node).each do |grouped_def_node|
@@ -131,7 +129,8 @@ module RuboCop
         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
 
@@ -151,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
 
@@ -173,7 +178,9 @@ module RuboCop
         end
 
         def find_argument_less_modifier_node(node)
-          node.parent.each_child_node(:send).find do |child|
+          return unless (parent = node.parent)
+
+          parent.each_child_node(:send).find do |child|
             child.method?(node.method_name) && child.arguments.empty?
           end
         end
@@ -184,17 +191,21 @@ module RuboCop
           end.select(&:def_type?)
         end
 
-        def insert_def(corrector, node, source)
-          source = [*processed_source.ast_with_comments[node].map(&:text), source].join("\n")
+        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.insert_before(
-              node.each_ancestor(:block, :class, :module).first.location.end,
-              "#{node.method_name}\n\n#{source}\n"
-            )
+            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)
@@ -204,6 +215,10 @@ module RuboCop
         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

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

@@ -84,6 +84,7 @@ module RuboCop
         def on_def(node)
           return unless node.body
           return unless (rest_args_name, args = use_rest_arguments?(node.arguments))
+          return if args.any?(&:default?)
 
           node.each_descendant(:send) do |send_node|
             kwargs_name, block_name = extract_argument_names_from(args)
@@ -123,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,8 +299,8 @@ 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
-          comment_range = range_between(range.end_pos, comment.loc.expression.end_pos)
-          corrector.remove(range_with_surrounding_space(comment_range, side: :right))
+          corrector.remove(range_with_surrounding_space(comment.source_range, side: :right))
+          remove_trailing_whitespace(corrector, range, comment)
           corrector.insert_after(range, "\n")
 
           corrector.insert_before(block_node, "#{comment.text}\n")
@@ -313,6 +313,12 @@ module RuboCop
           end_of_chain(node.parent)
         end
 
+        def remove_trailing_whitespace(corrector, range, comment)
+          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
+
         def with_block?(node)
           node.respond_to?(:block_node) && node.block_node
         end
@@ -336,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
@@ -346,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/class_and_module_children.rb

@@ -11,7 +11,7 @@ module RuboCop
       #
       #   Moving from compact to nested children requires knowledge of whether the
       #   outer parent is a module or a class. Moving from nested to compact requires
-      #   verification that the outer parent is defined elsewhere. Rubocop does not
+      #   verification that the outer parent is defined elsewhere. RuboCop does not
       #   have the knowledge to perform either operation safely and thus requires
       #   manual oversight.
       #
@@ -31,6 +31,7 @@ module RuboCop
       #
       # The compact style is only forced for classes/modules with one child.
       class ClassAndModuleChildren < Base
+        include Alignment
         include ConfigurableEnforcedStyle
         include RangeHelp
         extend AutoCorrector
@@ -59,7 +60,7 @@ module RuboCop
         end
 
         def nest_definition(corrector, node)
-          padding = ((' ' * indent_width) + leading_spaces(node)).to_s
+          padding = indentation(node) + leading_spaces(node)
           padding_for_trailing_end = padding.sub(' ' * node.loc.end.column, '')
 
           replace_namespace_keyword(corrector, node)
@@ -124,10 +125,6 @@ module RuboCop
           corrector.remove(range)
         end
 
-        def configured_indentation_width
-          config.for_badge(Layout::IndentationWidth.badge).fetch('Width', 2)
-        end
-
         def unindent(corrector, node)
           return if node.body.children.last.nil?
 
@@ -141,10 +138,6 @@ module RuboCop
           node.source_range.source_line[/\A\s*/]
         end
 
-        def indent_width
-          @config.for_cop('Layout/IndentationWidth')['Width'] || 2
-        end
-
         def check_style(node, body)
           return if node.identifier.children[0]&.cbase_type?
 
@@ -185,7 +178,7 @@ module RuboCop
         end
 
         def compact_node_name?(node)
-          /::/.match?(node.identifier.source)
+          node.identifier.source.include?('::')
         end
       end
     end

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

@@ -27,12 +27,16 @@ module RuboCop
       #   var.class.equal?(Date)
       #   var.class.eql?(Date)
       #   var.class.name == 'Date'
+      #   var.class.to_s == 'Date'
+      #   var.class.inspect == 'Date'
       #
       # @example AllowedMethods: [`==`]
       #   # good
       #   var.instance_of?(Date)
       #   var.class == Date
       #   var.class.name == 'Date'
+      #   var.class.to_s == 'Date'
+      #   var.class.inspect == 'Date'
       #
       #   # bad
       #   var.class.equal?(Date)
@@ -47,6 +51,8 @@ module RuboCop
       #   var.class.equal?(Date)
       #   var.class.eql?(Date)
       #   var.class.name == 'Date'
+      #   var.class.to_s == 'Date'
+      #   var.class.inspect == 'Date'
       #
       # @example AllowedPatterns: ['eq']
       #   # good
@@ -57,6 +63,8 @@ module RuboCop
       #   # bad
       #   var.class == Date
       #   var.class.name == 'Date'
+      #   var.class.to_s == 'Date'
+      #   var.class.inspect == 'Date'
       #
       class ClassEqualityComparison < Base
         include RangeHelp
@@ -64,14 +72,15 @@ module RuboCop
         include AllowedPattern
         extend AutoCorrector
 
-        MSG = 'Use `instance_of?(%<class_name>s)` instead of comparing classes.'
+        MSG = 'Use `instance_of?%<class_argument>s` instead of comparing classes.'
 
         RESTRICT_ON_SEND = %i[== equal? eql?].freeze
+        CLASS_NAME_METHODS = %i[name to_s inspect].freeze
 
         # @!method class_comparison_candidate?(node)
         def_node_matcher :class_comparison_candidate?, <<~PATTERN
           (send
-            {$(send _ :class) (send $(send _ :class) :name)}
+            {$(send _ :class) (send $(send _ :class) #class_name_method?)}
             {:== :equal? :eql?} $_)
         PATTERN
 
@@ -83,10 +92,12 @@ module RuboCop
 
           class_comparison_candidate?(node) do |receiver_node, class_node|
             range = offense_range(receiver_node, node)
-            class_name = class_name(class_node, node)
+            class_argument = (class_name = class_name(class_node, node)) ? "(#{class_name})" : ''
 
-            add_offense(range, message: format(MSG, class_name: class_name)) do |corrector|
-              corrector.replace(range, "instance_of?(#{class_name})")
+            add_offense(range, message: format(MSG, class_argument: class_argument)) do |corrector|
+              next unless class_name
+
+              corrector.replace(range, "instance_of?#{class_argument}")
             end
           end
         end
@@ -94,19 +105,41 @@ module RuboCop
         private
 
         def class_name(class_node, node)
-          if node.children.first.method?(:name)
-            return class_node.receiver.source if class_node.receiver
+          if class_name_method?(node.children.first.method_name)
+            if (receiver = class_node.receiver) && class_name_method?(class_node.method_name)
+              return receiver.source
+            end
 
             if class_node.str_type?
-              value = class_node.source.delete('"').delete("'")
-              value.prepend('::') if class_node.each_ancestor(:class, :module).any?
+              value = trim_string_quotes(class_node)
+              value.prepend('::') if require_cbase?(class_node)
               return value
+            elsif unable_to_determine_type?(class_node)
+              # When a variable or return value of a method is used, it returns nil
+              # because the type is not known and cannot be suggested.
+              return
             end
           end
 
           class_node.source
         end
 
+        def class_name_method?(method_name)
+          CLASS_NAME_METHODS.include?(method_name)
+        end
+
+        def require_cbase?(class_node)
+          class_node.each_ancestor(:class, :module).any?
+        end
+
+        def unable_to_determine_type?(class_node)
+          class_node.variable? || class_node.call_type?
+        end
+
+        def trim_string_quotes(class_node)
+          class_node.source.delete('"').delete("'")
+        end
+
         def offense_range(receiver_node, node)
           range_between(receiver_node.loc.selector.begin_pos, node.source_range.end_pos)
         end

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

@@ -36,11 +36,14 @@ module RuboCop
       class CollectionCompact < Base
         include RangeHelp
         extend AutoCorrector
+        extend TargetRubyVersion
 
         MSG = 'Use `%<good>s` instead of `%<bad>s`.'
         RESTRICT_ON_SEND = %i[reject reject! select select!].freeze
         TO_ENUM_METHODS = %i[to_enum lazy].freeze
 
+        minimum_target_ruby_version 2.4
+
         # @!method reject_method_with_block_pass?(node)
         def_node_matcher :reject_method_with_block_pass?, <<~PATTERN
           (send !nil? {:reject :reject!}
@@ -112,7 +115,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/command_literal.rb

@@ -148,7 +148,7 @@ module RuboCop
         end
 
         def contains_backtick?(node)
-          /`/.match?(node_body(node))
+          node_body(node).include?('`')
         end
 
         def node_body(node)

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