rubocop 1.15.0 → 1.18.1

data/lib/rubocop/cop/layout/space_around_operators.rb

@@ -120,6 +120,12 @@ module RuboCop
           check_operator(:special_asgn, node.loc.operator, right.source_range)
         end
 
+        def on_match_pattern(node)
+          return if target_ruby_version < 3.0
+
+          check_operator(:match_pattern, node.loc.operator, node.source_range)
+        end
+
         alias on_or       on_binary
         alias on_and      on_binary
         alias on_lvasgn   on_assignment
@@ -192,7 +198,7 @@ module RuboCop
           elsif excess_leading_space?(type, operator, with_space) ||
                 excess_trailing_space?(right_operand, with_space)
             "Operator `#{operator.source}` should be surrounded " \
-            'by a single space.'
+              'by a single space.'
           end
         end
 

data/lib/rubocop/cop/lint/empty_in_pattern.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for the presence of `in` pattern branches without a body.
+      #
+      # @example
+      #
+      #   # bad
+      #   case condition
+      #   in [a]
+      #     do_something
+      #   in [a, b]
+      #   end
+      #
+      #   # good
+      #   case condition
+      #   in [a]
+      #     do_something
+      #   in [a, b]
+      #     nil
+      #   end
+      #
+      # @example AllowComments: true (default)
+      #
+      #   # good
+      #   case condition
+      #   in [a]
+      #     do_something
+      #   in [a, b]
+      #     # noop
+      #   end
+      #
+      # @example AllowComments: false
+      #
+      #   # bad
+      #   case condition
+      #   in [a]
+      #     do_something
+      #   in [a, b]
+      #     # noop
+      #   end
+      #
+      class EmptyInPattern < Base
+        extend TargetRubyVersion
+
+        MSG = 'Avoid `in` branches without a body.'
+
+        minimum_target_ruby_version 2.7
+
+        def on_case_match(node)
+          node.in_pattern_branches.each do |branch|
+            next if branch.body || cop_config['AllowComments'] && comment_lines?(node)
+
+            add_offense(branch)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/literal_as_condition.rb

@@ -5,7 +5,7 @@ module RuboCop
     module Lint
       # This cop checks for literals used as the conditions or as
       # operands in and/or expressions serving as the conditions of
-      # if/while/until.
+      # if/while/until/case-when/case-in.
       #
       # @example
       #
@@ -67,6 +67,18 @@ module RuboCop
           end
         end
 
+        def on_case_match(case_match_node)
+          if case_match_node.condition
+            check_case(case_match_node)
+          else
+            case_match_node.each_in_pattern do |in_pattern_node|
+              next unless in_pattern_node.condition.literal?
+
+              add_offense(in_pattern_node)
+            end
+          end
+        end
+
         def on_send(node)
           return unless node.negation_method?
 

data/lib/rubocop/cop/lint/missing_cop_enable_directive.rb

@@ -45,37 +45,52 @@ module RuboCop
       class MissingCopEnableDirective < Base
         include RangeHelp
 
-        MSG = 'Re-enable %<cop>s cop with `# rubocop:enable` after disabling it.'
-        MSG_BOUND = 'Re-enable %<cop>s cop within %<max_range>s lines after disabling it.'
+        MSG = 'Re-enable %<cop>s %<type>s with `# rubocop:enable` after disabling it.'
+        MSG_BOUND = 'Re-enable %<cop>s %<type>s within %<max_range>s lines after disabling it.'
 
-        # rubocop:disable Metrics/AbcSize
         def on_new_investigation
-          max_range = cop_config['MaximumRangeSize']
-          processed_source.disabled_line_ranges.each do |cop, line_ranges|
-            line_ranges.each do |line_range|
-              # This has to remain a strict inequality to handle
-              # the case when max_range is Float::INFINITY
-              next if line_range.max - line_range.min < max_range + 2
+          each_missing_enable do |cop, line_range|
+            # This has to remain a strict inequality to handle
+            # the case when max_range is Float::INFINITY
+            next if line_range.max - line_range.min < max_range + 2
 
-              range = source_range(processed_source.buffer, line_range.min, (0..0))
+            range = source_range(processed_source.buffer, line_range.min, (0..0))
+            comment = processed_source.comment_at_line(line_range.begin)
 
-              add_offense(range, message: message(max_range: max_range, cop: cop))
-            end
+            add_offense(range, message: message(cop, comment))
           end
         end
