rubocop 1.71.1 → 1.92.1

data/lib/rubocop/cop/style/numeric_literal_prefix.rb

@@ -55,7 +55,11 @@ module RuboCop
           return unless type
 
           add_offense(node) do |corrector|
-            corrector.replace(node, send(:"format_#{type}", node.source))
+            # The prefix patterns below are anchored, so correct only the digits
+            # and leave any sign the literal's source carries in place.
+            range = unsigned_range(node)
+
+            corrector.replace(range, send(:"format_#{type}", range.source))
           end
         end
 
@@ -71,6 +75,12 @@ module RuboCop
           octal_literal_type(literal) || hex_bin_dec_literal_type(literal)
         end
 
+        def unsigned_range(node)
+          range = node.source_range
+
+          node.source.start_with?('+', '-') ? range.adjust(begin_pos: 1) : range
+        end
+
         def octal_literal_type(literal)
           if OCTAL_ZERO_ONLY_REGEX.match?(literal) && octal_zero_only?
             :octal_zero_only

data/lib/rubocop/cop/style/numeric_literals.rb

@@ -4,7 +4,8 @@ module RuboCop
   module Cop
     module Style
       # Checks for big numeric literals without `_` between groups
-      # of digits in them.
+      # of digits in them. Underscores make large numbers easier to
+      # read by visually separating groups of digits.
       #
       # Additional allowed patterns can be added by adding regexps to
       # the `AllowedPatterns` configuration. All regexps are treated
@@ -116,7 +117,7 @@ module RuboCop
         end
 
         def allowed_numbers
-          cop_config.fetch('AllowedNumbers', []).map(&:to_s)
+          @allowed_numbers ||= cop_config.fetch('AllowedNumbers', []).map(&:to_s).freeze
         end
 
         def allowed_patterns

data/lib/rubocop/cop/style/numeric_predicate.rb

@@ -90,9 +90,10 @@ module RuboCop
         def on_send(node)
           numeric, replacement = check(node)
           return unless numeric
+          return if handled_by_bitwise_predicate?(node)
 
           return if allowed_method_name?(node.method_name) ||
-                    node.each_ancestor(:send, :block).any? do |ancestor|
+                    node.each_ancestor(:send, :any_block).any? do |ancestor|
                       allowed_method_name?(ancestor.method_name)
                     end
 
@@ -108,6 +109,12 @@ module RuboCop
           allowed_method?(name) || matches_allowed_pattern?(name)
         end
 
+        def handled_by_bitwise_predicate?(node)
+          bitwise_predicate_candidate?(node) &&
+            config.for_cop('Style/BitwisePredicate').fetch('Enabled') &&
+            BitwisePredicate.support_target_ruby_version?(target_ruby_version)
+        end
+
         def check(node)
           numeric, operator =
             if style == :predicate
@@ -124,7 +131,7 @@ module RuboCop
         def replacement(node, numeric, operation)
           if style == :predicate
             [parenthesized_source(numeric), REPLACEMENTS.invert[operation.to_s]].join('.')
-          elsif negated?(node)
+          elsif comparison_requires_parentheses?(node)
             "(#{numeric.source} #{REPLACEMENTS[operation.to_s]} 0)"
           else
             [numeric.source, REPLACEMENTS[operation.to_s], 0].join(' ')
@@ -140,7 +147,7 @@ module RuboCop
         end
 
         def require_parentheses?(node)
-          node.send_type? && node.binary_operation? && !node.parenthesized?
+          node.send_type? && node.operator_method? && !node.parenthesized?
         end
 
         def replacement_supported?(operator)
@@ -159,10 +166,11 @@ module RuboCop
           end
         end
 
-        def negated?(node)
-          return false unless (parent = node.parent)
+        def comparison_requires_parentheses?(node)
+          return false unless (parent = node.parent)&.call_type?
+          return true if parent.receiver.equal?(node)
 
-          parent.send_type? && parent.method?(:!)
+          parent.operator_method? && !parent.method?(:[]) && !parent.method?(:[]=)
         end
 
         # @!method predicate(node)
@@ -179,6 +187,14 @@ module RuboCop
         def_node_matcher :inverted_comparison, <<~PATTERN
           (send (int 0) ${:== :> :<} [$(...) !gvar_type?])
         PATTERN
