rubocop 1.57.1 → 1.81.6

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

@@ -18,12 +18,15 @@ module RuboCop
       #   end
       #
       #   # bad
-      #   if some_var && true
+      #   # We're only interested in the left hand side being a truthy literal,
+      #   # because it affects the evaluation of the &&, whereas the right hand
+      #   # side will be conditionally executed/called and can be a literal.
+      #   if true && some_var
       #     do_something
       #   end
       #
       #   # good
-      #   if some_var && some_condition
+      #   if some_var
       #     do_something
       #   end
       #
@@ -34,32 +37,110 @@ module RuboCop
       #   end
       class LiteralAsCondition < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Literal `%<literal>s` appeared as a condition.'
+        RESTRICT_ON_SEND = [:!].freeze
+
+        def on_and(node)
+          return unless node.lhs.truthy_literal?
+
+          add_offense(node.lhs) do |corrector|
+            # Don't autocorrect `'foo' && return` because having `return` as
+            # the leftmost node can lead to a void value expression syntax error.
+            next if node.rhs.type?(:return, :break, :next)
+
+            corrector.replace(node, node.rhs.source)
+          end
+        end
+
+        def on_or(node)
+          return unless node.lhs.falsey_literal?
+
+          add_offense(node.lhs) do |corrector|
+            # Don't autocorrect `'foo' && return` because having `return` as
+            # the leftmost node can lead to a void value expression syntax error.
+            next if node.rhs.type?(:return, :break, :next)
+
+            corrector.replace(node, node.rhs.source)
+          end
+        end
 
         def on_if(node)
-          check_for_literal(node)
+          cond = condition(node)
+
+          return unless cond.falsey_literal? || cond.truthy_literal?
+
+          correct_if_node(node, cond)
         end
 
         def on_while(node)
-          return if condition(node).true_type?
+          return if node.condition.source == 'true'
 
-          check_for_literal(node)
+          if node.condition.truthy_literal?
+            add_offense(node.condition) do |corrector|
+              corrector.replace(node.condition, 'true')
+            end
+          elsif node.condition.falsey_literal?
+            add_offense(node.condition) do |corrector|
+              corrector.remove(node)
+            end
+          end
         end
-        alias on_while_post on_while
+
+        # rubocop:disable Metrics/AbcSize
+        def on_while_post(node)
+          return if node.condition.source == 'true'
+
+          if node.condition.truthy_literal?
+            add_offense(node.condition) do |corrector|
+              corrector.replace(node, node.source.sub(node.condition.source, 'true'))
+            end
+          elsif node.condition.falsey_literal?
+            add_offense(node.condition) do |corrector|
+              corrector.replace(node, node.body.child_nodes.map(&:source).join("\n"))
+            end
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
 
         def on_until(node)
-          return if condition(node).false_type?
+          return if node.condition.source == 'false'
 
-          check_for_literal(node)
+          if node.condition.falsey_literal?
+            add_offense(node.condition) do |corrector|
+              corrector.replace(node.condition, 'false')
+            end
+          elsif node.condition.truthy_literal?
+            add_offense(node.condition) do |corrector|
+              corrector.remove(node)
+            end
+          end
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        def on_until_post(node)
+          return if node.condition.source == 'false'
+
+          if node.condition.falsey_literal?
+            add_offense(node.condition) do |corrector|
+              corrector.replace(node, node.source.sub(node.condition.source, 'false'))
+            end
+          elsif node.condition.truthy_literal?
+            add_offense(node.condition) do |corrector|
+              corrector.replace(node, node.body.child_nodes.map(&:source).join("\n"))
+            end
+          end
         end
-        alias on_until_post on_until
+        # rubocop:enable Metrics/AbcSize
 
         def on_case(case_node)
-          if case_node.condition
+          if (cond = case_node.condition)
+            return if !cond.falsey_literal? && !cond.truthy_literal?
+
             check_case(case_node)
           else
-            case_node.each_when do |when_node|
+            case_node.when_branches.each do |when_node|
               next unless when_node.conditions.all?(&:literal?)
 
               range = when_conditions_range(when_node)
