rubocop 0.92.0 → 0.93.0

data/lib/rubocop/cop/metrics/class_length.rb

@@ -29,6 +29,8 @@ module RuboCop
       #     HEREDOC
       #   end                 # 5 points
       #
+      #
+      # NOTE: This cop also applies for `Struct` definitions.
       class ClassLength < Base
         include CodeLength
 
@@ -37,17 +39,17 @@ module RuboCop
         end
 
         def on_casgn(node)
-          class_definition?(node) do
-            check_code_length(node)
+          if node.parent&.assignment?
+            block_node = node.parent.children[1]
+          else
+            _scope, _name, block_node = *node
           end
+
+          check_code_length(block_node) if block_node.class_definition?
         end
 
         private
 
-        def_node_matcher :class_definition?, <<~PATTERN
-          (casgn nil? _ (block (send (const {nil? cbase} :Class) :new) ...))
-        PATTERN
-
         def message(length, max_length)
           format('Class has too many lines. [%<length>d/%<max>d]',
                  length: length,

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

@@ -137,7 +137,7 @@ module RuboCop
       end
 
       # Internal helper class to hold autocorrect data
-      Autocorrection = Struct.new(:match, :block_node, :leading, :trailing) do # rubocop:disable Metrics/BlockLength
+      Autocorrection = Struct.new(:match, :block_node, :leading, :trailing) do
         def self.from_each_with_object(node, match)
           new(match, node, 0, 0)
         end

data/lib/rubocop/cop/offense.rb

@@ -63,10 +63,23 @@ module RuboCop
       attr_reader :corrector
 
       PseudoSourceRange = Struct.new(:line, :column, :source_line, :begin_pos,
-                                     :end_pos)
+                                     :end_pos) do
+        alias_method :first_line, :line
+        alias_method :last_line, :line
+        alias_method :last_column, :column
+
+        def column_range
+          column...last_column
+        end
+
+        def size
+          end_pos - begin_pos
+        end
+        alias_method :length, :size
+      end
       private_constant :PseudoSourceRange
 