+
+        # @!method bitwise_predicate_candidate?(node)
+        def_node_matcher :bitwise_predicate_candidate?, <<~PATTERN
+          {
+            (send {(begin (send _ :& _)) (send _ :& _)} {:positive? :zero?})
+            (send {(begin (send _ :& _)) (send _ :& _)} {:> :==} (int 0))
+          }
+        PATTERN
       end
     end
   end

data/lib/rubocop/cop/style/object_then.rb

@@ -38,6 +38,7 @@ module RuboCop
           check_method_node(node.send_node)
         end
         alias on_numblock on_block
+        alias on_itblock on_block
 
         def on_send(node)
           return unless node.arguments.one? && node.first_argument.block_pass_type?

data/lib/rubocop/cop/style/one_class_per_file.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks that each source file defines at most one top-level class or module.
+      #
+      # Keeping one class or module per file makes it easier to find and navigate
+      # code, and follows the convention used by most Ruby projects.
+      #
+      # Classes and modules listed in `AllowedClasses` are not counted toward the
+      # limit. This is useful for small ancillary classes like custom exception
+      # classes that logically belong with the main class.
+      #
+      # @example
+      #   # bad - Multiple top-level classes
+      #   class Foo
+      #   end
+      #
+      #   class Bar
+      #   end
+      #
+      #   # bad - Multiple top-level modules
+      #   module Foo
+      #   end
+      #
+      #   module Bar
+      #   end
+      #
+      #   # bad - A top-level class and a top-level module
+      #   class Foo
+      #   end
+      #
+      #   module Bar
+      #   end
+      #
+      #   # good - A single top-level class
+      #   class Foo
+      #   end
+      #
+      #   # good - A single top-level module
+      #   module Foo
+      #   end
+      #
+      #   # good - Nested classes within a single top-level class
+      #   class Foo
+      #     class Bar
+      #     end
+      #   end
+      #
+      #   # good - Multiple classes within a single top-level module
+      #   module Foo
+      #     class Bar
+      #     end
+      #
+      #     class Baz
+      #     end
+      #   end
+      #
+      # @example AllowedClasses: ['AllowedClass']
+      #   # good
+      #   class Foo
+      #   end
+      #
+      #   class AllowedClass
+      #   end
+      #
+      class OneClassPerFile < Base
+        include RangeHelp
+
+        MSG = 'Do not define multiple classes/modules at the top level in a single file.'
+
+        def on_new_investigation
+          @top_level_definitions = []
+        end
+
+        def on_class(node)
+          check_top_level(node)
+        end
+
+        def on_module(node)
+          check_top_level(node)
+        end
+
+        private
+
+        def check_top_level(node)
+          return unless top_level_definition?(node)
+          return if allowed_class?(node)
+
+          @top_level_definitions << node
+          return unless @top_level_definitions.length > 1
+
+          add_offense(range_between(node.source_range.begin_pos, node.loc.name.end_pos))
+        end
+
+        def top_level_definition?(node)
+          if node.parent&.begin_type?
+            node.parent.root?
+          else
+            node.root?
+          end
+        end
+
+        def allowed_class?(node)
+          allowed_classes.include?(node.identifier.short_name)
+        end
+
+        def allowed_classes
+          @allowed_classes ||= cop_config.fetch('AllowedClasses', []).map(&:intern)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/one_line_conditional.rb

@@ -3,9 +3,10 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for uses of if/then/else/end constructs on a single line.
-      # `AlwaysCorrectToMultiline` config option can be set to true to autocorrect all offenses to
-      # multi-line constructs. When `AlwaysCorrectToMultiline` is false (default case) the
+      # Checks for uses of `if/then/else/end` constructs on a single line.
+      # A ternary operator (`?:`) or multi-line `if` is more readable.
+      # `AlwaysCorrectToMultiline` config option can be set to `true` to autocorrect all offenses to
+      # multi-line constructs. When `AlwaysCorrectToMultiline` is `false` (default case) the
       # autocorrect will first try converting them to ternary operators.
       #
       # @example
@@ -55,19 +56,21 @@ module RuboCop
         include OnNormalIfUnless
         extend AutoCorrector
 
