rubocop 1.18.1 → 1.22.3

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

@@ -9,6 +9,16 @@ module RuboCop
       # example, mistranslating an array of literals to percent string notation)
       # rather than meant to be part of the resulting strings.
       #
+      # @safety
+      #   The cop is unsafe because the correction changes the values in the array
+      #   and that might have been done purposely.
+      #
+      #   [source,ruby]
+      #   ----
+      #   %w('foo', "bar") #=> ["'foo',", '"bar"']
+      #   %w(foo bar)      #=> ['foo', 'bar']
+      #   ----
+      #
       # @example
       #
       #   # bad

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

@@ -13,6 +13,10 @@ module RuboCop
       # `Exception`. Alternatively, make `Exception` a fully qualified class
       # name with an explicit namespace.
       #
+      # @safety
+      #   This cop is unsafe because it will change the exception class being
+      #   raised, which is a change in behaviour.
+      #
       # @example
       #   # bad
       #   raise Exception, 'Error message here'

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

@@ -7,13 +7,14 @@ module RuboCop
       # `instance_of?`, `kind_of?`, `is_a?`, `eql?`, `respond_to?`, and `equal?` methods
       # are checked by default. These are customizable with `AllowedMethods` option.
       #
-      # This cop is marked as unsafe, because auto-correction can change the
-      # return type of the expression. An offending expression that previously
-      # could return `nil` will be auto-corrected to never return `nil`.
-      #
       # In the example below, the safe navigation operator (`&.`) is unnecessary
       # because `NilClass` has methods like `respond_to?` and `is_a?`.
       #
+      # @safety
+      #   This cop is unsafe, because auto-correction can change the return type of
+      #   the expression. An offending expression that previously could return `nil`
+      #   will be auto-corrected to never return `nil`.
+      #
       # @example
       #   # bad
       #   do_something if attrs&.respond_to?(:[])

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for uses a file requiring itself with `require_relative`.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   # foo.rb
+      #   require_relative 'foo'
+      #   require_relative 'bar'
+      #
+      #   # good
+      #
+      #   # foo.rb
+      #   require_relative 'bar'
+      #
+      class RequireRelativeSelfPath < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Remove the `require_relative` that requires itself.'
+        RESTRICT_ON_SEND = %i[require_relative].freeze
+
+        def on_send(node)
+          return unless (required_feature = node.first_argument)
+          return unless required_feature.respond_to?(:value)
+          return unless same_file?(processed_source.file_path, required_feature.value)
+
+          add_offense(node) do |corrector|
+            corrector.remove(range_by_whole_lines(node.source_range, include_final_newline: true))
+          end
+        end
+
+        private
+
+        def same_file?(file_path, required_feature)
+          file_path == required_feature || remove_ext(file_path) == required_feature
+        end
+
+        def remove_ext(file_path)
+          File.basename(file_path, File.extname(file_path))
+        end
+      end
+    end
+  end
+end

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

@@ -141,7 +141,7 @@ module RuboCop
         end
 
         def reference_pos(node)
-          node = node.parent.masgn_type? ? node.parent : node
+          node = node.parent if node.parent.masgn_type?
 
           node.source_range.begin_pos
         end

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

@@ -10,7 +10,7 @@ module RuboCop
       #
       # NOTE: Shadowing of variables in block passed to `Ractor.new` is allowed
       # because `Ractor` should not access outer variables.
-      # eg. following syle is encouraged:
+      # eg. following style is encouraged:
       #
       #   worker_id, pipe = env
       #   Ractor.new(worker_id, pipe) do |worker_id, pipe|

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

@@ -143,7 +143,7 @@ module RuboCop
           # Although some operators can be converted to symbols normally
           # (ie. `:==`), these are not accepted as hash keys and will
           # raise a syntax error (eg. `{ ==: ... }`). Therefore, if the