-      NO_LOCATION = PseudoSourceRange.new(1, 0, '', 0, 1).freeze
+      NO_LOCATION = PseudoSourceRange.new(1, 0, '', 0, 0).freeze
 
       # @api private
       def initialize(severity, location, message, cop_name, # rubocop:disable Metrics/ParameterLists

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

@@ -83,8 +83,8 @@ module RuboCop
 
         def on_send(node)
           return unless node.access_modifier?
-          return if node.parent.pair_type?
-          return if cop_config['AllowModifiersOnSymbols'] && access_modifier_with_symbol?(node)
+          return if node.parent&.pair_type?
+          return if allow_modifiers_on_symbols?(node)
 
           if offense?(node)
             add_offense(node.loc.selector) if opposite_style_detected
@@ -95,6 +95,10 @@ module RuboCop
 
         private
 
+        def allow_modifiers_on_symbols?(node)
+          cop_config['AllowModifiersOnSymbols'] && access_modifier_with_symbol?(node)
+        end
+
         def offense?(node)
           (group_style? && access_modifier_is_inlined?(node)) ||
             (inline_style? && access_modifier_is_not_inlined?(node))

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

@@ -7,6 +7,9 @@ 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.
+      #
       # @example EnforcedStyle: grouped (default)
       #   # bad
       #   class Foo

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

@@ -42,6 +42,8 @@ module RuboCop
           convertible = true
 
           branch_conditions(node).each do |branch_condition|
+            return false if regexp_with_working_captures?(branch_condition)
+
             conditions << []
             convertible = collect_conditions(branch_condition, target, conditions.last)
             break unless convertible
@@ -49,9 +51,7 @@ module RuboCop
 
           return unless convertible
 
-          add_offense(node) do |corrector|
-            autocorrect(corrector, node)
-          end
+          add_offense(node) { |corrector| autocorrect(corrector, node) }
         end
 
         private
@@ -107,7 +107,7 @@ module RuboCop
           when :include?, :cover?
             receiver = deparenthesize(node.receiver)
             node.arguments.first if receiver.range_type?
-          when :match, :match?
+          when :match, :match?, :=~
             find_target_in_match_node(node)
           end
         end
@@ -230,6 +230,22 @@ module RuboCop
         def indent(node)
           ' ' * node.loc.column
         end
+
+        # Named captures work with `=~` (if regexp is on lhs) and with `match` (both sides)
+        def regexp_with_working_captures?(node)
+          case node.type
+          when :match_with_lvasgn
+            lhs, _rhs = *node
+            node.loc.selector.source == '=~' && regexp_with_named_captures?(lhs)
+          when :send
+            lhs, method, rhs = *node
+            method == :match && [lhs, rhs].any? { |n| regexp_with_named_captures?(n) }
+          end
+        end
+
+        def regexp_with_named_captures?(node)
+          node.regexp_type? && node.each_capture(named: true).count.positive?
+        end
       end
     end
   end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop enforces the use of `Object#instance_of?` instead of class comparison
+      # for equality.
+      #
+      # @example
+      #   # bad
+      #   var.class == Date
+      #   var.class.equal?(Date)
+      #   var.class.eql?(Date)
+      #   var.class.name == 'Date'
+      #
+      #   # good
+      #   var.instance_of?(Date)
+      #
+      class ClassEqualityComparison < Base
+        include RangeHelp
+        include IgnoredMethods
+        extend AutoCorrector
+
+        MSG = 'Use `Object.instance_of?` instead of comparing classes.'
+
+        RESTRICT_ON_SEND = %i[== equal? eql?].freeze
+
+        def_node_matcher :class_comparison_candidate?, <<~PATTERN
+          (send
+            {$(send _ :class) (send $(send _ :class) :name)}
+            {:== :equal? :eql?} $_)
+        PATTERN
+
+        def on_send(node)
+          def_node = node.each_ancestor(:def, :defs).first
+          return if def_node && ignored_method?(def_node.method_name)
+
+          class_comparison_candidate?(node) do |receiver_node, class_node|
+            range = range_between(receiver_node.loc.selector.begin_pos, node.source_range.end_pos)
+
+            add_offense(range) do |corrector|
+              corrector.replace(range, "instance_of?(#{class_node.source})")
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -49,6 +49,12 @@ module RuboCop
       #     end
       #   end
       #
+      #   # good
+      #   def method
+      #     each_slice(2) { |slice| do_something(slice) }
+      #     each_slice(3) { |slice| do_something(slice) }
+      #   end
+      #
       class CombinableLoops < Base
         MSG = 'Combine this loop with the previous loop.'
 
@@ -76,7 +82,8 @@ module RuboCop
         def same_collection_looping?(node, sibling)
           sibling&.block_type? &&
             sibling.send_node.method?(node.method_name) &&
-            sibling.send_node.receiver == node.send_node.receiver
+            sibling.send_node.receiver == node.send_node.receiver &&
+            sibling.send_node.arguments == node.send_node.arguments
         end
       end
     end

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

@@ -6,6 +6,12 @@ module RuboCop
       # This cop checks that comment annotation keywords are written according
       # to guidelines.
       #
+      # NOTE: With a multiline comment block (where each line is only a
+      # comment), only the first line will be able to register an offense, even
+      # if an annotation keyword starts another line. This is done to prevent
+      # incorrect registering of keywords (eg. `review`) inside a paragraph as an
+      # annotation.
+      #
       # @example
       #   # bad
       #   # TODO make better

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

@@ -57,12 +57,16 @@ module RuboCop
           yielding_block?(block_node) do |send_node, block_args, yield_args|
             return unless yielding_arguments?(block_args, yield_args)
 
+            def_node = block_node.each_ancestor(:def, :defs).first
+            # if `yield` is being called outside of a method context, ignore
+            # this is not a valid ruby pattern, but can happen in haml or erb,
+            # so this can cause crashes in haml_lint
+            return unless def_node
+
             add_offense(block_node) do |corrector|
               corrector.remove(block_body_range(block_node, send_node))
 
               add_block_argument(send_node, corrector)
-
-              def_node = block_node.each_ancestor(:def, :defs).first
               add_block_argument(def_node, corrector) if @def_nodes.add?(def_node)
             end
           end

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

@@ -49,8 +49,6 @@ module RuboCop
 
         def on_for(node)
           if style == :each
-            return unless opposite_style_detected
-
             add_offense(node, message: PREFER_EACH) do |corrector|
               ForToEachCorrector.new(node).call(corrector)
             end
@@ -63,8 +61,6 @@ module RuboCop
           return unless suspect_enumerable?(node)
 
           if style == :for
-            return unless opposite_style_detected
-
             add_offense(node, message: PREFER_FOR) do |corrector|
               EachToForCorrector.new(node).call(corrector)
             end

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

@@ -33,7 +33,7 @@ module RuboCop
       #
       #   # bad
       #   format('%<greeting>s', greeting: 'Hello')
-      #   format('%{greeting}', 'Hello')
+      #   format('%{greeting}', greeting: 'Hello')
       #
       #   # good
       #   format('%s', 'Hello')

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

@@ -140,16 +140,12 @@ module RuboCop
         def missing_parentheses(node)
           location = node.arguments.source_range
 
-          return unless unexpected_style_detected(:require_no_parentheses)
-
           add_offense(location, message: MSG_MISSING) do |corrector|
             correct_definition(node, corrector)
           end
         end
 
         def unwanted_parentheses(args)
-          return unless unexpected_style_detected(:require_parentheses)
-
           add_offense(args, message: MSG_PRESENT) do |corrector|
             # offense is registered on args node when parentheses are unwanted
             correct_arguments(args, corrector)

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

@@ -49,6 +49,8 @@ module RuboCop
         end
 
         def remove_parentheses(source)
+          return source unless source.start_with?('(')
+
           source.gsub(/\A\(/, '').gsub(/\)\z/, '')
         end
       end

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

@@ -84,8 +84,6 @@ module RuboCop
 
         def check_compact(node)
           if node.arguments.size > 1
-            return unless opposite_style_detected
-
             add_offense(node, message: format(COMPACT_MSG, method: node.method_name)) do |corrector|
               replacement = correction_exploded_to_compact(node)
 
@@ -103,7 +101,6 @@ module RuboCop
 
           return unless first_arg.send_type? && first_arg.method?(:new)
           return if acceptable_exploded_args?(first_arg.arguments)
-          return unless opposite_style_detected
 
           add_offense(node, message: format(EXPLODED_MSG, method: node.method_name)) do |corrector|
             replacement = correction_compact_to_exploded(node)

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

@@ -28,6 +28,14 @@ module RuboCop
       #   end
       #
       #   # bad
+      #   begin
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   do_something
+      #
+      #   # bad
       #   # When using Ruby 2.5 or later.
       #   do_something do
       #     begin
@@ -60,7 +68,9 @@ module RuboCop
         MSG = 'Redundant `begin` block detected.'
 
         def on_def(node)
-          check(node)
+          return unless node.body&.kwbegin_type?
+
+          register_offense(node.body)
         end
         alias on_defs on_def
 
@@ -69,18 +79,26 @@ module RuboCop
 
           return if node.send_node.lambda_literal?
           return if node.braces?
+          return unless node.body&.kwbegin_type?
 
-          check(node)
+          register_offense(node.body)
         end
 
-        private
+        def on_kwbegin(node)
+          return if node.parent&.assignment?
 
-        def check(node)
-          return unless node.body&.kwbegin_type?
+          first_child = node.children.first
+          return if first_child.rescue_type? || first_child.ensure_type?
+
+          register_offense(node)
+        end
+
+        private
 
-          add_offense(node.body.loc.begin) do |corrector|
-            corrector.remove(node.body.loc.begin)
-            corrector.remove(node.body.loc.end)
+        def register_offense(node)
+          add_offense(node.loc.begin) do |corrector|
+            corrector.remove(node.loc.begin)
+            corrector.remove(node.loc.end)
           end
         end
       end

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

@@ -75,7 +75,7 @@ module RuboCop
         def offense?(node)
           condition, if_branch, else_branch = *node
 
-          return false if use_if_branch?(else_branch)
+          return false if use_if_branch?(else_branch) || use_hash_key_assignment?(else_branch)
 
           condition == if_branch && !node.elsif? && (
             node.ternary? ||
@@ -88,6 +88,10 @@ module RuboCop
           else_branch&.if_type?
         end
 
+        def use_hash_key_assignment?(else_branch)
+          else_branch&.send_type? && else_branch&.method?(:[]=)
+        end
+
         def else_source(else_branch)
           if require_parentheses?(else_branch)
             "(#{else_branch.source})"

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

@@ -51,7 +51,12 @@ module RuboCop
         end
 
         def single_variable_interpolation?(node)
-          node.children.one? && variable_interpolation?(node.children.first)
+          return false unless node.children.one?
+
+          first_child = node.children.first
+
+          variable_interpolation?(first_child) ||
+            first_child.send_type? && !first_child.operator_method?
         end
 
         def interpolation?(node)

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

@@ -22,32 +22,14 @@ module RuboCop
       #   # good
       #   r = /[ab]/
       class RedundantRegexpCharacterClass < Base
-        include MatchRange
-        include RegexpLiteralHelp
         extend AutoCorrector
 
+        REQUIRES_ESCAPE_OUTSIDE_CHAR_CLASS_CHARS = '.*+?{}()|$'.chars.freeze
         MSG_REDUNDANT_CHARACTER_CLASS = 'Redundant single-element character class, ' \
         '`%<char_class>s` can be replaced with `%<element>s`.'
 
-        PATTERN = /
-          (
-            (?<!\\)           # No \-prefix (i.e. not escaped)
-            \[                # Literal [
-            (?!\#\{)          # Not (the start of) an interpolation
-            (?:               # Either...
-             \\[^b] |         # Any escaped character except b (which would change behaviour)
-             [^.*+?{}()|$] |  # or one that doesn't require escaping outside the character class
-             \\[upP]\{[^}]+\} # or a unicode code-point or property
-            )
-            (?<!\\)           # No \-prefix (i.e. not escaped)
-            \]                # Literal ]
-          )
-        /x.freeze
-
         def on_regexp(node)
           each_redundant_character_class(node) do |loc|
-            next if whitespace_in_free_space_mode?(node, loc)
-
             add_offense(
               loc, message: format(
                 MSG_REDUNDANT_CHARACTER_CLASS,
@@ -63,19 +45,52 @@ module RuboCop
         private
 
         def each_redundant_character_class(node)
-          pattern_source(node).scan(PATTERN) do
-            yield match_range(node.loc.begin.end, Regexp.last_match)
+          each_single_element_character_class(node) do |char_class|
+            next unless redundant_single_element_character_class?(node, char_class)
+
+            yield node.loc.begin.adjust(begin_pos: 1 + char_class.ts, end_pos: char_class.te)
+          end
+        end
+
+        def each_single_element_character_class(node)
+          node.parsed_tree&.each_expression do |expr|
+            next if expr.type != :set || expr.expressions.size != 1
+            next if expr.negative?
+            next if %i[set posixclass nonposixclass].include?(expr.expressions.first.type)
+
+            yield expr
           end
         end
 
+        def redundant_single_element_character_class?(node, char_class)
+          class_elem = char_class.expressions.first.text
+
+          non_redundant =
+            whitespace_in_free_space_mode?(node, class_elem) ||
+            backslash_b?(class_elem) ||
+            requires_escape_outside_char_class?(class_elem)
+
+          !non_redundant
+        end
+
         def without_character_class(loc)
           loc.source[1..-2]
         end
 
-        def whitespace_in_free_space_mode?(node, loc)
-          return false unless freespace_mode_regexp?(node)
+        def whitespace_in_free_space_mode?(node, elem)
+          return false unless node.extended?
+
+          /\s/.match?(elem)
+        end
+
+        def backslash_b?(elem)
+          # \b's behaviour is different inside and outside of a character class, matching word
+          # boundaries outside but backspace (0x08) when inside.
+          elem == '\b'
+        end
 
-          /\[\s\]/.match?(loc.source)
+        def requires_escape_outside_char_class?(elem)
+          REQUIRES_ESCAPE_OUTSIDE_CHAR_CLASS_CHARS.include?(elem)
         end
       end
     end