-        MSG = 'Favor the ternary operator (`?:`) or multi-line constructs ' \
-              'over single-line `%<keyword>s/then/else/end` constructs.'
+        MSG_SUFFIX = 'over single-line `%<keyword>s/then/else/end` constructs.'
+        MSG_TERNARY = "Favor the ternary operator (`?:`) #{MSG_SUFFIX}"
+        MSG_MULTILINE = "Favor multi-line `%<keyword>s` #{MSG_SUFFIX}"
 
         def on_normal_if_unless(node)
           return unless node.single_line?
           return unless node.else_branch
           return if node.elsif? || node.if_branch&.begin_type?
 
-          message = message(node)
-          add_offense(node, message: message) do |corrector|
+          multiline = multiline?(node)
+
+          add_offense(node, message: message(node, multiline)) do |corrector|
             next if part_of_ignored_node?(node)
 
-            autocorrect(corrector, node)
+            autocorrect(corrector, node, multiline)
 
             ignore_node(node)
           end
@@ -75,12 +78,18 @@ module RuboCop
 
         private
 
-        def message(node)
-          format(MSG, keyword: node.keyword)
+        def multiline?(node)
+          always_multiline? || cannot_replace_to_ternary?(node)
+        end
+
+        def message(node, multiline)
+          template = multiline ? MSG_MULTILINE : MSG_TERNARY
+
+          format(template, keyword: node.keyword)
         end
 
-        def autocorrect(corrector, node)
-          if always_multiline? || cannot_replace_to_ternary?(node)
+        def autocorrect(corrector, node, multiline)
+          if multiline
             IfThenCorrector.new(node, indentation: configured_indentation_width).call(corrector)
           else
             corrector.replace(node, ternary_correction(node))
@@ -93,6 +102,7 @@ module RuboCop
           return replaced_node unless node.parent
           return "(#{replaced_node})" if node.parent.operator_keyword?
           return "(#{replaced_node})" if node.parent.send_type? && node.parent.operator_method?
+          return "(#{replaced_node})" if parent_binds_tighter_than_ternary?(node)
 
           replaced_node
         end
@@ -108,13 +118,21 @@ module RuboCop
         end
 
         def ternary_replacement(node)
-          condition, if_branch, else_branch = *node # rubocop:disable InternalAffairs/NodeDestructuring
+          condition, if_branch, else_branch = *node # rubocop:disable InternalAffairs/NodeDestructuring -- takes all three branches in one step
 
           "#{expr_replacement(condition)} ? " \
             "#{expr_replacement(if_branch)} : " \
             "#{expr_replacement(else_branch)}"
         end
 
+        def parent_binds_tighter_than_ternary?(node)
+          parent = node.parent
+          return parent.receiver.equal?(node) if parent.call_type?
+          return parent.namespace.equal?(node) if parent.type?(:const, :casgn)
+
+          parent.if_type? && parent.ternary? && parent.condition.equal?(node)
+        end
+
         def expr_replacement(node)
           return 'nil' if node.nil?
 
@@ -122,7 +140,9 @@ module RuboCop
         end
 
         def requires_parentheses?(node)
-          return true if %i[and or if].include?(node.type)
+          return true if node.type?(
+            :and, :or, :if, :rescue, :while, :until, :while_post, :until_post, :any_match_pattern
+          )
           return true if node.assignment?
           return true if method_call_with_changed_precedence?(node)
 
@@ -130,7 +150,7 @@ module RuboCop
         end
 
         def method_call_with_changed_precedence?(node)
-          return false unless node.send_type? && node.arguments?
+          return false unless node.call_type? && node.arguments?
           return false if node.parenthesized_call?
 
           !node.operator_method?

data/lib/rubocop/cop/style/open_struct_use.rb

@@ -61,7 +61,7 @@ module RuboCop
         def custom_class_or_module_definition?(node)
           parent = node.parent
 
-          parent.type?(:class, :module) && node.left_siblings.empty?
+          parent&.type?(:class, :module) && node.left_siblings.empty?
         end
       end
     end

data/lib/rubocop/cop/style/operator_method_call.rb

@@ -26,9 +26,10 @@ module RuboCop
           splat kwsplat forwarded_args forwarded_restarg forwarded_kwrestarg block_pass
         ].freeze
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+        # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def on_send(node)
           return unless (dot = node.loc.dot)
+          return if unary_method_no_operator?(node)
           return if node.receiver.const_type? || !node.arguments.one?
 
           return unless (rhs = node.first_argument)
@@ -43,10 +44,17 @@ module RuboCop
             corrector.insert_after(selector, ' ') if insert_space_after?(node)
           end
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
 
         private
 
