rubocop 1.19.1 → 1.22.1

data/lib/rubocop/cop/gemspec/ordered_dependencies.rb

@@ -50,15 +50,15 @@ module RuboCop
       #   spec.add_dependency 'rubocop'
       #   # For tests
       #   spec.add_dependency 'rspec'
-      class OrderedDependencies < Cop # rubocop:disable InternalAffairs/InheritDeprecatedCopClass
-        include ConfigurableEnforcedStyle
+      class OrderedDependencies < Base
+        extend AutoCorrector
         include OrderedGemNode
 
         MSG = 'Dependencies should be sorted in an alphabetical order within ' \
               'their section of the gemspec. '\
               'Dependency `%<previous>s` should appear before `%<current>s`.'
 
-        def investigate(processed_source)
+        def on_new_investigation
           return if processed_source.blank?
 
           dependency_declarations(processed_source.ast)
@@ -71,15 +71,6 @@ module RuboCop
           end
         end
 
-        def autocorrect(node)
-          OrderedGemCorrector.correct(
-            processed_source,
-            node,
-            previous_declaration(node),
-            treat_comments_as_separators
-          )
-        end
-
         private
 
         def previous_declaration(node)

data/lib/rubocop/cop/gemspec/required_ruby_version.rb

@@ -42,7 +42,7 @@ module RuboCop
       #   end
       #
       #   # accepted but not recommended, since
-      #   # Ruby does not really follow semantic versionning
+      #   # Ruby does not really follow semantic versioning
       #   Gem::Specification.new do |spec|
       #     spec.required_ruby_version = '~> 2.5'
       #   end

data/lib/rubocop/cop/generator.rb

@@ -24,6 +24,11 @@ module RuboCop
               # `SupportedStyle` and unique configuration, there needs to be examples.
               # Examples must have valid Ruby syntax. Do not use upticks.
               #
+              # @safety
+              #   Delete this section if the cop is not unsafe (`Safe: false` or
+              #   `SafeAutoCorrect: false`), or use it to explain how the cop is
+              #   unsafe.
+              #
               # @example EnforcedStyle: bar (default)
               #   # Description of the `bar` style.
               #
@@ -106,9 +111,8 @@ module RuboCop
         '[modify] A configuration for the cop is added into ' \
         '%<configuration_file_path>s.'
 
-      def initialize(name, github_user, output: $stdout)
+      def initialize(name, output: $stdout)
         @badge = Badge.parse(name)
-        @github_user = github_user
         @output = output
         return if badge.qualified?
 
@@ -142,17 +146,19 @@ module RuboCop
 
       def todo
         <<~TODO
-          Do 3 steps:
-            1. Add an entry to the "New features" section in CHANGELOG.md,
-               e.g. "Add new `#{badge}` cop. ([@#{github_user}][])"
-            2. Modify the description of #{badge} in config/default.yml
-            3. Implement your new cop in the generated file!
+          Do 4 steps:
+            1. Modify the description of #{badge} in config/default.yml
+            2. Implement your new cop in the generated file!
+            3. Commit your new cop with a message such as
+               e.g. "Add new `#{badge}` cop."
+            4. Run `bundle exec rake changelog:new` to generate a changelog entry
+               for your new cop.
         TODO
       end
 
       private
 
-      attr_reader :badge, :github_user, :output
+      attr_reader :badge, :output
 
       def write_unless_file_exists(path, contents)
         if File.exist?(path)

data/lib/rubocop/cop/internal_affairs/node_matcher_directive.rb

@@ -23,7 +23,7 @@ module RuboCop
         extend AutoCorrector
         include RangeHelp
 
-        MSG = 'Preceed `%<method>s` with a `@!method` YARD directive.'
+        MSG = 'Precede `%<method>s` with a `@!method` YARD directive.'
         MSG_WRONG_NAME = '`@!method` YARD directive has invalid method name, ' \
                          'use `%<expected>s` instead of `%<actual>s`.'
         MSG_TOO_MANY = 'Multiple `@!method` YARD directives found for this matcher.'

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

@@ -54,7 +54,7 @@ module RuboCop
 
         def on_send(node)
           first_arg = node.first_argument
-          return if !multiple_arguments?(node, first_arg) || node.send_type? && node.method?(:[]=)
+          return if !multiple_arguments?(node, first_arg) || (node.send_type? && node.method?(:[]=))
 
           if first_arg.hash_type? && !first_arg.braces?
             pairs = first_arg.pairs

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

@@ -264,7 +264,8 @@ module RuboCop
 
         def source_range_with_comment(node)
           begin_pos, end_pos =