-        # rubocop:enable Metrics/AbcSize
 
         private
 
-        def message(max_range:, cop:)
+        def each_missing_enable
+          processed_source.disabled_line_ranges.each do |cop, line_ranges|
+            line_ranges.each { |line_range| yield cop, line_range }
+          end
+        end
+
+        def max_range
+          @max_range ||= cop_config['MaximumRangeSize']
+        end
+
+        def message(cop, comment, type = 'cop')
+          if department_enabled?(cop, comment)
+            type = 'department'
+            cop = cop.split('/').first
+          end
+
           if max_range == Float::INFINITY
-            format(MSG, cop: cop)
+            format(MSG, cop: cop, type: type)
           else
-            format(MSG_BOUND, cop: cop, max_range: max_range)
+            format(MSG_BOUND, cop: cop, type: type, max_range: max_range)
           end
         end
+
+        def department_enabled?(cop, comment)
+          DirectiveComment.new(comment).in_directive_department?(cop)
+        end
       end
     end
   end
 end
-# rubocop:enable Lint/RedundantCopDisableDirective, Layout/SpaceAroundOperators
+# rubocop:enable Lint/RedundantCopDisableDirective

data/lib/rubocop/cop/lint/nested_percent_literal.rb

@@ -33,7 +33,7 @@ module RuboCop
         include PercentLiteral
 
         MSG = 'Within percent literals, nested percent literals do not ' \
-          'function and may be unwanted in the result.'
+              'function and may be unwanted in the result.'
 
         # The array of regular expressions representing percent literals that,
         # if found within a percent literal expression, will cause a

data/lib/rubocop/cop/lint/percent_string_array.rb