+        # `foo.~@` and `foo.!@` call the method `~` and `!` respectively. While those
+        # are operator methods, we don't want to actually consider them as such.
+        def unary_method_no_operator?(node)
+          return false unless node.nonmutating_unary_operator_method?
+
+          node.method_name.to_s != node.selector.source
+        end
+
         # Checks for an acceptable case of `foo.+(bar).baz`.
         def method_call_with_parenthesized_arg?(argument)
           return false unless argument.parent.parent&.send_type?

data/lib/rubocop/cop/style/option_hash.rb

@@ -46,7 +46,7 @@ module RuboCop
         end
 
         def super_used?(node)
-          node.parent.each_node(:zsuper).any?
+          node.parent.each_node(:zsuper, :super).any?
         end
       end
     end

data/lib/rubocop/cop/style/optional_arguments.rb

@@ -27,6 +27,7 @@ module RuboCop
         def on_def(node)
           each_misplaced_optional_arg(node.arguments) { |argument| add_offense(argument) }
         end
+        alias on_defs on_def
 
         private
 

data/lib/rubocop/cop/style/parallel_assignment.rb

@@ -1,11 +1,13 @@
 # frozen_string_literal: true
 
-require 'tsort'
-
 module RuboCop
   module Cop
     module Style
       # Checks for simple usages of parallel assignment.
+      # Parallel assignment is less readable than individual
+      # assignments and makes it harder to follow what each
+      # variable is being set to.
+      #
       # This will only complain when the number of variables
       # being assigned matched the number of assigning variables.
       #
@@ -16,7 +18,7 @@ module RuboCop
       #
       #   # good
       #   one, two = *foo
-      #   a, b = foo()
+      #   a, b = foo
       #   a, b = b, a
       #
       #   a = 1
@@ -29,18 +31,21 @@ module RuboCop
         MSG = 'Do not use parallel assignment.'
 
         def on_masgn(node) # rubocop:disable Metrics/AbcSize
+          return if part_of_ignored_node?(node)
+
           rhs = node.rhs
           rhs = rhs.body if rhs.rescue_type?
           rhs_elements = Array(rhs).compact # edge case for one constant
 
           return if allowed_lhs?(node.assignments) || allowed_rhs?(rhs) ||
-                    allowed_masign?(node.assignments, rhs_elements)
+                    allowed_masign?(node.assignments, rhs_elements) || contains_heredoc?(rhs)
 
           range = node.source_range.begin.join(rhs.source_range.end)
 
           add_offense(range) do |corrector|
             autocorrect(corrector, node, rhs)
           end
+          ignore_node(node)
         end
 
         private
@@ -72,6 +77,13 @@ module RuboCop
           !node.array_type? || elements.any?(&:splat_type?)
         end
 
+        # Autocorrection splits the assignment into single assignments on
+        # consecutive lines, which would put following assignments into the
+        # heredoc body unless the heredoc bodies were moved along.
+        def contains_heredoc?(node)
+          node.each_descendant(:any_str).any?(&:heredoc?)
+        end
+
         def assignment_corrector(node, rhs, order)
           if node.parent&.rescue_type?
             _assignment, modifier = *node.parent
@@ -91,15 +103,9 @@ module RuboCop
         def find_valid_order(left_elements, right_elements)
           # arrange left_elements in an order such that no corresponding right
           # element refers to a left element earlier in the sequence
-          # this can be done using an algorithm called a "topological sort"
-          # fortunately for us, Ruby's stdlib contains an implementation
           assignments = left_elements.zip(right_elements)
 
-          begin
-            AssignmentSorter.new(assignments).tsort
-          rescue TSort::Cyclic
-            nil
-          end
+          AssignmentSorter.new(assignments).tsort
         end
 
         # Converts (send nil :something) nodes to (send (:self) :something).
@@ -114,10 +120,9 @@ module RuboCop
         # @!method implicit_self_getter?(node)
         def_node_matcher :implicit_self_getter?, '(send nil? $_)'
 
-        # Helper class necessitated by silly design of TSort prior to Ruby 2.1
-        # Newer versions have a better API, but that doesn't help us
+        # Topologically sorts the assignments with Kahn's algorithm.
+        # https://en.wikipedia.org/wiki/Topological_sorting#Kahn's_algorithm
         class AssignmentSorter
-          include TSort
           extend RuboCop::NodePattern::Macros
 
           # @!method var_name(node)
