rubocop 1.20.0 → 1.21.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e89a054e431c4e739e8e4b0bcdc36452704f1cffd6bda1e5710241e6712161a9
-  data.tar.gz: 632d9503cddcb39443ad8fc8b31bd1f1576803e9490ae77d22ee06f34d40784b
+  metadata.gz: dd3bb4ebea9d6db387e52e92a0c9ffac3f6215f0b5b9bcd7d555e979c8fb9fa7
+  data.tar.gz: 208d08bf57f092a0857776924cb529db1324ecdf4696476475f51878f803b6ac
 SHA512:
-  metadata.gz: b765c92c6118f7e8e958d0787714764c392453efa450048629002a69634fe032648a6f88654afc522d9ca01b2fb2c7f70c573d6bd9a227e85168cfcbe5613091
-  data.tar.gz: 22d0b80509def399c10586f579f08520e47c1d03a7eab14e0c9b998d9fea0b7a477333677c0af2aed3e768bb9c9d6a30f51a88f7d9e4973acd8057389ac01357
+  metadata.gz: 9d32668f49f495948628017c042cbc292d62c4ba93d905635d47ecba7c12e69ff7cbff3999a6cccba62bbc27ff7b51827e1a00f41769c1dd711f342fe10e8519
+  data.tar.gz: 9798e105b8ea95245d153e9e295a95a593e49464f91ac8c508ce0900f7f2ef0e97759a1144044f32acb726e11d3552de1f5de8d2d477151606bfd39090df3260

data/README.md