@@ -29,7 +29,7 @@ module RuboCop
         TRAILING_QUOTE = /['"]?,?$/.freeze
 
         MSG = "Within `%w`/`%W`, quotes and ',' are unnecessary and may be " \
-          'unwanted in the resulting strings.'
+              'unwanted in the resulting strings.'
 
         def on_array(node)
           process(node, '%w', '%W')

data/lib/rubocop/cop/lint/percent_symbol_array.rb

@@ -25,7 +25,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = "Within `%i`/`%I`, ':' and ',' are unnecessary and may be " \
-          'unwanted in the resulting symbols.'
+              'unwanted in the resulting symbols.'
 
         def on_array(node)
           process(node, '%i', '%I')

data/lib/rubocop/cop/lint/redundant_cop_disable_directive.rb

@@ -25,11 +25,12 @@ module RuboCop
       #
       #   # good
       #   x += 1
-      class RedundantCopDisableDirective < Base
+      class RedundantCopDisableDirective < Base # rubocop:todo Metrics/ClassLength
         include RangeHelp
         extend AutoCorrector
 
         COP_NAME = 'Lint/RedundantCopDisableDirective'
+        DEPARTMENT_MARKER = 'DEPARTMENT'
 
         attr_accessor :offenses_to_check
 
@@ -41,12 +42,9 @@ module RuboCop
         def on_new_investigation
           return unless offenses_to_check
 
-          cop_disabled_line_ranges = processed_source.disabled_line_ranges
-
           redundant_cops = Hash.new { |h, k| h[k] = Set.new }
 
-          each_redundant_disable(cop_disabled_line_ranges,
-                                 offenses_to_check) do |comment, redundant_cop|
+          each_redundant_disable do |comment, redundant_cop|
             redundant_cops[comment].add(redundant_cop)
           end
 
@@ -56,20 +54,31 @@ module RuboCop
 
         private
 
+        def cop_disabled_line_ranges
+          processed_source.disabled_line_ranges
+        end
+
+        def disabled_ranges
+          cop_disabled_line_ranges[COP_NAME] || [0..0]
+        end
+
         def previous_line_blank?(range)
           processed_source.buffer.source_line(range.line - 1).blank?
         end
 
-        def comment_range_with_surrounding_space(range)
-          if previous_line_blank?(range) &&
-             processed_source.comment_config.comment_only_line?(range.line)
+        def comment_range_with_surrounding_space(directive_comment_range, line_comment_range)
+          if previous_line_blank?(directive_comment_range) &&
+             processed_source.comment_config.comment_only_line?(directive_comment_range.line) &&
+             directive_comment_range.begin_pos == line_comment_range.begin_pos
             # When the previous line is blank, it should be retained
-            range_with_surrounding_space(range: range, side: :right)
+            range_with_surrounding_space(range: directive_comment_range, side: :right)
           else
             # Eat the entire comment, the preceding space, and the preceding
             # newline if there is one.
-            original_begin = range.begin_pos
-            range = range_with_surrounding_space(range: range, side: :left, newlines: true)
+            original_begin = directive_comment_range.begin_pos
+            range = range_with_surrounding_space(
+              range: directive_comment_range, side: :left, newlines: true
+            )
 
             range_with_surrounding_space(range: range,
                                          side: :right,
@@ -94,32 +103,34 @@ module RuboCop
           range_with_surrounding_space(range: range, side: :right, newlines: false)
         end
 
-        def each_redundant_disable(cop_disabled_line_ranges, offenses,
-                                   &block)
-          disabled_ranges = cop_disabled_line_ranges[COP_NAME] || [0..0]
-
+        def each_redundant_disable(&block)
           cop_disabled_line_ranges.each do |cop, line_ranges|
-            each_already_disabled(line_ranges, disabled_ranges) { |comment| yield comment, cop }
-
-            each_line_range(line_ranges, disabled_ranges, offenses, cop, &block)
+            each_already_disabled(cop, line_ranges, &block)
+            each_line_range(cop, line_ranges, &block)
           end
         end
 
-        def each_line_range(line_ranges, disabled_ranges, offenses,
-                            cop)
-          line_ranges.each_with_index do |line_range, ix|
-            comment = processed_source.comment_at_line(line_range.begin)
-            next if ignore_offense?(disabled_ranges, line_range)
+        def each_line_range(cop, line_ranges)
+          line_ranges.each_with_index do |line_range, line_range_index|
+            next if ignore_offense?(line_range)
 
-            redundant_cop = find_redundant(comment, offenses, cop, line_range, line_ranges[ix + 1])
-            yield comment, redundant_cop if redundant_cop
+            comment = processed_source.comment_at_line(line_range.begin)
+            redundant = if all_disabled?(comment)
+                          find_redundant_all(line_range, line_ranges[line_range_index + 1])
+                        elsif department_disabled?(cop, comment)
+                          find_redundant_department(cop, line_range)
+                        else
+                          find_redundant_cop(cop, line_range)
+                        end
+
+            yield comment, redundant if redundant
           end
         end
 
-        def each_already_disabled(line_ranges, disabled_ranges)
+        def each_already_disabled(cop, line_ranges)
           line_ranges.each_cons(2) do |previous_range, range|
-            next if ignore_offense?(disabled_ranges, range)
-            next if previous_range.end != range.begin
+            next if ignore_offense?(range)
+            next unless followed_ranges?(previous_range, range)
 
             # If a cop is disabled in a range that begins on the same line as
             # the end of the previous range, it means that the cop was
@@ -130,42 +141,56 @@ module RuboCop
             # Comments disabling all cops don't count since it's reasonable
             # to disable a few select cops first and then all cops further
             # down in the code.
-            yield comment if comment && !all_disabled?(comment)
+            yield comment, cop if comment && !all_disabled?(comment)
           end
         end
 
-        # rubocop:todo Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-        def find_redundant(comment, offenses, cop, line_range, next_line_range)
-          if all_disabled?(comment)
-            # If there's a disable all comment followed by a comment
-            # specifically disabling `cop`, we don't report the `all`
-            # comment. If the disable all comment is truly redundant, we will
-            # detect that when examining the comments of another cop, and we
-            # get the full line range for the disable all.
-            if (next_line_range.nil? || line_range.last != next_line_range.first) &&
-               offenses.none? { |o| line_range.cover?(o.line) }
-              'all'
-            end
-          else
-            cop_offenses = offenses.select { |o| o.cop_name == cop }
-            cop if cop_offenses.none? { |o| line_range.cover?(o.line) }
-          end
+        def find_redundant_cop(cop, range)
+          cop_offenses = offenses_to_check.select { |offense| offense.cop_name == cop }
+          cop if range_with_offense?(range, cop_offenses)
+        end
+
+        def find_redundant_all(range, next_range)
+          # If there's a disable all comment followed by a comment
+          # specifically disabling `cop`, we don't report the `all`
+          # comment. If the disable all comment is truly redundant, we will
+          # detect that when examining the comments of another cop, and we
+          # get the full line range for the disable all.
+          has_no_next_range = next_range.nil? || !followed_ranges?(range, next_range)
+          'all' if has_no_next_range && range_with_offense?(range)
+        end
+
+        def find_redundant_department(cop, range)
+          department = cop.split('/').first
+          offenses = offenses_to_check.select { |offense| offense.cop_name.start_with?(department) }
+          add_department_marker(department) if range_with_offense?(range, offenses)
+        end
+
+        def followed_ranges?(range, next_range)
+          range.end == next_range.begin
+        end
+
+        def range_with_offense?(range, offenses = offenses_to_check)
+          offenses.none? { |offense| range.cover?(offense.line) }
         end
-        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def all_disabled?(comment)
-          /rubocop\s*:\s*(?:disable|todo)\s+all\b/.match?(comment.text)
+          DirectiveComment.new(comment).disabled_all?
         end
 
-        def ignore_offense?(disabled_ranges, line_range)
+        def ignore_offense?(line_range)
           disabled_ranges.any? do |range|
             range.cover?(line_range.min) && range.cover?(line_range.max)
           end
         end
 
+        def department_disabled?(cop, comment)
+          directive = DirectiveComment.new(comment)
+          directive.in_directive_department?(cop) && !directive.overridden_by_department?(cop)
+        end
+
         def directive_count(comment)
-          _, cops_string = DirectiveComment.new(comment).match_captures
-          cops_string.split(/,\s*/).size
+          DirectiveComment.new(comment).directive_count
         end
 
         def add_offenses(redundant_cops)
@@ -179,14 +204,11 @@ module RuboCop
         end
 
         def add_offense_for_entire_comment(comment, cops)
-          location = comment.loc.expression
-          cop_list = cops.sort.map { |c| describe(c) }
-
-          add_offense(
-            location,
-            message: "Unnecessary disabling of #{cop_list.join(', ')}."
-          ) do |corrector|
-            range = comment_range_with_surrounding_space(location)
+          location = DirectiveComment.new(comment).range
+          cop_names = cops.sort.map { |c| describe(c) }.join(', ')
+
+          add_offense(location, message: message(cop_names)) do |corrector|
+            range = comment_range_with_surrounding_space(location, comment.loc.expression)
             corrector.remove(range)
           end
         end
@@ -197,10 +219,8 @@ module RuboCop
           ranges = cop_ranges.map { |_, r| r }
 
           cop_ranges.each do |cop, range|
-            add_offense(
-              range,
-              message: "Unnecessary disabling of #{describe(cop)}."
-            ) do |corrector|
+            cop_name = describe(cop)
+            add_offense(range, message: message(cop_name)) do |corrector|
               range = directive_range_in_list(range, ranges)
               corrector.remove(range)
             end
@@ -208,6 +228,7 @@ module RuboCop
         end
 
         def cop_range(comment, cop)
+          cop = remove_department_marker(cop)
           matching_range(comment.loc.expression, cop) ||
             matching_range(comment.loc.expression, Badge.parse(cop).cop_name) ||
             raise("Couldn't find #{cop} in comment: #{comment.text}")
@@ -230,18 +251,16 @@ module RuboCop
         end
 
         def describe(cop)
-          if cop == 'all'
-            'all cops'
-          elsif all_cop_names.include?(cop)
-            "`#{cop}`"
-          else
-            similar = NameSimilarity.find_similar_name(cop, all_cop_names)
-            if similar
-              "`#{cop}` (did you mean `#{similar}`?)"
-            else
-              "`#{cop}` (unknown cop)"
-            end
-          end
+          return 'all cops' if cop == 'all'
+          return "`#{remove_department_marker(cop)}` department" if department_marker?(cop)
+          return "`#{cop}`" if all_cop_names.include?(cop)
+
+          similar = NameSimilarity.find_similar_name(cop, all_cop_names)
+          similar ? "`#{cop}` (did you mean `#{similar}`?)" : "`#{cop}` (unknown cop)"
+        end
+
+        def message(cop_names)
+          "Unnecessary disabling of #{cop_names}."
         end
 
         def all_cop_names
@@ -252,6 +271,18 @@ module RuboCop
           line = range.source_buffer.source_line(range.last_line)
           (line =~ /\s*\z/) == range.last_column
         end
+
+        def department_marker?(department)
+          department.start_with?(DEPARTMENT_MARKER)
+        end
+
+        def remove_department_marker(department)
+          department.gsub(DEPARTMENT_MARKER, '')
+        end
+
+        def add_department_marker(department)
+          DEPARTMENT_MARKER + department
+        end
       end
     end
   end