@@ -129,6 +210,8 @@ module RuboCop
 
         def handle_node(node)
           if node.literal?
+            return if node.parent.and_type?
+
             add_offense(node)
           elsif %i[send and or begin].include?(node.type)
             check_node(node)
@@ -158,6 +241,38 @@ module RuboCop
             when_node.conditions.last.source_range.end_pos
           )
         end
+
+        def condition_evaluation?(node, cond)
+          if node.unless?
+            cond.falsey_literal?
+          else
+            cond.truthy_literal?
+          end
+        end
+
+        # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def correct_if_node(node, cond)
+          result = condition_evaluation?(node, cond)
+
+          new_node = if node.elsif? && result
+                       "else\n  #{range_with_comments(node.if_branch).source}"
+                     elsif node.elsif? && !result
+                       "else\n  #{node.else_branch.source}"
+                     elsif node.if_branch && result
+                       node.if_branch.source
+                     elsif node.elsif_conditional?
+                       "#{node.else_branch.source.sub('elsif', 'if')}\nend"
+                     elsif node.else? || node.ternary?
+                       node.else_branch.source
+                     else
+                       '' # Equivalent to removing the node
+                     end
+
+          add_offense(cond) do |corrector|
+            corrector.replace(node, new_node)
+          end
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       end
     end
   end

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for literal assignments in the conditions of `if`, `while`, and `until`.
+      # It emulates the following Ruby warning:
+      #
+      # [source,console]
+      # ----
+      # $ ruby -we 'if x = true; end'
+      # -e:1: warning: found `= literal' in conditional, should be ==
+      # ----
+      #
+      # As a lint cop, it cannot be determined if `==` is appropriate as intended,
+      # therefore this cop does not provide autocorrection.
+      #
+      # @example
+      #
+      #   # bad
+      #   if x = 42
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   if x == 42
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   if x = y
+      #     do_something
+      #   end
+      #
+      class LiteralAssignmentInCondition < Base
+        MSG = "Don't use literal assignment `= %<literal>s` in conditional, " \
+              'should be `==` or non-literal operand.'
+
+        def on_if(node)
+          traverse_node(node.condition) do |asgn_node|
+            next unless asgn_node.loc.operator
+
+            rhs = asgn_node.rhs
+            next if !all_literals?(rhs) || parallel_assignment_with_splat_operator?(rhs)
+
+            range = offense_range(asgn_node, rhs)
+
+            add_offense(range, message: format(MSG, literal: rhs.source))
+          end
+        end
+        alias on_while on_if
+        alias on_until on_if
+
+        private
+
+        def traverse_node(node, &block)
+          yield node if node.equals_asgn?
+
+          node.each_child_node { |child| traverse_node(child, &block) }
+        end
+
+        def all_literals?(node)
+          case node.type
+          when :dstr, :xstr
+            false
+          when :array
+            node.values.all? { |value| all_literals?(value) }
+          when :hash
+            (node.values + node.keys).all? { |item| all_literals?(item) }
+          else
+            node.respond_to?(:literal?) && node.literal?
+          end
+        end
+
+        def parallel_assignment_with_splat_operator?(node)
+          node.array_type? && node.values.first&.splat_type?
+        end
+
+        def offense_range(asgn_node, rhs)
+          asgn_node.loc.operator.join(rhs.source_range.end)
+        end
+      end
+    end
+  end
+end

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

@@ -5,16 +5,15 @@ module RuboCop
     module Lint
       # Checks for interpolated literals.
       #
+      # NOTE: Array literals interpolated in regexps are not handled by this cop, but
+      # by `Lint/ArrayLiteralInRegexp` instead.
+      #
       # @example
       #
       #   # bad
-      #
       #   "result is #{10}"
       #
-      # @example
-      #
       #   # good
-      #
       #   "result is 10"
       class LiteralInInterpolation < Base
         include Interpolation
@@ -25,6 +24,7 @@ module RuboCop
         MSG = 'Literal interpolation detected.'
         COMPOSITE = %i[array hash pair irange erange].freeze
 
+        # rubocop:disable Metrics/AbcSize
         def on_interpolation(begin_node)
           final_node = begin_node.children.last
           return unless offending?(final_node)
