rubocop 1.14.0 → 1.18.0

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

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

@@ -54,6 +54,7 @@ module RuboCop
           directive = DirectiveComment.new(comment)
 
           cop_names.each do |name|
+            name = name.split('/').first if department?(directive, name)
             add_offense(
               range_of_offense(comment, name),
               message: format(MSG, cop: all_or_name(name))
@@ -119,6 +120,10 @@ module RuboCop
         def all_or_name(name)
           name == 'all' ? 'all cops' : name
         end
+
+        def department?(directive, name)
+          directive.in_directive_department?(name) && !directive.overridden_by_department?(name)
+        end
       end
     end
   end

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

@@ -66,10 +66,11 @@ module RuboCop
       class SymbolConversion < Base
         extend AutoCorrector
         include ConfigurableEnforcedStyle
+        include SymbolHelp
 
         MSG = 'Unnecessary symbol conversion; use `%<correction>s` instead.'
         MSG_CONSISTENCY = 'Symbol hash key should be quoted for consistency; ' \
-          'use `%<correction>s` instead.'
+                          'use `%<correction>s` instead.'
         RESTRICT_ON_SEND = %i[to_sym intern].freeze
 
         def on_send(node)
@@ -138,10 +139,6 @@ module RuboCop
           node.parent&.array_type? && node.parent&.percent_literal?
         end
 
-        def hash_key?(node)
-          node.parent&.pair_type? && node == node.parent.child_nodes.first
-        end
-
         def correct_hash_key(node)
           # Although some operators can be converted to symbols normally
           # (ie. `:==`), these are not accepted as hash keys and will
@@ -167,7 +164,7 @@ module RuboCop
             next if requires_quotes?(key)
             next if properly_quoted?(key.source, %("#{key.value}"))
 
-            correction = "#{quote_type}#{key.value}#{quote_type}"
+            correction = %("#{key.value}")
             register_offense(
               key,
               correction: correction,
@@ -175,13 +172,6 @@ module RuboCop
             )
           end
         end
-
-        def quote_type
-          # Use the `Style/StringLiterals` configuration for quoting symbols
-          return '"' unless config.for_cop('Style/StringLiterals')['Enabled']
-
-          config.for_cop('Style/StringLiterals')['EnforcedStyle'] == 'single_quotes' ? "'" : '"'
-        end
       end
     end
   end

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

@@ -143,7 +143,7 @@ module RuboCop
 
         def message_for_underscore_prefix(variable)
           "If it's necessary, use `_` or `_#{variable.name}` " \
-          "as an argument name to indicate that it won't be used."
+            "as an argument name to indicate that it won't be used."
         end
 
         def define_method_call?(variable)

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

@@ -85,7 +85,7 @@ module RuboCop
           return unless assignment.meta_assignment_node.equal?(return_value_node)
 
           " Use `#{assignment.operator.sub(/=$/, '')}` " \
-          "instead of `#{assignment.operator}`."
+            "instead of `#{assignment.operator}`."
         end
 
         def similar_name_message(variable)

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

@@ -104,7 +104,7 @@ module RuboCop
         end
 
         def check_literal(node)
-          return if !node.literal? || node.xstr_type?
+          return if !node.literal? || node.xstr_type? || node.range_type?
 
           add_offense(node, message: format(LIT_MSG, lit: node.source))
         end

data/lib/rubocop/cop/metrics/utils/code_length_calculator.rb

@@ -50,7 +50,7 @@ module RuboCop
                 ->(node) { heredoc_node?(node) }
               else
                 raise ArgumentError, "Unknown foldable type: #{type.inspect}. "\
-                  "Valid foldable types are: #{FOLDABLE_TYPES.join(', ')}."
+                                     "Valid foldable types are: #{FOLDABLE_TYPES.join(', ')}."
               end
             end
           end

data/lib/rubocop/cop/migration/department_name.rb

@@ -61,7 +61,9 @@ module RuboCop
         end
 
         def valid_content_token?(content_token)
-          /\W+/.match?(content_token) || DISABLING_COPS_CONTENT_TOKEN.match?(content_token)
+          /\W+/.match?(content_token) ||
+            DISABLING_COPS_CONTENT_TOKEN.match?(content_token) ||
+            Registry.global.department?(content_token)
         end
 
         def contain_unexpected_character_for_department_name?(name)

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

@@ -70,17 +70,42 @@ module RuboCop
       def extract_first_element_over_column_limit(node, elements, max)
         line = node.first_line
 
-        # If the first argument is a hash pair but the method is not parenthesized,
-        # the argument cannot be moved to another line because it cause a syntax error.
-        elements.shift if node.send_type? && !node.parenthesized? && elements.first.pair_type?
+        # If a `send` node is not parenthesized, don't move the first element, because it
+        # can result in changed behavior or a syntax error.
+        if node.send_type? && !node.parenthesized? && !first_argument_is_heredoc?(node)
+          elements = elements.drop(1)
+        end
 
         i = 0
         i += 1 while within_column_limit?(elements[i], max, line)
+        i = shift_elements_for_heredoc_arg(node, elements, i)
+
+        return if i.nil?
         return elements.first if i.zero?
 
         elements[i - 1]
       end
 
+      # @api private
+      def first_argument_is_heredoc?(node)
+        first_argument = node.first_argument
+
+        first_argument.respond_to?(:heredoc?) && first_argument.heredoc?
+      end
+
+      # @api private
+      # If a send node contains a heredoc argument, splitting cannot happen
+      # after the heredoc or else it will cause a syntax error.
+      def shift_elements_for_heredoc_arg(node, elements, index)
+        return index unless node.send_type?
+
+        heredoc_index = elements.index { |arg| (arg.str_type? || arg.dstr_type?) && arg.heredoc? }
+        return index unless heredoc_index
+        return nil if heredoc_index.zero?
+
+        heredoc_index >= index ? index : heredoc_index + 1
+      end
+
       # @api private
       def within_column_limit?(element, max, line)
         element && element.loc.column <= max && element.loc.line == line