-          # symbol does not start with an alpha-numeric or underscore, it
+          # symbol does not start with an alphanumeric or underscore, it
           # will be ignored.
           return unless node.value.to_s.match?(/\A[a-z0-9_]/i)
 

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for "triple quotes" (strings delimted by any odd number
+      # This cop checks for "triple quotes" (strings delimited by any odd number
       # of quotes greater than 1).
       #
       # Ruby allows multiple strings to be implicitly concatenated by just

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

@@ -13,14 +13,19 @@ module RuboCop
       # Keyword arguments (including `**kwargs`) do not get counted towards
       # this, as they are not used by the methods in question.
       #
-      # NOTE: This cop matches for method names only and hence cannot tell apart
-      # methods with same name in different classes.
-      #
       # Method names and their expected arity can be configured like this:
       #
+      # [source,yaml]
+      # ----
       # Methods:
       #   inject: 2
       #   reduce: 2
+      # ----
+      #
+      # @safety
+      #  This cop matches for method names only and hence cannot tell apart
+      #  methods with same name in different classes, which may lead to a
+      #  false positive.
       #
       # @example
       #   # bad

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

@@ -87,9 +87,8 @@ module RuboCop
         end
 
         def ignored_method?(body)
-          cop_config['IgnoreEmptyMethods'] && body.nil? ||
-            cop_config['IgnoreNotImplementedMethods'] &&
-              not_implemented?(body)
+          (cop_config['IgnoreEmptyMethods'] && body.nil?) ||
+            (cop_config['IgnoreNotImplementedMethods'] && not_implemented?(body))
         end
 
         def message(variable)

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

@@ -6,8 +6,9 @@ module RuboCop
       # This cop checks for useless method definitions, specifically: empty constructors
       # and methods just delegating to `super`.
       #
-      # This cop is marked as unsafe as it can trigger false positives for cases when
-      # an empty constructor just overrides the parent constructor, which is bad anyway.
+      # @safety
+      #   This cop is unsafe as it can register false positives for cases when an empty
+      #   constructor just overrides the parent constructor, which is bad anyway.
       #
       # @example
       #   # bad

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

@@ -5,11 +5,14 @@ module RuboCop
     module Lint
       # This cop checks for setter call to local variable as the final
       # expression of a function definition.
-      # Its auto-correction is marked as unsafe because return value will be changed.
       #
-      # NOTE: There are edge cases in which the local variable references a
-      # value that is also accessible outside the local scope. This is not
-      # detected by the cop, and it can yield a false positive.
+      # @safety
+      #   There are edge cases in which the local variable references a
+      #   value that is also accessible outside the local scope. This is not
+      #   detected by the cop, and it can yield a false positive.
+      #
+      #   As well, auto-correction is unsafe because the method's
+      #   return value will be changed.
       #
       # @example
       #

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

@@ -7,8 +7,9 @@ module RuboCop
       # (when the integer <= 0) or that will only ever yield once
       # (`1.times`).
       #
-      # This cop is marked as unsafe as `times` returns its receiver, which
-      # is *usually* OK, but might change behavior.
+      # @safety
+      #   This cop is unsafe as `times` returns its receiver, which is
+      #   *usually* OK, but might change behavior.
       #
       # @example
       #   # bad
@@ -65,7 +66,7 @@ module RuboCop
         private
 
         def never_process?(count, node)
-          count < 1 || node.block_type? && node.body.nil?
+          count < 1 || (node.block_type? && node.body.nil?)
         end
 
         def remove_node(corrector, node)
@@ -81,7 +82,7 @@ module RuboCop
           return if block_reassigns_arg?(node, block_arg)
 
           source = node.body.source
-          source.gsub!(/\b#{block_arg}\b/, '1') if block_arg
+          source.gsub!(/\b#{block_arg}\b/, '0') if block_arg
 
           corrector.replace(node, fix_indentation(source, node.loc.column...node.body.loc.column))
         end

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

@@ -8,6 +8,12 @@ module RuboCop
       # (method calls), and conditions. See http://c2.com/cgi/wiki?AbcMetric
       # and https://en.wikipedia.org/wiki/ABC_Software_Metric.
       #
+      # Interpreting ABC size:
+      #
+      # * <= 17 satisfactory
+      # * 18..30 unsatisfactory
+      # * > 30 dangerous
+      #
       # You can have repeated "attributes" calls count as a single "branch".
       # For this purpose, attributes are any method with no argument; no attempt
       # is meant to distinguish actual `attr_reader` from other methods.

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

@@ -9,6 +9,9 @@ module RuboCop
       # Keyword arguments can optionally be excluded from the total count,
       # as they add less complexity than positional or optional parameters.
       #
+      # NOTE: Explicit block argument `&block` is not counted to prevent
+      #       erroneous change that is avoided by making block argument implicit.
+      #
       # @example Max: 3
       #   # good
       #   def foo(a, b, c = 1)
@@ -94,9 +97,9 @@ module RuboCop
 
         def args_count(node)
           if count_keyword_args?
-            node.children.size
+            node.children.count { |a| !a.blockarg_type? }
           else
-            node.children.count { |a| !NAMED_KEYWORD_TYPES.include?(a.type) }
+            node.children.count { |a| !NAMED_KEYWORD_TYPES.include?(a.type) && !a.blockarg_type? }
           end
         end
 

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

@@ -45,7 +45,7 @@ module RuboCop
             else
               # Otherwise, the case node gets 0.8 complexity points and each
               # when gets 0.2.
-              (0.8 + 0.2 * nb_branches).round
+              (0.8 + (0.2 * nb_branches)).round
             end
           when :if
             node.else? && !node.elsif? ? 2 : 1

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

@@ -46,7 +46,7 @@ module RuboCop
             visit_depth_last(@node) { |child| calculate_node(child) }
 
             [
-              Math.sqrt(@assignment**2 + @branch**2 + @condition**2).round(2),
+              Math.sqrt((@assignment**2) + (@branch**2) + (@condition**2)).round(2),
               "<#{@assignment}, #{@branch}, #{@condition}>"
             ]
           end

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

@@ -147,7 +147,7 @@ module RuboCop
 
           # Returns true for lines that shall not be included in the count.
           def irrelevant_line?(source_line)
-            source_line.blank? || !count_comments? && comment_line?(source_line)
+            source_line.blank? || (!count_comments? && comment_line?(source_line))
           end
 
           def count_comments?

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

@@ -2,40 +2,63 @@
 
 module RuboCop
   module Cop
-    module Style
-      # Common functionality related to annotation comments.
-      module AnnotationComment
-        private
-
-        # @api public
-        def annotation?(comment)
-          _margin, first_word, colon, space, note = split_comment(comment)
-          keyword_appearance?(first_word, colon, space) &&
-            !just_first_word_of_sentence?(first_word, colon, space, note)
-        end
-
-        # @api public
-        def split_comment(comment)
-          match = comment.text.match(/^(# ?)([A-Za-z]+)(\s*:)?(\s+)?(\S+)?/)
-          return false unless match
-
-          match.captures
-        end
-
-        # @api public
-        def keyword_appearance?(first_word, colon, space)
-          first_word && keyword?(first_word.upcase) && (colon || space)
-        end
-
-        # @api private
-        def just_first_word_of_sentence?(first_word, colon, space, note)
-          first_word == first_word.capitalize && !colon && space && note
-        end
-
-        # @api public
-        def keyword?(word)
-          config.for_cop('Style/CommentAnnotation')['Keywords'].include?(word)
-        end
+    # Representation of an annotation comment in source code (eg. `# TODO: blah blah blah`).
+    class AnnotationComment
+      extend Forwardable
+
+      attr_reader :comment, :margin, :keyword, :colon, :space, :note
+
+      # @param [Parser::Source::Comment] comment
+      # @param [Array<String>] keywords
+      def initialize(comment, keywords)
+        @comment = comment
+        @keywords = keywords
+        @margin, @keyword, @colon, @space, @note = split_comment(comment)
+      end
+
+      def annotation?
+        keyword_appearance? && !just_keyword_of_sentence?
+      end
+
+      def correct?(colon:)
+        return false unless keyword && space && note
+        return false unless keyword == keyword.upcase
+
+        self.colon.nil? == !colon
+      end
+
+      # Returns the range bounds for just the annotation
+      def bounds
+        start = comment.loc.expression.begin_pos + margin.length
+        length = [keyword, colon, space].reduce(0) { |len, elem| len + elem.to_s.length }
+        [start, start + length]
+      end
+
+      private
+
+      attr_reader :keywords
+
+      def split_comment(comment)
+        # Sort keywords by reverse length so that if a keyword is in a phrase
+        # but also on its own, both will match properly.
+        keywords_regex = Regexp.new(
+          Regexp.union(keywords.sort_by { |w| -w.length }).source,
+          Regexp::IGNORECASE
+        )
+        regex = /^(# ?)(\b#{keywords_regex}\b)(\s*:)?(\s+)?(\S+)?/i
+
+        match = comment.text.match(regex)
+        return false unless match
+
+        match.captures
+      end
+
+      def keyword_appearance?
+        keyword && (colon || space)
+      end
+
+      def just_keyword_of_sentence?
+        keyword == keyword.capitalize && !colon && space && note
       end
     end
   end

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

@@ -97,9 +97,9 @@ module RuboCop
       # 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?
+        return index unless node.send_type? || node.array_type?
 
-        heredoc_index = elements.index { |arg| (arg.str_type? || arg.dstr_type?) && arg.heredoc? }
+        heredoc_index = elements.index { |arg| arg.respond_to?(:heredoc?) && arg.heredoc? }
         return index unless heredoc_index
         return nil if heredoc_index.zero?
 

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

@@ -43,7 +43,7 @@ module RuboCop
 
       # Returns true for lines that shall not be included in the count.
       def irrelevant_line(source_line)
-        source_line.blank? || !count_comments? && comment_line?(source_line)
+        source_line.blank? || (!count_comments? && comment_line?(source_line))
       end
 
       def build_code_length_calculator(node)

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

@@ -5,7 +5,6 @@ module RuboCop
     # Common functionality for checking documentation.
     module DocumentationComment
       extend NodePattern::Macros
-      include Style::AnnotationComment
 
       private
 
@@ -15,7 +14,7 @@ module RuboCop
         return false unless preceding_comment?(node, preceding_lines.last)
 
         preceding_lines.any? do |comment|
-          !annotation?(comment) &&
+          !AnnotationComment.new(comment, annotation_keywords).annotation? &&
             !interpreter_directive_comment?(comment) &&
             !rubocop_directive_comment?(comment)
         end
@@ -44,6 +43,10 @@ module RuboCop
       def rubocop_directive_comment?(comment)
         !!DirectiveComment.new(comment).match_captures
       end
+
+      def annotation_keywords
+        config.for_cop('Style/CommentAnnotation')['Keywords']
+      end
     end
   end
 end

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

@@ -34,8 +34,7 @@ module RuboCop
 
       def matching_ranges(end_loc, align_ranges)
         align_ranges.select do |_, range|
-          range.line == end_loc.line ||
-            column_offset_between(range, end_loc).zero?
+          same_line?(range, end_loc) || column_offset_between(range, end_loc).zero?
         end
       end
 

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

@@ -8,7 +8,9 @@ module RuboCop
 
       FROZEN_STRING_LITERAL = '# frozen_string_literal:'
       FROZEN_STRING_LITERAL_ENABLED = '# frozen_string_literal: true'
-      FROZEN_STRING_LITERAL_TYPES = %i[str dstr].freeze
+      FROZEN_STRING_LITERAL_TYPES_RUBY27 = %i[str dstr].freeze
+
+      private_constant :FROZEN_STRING_LITERAL_TYPES_RUBY27
 
       def frozen_string_literal_comment_exists?
         leading_comment_lines.any? { |line| MagicComment.parse(line).valid_literal_value? }
@@ -16,6 +18,26 @@ module RuboCop
 
       private
 
+      def frozen_string_literal?(node)
+        frozen_string = if target_ruby_version >= 3.0
+                          uninterpolated_string?(node) || frozen_heredoc?(node)
+                        else
+                          FROZEN_STRING_LITERAL_TYPES_RUBY27.include?(node.type)
+                        end
+
+        frozen_string && frozen_string_literals_enabled?
+      end
+
+      def uninterpolated_string?(node)
+        node.str_type? || (node.dstr_type? && node.each_descendant(:begin).none?)
+      end
+
+      def frozen_heredoc?(node)
+        return false unless node.dstr_type? && node.heredoc?
+
+        node.children.all?(&:str_type?)
+      end
+
       def frozen_string_literals_enabled?
         ruby_version = processed_source.ruby_version
         return false unless ruby_version

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

@@ -139,9 +139,9 @@ module RuboCop
         end
 
         def self.from_map_to_h(node, match)
-          strip_trailing_chars = 0
-
-          unless node.parent&.block_type?
+          if node.parent&.block_type? && node.parent.send_node == node
+            strip_trailing_chars = 0
+          else
             map_range = node.children.first.source_range
             node_range = node.source_range
             strip_trailing_chars = node_range.end_pos - map_range.end_pos
@@ -175,7 +175,12 @@ module RuboCop
         end
 
         def set_new_body_expression(transforming_body_expr, corrector)
-          corrector.replace(block_node.body, transforming_body_expr.loc.expression.source)
+          body_source = transforming_body_expr.loc.expression.source
+          if transforming_body_expr.hash_type? && !transforming_body_expr.braces?
+            body_source = "{ #{body_source} }"
+          end
+
+          corrector.replace(block_node.body, body_source)
         end
       end
     end

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

@@ -20,6 +20,11 @@ module RuboCop
 
       private
 
+      def indent_level(str)
+        indentations = str.lines.map { |line| line[/^\s*/] }.reject { |line| line.end_with?("\n") }
+        indentations.empty? ? 0 : indentations.min_by(&:size).size
+      end
+
       def delimiter_string(node)
         node.source.match(OPENING_DELIMITER).captures[1]
       end

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

@@ -15,7 +15,7 @@ module RuboCop
         node.arguments.each do |arg|
           on_node(type, arg, :send) do |type_node|
             left_brace = type_node.loc.begin
-            if left_brace && left_brace.line == left_parenthesis.line
+            if left_brace && same_line?(left_brace, left_parenthesis)
               yield type_node, left_parenthesis
               ignore_node(type_node)
             end

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

@@ -134,7 +134,7 @@ module RuboCop
 
           next if a.setter_method?
           next unless kind == :with_or_without_parentheses ||
-                      kind == :with_parentheses && parentheses?(a)
+                      (kind == :with_parentheses && parentheses?(a))
 
           a.arguments.any? { |arg| within_node?(node, arg) }
         end
@@ -156,7 +156,7 @@ module RuboCop
 
       def disqualified_rhs?(candidate, ancestor)
         UNALIGNED_RHS_TYPES.include?(ancestor.type) ||
-          ancestor.block_type? && part_of_block_body?(candidate, ancestor)
+          (ancestor.block_type? && part_of_block_body?(candidate, ancestor))
       end
 
       def valid_rhs?(candidate, ancestor)

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

@@ -90,7 +90,7 @@ module RuboCop
       # This method depends on the fact that we have guarded
       # against implicit and empty literals.
       def opening_brace_on_same_line?(node)
-        node.loc.begin.line == children(node).first.first_line
+        same_line?(node.loc.begin, children(node).first)
       end
 
       # This method depends on the fact that we have guarded

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

@@ -35,7 +35,15 @@ module RuboCop
           previous: gem_name(current),
           current: gem_name(previous)
         )
-        add_offense(current, message: message)
+
+        add_offense(current, message: message) do |corrector|
+          OrderedGemCorrector.correct(
+            processed_source,
+            current,
+            previous_declaration(current),
+            treat_comments_as_separators
+          ).call(corrector)
+        end
       end
 
       def gem_name(declaration_node)

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

@@ -18,15 +18,16 @@ module RuboCop
           !parent.parenthesized? && parent&.block_literal?
       end
 
+      # Override to determine values that are invalid in a percent array
+      def invalid_percent_array_contents?(_node)
+        false
+      end
+
       def allowed_bracket_array?(node)
         comments_in_array?(node) || below_array_length?(node) ||
           invalid_percent_array_context?(node)
       end
 
-      def message(_node)
-        style == :percent ? self.class::PERCENT_MSG : self.class::ARRAY_MSG
-      end
-
       def comments_in_array?(node)
         line_span = node.source_range.first_line...node.source_range.last_line
         processed_source.each_comment_in_lines(line_span).any?
@@ -35,9 +36,19 @@ module RuboCop
       def check_percent_array(node)
         array_style_detected(:percent, node.values.size)
 
-        return unless style == :brackets
+        brackets_required = invalid_percent_array_contents?(node)
+        return unless style == :brackets || brackets_required
 
-        add_offense(node) { |corrector| correct_bracketed(corrector, node) }
+        # If in percent style but brackets are required due to
+        # string content, the file should be excluded in auto-gen-config
+        no_acceptable_style! if brackets_required
+
+        bracketed_array = build_bracketed_array(node)
+        message = format(self.class::ARRAY_MSG, prefer: bracketed_array)
+
+        add_offense(node, message: message) do |corrector|
+          corrector.replace(node, bracketed_array)
+        end
       end
 
       def check_bracketed_array(node, literal_prefix)
@@ -47,7 +58,7 @@ module RuboCop
 
         return unless style == :percent
 
-        add_offense(node) do |corrector|
+        add_offense(node, message: self.class::PERCENT_MSG) do |corrector|
           percent_literal_corrector = PercentLiteralCorrector.new(@config, @preferred_delimiters)
           percent_literal_corrector.correct(corrector, node, literal_prefix)
         end