rubocop 1.44.1 → 1.78.0

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

@@ -9,13 +9,9 @@ module RuboCop
       # @example
       #
       #   # bad
-      #
       #   array = ['Item 1' 'Item 2']
       #
-      # @example
-      #
       #   # good
-      #
       #   array = ['Item 1Item 2']
       #   array = ['Item 1' + 'Item 2']
       #   array = [
@@ -23,27 +19,40 @@ module RuboCop
       #     'Item 2'
       #   ]
       class ImplicitStringConcatenation < Base
-        MSG = 'Combine %<string1>s and %<string2>s into a single string ' \
+        extend AutoCorrector
+
+        MSG = 'Combine %<lhs>s and %<rhs>s into a single string ' \
               'literal, rather than using implicit string concatenation.'
         FOR_ARRAY = ' Or, if they were intended to be separate array ' \
                     'elements, separate them with a comma.'
         FOR_METHOD = ' Or, if they were intended to be separate method ' \
                      'arguments, separate them with a comma.'
 
+        # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/PerceivedComplexity
         def on_dstr(node)
-          each_bad_cons(node) do |child_node1, child_node2|
-            range   = child_node1.source_range.join(child_node2.source_range)
-            message = format(MSG,
-                             string1: display_str(child_node1),
-                             string2: display_str(child_node2))
+          each_bad_cons(node) do |lhs_node, rhs_node|
+            range = lhs_node.source_range.join(rhs_node.source_range)
+            message = format(MSG, lhs: display_str(lhs_node), rhs: display_str(rhs_node))
             if node.parent&.array_type?
               message << FOR_ARRAY
             elsif node.parent&.send_type?
               message << FOR_METHOD
             end
-            add_offense(range, message: message)
+
+            add_offense(range, message: message) do |corrector|
+              if lhs_node.value == ''
+                corrector.remove(lhs_node)
+              elsif rhs_node.value == ''
+                corrector.remove(rhs_node)
+              else
+                range = lhs_node.source_range.end.join(rhs_node.source_range.begin)
+
+                corrector.replace(range, ' + ')
+              end
+            end
           end
         end
+        # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/PerceivedComplexity
 
         private
 
@@ -73,7 +82,7 @@ module RuboCop
         end
 
         def string_literal?(node)
-          node.str_type? || (node.dstr_type? && node.children.all? { |c| string_literal?(c) })
+          node.type?(:str, :dstr)
         end
 
         def string_literals?(node1, node2)
@@ -81,7 +90,7 @@ module RuboCop
         end
 
         def display_str(node)
-          if /\n/.match?(node.source)
+          if node.source.include?("\n")
             str_content(node).inspect
           else
             node.source
@@ -89,6 +98,8 @@ module RuboCop
         end
 
         def str_content(node)
+          return unless node.respond_to?(:str_type?)
+
           if node.str_type?
             node.children[0]
           else

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

@@ -3,8 +3,10 @@
 module RuboCop
   module Cop
     module Lint
+      # Checks for `IO.select` that is incompatible with Fiber Scheduler since Ruby 3.0.
       #
-      # This cop checks for `IO.select` that is incompatible with Fiber Scheduler since Ruby 3.0.
+      # When an array of IO objects waiting for an exception (the third argument of `IO.select`)
+      # is used as an argument, there is no alternative API, so offenses are not registered.
       #
       # NOTE: When the method is successful the return value of `IO.select` is `[[IO]]`,
       # and the return value of `io.wait_readable` and `io.wait_writable` are `self`.
@@ -42,8 +44,8 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          read, write, _excepts, timeout = *io_select(node)
-          return unless read
+          read, write, excepts, timeout = *io_select(node)
+          return if excepts && !excepts.children.empty?
           return unless scheduler_compatible?(read, write) || scheduler_compatible?(write, read)
 
           preferred = preferred_method(read, write, timeout)

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

@@ -11,7 +11,6 @@ module RuboCop
       # @example
       #
       #   # bad
-      #
       #   class C
       #     private
       #
@@ -20,10 +19,7 @@ module RuboCop
       #     end
       #   end
       #
-      # @example
-      #
       #   # good
-      #
       #   class C
       #     def self.method
       #       puts 'hi'
@@ -32,10 +28,7 @@ module RuboCop
       #     private_class_method :method
       #   end
       #
-      # @example
-      #
       #   # good
-      #
       #   class C
       #     class << self
       #       private