@@ -133,21 +138,39 @@ module RuboCop
             @assignments = assignments
           end
 
-          def tsort_each_node(...)
-            @assignments.each(...)
+          def tsort
+            dependencies = @assignments.to_h do |assignment|
+              [assignment, dependencies_for_assignment(assignment)]
+            end
+            result = []
+
+            while (matched_node, = dependencies.find { |_node, edges| edges.empty? })
+              dependencies.delete(matched_node)
+              result.push(matched_node)
+
+              dependencies.each do |node, edges|
+                dependencies[node].delete(matched_node) if edges.include?(matched_node)
+              end
+            end
+            # Cyclic dependency
+            return nil if dependencies.any?
+
+            result
           end
 
-          def tsort_each_child(assignment)
-            # yield all the assignments which must come after `assignment`
-            # (due to dependencies on the previous value of the assigned var)
+          # Returns all the assignments which must come after `assignment`
+          # (due to dependencies on the previous value of the assigned var)
+          def dependencies_for_assignment(assignment)
             my_lhs, _my_rhs = *assignment
 
-            @assignments.each do |other|
-              _other_lhs, other_rhs = *other
+            @assignments.filter_map do |other|
+              # Exclude self, there are no dependencies in cases such as `a, b = a, b`.
+              next if other == assignment
 
+              _other_lhs, other_rhs = *other
               next unless dependency?(my_lhs, other_rhs)
 
-              yield other
+              other
             end
           end
 
@@ -161,9 +184,8 @@ module RuboCop
           def accesses?(rhs, lhs)
             if lhs.method?(:[]=)
               # FIXME: Workaround `rubocop:disable` comment for JRuby.
-              # rubocop:disable Performance/RedundantEqualityComparisonBlock
+              # rubocop:disable-next Performance/RedundantEqualityComparisonBlock -- a JRuby workaround, as the comment above says
               matching_calls(rhs, lhs.receiver, :[]).any? { |args| args == lhs.arguments }
-              # rubocop:enable Performance/RedundantEqualityComparisonBlock
             else
               access_method = lhs.method_name.to_s.chop.to_sym
               matching_calls(rhs, lhs.receiver, access_method).any?
@@ -210,14 +232,23 @@ module RuboCop
           def source(node, loc)
             # __FILE__ is treated as a StrNode but has no begin
             if node.str_type? && loc.respond_to?(:begin) && loc.begin.nil?
-              "'#{node.source}'"
-            elsif node.sym_type? && loc.begin.nil?
-              ":#{node.source}"
+              # `%w` elements have no per-element delimiter, so the value must be
+              # quoted and escaped to stay valid (e.g. `%w(it's)` -> `'it\'s'`).
+              quote(node.value)
+            elsif node.sym_type? && !node.loc?(:begin)
+              # `%i` elements have no per-element delimiter, so a symbol that needs
+              # quoting must be emitted as `:"..."` (e.g. `%i(foo-bar)` -> `:"foo-bar"`),
+              # otherwise `:foo-bar` would parse as `:foo.-(bar)`.
+              node.value.inspect
             else
               node.source
             end
           end
 
+          def quote(string)
+            "'#{string.gsub(/[\\']/) { |char| "\\#{char}" }}'"
+          end
+
           def extract_sources(node)
             node.children.map(&:source)
           end

data/lib/rubocop/cop/style/parentheses_around_condition.rb

@@ -83,7 +83,7 @@ module RuboCop
           control_op_condition(cond) do |first_child, rest_children|
             return if require_parentheses?(node, first_child)
             return if semicolon_separated_expressions?(first_child, rest_children)
-            return if modifier_op?(first_child)
+            return if modifier_op?(first_child) || first_child.masgn_type?
             return if parens_allowed?(cond)
 
             message = message(cond)
@@ -123,10 +123,15 @@ module RuboCop
 
         def parens_allowed?(node)
           parens_required?(node) ||
-            (safe_assignment?(node) && safe_assignment_allowed?) ||
+            (safe_assignment?(node) && safe_assignment_kept?) ||
             (node.multiline? && allow_multiline_conditions?)
         end
 
+        def safe_assignment_kept?
+          safe_assignment_allowed? ||
+            config.for_enabled_cop('Lint/AssignmentInCondition')['AllowSafeAssignment']
+        end
+
         def allow_multiline_conditions?
           cop_config['AllowInMultilineConditions']
         end