@@ -34,14 +34,23 @@ module RuboCop
           # interpolation should not be removed if the expanded value
           # contains a space character.
           expanded_value = autocorrected_value(final_node)
+          expanded_value = handle_special_regexp_chars(begin_node, expanded_value)
+
           return if in_array_percent_literal?(begin_node) && /\s|\A\z/.match?(expanded_value)
 
           add_offense(final_node) do |corrector|
-            return if final_node.dstr_type? # nested, fixed in next iteration
+            next if final_node.dstr_type? # nested, fixed in next iteration
 
-            corrector.replace(final_node.parent, expanded_value)
+            replacement = if final_node.str_type? && !final_node.value.valid_encoding?
+                            final_node.source.delete_prefix('"').delete_suffix('"')
+                          else
+                            expanded_value
+                          end
+
+            corrector.replace(final_node.parent, replacement)
           end
         end
+        # rubocop:enable Metrics/AbcSize
 
         private
 
@@ -49,8 +58,10 @@ module RuboCop
           node &&
             !special_keyword?(node) &&
             prints_as_self?(node) &&
-            # Special case for Layout/TrailingWhitespace
-            !(space_literal?(node) && ends_heredoc_line?(node))
+            # Special case for `Layout/TrailingWhitespace`
+            !(space_literal?(node) && ends_heredoc_line?(node)) &&
+            # Handled by `Lint/ArrayLiteralInRegexp`
+            !array_in_regexp?(node)
         end
 
         def special_keyword?(node)
@@ -58,6 +69,11 @@ module RuboCop
           (node.str_type? && !node.loc.respond_to?(:begin)) || node.source_range.is?('__LINE__')
         end
 
+        def array_in_regexp?(node)
+          grandparent = node.parent.parent
+          node.array_type? && grandparent.regexp_type?
+        end
+
         # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity
         def autocorrected_value(node)
           case node.type
@@ -81,6 +97,27 @@ module RuboCop
         end
         # rubocop:enable Metrics/MethodLength, Metrics/CyclomaticComplexity
 
+        def handle_special_regexp_chars(begin_node, value)
+          parent_node = begin_node.parent
+
+          return value unless parent_node.regexp_type? && parent_node.slash_literal? && value['/']
+
+          # When a literal string containing a forward slash preceded by backslashes
+          # is interpolated inside a regexp, the number of resultant backslashes in the
+          # compiled Regexp is `(2(n+1) / 4)+1`, where `n` is the number of backslashes
+          # inside the interpolation.
+          # ie. 0-2 backslashes is compiled to 1, 3-6 is compiled to 3, etc.
+          # This maintains that same behavior in order to ensure the Regexp behavior
+          # does not change upon removing the interpolation.
+          value.gsub(%r{(\\*)/}) do
+            backslashes = Regexp.last_match[1]
+            backslash_count = backslashes.length
+            needed_backslashes = (2 * ((backslash_count + 1) / 4)) + 1
+
+            "#{'\\' * needed_backslashes}/"
+          end
+        end
+
         def autocorrected_value_for_string(node)
           if node.source.start_with?("'", '%q')
             node.children.last.inspect[1..-2]
@@ -149,12 +186,12 @@ module RuboCop
         end
 
         def space_literal?(node)
-          node.str_type? && node.value.blank?
+          node.str_type? && node.value.valid_encoding? && node.value.blank?
         end
 
         def ends_heredoc_line?(node)
           grandparent = node.parent.parent
-          return false unless grandparent&.dstr_type? && grandparent&.heredoc?
+          return false unless grandparent&.dstr_type? && grandparent.heredoc?
 
           line = processed_source.lines[node.last_line - 1]
           line.size == node.loc.last_column + 1
@@ -162,10 +199,10 @@ module RuboCop
 
         def in_array_percent_literal?(node)
           parent = node.parent
-          return false unless parent.dstr_type? || parent.dsym_type?
+          return false unless parent.type?(:dstr, :dsym)
 
           grandparent = parent.parent
-          grandparent&.array_type? && grandparent&.percent_literal?
+          grandparent&.array_type? && grandparent.percent_literal?
         end
       end
     end

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