-            if node.def_type? && !node.method?(:initialize) || node.send_type? && node.def_modifier?
+            if (node.def_type? && !node.method?(:initialize)) ||
+               (node.send_type? && node.def_modifier?)
               start_node = find_visibility_start(node) || node
               end_node = find_visibility_end(node) || node
               [begin_pos_with_comment(start_node),

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

@@ -68,19 +68,26 @@ module RuboCop
         end
 
         def proper_dot_position?(node)
-          receiver_line = node.receiver.source_range.end.line
           selector_line = selector_range(node).line
 
-          # receiver and selector are on the same line
-          return true if selector_line == receiver_line
+          # If the receiver is a HEREDOC and the selector is on the same line
+          # then there is nothing to do
+          return true if heredoc?(node.receiver) && node.receiver.loc.first_line == selector_line
 
+          receiver_line = receiver_end_line(node.receiver)
           dot_line = node.loc.dot.line
 
+          # receiver and selector are on the same line
+          return true if selector_line == receiver_line
+
           # don't register an offense if there is a line comment between the
           # dot and the selector otherwise, we might break the code while
           # "correcting" it (even if there is just an extra blank line, treat
           # it the same)
-          return true if line_between?(selector_line, dot_line)
+          # Also, in the case of a heredoc, the receiver will end after the dot,
+          # because the heredoc body is on subsequent lines, so use the highest
+          # line to compare to.
+          return true if line_between?(selector_line, [receiver_line, dot_line].max)
 
           correct_dot_position_style?(dot_line, selector_line)
         end
@@ -96,6 +103,26 @@ module RuboCop
           end
         end
 
+        def receiver_end_line(node)
+          if (line = last_heredoc_line(node))
+            line
+          else
+            node.source_range.end.line
+          end
+        end
+
+        def last_heredoc_line(node)
+          if node.send_type?
+            node.arguments.select { |arg| heredoc?(arg) }.map { |arg| arg.loc.heredoc_end.line }.max
+          elsif heredoc?(node)
+            node.loc.heredoc_end.line
+          end
+        end
+
+        def heredoc?(node)
+          (node.str_type? || node.dstr_type?) && node.heredoc?
+        end
+
         def selector_range(node)
           # l.(1) has no selector, so we use the opening parenthesis instead
           node.loc.selector || node.loc.begin

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

@@ -182,7 +182,7 @@ module RuboCop
 
         def assignment_or_operator_method(node)
           node.ancestors.find do |ancestor|
-            ancestor.assignment_or_similar? || ancestor.send_type? && ancestor.operator_method?
+            ancestor.assignment_or_similar? || (ancestor.send_type? && ancestor.operator_method?)
           end
         end
       end

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

@@ -77,7 +77,7 @@ module RuboCop
         end
 
         def allowed_on_first_line?(comment)
-          shebang?(comment) || rackup_config_file? && rackup_options?(comment)
+          shebang?(comment) || (rackup_config_file? && rackup_options?(comment))
         end
 
         def shebang?(comment)

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

@@ -176,15 +176,15 @@ module RuboCop
         def ignored_line?(line, line_index)
           matches_ignored_pattern?(line) ||
             shebang?(line, line_index) ||
-            heredocs && line_in_permitted_heredoc?(line_index.succ)
+            (heredocs && line_in_permitted_heredoc?(line_index.succ))
         end
 
         def shebang?(line, line_index)
           line_index.zero? && line.start_with?('#!')
         end
 
-        def register_offense(loc, line, line_index)
-          message = format(MSG, length: line_length(line), max: max)
+        def register_offense(loc, line, line_index, length: line_length(line))
+          message = format(MSG, length: length, max: max)
 
           self.breakable_range = breakable_range_by_line_index[line_index]
 
@@ -241,9 +241,10 @@ module RuboCop
         end
 
         def check_directive_line(line, line_index)
-          return if line_length_without_directive(line) <= max
+          length_without_directive = line_length_without_directive(line)
+          return if length_without_directive <= max
 
-          range = max..(line_length_without_directive(line) - 1)
+          range = max..(length_without_directive - 1)
           register_offense(
             source_range(
               processed_source.buffer,
@@ -251,7 +252,8 @@ module RuboCop
               range
             ),
             line,
-            line_index
+            line_index,
+            length: length_without_directive
           )
         end
 

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

@@ -89,7 +89,7 @@ module RuboCop
           if node.source.lines.first.end_with?("|\n")
             PIPE_SIZE
           else
-            1 + PIPE_SIZE * 2
+            1 + (PIPE_SIZE * 2)
           end
         end
 

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

@@ -6,6 +6,9 @@ module RuboCop
       # This cop ensures that each argument in a multi-line method call
       # starts on a separate line.
       #
+      # NOTE: this cop does not move the first argument, if you want that to
+      # be on a separate line, see `Layout/FirstMethodArgumentLineBreak`.
+      #
       # @example
       #
       #   # bad

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

@@ -127,6 +127,7 @@ module RuboCop
             .gsub(/" *\\\n\s*'/, %q(" + ')) # Double quote, backslash, and then single quote
             .gsub(/' *\\\n\s*"/, %q(' + ")) # Single quote, backslash, and then double quote
             .gsub(/(["']) *\\\n\s*\1/, '')  # Double or single quote, backslash, then same quote
+            .gsub(/\n\s*(?=\.\w)/, '')      # Extra space within method chaining
             .gsub(/\s*\\?\n\s*/, ' ')       # Any other line break, with or without backslash
         end
 

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

@@ -37,15 +37,26 @@ module RuboCop
           return unless receiver&.block_type?
 
           receiver_location = receiver.loc
-          closing_block_delimiter_line_number = receiver_location.end.line
-          return if receiver_location.begin.line < closing_block_delimiter_line_number
+          closing_block_delimiter_line_num = receiver_location.end.line
+          return if receiver_location.begin.line < closing_block_delimiter_line_num
 
           node_location = node.loc
           dot_range = node_location.dot
           return unless dot_range
-          return if dot_range.line > closing_block_delimiter_line_number
+          return unless call_method_after_block?(node, dot_range, closing_block_delimiter_line_num)
 
-          range_between(dot_range.begin_pos, node_location.selector.end_pos)
+          range_between(dot_range.begin_pos, selector_range(node).end_pos)
+        end
+
+        def call_method_after_block?(node, dot_range, closing_block_delimiter_line_num)
+          return false if dot_range.line > closing_block_delimiter_line_num
+
+          dot_range.column < selector_range(node).column
+        end
+
+        def selector_range(node)
+          # l.(1) has no selector, so we use the opening parenthesis instead
+          node.loc.selector || node.loc.begin
         end
       end
     end

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

@@ -16,6 +16,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Do not leave space between `!` and its argument.'
+        RESTRICT_ON_SEND = %i[!].freeze
 
         def on_send(node)
           return unless node.prefix_bang? && whitespace_after_operator?(node)

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

@@ -47,7 +47,8 @@ module RuboCop
           space_on_both_sides = space_on_both_sides?(arg, equals)
           no_surrounding_space = no_surrounding_space?(arg, equals)
 
-          if style == :space && space_on_both_sides || style == :no_space && no_surrounding_space
+          if (style == :space && space_on_both_sides) ||
+             (style == :no_space && no_surrounding_space)
             correct_style_detected
           else
             incorrect_style_detected(arg, value)

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

@@ -228,8 +228,8 @@ module RuboCop
         def accepted_opening_delimiter?(range, char)
           return true unless char
 
-          accept_left_square_bracket?(range) && char == '[' ||
-            accept_left_parenthesis?(range) && char == '('
+          (accept_left_square_bracket?(range) && char == '[') ||
+            (accept_left_parenthesis?(range) && char == '(')
         end
 
         def accept_left_parenthesis?(range)

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

@@ -19,6 +19,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Remove the space before the opening brackets.'
+        RESTRICT_ON_SEND = %i[[] []=].freeze
 
         def on_send(node)
           return unless (first_argument = node.first_argument)

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

@@ -33,6 +33,27 @@ module RuboCop
       #   g = ( a + 3 )
       #   y()
       #
+      # @example EnforcedStyle: compact
+      #   # The `compact` style enforces that parentheses have a space at the
+      #   # beginning with the exception that successive parentheses are allowed.
+      #   # Note: Empty parentheses should not have spaces.
+      #
+      #   # bad
+      #   f(3)
+      #   g = (a + 3)
+      #   y( )
+      #   g( f( x ) )
+      #   g( f( x( 3 ) ), 5 )
+      #   g( ( ( 3 + 5 ) * f) ** x, 5 )
+      #
+      #   # good
+      #   f( 3 )
+      #   g = ( a + 3 )
+      #   y()
+      #   g( f( x ))
+      #   g( f( x( 3 )), 5 )
+      #   g((( 3 + 5 ) * f ) ** x, 5 )
+      #
       class SpaceInsideParens < Base
         include SurroundingSpace
         include RangeHelp
@@ -45,14 +66,13 @@ module RuboCop
         def on_new_investigation
           tokens = processed_source.sorted_tokens
 
-          if style == :space
+          case style
+          when :space
             process_with_space_style(tokens)
+          when :compact
+            process_with_compact_style(tokens)
           else
-            each_extraneous_space(tokens) do |range|
-              add_offense(range) do |corrector|
-                corrector.remove(range)
-              end
-            end
+            correct_extraneous_space(tokens)
           end
         end
 
@@ -60,20 +80,23 @@ module RuboCop
 
         def process_with_space_style(tokens)
           tokens.each_cons(2) do |token1, token2|
-            each_extraneous_space_in_empty_parens(token1, token2) do |range|
-              add_offense(range) do |corrector|
-                corrector.remove(range)
-              end
-            end
-            each_missing_space(token1, token2) do |range|
-              add_offense(range, message: MSG_SPACE) do |corrector|
-                corrector.insert_before(range, ' ')
-              end
+            correct_extraneous_space_in_empty_parens(token1, token2)
+            correct_missing_space(token1, token2)
+          end
+        end
+
+        def process_with_compact_style(tokens)
+          tokens.each_cons(2) do |token1, token2|
+            correct_extraneous_space_in_empty_parens(token1, token2)
+            if !left_parens?(token1, token2) && !right_parens?(token1, token2)
+              correct_missing_space(token1, token2)
+            else
+              correct_extaneus_space_between_consecutive_parens(token1, token2)
             end
           end
         end
 
-        def each_extraneous_space(tokens)
+        def correct_extraneous_space(tokens)
           tokens.each_cons(2) do |token1, token2|
             next unless parens?(token1, token2)
 
@@ -82,25 +105,44 @@ module RuboCop
             next if token2.comment?
             next unless same_line?(token1, token2) && token1.space_after?
 
-            yield range_between(token1.end_pos, token2.begin_pos)
+            range = range_between(token1.end_pos, token2.begin_pos)
+            add_offense(range) do |corrector|
+              corrector.remove(range)
+            end
+          end
+        end
+
+        def correct_extaneus_space_between_consecutive_parens(token1, token2)
+          return if range_between(token1.end_pos, token2.begin_pos).source != ' '
+
+          range = range_between(token1.end_pos, token2.begin_pos)
+          add_offense(range) do |corrector|
+            corrector.remove(range)
           end
         end
 
-        def each_extraneous_space_in_empty_parens(token1, token2)
+        def correct_extraneous_space_in_empty_parens(token1, token2)
           return unless token1.left_parens? && token2.right_parens?
 
           return if range_between(token1.begin_pos, token2.end_pos).source == '()'
 
-          yield range_between(token1.end_pos, token2.begin_pos)
+          range = range_between(token1.end_pos, token2.begin_pos)
+          add_offense(range) do |corrector|
+            corrector.remove(range)
+          end
         end
 
-        def each_missing_space(token1, token2)
+        def correct_missing_space(token1, token2)
           return if can_be_ignored?(token1, token2)
 
-          if token1.left_parens?
-            yield range_between(token2.begin_pos, token2.begin_pos + 1)
-          elsif token2.right_parens?
-            yield range_between(token2.begin_pos, token2.end_pos)
+          range = if token1.left_parens?
+                    range_between(token2.begin_pos, token2.begin_pos + 1)
+                  elsif token2.right_parens?
+                    range_between(token2.begin_pos, token2.end_pos)
+                  end
+
+          add_offense(range, message: MSG_SPACE) do |corrector|
+            corrector.insert_before(range, ' ')
           end
         end
 
@@ -112,6 +154,14 @@ module RuboCop
           token1.left_parens? || token2.right_parens?
         end
 
+        def left_parens?(token1, token2)
+          token1.left_parens? && token2.left_parens?
+        end
+
+        def right_parens?(token1, token2)
+          token1.right_parens? && token2.right_parens?
+        end
+
         def can_be_ignored?(token1, token2)
           return true unless parens?(token1, token2)
 

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

@@ -107,7 +107,7 @@ module RuboCop
           current_token = tokens.reverse.find(&:left_ref_bracket?)
           previous_token = previous_token(current_token)
 
-          if node.method?(:[]=) || previous_token && !previous_token.right_bracket?
+          if node.method?(:[]=) || (previous_token && !previous_token.right_bracket?)
             tokens.find(&:left_ref_bracket?)
           else
             current_token

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

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop looks for expressions containing multiple binary operators
+      # where precedence is ambiguous due to lack of parentheses. For example,
+      # in `1 + 2 * 3`, the multiplication will happen before the addition, but
+      # lexically it appears that the addition will happen first.
+      #
+      # The cop does not consider unary operators (ie. `!a` or `-b`) or comparison
+      # operators (ie. `a =~ b`) because those are not ambiguous.
+      #
+      # NOTE: Ranges are handled by `Lint/AmbiguousRange`.
+      #
+      # @example
+      #   # bad
+      #   a + b * c
+      #   a || b && c
+      #   a ** b + c
+      #
+      #   # good (different precedence)
+      #   a + (b * c)
+      #   a || (b && c)
+      #   (a ** b) + c
+      #
+      #   # good (same precedence)
+      #   a + b + c
+      #   a * b / c % d
+      class AmbiguousOperatorPrecedence < Base
+        extend AutoCorrector
+
+        # See https://ruby-doc.org/core-3.0.2/doc/syntax/precedence_rdoc.html
+        PRECEDENCE = [
+          %i[**],
+          %i[* / %],
+          %i[+ -],
+          %i[<< >>],
+          %i[&],
+          %i[| ^],
+          %i[&&],
+          %i[||]
+        ].freeze
+        RESTRICT_ON_SEND = PRECEDENCE.flatten.freeze
+        MSG = 'Wrap expressions with varying precedence with parentheses to avoid ambiguity.'
+
+        def on_new_investigation
+          # Cache the precedence of each node being investigated
+          # so that we only need to calculate it once
+          @node_precedences = {}
+          super
+        end
+
+        def on_and(node)
+          return unless (parent = node.parent)
+
+          return if parent.begin_type? # if the `and` is in a `begin`, it's parenthesized already
+          return unless parent.or_type?
+
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        def on_send(node)
+          return if node.parenthesized?
+
+          return unless (parent = node.parent)
+          return unless operator?(parent)
+          return unless greater_precedence?(node, parent)
+
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        private
+
+        def precedence(node)
+          @node_precedences.fetch(node) do
+            PRECEDENCE.index { |operators| operators.include?(operator_name(node)) }
+          end
+        end
+
+        def operator?(node)
+          (node.send_type? && RESTRICT_ON_SEND.include?(node.method_name)) || node.operator_keyword?
+        end
+
+        def greater_precedence?(node1, node2)
+          node1_precedence = precedence(node1)
+          node2_precedence = precedence(node2)
+          return false unless node1_precedence && node2_precedence
+
+          node2_precedence > node1_precedence
+        end
+
+        def operator_name(node)
+          if node.send_type?
+            node.method_name
+          else
+            node.operator.to_sym
+          end
+        end
+
+        def autocorrect(corrector, node)
+          corrector.wrap(node, '(', ')')
+        end
+      end
+    end
+  end
+end

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

@@ -10,12 +10,6 @@ module RuboCop
       # explicit by requiring parenthesis around complex range boundaries (anything
       # that is not a basic literal: numerics, strings, symbols, etc.).
       #
-      # NOTE: The cop auto-corrects by wrapping the entire boundary in parentheses, which
-      # makes the outcome more explicit but is possible to not be the intention of the
-      # programmer. For this reason, this cop's auto-correct is marked as unsafe (it
-      # will not change the behaviour of the code, but will not necessarily match the
-      # intent of the program).
-      #
       # This cop can be configured with `RequireParenthesesForMethodChains` in order to
       # specify whether method chains (including `self.foo`) should be wrapped in parens
       # by this cop.
@@ -23,6 +17,13 @@ module RuboCop
       # NOTE: Regardless of this configuration, if a method receiver is a basic literal
       # value, it will be wrapped in order to prevent the ambiguity of `1..2.to_a`.
       #
+      # @safety
+      #   The cop auto-corrects by wrapping the entire boundary in parentheses, which
+      #   makes the outcome more explicit but is possible to not be the intention of the
+      #   programmer. For this reason, this cop's auto-correct is unsafe (it will not
+      #   change the behaviour of the code, but will not necessarily match the
+      #   intent of the program).
+      #
       # @example
       #   # bad
       #   x || 1..2
@@ -55,7 +56,6 @@ module RuboCop
       #
       #   # good
       #   (a.foo)..(b.bar)
-      #
       class AmbiguousRange < Base
         extend AutoCorrector
 
@@ -83,7 +83,7 @@ module RuboCop
           node.begin_type? ||
             node.basic_literal? ||
             node.variable? || node.const_type? ||
-            node.call_type? && acceptable_call?(node)
+            (node.call_type? && acceptable_call?(node))
         end
 
         def acceptable_call?(node)