@@ -54,7 +54,7 @@ To prevent an unwanted RuboCop update you might want to use a conservative versi
 in your `Gemfile`:
 
 ```rb
-gem 'rubocop', '~> 1.20', require: false
+gem 'rubocop', '~> 1.21', require: false
 ```
 
 See [our versioning policy](https://docs.rubocop.org/rubocop/versioning.html) for further details.

data/config/default.yml

@@ -957,7 +957,6 @@ Layout/LineLength:
   Enabled: true
   VersionAdded: '0.25'
   VersionChanged: '1.4'
-  AutoCorrect: true
   Max: 120
   # To make it possible to copy or click on URIs in the code, we allow lines
   # containing a URI to be longer than Max.
@@ -1448,6 +1447,13 @@ Lint/AmbiguousOperator:
   VersionAdded: '0.17'
   VersionChanged: '0.83'
 
+Lint/AmbiguousOperatorPrecedence:
+  Description: >-
+                 Checks for expressions containing multiple binary operations with
+                 ambiguous precedence.
+  Enabled: pending
+  VersionAdded: '1.21'
+
 Lint/AmbiguousRange:
   Description: Checks for ranges with ambiguous boundaries.
   Enabled: pending
@@ -1771,6 +1777,11 @@ Lint/ImplicitStringConcatenation:
   Enabled: true
   VersionAdded: '0.36'
 
+Lint/IncompatibleIoSelectWithFiberScheduler:
+  Description: 'Checks for `IO.select` that is incompatible with Fiber Scheduler.'
+  Enabled: pending
+  VersionAdded: '1.21'
+
 Lint/IneffectiveAccessModifier:
   Description: >-
                  Checks for attempts to use `private` or `protected` to set
@@ -2563,8 +2574,9 @@ Naming/HeredocDelimiterNaming:
 
 Naming/InclusiveLanguage:
   Description: 'Recommend the use of inclusive language instead of problematic terms.'
-  Enabled: pending
+  Enabled: false
   VersionAdded: '1.18'
+  VersionChanged: '1.21'
   CheckIdentifiers: true
   CheckConstants: true
   CheckVariables: true
@@ -2796,8 +2808,9 @@ Style/AndOr:
   Description: 'Use &&/|| instead of and/or.'
   StyleGuide: '#no-and-or-or'
   Enabled: true
+  SafeAutoCorrect: false
   VersionAdded: '0.9'
-  VersionChanged: '0.25'
+  VersionChanged: '1.21'
   # Whether `and` and `or` are banned only in conditionals (conditionals)
   # or completely (always).
   EnforcedStyle: conditionals
@@ -2831,9 +2844,9 @@ Style/ArrayJoin:
 Style/AsciiComments:
   Description: 'Use only ascii symbols in comments.'
   StyleGuide: '#english-comments'
-  Enabled: true
+  Enabled: false
   VersionAdded: '0.9'
-  VersionChanged: '0.52'
+  VersionChanged: '1.21'
   AllowedChars:
     - ©
 
@@ -2995,7 +3008,7 @@ Style/CaseEquality:
   Enabled: true
   VersionAdded: '0.9'
   VersionChanged: '0.89'
-  # If AllowOnConstant is enabled, the cop will ignore violations when the receiver of
+  # If `AllowOnConstant` option is enabled, the cop will ignore violations when the receiver of
   # the case equality operator is a constant.
   #
   #   # bad

data/lib/rubocop/cop/base.rb

@@ -222,8 +222,8 @@ module RuboCop
 
       def relevant_file?(file)
         file == RuboCop::AST::ProcessedSource::STRING_SOURCE_NAME ||
-          file_name_matches_any?(file, 'Include', true) &&
-            !file_name_matches_any?(file, 'Exclude', false)
+          (file_name_matches_any?(file, 'Include', true) &&
+            !file_name_matches_any?(file, 'Exclude', false))
       end
 
       def excluded_file?(file)

data/lib/rubocop/cop/bundler/insecure_protocol_source.rb

@@ -3,18 +3,18 @@
 module RuboCop
   module Cop
     module Bundler
-      # The symbol argument `:gemcutter`, `:rubygems`, and `:rubyforge`
-      # are deprecated. So please change your source to URL string that
-      # 'https://rubygems.org' if possible, or 'http://rubygems.org' if not.
+      # Passing symbol arguments to `source` (e.g. `source :rubygems`) is
+      # deprecated because they default to using HTTP requests. Instead, specify
+      # `'https://rubygems.org'` if possible, or `'http://rubygems.org'` if not.
       #
-      # This autocorrect will replace these symbols with 'https://rubygems.org'.
-      # Because it is secure, HTTPS request is strongly recommended. And in
-      # most use cases HTTPS will be fine.
+      # When autocorrecting, this cop will replace symbol arguments with
+      # `'https://rubygems.org'`.
       #
-      # However, it don't replace all `sources` of `http://` with `https://`.
-      # For example, when specifying an internal gem server using HTTP on the
-      # intranet, a use case where HTTPS cannot be specified was considered.
-      # Consider using HTTP only if you cannot use HTTPS.
+      # This cop will not replace existing sources that use `http://`. This may
+      # be necessary where HTTPS is not available. For example, where using an
+      # internal gem server via an intranet, or where HTTPS is prohibited.
+      # However, you should strongly prefer `https://` where possible, as it is
+      # more secure.
       #
       # @example
       #   # bad
@@ -24,7 +24,8 @@ module RuboCop
       #
       #   # good
       #   source 'https://rubygems.org' # strongly recommended
-      #   source 'http://rubygems.org'
+      #   source 'http://rubygems.org' # use only if HTTPS is unavailable
+      #
       class InsecureProtocolSource < Base
         include RangeHelp
         extend AutoCorrector

data/lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb

@@ -87,8 +87,8 @@ module RuboCop
       end
 
       def needs_separating_space?
-        block_begin.begin_pos == arguments_end_pos &&
-          selector_end.end_pos == arguments_begin_pos ||
+        (block_begin.begin_pos == arguments_end_pos &&
+          selector_end.end_pos == arguments_begin_pos) ||
           block_begin.begin_pos == selector_end.end_pos
       end
 

data/lib/rubocop/cop/correctors/line_break_corrector.rb

@@ -28,7 +28,7 @@ module RuboCop
                               indent_steps: 1)
           corrector.insert_before(
             range,
-            "\n#{' ' * (node.loc.keyword.column + indent_steps * configured_width)}"
+            "\n#{' ' * (node.loc.keyword.column + (indent_steps * configured_width))}"
           )
         end
 

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/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,7 +176,7 @@ 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)

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/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_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,107 @@
+# 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)
+          precedence(node2) > precedence(node1)
+        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

@@ -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)

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

@@ -57,8 +57,6 @@ module RuboCop
       class Debugger < Base
         MSG = 'Remove debugger entry point `%<source>s`.'
 
-        RESTRICT_ON_SEND = [].freeze
-
         # @!method kernel?(node)
         def_node_matcher :kernel?, <<~PATTERN
           (const {nil? cbase} :Kernel)