@@ -83,7 +76,7 @@ module RuboCop
                           ALTERNATIVE_PROTECTED
                         end
           format(MSG, modifier: visibility,
-                      line: modifier.location.expression.line,
+                      line: modifier.source_range.line,
                       alternative: alternative)
         end
 

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

@@ -58,6 +58,7 @@ module RuboCop
 
         def on_class(node)
           return unless node.parent_class && exception_class?(node.parent_class)
+          return if inherit_exception_class_with_omitted_namespace?(node)
 
           message = message(node.parent_class)
 
@@ -87,6 +88,14 @@ module RuboCop
           class_node.const_name == 'Exception'
         end
 
+        def inherit_exception_class_with_omitted_namespace?(class_node)
+          return false if class_node.parent_class.namespace&.cbase_type?
+
+          class_node.left_siblings.any? do |sibling|
+            sibling.respond_to?(:identifier) && exception_class?(sibling.identifier)
+          end
+        end
+
         def preferred_base_class
           PREFERRED_BASE_CLASS[style]
         end

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

@@ -14,13 +14,9 @@ module RuboCop
       # @example
       #
       #   # bad
-      #
       #   foo = 'something with #{interpolation} inside'
       #
-      # @example
-      #
       #   # good
-      #
       #   foo = "something with #{interpolation} inside"
       class InterpolationCheck < Base
         extend AutoCorrector
@@ -28,14 +24,17 @@ module RuboCop
         MSG = 'Interpolation in single quoted string detected. ' \
               'Use double quoted strings if you need interpolation.'
 
+        # rubocop:disable Metrics/CyclomaticComplexity
         def on_str(node)
           return if node.parent&.regexp_type?
           return unless /(?<!\\)#\{.*\}/.match?(node.source)
           return if heredoc?(node)
           return unless node.loc.begin && node.loc.end
+          return unless valid_syntax?(node)
 
           add_offense(node) { |corrector| autocorrect(corrector, node) }
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
 
         private
 
@@ -53,6 +52,12 @@ module RuboCop
         def heredoc?(node)
           node.loc.is_a?(Parser::Source::Map::Heredoc) || (node.parent && heredoc?(node.parent))
         end
+
+        def valid_syntax?(node)
+          double_quoted_string = node.source.gsub(/\A'|'\z/, '"')
+
+          parse(double_quoted_string).valid_syntax?
+        end
       end
     end
   end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Emulates the following Ruby warning in Ruby 3.3.
+      #
+      # [source,ruby]
+      # ----
+      # $ ruby -e '0.times { it }'
+      # -e:1: warning: `it` calls without arguments will refer to the first block param in Ruby 3.4;
+      # use it() or self.it
+      # ----
+      #
+      # `it` calls without arguments will refer to the first block param in Ruby 3.4.
+      # So use `it()` or `self.it` to ensure compatibility.
+      #
+      # @example
+      #
+      #   # bad
+      #   do_something { it }
+      #
+      #   # good
+      #   do_something { it() }
+      #   do_something { self.it }
+      #
+      class ItWithoutArgumentsInBlock < Base
+        include NodePattern::Macros
+        extend TargetRubyVersion
+
+        maximum_target_ruby_version 3.3
+
+        MSG = '`it` calls without arguments will refer to the first block param in Ruby 3.4; ' \
+              'use `it()` or `self.it`.'
+        RESTRICT_ON_SEND = %i[it].freeze
+
+        def on_send(node)
+          return unless (block_node = node.each_ancestor(:block).first)
+          return unless block_node.arguments.empty_and_without_delimiters?
+
+          add_offense(node) if deprecated_it_method?(node)
+        end
+
+        def deprecated_it_method?(node)
+          !node.receiver && node.arguments.empty? && !node.parenthesized? && !node.block_literal?
+        end
+      end
+    end
+  end
+end

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

@@ -6,7 +6,7 @@ module RuboCop
       # Checks uses of lambda without a literal block.
       # It emulates the following warning in Ruby 3.0:
       #
-      #   % ruby -vwe 'lambda(&proc {})'
+      #   $ ruby -vwe 'lambda(&proc {})'
       #   ruby 3.0.0p0 (2020-12-25 revision 95aff21468) [x86_64-darwin19]
       #   -e:1: warning: lambda without a literal block is deprecated; use the proc without
       #   lambda instead

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,98 @@ 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_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
+
+        # 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
-        alias on_while_post on_while
+        # 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 +198,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 +229,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