rubocop 1.67.0 → 1.68.0

data/lib/rubocop/cop/offense.rb

@@ -43,11 +43,10 @@ module RuboCop
       # @!attribute [r] cop_name
       #
       # @return [String]
-      #   a cop class name without department.
-      #   i.e. type of the violation.
+      #   the cop name as a String for which this offense is for.
       #
       # @example
-      #   'LineLength'
+      #   'Layout/LineLength'
       attr_reader :cop_name
 
       # @api private

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Looks for endless methods inside operations of lower precedence (`and`, `or`, and
+      # modifier forms of `if`, `unless`, `while`, `until`) that are ambiguous due to
+      # lack of parentheses. This may lead to unexpected behavior as the code may appear
+      # to use these keywords as part of the method but in fact they modify
+      # the method definition itself.
+      #
+      # In these cases, using a normal method definition is more clear.
+      #
+      # @example
+      #
+      #   # bad
+      #   def foo = true if bar
+      #
+      #   # good - using a non-endless method is more explicit
+      #   def foo
+      #     true
+      #   end if bar
+      #
+      #   # ok - method body is explicit
+      #   def foo = (true if bar)
+      #
+      #   # ok - method definition is explicit
+      #   (def foo = true) if bar
+      class AmbiguousEndlessMethodDefinition < Base
+        extend TargetRubyVersion
+        extend AutoCorrector
+        include EndlessMethodRewriter
+        include RangeHelp
+
+        minimum_target_ruby_version 3.0
+
+        MSG = 'Avoid using `%<keyword>s` statements with endless methods.'
+
+        # @!method ambiguous_endless_method_body(node)
+        def_node_matcher :ambiguous_endless_method_body, <<~PATTERN
+          ^${
+            (if _ <def _>)
+            ({and or} def _)
+            ({while until} _ def)
+          }
+        PATTERN
+
+        def on_def(node)
+          return unless node.endless?
+
+          operation = ambiguous_endless_method_body(node)
+          return unless operation
+
+          return unless modifier_form?(operation)
+
+          add_offense(operation, message: format(MSG, keyword: keyword(operation))) do |corrector|
+            correct_to_multiline(corrector, node)
+          end
+        end
+
+        private
+
+        def modifier_form?(operation)
+          return true if operation.and_type? || operation.or_type?
+
+          operation.modifier_form?
+        end
+
+        def keyword(operation)
+          if operation.respond_to?(:keyword)
+            operation.keyword
+          else
+            operation.operator
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Prefer bitwise predicate methods over direct comparison operations.
+      #
+      # @safety
+      #   This cop is unsafe, as it can produce false positives if the receiver
+      #   is not an `Integer` object.
+      #
+      # @example
+      #
+      #   # bad - checks any set bits
+      #   (variable & flags).positive?
+      #
+      #   # good
+      #   variable.anybits?(flags)
+      #
+      #   # bad - checks all set bits
+      #   (variable & flags) == flags
+      #
+      #   # good
+      #   variable.allbits?(flags)
+      #
+      #   # bad - checks no set bits
+      #   (variable & flags).zero?
+      #
+      #   # good
+      #   variable.nobits?(flags)
+      #
+      class BitwisePredicate < Base
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        MSG = 'Replace with `%<preferred>s` for comparison with bit flags.'
+        RESTRICT_ON_SEND = %i[!= == > >= positive? zero?].freeze
+
+        minimum_target_ruby_version 2.5
+
+        # @!method anybits?(node)
+        def_node_matcher :anybits?, <<~PATTERN
+          {
+            (send #bit_operation? :positive?)
+            (send #bit_operation? :> (int 0))
+            (send #bit_operation? :>= (int 1))
+            (send #bit_operation? :!= (int 0))
+          }
+        PATTERN
+
+        # @!method allbits?(node)
+        def_node_matcher :allbits?, <<~PATTERN
+          {
+            (send (begin (send _ :& _flags)) :== _flags)
+            (send (begin (send _flags :& _)) :== _flags)
+          }
+        PATTERN
+
+        # @!method nobits?(node)
+        def_node_matcher :nobits?, <<~PATTERN
+          {
+            (send #bit_operation? :zero?)
+            (send #bit_operation? :== (int 0))
+          }
+        PATTERN
+
+        # @!method bit_operation?(node)
+        def_node_matcher :bit_operation?, <<~PATTERN
+          (begin
+            (send _ :& _))
+        PATTERN
+
+        def on_send(node)
+          return unless node.receiver.begin_type?
+          return unless (preferred_method = preferred_method(node))
+
+          bit_operation = node.receiver.children.first
+          lhs, _operator, rhs = *bit_operation
+          preferred = "#{lhs.source}.#{preferred_method}(#{rhs.source})"
+
+          add_offense(node, message: format(MSG, preferred: preferred)) do |corrector|
+            corrector.replace(node, preferred)
+          end
+        end
+
+        private
+
+        def preferred_method(node)
+          if anybits?(node)
+            'anybits?'
+          elsif allbits?(node)
+            'allbits?'
+          elsif nobits?(node)
+            'nobits?'
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -303,13 +303,28 @@ module RuboCop
 
         def move_comment_before_block(corrector, comment, block_node, closing_brace)
           range = block_node.chained? ? end_of_chain(block_node.parent).source_range : closing_brace
+
+          # It is possible that there is code between the block and the comment
+          # which needs to be preserved and trimmed.
+          pre_comment_range = source_range_before_comment(range, comment)
+
           corrector.remove(range_with_surrounding_space(comment.source_range, side: :right))
-          remove_trailing_whitespace(corrector, range, comment)
-          corrector.insert_after(range, "\n")
+          remove_trailing_whitespace(corrector, pre_comment_range, comment)
+          corrector.insert_after(pre_comment_range, "\n")
 
           corrector.insert_before(block_node, "#{comment.text}\n")
         end
 
+        def source_range_before_comment(range, comment)
+          range = range.end.join(comment.source_range.begin)
+
+          # End the range before any whitespace that precedes the comment
+          trailing_whitespace_count = range.source[/\s+\z/]&.length
+          range = range.adjust(end_pos: -trailing_whitespace_count) if trailing_whitespace_count
+
+          range
+        end
+
         def end_of_chain(node)
           return end_of_chain(node.block_node) if with_block?(node)
           return node unless node.chained?

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

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for multiple `defined?` calls joined by `&&` that can be combined
+      # into a single `defined?`.
+      #
+      # When checking that a nested constant or chained method is defined, it is
+      # not necessary to check each ancestor or component of the chain.
+      #
+      # @example
+      #   # bad
+      #   defined?(Foo) && defined?(Foo::Bar) && defined?(Foo::Bar::Baz)
+      #
+      #   # good
+      #   defined?(Foo::Bar::Baz)
+      #
+      #   # bad
+      #   defined?(foo) && defined?(foo.bar) && defined?(foo.bar.baz)
+      #
+      #   # good
+      #   defined?(foo.bar.baz)
+      class CombinableDefined < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = 'Combine nested `defined?` calls.'
+        OPERATORS = %w[&& and].freeze
+
+        def on_and(node)
+          # Only register an offense if all `&&` terms are `defined?` calls
+          return unless (terms = terms(node)).all?(&:defined_type?)
+
+          calls = defined_calls(terms)
+          namespaces = namespaces(calls)
+
+          calls.each do |call|
+            next unless namespaces.any?(call)
+
+            add_offense(node) do |corrector|
+              remove_term(corrector, call)
+            end
+          end
+        end
+
+        private
+
+        def terms(node)
+          node.each_descendant.select do |descendant|
+            descendant.parent.and_type? && !descendant.and_type?
+          end
+        end
+
+        def defined_calls(nodes)
+          nodes.filter_map do |defined_node|
+            subject = defined_node.first_argument
+            subject if subject.const_type? || subject.call_type?
+          end
+        end
+
+        def namespaces(nodes)
+          nodes.filter_map do |node|
+            if node.respond_to?(:namespace)
+              node.namespace
+            elsif node.respond_to?(:receiver)
+              node.receiver
+            end
+          end
+        end
+
+        def remove_term(corrector, term)
+          term = term.parent until term.parent.and_type?
+          range = if term == term.parent.children.last
+                    rhs_range_to_remove(term)
+                  else
+                    lhs_range_to_remove(term)
+                  end
+
+          corrector.remove(range)
+        end
+
+        # If the redundant `defined?` node is the LHS of an `and` node,
+        # the term as well as the subsequent `&&`/`and` operator will be removed.
+        def lhs_range_to_remove(term)
+          source = @processed_source.buffer.source
+
+          pos = term.source_range.end_pos
+          pos += 1 until source[..pos].end_with?(*OPERATORS)
+
+          range_with_surrounding_space(
+            range: term.source_range.with(end_pos: pos + 1),
+            side: :right,
+            newlines: false
+          )
+        end
+
+        # If the redundant `defined?` node is the RHS of an `and` node,
+        # the term as well as the preceding `&&`/`and` operator will be removed.
+        def rhs_range_to_remove(term)
+          source = @processed_source.buffer.source
+
+          pos = term.source_range.begin_pos
+          pos -= 1 until source[pos, 3].start_with?(*OPERATORS)
+
+          range_with_surrounding_space(
+            range: term.source_range.with(begin_pos: pos - 1),
+            side: :right,
+            newlines: false
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -48,6 +48,7 @@ module RuboCop
       #
       class EndlessMethod < Base
         include ConfigurableEnforcedStyle
+        include EndlessMethodRewriter
         extend TargetRubyVersion
         extend AutoCorrector
 
@@ -81,20 +82,6 @@ module RuboCop
 
           add_offense(node) { |corrector| correct_to_multiline(corrector, node) }
         end
-
-        def correct_to_multiline(corrector, node)
-          replacement = <<~RUBY.strip
-            def #{node.method_name}#{arguments(node)}
-              #{node.body.source}
-            end
-          RUBY
-
-          corrector.replace(node, replacement)
-        end
-
-        def arguments(node, missing = '')
-          node.arguments.any? ? node.arguments.source : missing
-        end
       end
     end
   end

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

@@ -283,7 +283,8 @@ module RuboCop
         end
 
         def accepted_if?(node, ending)
-          return true if node.modifier_form? || node.ternary? || node.elsif_conditional?
+          return true if node.modifier_form? || node.ternary? || node.elsif_conditional? ||
+                         assigned_lvar_used_in_if_branch?(node)
 
           if ending
             node.else?
@@ -292,6 +293,18 @@ module RuboCop
           end
         end
 
+        def assigned_lvar_used_in_if_branch?(node)
+          return false unless (if_branch = node.if_branch)
+
+          assigned_lvars_in_condition = node.condition.each_descendant(:lvasgn).map do |lvasgn|
+            lvar_name, = *lvasgn
+            lvar_name.to_s
+          end
+          used_lvars_in_branch = if_branch.each_descendant(:lvar).map(&:source) || []
+
+          (assigned_lvars_in_condition & used_lvars_in_branch).any?
+        end
+
         def remove_whole_lines(corrector, range)
           corrector.remove(range_by_whole_lines(range, include_final_newline: true))
         end

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # When passing an existing hash as keyword arguments, provide additional arguments
+      # directly rather than using `merge`.
+      #
+      # Providing arguments directly is more performant, than using `merge`, and
+      # also leads to a shorter and simpler code.
+      #
+      # @example
+      #   # bad
+      #   some_method(**opts.merge(foo: true))
+      #   some_method(**opts.merge(other_opts))
+      #
+      #   # good
+      #   some_method(**opts, foo: true)
+      #   some_method(**opts, **other_opts)
+      #
+      class KeywordArgumentsMerging < Base
+        extend AutoCorrector
+
+        MSG = 'Provide additional arguments directly rather than using `merge`.'
+
+        # @!method merge_kwargs?(node)
+        def_node_matcher :merge_kwargs?, <<~PATTERN
+          (send _ _
+            ...
+            (hash
+              (kwsplat
+                $(send $_ :merge $...))
+              ...))
+        PATTERN
+
+        def on_kwsplat(node)
+          return unless (ancestor = node.parent&.parent)
+
+          merge_kwargs?(ancestor) do |merge_node, hash_node, other_hash_node|
+            add_offense(merge_node) do |corrector|
+              autocorrect(corrector, node, hash_node, other_hash_node)
+            end
+          end
+        end
+
+        private
+
+        def autocorrect(corrector, kwsplat_node, hash_node, other_hash_node)
+          other_hash_node_replacement =
+            other_hash_node.map do |node|
+              if node.hash_type?
+                if node.braces?
+                  node.source[1...-1]
+                else
+                  node.source
+                end
+              else
+                "**#{node.source}"
+              end
+            end.join(', ')
+
+          corrector.replace(kwsplat_node, "**#{hash_node.source}, #{other_hash_node_replacement}")
+        end
+      end
+    end
+  end
+end

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

@@ -63,12 +63,17 @@ module RuboCop
 
         MSG = 'Use `%<new_method_name>s` instead of `each` to map elements into an array.'
 
+        # @!method suitable_argument_node?(node)
+        def_node_matcher :suitable_argument_node?, <<-PATTERN
+          !{splat forwarded-restarg forwarded-args (hash (forwarded-kwrestarg)) (block-pass nil?)}
+        PATTERN
+
         # @!method each_block_with_push?(node)
         def_node_matcher :each_block_with_push?, <<-PATTERN
           [
             ^({begin kwbegin block} ...)
             ({block numblock} (send !{nil? self} :each) _
-              (send (lvar _) {:<< :push :append} {send lvar begin}))
+              (send (lvar _) {:<< :push :append} #suitable_argument_node?))
           ]
         PATTERN
 

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

@@ -55,25 +55,19 @@ module RuboCop
         MSG = 'Avoid comparing a variable with multiple items ' \
               'in a conditional, use `Array#include?` instead.'
 
-        def on_new_investigation
-          reset_comparison
-        end
-
         def on_or(node)
           root_of_or_node = root_of_or_node(node)
-
           return unless node == root_of_or_node
-          return unless nested_variable_comparison?(root_of_or_node)
-          return if @allowed_method_comparison
-          return if @compared_elements.size < comparisons_threshold
+          return unless nested_comparison?(node)
+
+          return unless (variable, values = find_offending_var(node))
+          return if values.size < comparisons_threshold
 
           add_offense(node) do |corrector|
-            elements = @compared_elements.join(', ')
-            prefer_method = "[#{elements}].include?(#{variables_in_node(node).first})"
+            elements = values.map(&:source).join(', ')
+            prefer_method = "[#{elements}].include?(#{variable_name(variable)})"
 
             corrector.replace(node, prefer_method)
-
-            reset_comparison
           end
         end
 
@@ -92,32 +86,25 @@ module RuboCop
           (send $_ :== $lvar)
         PATTERN
 
-        def nested_variable_comparison?(node)
-          return false unless nested_comparison?(node)
-
-          variables_in_node(node).count == 1
-        end
-
-        def variables_in_node(node)
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def find_offending_var(node, variables = Set.new, values = [])
           if node.or_type?
-            node.node_parts.flat_map { |node_part| variables_in_node(node_part) }.uniq
-          else
-            variables_in_simple_node(node)
-          end
-        end
+            find_offending_var(node.lhs, variables, values)
+            find_offending_var(node.rhs, variables, values)
+          elsif simple_double_comparison?(node)
+            return
+          elsif (var, obj = simple_comparison?(node))
+            return if allow_method_comparison? && obj.send_type?
 
-        def variables_in_simple_node(node)
-          simple_double_comparison?(node) do |var1, var2|
-            return [variable_name(var1), variable_name(var2)]
-          end
-          if (var, obj = simple_comparison_lhs?(node)) || (obj, var = simple_comparison_rhs?(node))
-            @allowed_method_comparison = true if allow_method_comparison? && obj.send_type?
-            @compared_elements << obj.source
-            return [variable_name(var)]
+            variables << var
+            return if variables.size > 1
+
+            values << obj
           end
 
-          []
+          [variables.first, values] if variables.any?
         end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def variable_name(node)
           node.children[0]
@@ -132,7 +119,14 @@ module RuboCop
         end
 
         def comparison?(node)
-          simple_comparison_lhs?(node) || simple_comparison_rhs?(node) || nested_comparison?(node)
+          simple_comparison?(node) || nested_comparison?(node)
+        end
+
+        def simple_comparison?(node)
+          if (var, obj = simple_comparison_lhs?(node)) ||
+             (obj, var = simple_comparison_rhs?(node))
+            [var, obj]
+          end
         end
 
         def root_of_or_node(or_node)
@@ -145,11 +139,6 @@ module RuboCop
           end
         end
 
-        def reset_comparison
-          @compared_elements = []
-          @allowed_method_comparison = false
-        end
-
         def allow_method_comparison?
           cop_config.fetch('AllowMethodComparison', true)
         end

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

@@ -69,6 +69,8 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Redundant line continuation.'
+        LINE_CONTINUATION = "\\\n"
+        LINE_CONTINUATION_PATTERN = /(\\\n)/.freeze
         ALLOWED_STRING_TOKENS = %i[tSTRING tSTRING_CONTENT].freeze
         ARGUMENT_TYPES = %i[
           kFALSE kNIL kSELF kTRUE tCONSTANT tCVAR tFLOAT tGVAR tIDENTIFIER tINTEGER tIVAR
@@ -79,7 +81,7 @@ module RuboCop
         def on_new_investigation
           return unless processed_source.ast
 
-          each_match_range(processed_source.ast.source_range, /(\\\n)/) do |range|
+          each_match_range(processed_source.ast.source_range, LINE_CONTINUATION_PATTERN) do |range|
             next if require_line_continuation?(range)
             next unless redundant_line_continuation?(range)
 
@@ -87,6 +89,8 @@ module RuboCop
               corrector.remove_leading(range, 1)
             end
           end
+
+          inspect_eof_line_continuation
         end
 
         private
@@ -125,10 +129,24 @@ module RuboCop
           return true unless (node = find_node_for_line(range.last_line))
           return false if argument_newline?(node)
 
-          source = node.parent ? node.parent.source : node.source
+          source = node.source
+          while (node = node.parent)
+            source = node.source
+          end
           parse(source.gsub("\\\n", "\n")).valid_syntax?
         end
 
+        def inspect_eof_line_continuation
+          return unless processed_source.raw_source.end_with?(LINE_CONTINUATION)
+
+          rindex = processed_source.raw_source.rindex(LINE_CONTINUATION)
+          line_continuation_range = range_between(rindex, rindex + 1)
+
+          add_offense(line_continuation_range) do |corrector|
+            corrector.remove_trailing(line_continuation_range, 1)
+          end
+        end
+
         def inside_string_literal?(range, token)
           ALLOWED_STRING_TOKENS.include?(token.type) && token.pos.overlaps?(range)
         end