@@ -19,17 +19,6 @@ module RuboCop
       #     do_something
       #   end while some_condition
       #
-      # @example
-      #
-      #   # bad
-      #
-      #   # using until
-      #   begin
-      #     do_something
-      #   end until some_condition
-      #
-      # @example
-      #
       #   # good
       #
       #   # while replacement
@@ -38,7 +27,12 @@ module RuboCop
       #     break unless some_condition
       #   end
       #
-      # @example
+      #   # bad
+      #
+      #   # using until
+      #   begin
+      #     do_something
+      #   end until some_condition
       #
       #   # good
       #

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

@@ -52,10 +52,9 @@ module RuboCop
           each_missing_enable do |cop, line_range|
             next if acceptable_range?(cop, line_range)
 
-            range = source_range(processed_source.buffer, line_range.min, (0..0))
             comment = processed_source.comment_at_line(line_range.begin)
 
-            add_offense(range, message: message(cop, comment))
+            add_offense(comment, message: message(cop, comment))
           end
         end
 

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

@@ -97,7 +97,7 @@ module RuboCop
 
         # @!method class_new_block(node)
         def_node_matcher :class_new_block, <<~RUBY
-          ({block numblock}
+          (any_block
             (send
               (const {nil? cbase} :Class) :new $_) ...)
         RUBY
@@ -135,7 +135,7 @@ module RuboCop
         end
 
         def inside_class_with_stateful_parent?(node)
-          if (block_node = node.each_ancestor(:block, :numblock).first)
+          if (block_node = node.each_ancestor(:any_block).first)
             return false unless (super_class = class_new_block(block_node))
 
             !allowed_class?(super_class)

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

@@ -8,7 +8,7 @@ module RuboCop
       # Offenses are registered for regexp character classes like `/[A-z]/`
       # as well as range objects like `('A'..'z')`.
       #
-      # NOTE: Range objects cannot be autocorrected.
+      # NOTE: `Range` objects cannot be autocorrected.
       #
       # @safety
       #   The cop autocorrects regexp character classes
@@ -36,19 +36,18 @@ module RuboCop
 
         def on_irange(node)
           return unless node.children.compact.all?(&:str_type?)
+          return if node.begin.nil? || node.end.nil?
 
-          range_start, range_end = node.children
-
-          return if range_start.nil? || range_end.nil?
-
-          add_offense(node) if unsafe_range?(range_start.value, range_end.value)
+          add_offense(node) if unsafe_range?(node.begin.value, node.end.value)
         end
         alias on_erange on_irange
 
         def on_regexp(node)
           each_unsafe_regexp_range(node) do |loc|
+            next unless (replacement = regexp_range(loc.source))
+
             add_offense(loc) do |corrector|
-              corrector.replace(loc, rewrite_regexp_range(loc.source))
+              corrector.replace(loc, replacement)
             end
           end
         end
@@ -80,7 +79,7 @@ module RuboCop
         end
 
         def range_pairs(expr)
-          RuboCop::Cop::Utils::RegexpRanges.new(expr).pairs
+          expr.expressions.filter_map { |e| [e.expressions[0], e.expressions[1]] if e.type == :set }
         end
 
         def unsafe_range?(range_start, range_end)
@@ -95,14 +94,17 @@ module RuboCop
 
         def skip_range?(range_start, range_end)
           [range_start, range_end].any? do |bound|
-            bound.type != :literal
+            bound&.type != :literal
           end
         end
 
-        def rewrite_regexp_range(source)
+        def regexp_range(source)
           open, close = source.split('-')
-          first = [open, range_for(open).end]
-          second = [range_for(close).begin, close]
+          return unless (open_range = range_for(open))
+          return unless (close_range = range_for(close))
+
+          first = [open, open_range.end]
+          second = [close_range.begin, close]
           "#{first.uniq.join('-')}#{second.uniq.join('-')}"
         end
       end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # Do not mix named captures and numbered captures in a Regexp literal
+      # Do not mix named captures and numbered captures in a `Regexp` literal
       # because numbered capture is ignored if they're mixed.
       # Replace numbered captures with non-capturing groupings or
       # named captures.

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

@@ -17,8 +17,6 @@ module RuboCop
       #     end
       #   end
       #
-      # @example
-      #
       #   # good
       #
       #   def foo
@@ -26,8 +24,6 @@ module RuboCop
       #     bar.call
       #   end
       #
-      # @example
-      #
       #   # good
       #
       #   # `class_eval`, `instance_eval`, `module_eval`, `class_exec`, `instance_exec`, and
@@ -47,8 +43,6 @@ module RuboCop
       #     end
       #   end
       #
-      # @example
-      #
       #   # good
       #
       #   def foo
@@ -101,14 +95,14 @@ module RuboCop
         MSG = 'Method definitions must not be nested. Use `lambda` instead.'
 
         def on_def(node)
-          subject, = *node
-          return if node.defs_type? && subject.lvar_type?
+          subject, = *node # rubocop:disable InternalAffairs/NodeDestructuring
+          return if node.defs_type? && allowed_subject_type?(subject)
 
-          def_ancestor = node.each_ancestor(:def, :defs).first
+          def_ancestor = node.each_ancestor(:any_def).first
           return unless def_ancestor
 
           within_scoping_def =
-            node.each_ancestor(:block, :numblock, :sclass).any? do |ancestor|
+            node.each_ancestor(:any_block, :sclass).any? do |ancestor|
               scoping_method_call?(ancestor)
             end
 
@@ -123,6 +117,10 @@ module RuboCop
             child.class_constructor? || allowed_method_name?(child)
         end
 
+        def allowed_subject_type?(subject)
+          subject.variable? || subject.const_type? || subject.call_type?
+        end
+
         def allowed_method_name?(node)
           name = node.method_name
 
@@ -131,12 +129,12 @@ module RuboCop
 
         # @!method eval_call?(node)
         def_node_matcher :eval_call?, <<~PATTERN
-          ({block numblock} (send _ {:instance_eval :class_eval :module_eval} ...) ...)
+          (any_block (send _ {:instance_eval :class_eval :module_eval} ...) ...)
         PATTERN
 
         # @!method exec_call?(node)
         def_node_matcher :exec_call?, <<~PATTERN
-          ({block numblock} (send _ {:instance_exec :class_exec :module_exec} ...) ...)
+          (any_block (send _ {:instance_exec :class_exec :module_exec} ...) ...)
         PATTERN
       end
     end

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

@@ -8,16 +8,12 @@ module RuboCop
       # @example
       #
       #   # bad
-      #
       #   result = (1..4).reduce(0) do |acc, i|
       #     next if i.odd?
       #     acc + i
       #   end
       #
-      # @example
-      #
       #   # good
-      #
       #   result = (1..4).reduce(0) do |acc, i|
       #     next acc if i.odd?
       #     acc + i
@@ -34,35 +30,20 @@ module RuboCop
             add_offense(void_next) if void_next
           end
         end
-
-        def on_numblock(node)
-          on_numblock_body_of_reduce(node) do |body|
-            void_next = body.each_node(:next).find do |n|
-              n.children.empty? && parent_numblock_node(n) == node
-            end
-
-            add_offense(void_next) if void_next
-          end
-        end
+        alias on_numblock on_block
 
         private
 
         # @!method on_block_body_of_reduce(node)
         def_node_matcher :on_block_body_of_reduce, <<~PATTERN
-          (block (send _recv {:reduce :inject} !sym) _blockargs $(begin ...))
-        PATTERN
-
-        # @!method on_numblock_body_of_reduce(node)
-        def_node_matcher :on_numblock_body_of_reduce, <<~PATTERN
-          (numblock (send _recv {:reduce :inject} !sym) _argscount $(begin ...))
+          {
+            (block (call _recv {:reduce :inject} !sym) _blockargs $(begin ...))
+            (numblock (call _recv {:reduce :inject} !sym) _argscount $(begin ...))
+          }
         PATTERN
 
         def parent_block_node(node)
-          node.each_ancestor(:block).first
-        end
-
-        def parent_numblock_node(node)
-          node.each_ancestor(:numblock).first
+          node.each_ancestor(:any_block).first
         end
       end
     end