rubocop 1.22.0 → 1.45.1

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

@@ -3,11 +3,11 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for odd `else` block layout - like
+      # Checks for odd `else` block layout - like
       # having an expression on the same line as the `else` keyword,
       # which is usually a mistake.
       #
-      # Its auto-correction tweaks layout to keep the syntax. So, this auto-correction
+      # Its autocorrection tweaks layout to keep the syntax. So, this autocorrection
       # is compatible correction for bad case syntax, but if your code makes a mistake
       # with `elsif` and `else`, you will have to correct it manually.
       #
@@ -25,7 +25,7 @@ module RuboCop
       #
       #   # good
       #
-      #   # This code is compatible with the bad case. It will be auto-corrected like this.
+      #   # This code is compatible with the bad case. It will be autocorrected like this.
       #   if something
       #     # ...
       #   else
@@ -41,6 +41,7 @@ module RuboCop
       #     do_that
       #   end
       class ElseLayout < Base
+        include Alignment
         include RangeHelp
         extend AutoCorrector
 
@@ -72,7 +73,7 @@ module RuboCop
           first_else = else_branch.begin_type? ? else_branch.children.first : else_branch
 
           return unless first_else
-          return unless first_else.source_range.line == node.loc.else.line
+          return unless same_line?(first_else, node.loc.else)
 
           add_offense(first_else) { |corrector| autocorrect(corrector, node, first_else) }
         end
@@ -81,12 +82,7 @@ module RuboCop
           corrector.insert_after(node.loc.else, "\n")
 
           blank_range = range_between(node.loc.else.end_pos, first_else.loc.expression.begin_pos)
-          indentation = indent(node, offset: indentation_width)
-          corrector.replace(blank_range, indentation)
-        end
-
-        def indentation_width
-          @config.for_cop('Layout/IndentationWidth')['Width'] || 2
+          corrector.replace(blank_range, indentation(node))
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for blocks without a body.
+      # Checks for blocks without a body.
       # Such empty blocks are typically an oversight or we should provide a comment
       # be clearer what we're aiming for.
       #
@@ -63,9 +63,9 @@ module RuboCop
       class EmptyBlock < Base
         MSG = 'Empty block detected.'
 
-        def on_block(node)
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
           return if node.body
-          return if allow_empty_lambdas? && lambda_or_proc?(node)
+          return if allow_empty_lambdas? && node.lambda_or_proc?
           return if cop_config['AllowComments'] && allow_comment?(node)
 
           add_offense(node)
@@ -88,10 +88,6 @@ module RuboCop
           regexp_pattern = "# rubocop : (disable|todo) ([^,],)* (all|#{cop_name})"
           Regexp.new(regexp_pattern.gsub(' ', '\s*')).match?(comment)
         end
-
-        def lambda_or_proc?(node)
-          node.lambda? || node.proc?
-        end
       end
     end
   end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for classes and metaclasses without a body.
+      # Checks for classes and metaclasses without a body.
       # Such empty classes and metaclasses are typically an oversight or we should provide a comment
       # to be clearer what we're aiming for.
       #
@@ -85,7 +85,9 @@ module RuboCop
         private
 
         def body_or_allowed_comment_lines?(node)
-          node.body || (cop_config['AllowComments'] && comment_lines?(node))
+          return true if node.body
+
+          cop_config['AllowComments'] && processed_source.contains_comment?(node.source_range)
         end
       end
     end

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

@@ -3,7 +3,15 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for the presence of `if`, `elsif` and `unless` branches without a body.
+      # Checks for the presence of `if`, `elsif` and `unless` branches without a body.
+      #
+      # NOTE: empty `else` branches are handled by `Style/EmptyElse`.
+      #
+      # @safety
+      #   Autocorrection for this cop is not safe. The conditions for empty branches that
+      #   the autocorrection removes may have side effects, or the logic in subsequent
+      #   branches may change due to the removal of a previous condition.
+      #
       # @example
       #   # bad
       #   if condition
@@ -53,13 +61,113 @@ module RuboCop
       #   end
       #
       class EmptyConditionalBody < Base
+        extend AutoCorrector
+        include CommentsHelp
+        include RangeHelp
+
         MSG = 'Avoid `%<keyword>s` branches without a body.'
 
         def on_if(node)
-          return if node.body
-          return if cop_config['AllowComments'] && comment_lines?(node)
+          return if node.body || same_line?(node.loc.begin, node.loc.end)
+          return if cop_config['AllowComments'] && contains_comments?(node)
+
+          add_offense(node, message: format(MSG, keyword: node.keyword)) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        private
+
+        def autocorrect(corrector, node)
+          remove_comments(corrector, node)
+          remove_empty_branch(corrector, node)
+          correct_other_branches(corrector, node)
+        end
+
+        def remove_comments(corrector, node)
+          comments_in_range(node).each do |comment|
+            range = range_by_whole_lines(comment.loc.expression, include_final_newline: true)
+            corrector.remove(range)
+          end
+        end
+
+        def remove_empty_branch(corrector, node)
+          if empty_if_branch?(node) && else_branch?(node)
+            corrector.remove(branch_range(node))
+          else
+            corrector.remove(deletion_range(branch_range(node)))
+          end
+        end
+
+        def correct_other_branches(corrector, node)
+          return unless require_other_branches_correction?(node)
+
+          if node.else_branch&.if_type?
+            # Replace an orphaned `elsif` with `if`
+            corrector.replace(node.else_branch.loc.keyword, 'if')
+          else
+            # Flip orphaned `else`
+            corrector.replace(node.loc.else, "#{node.inverse_keyword} #{node.condition.source}")
+          end
+        end
+
+        def require_other_branches_correction?(node)
+          return false unless node.if_type? && node.else?
+          return false if !empty_if_branch?(node) && node.elsif?
+
+          !empty_elsif_branch?(node)
+        end
+
+        def empty_if_branch?(node)
+          return false unless (parent = node.parent)
+          return true unless parent.if_type?
+          return true unless (if_branch = parent.if_branch)
+
+          if_branch.if_type? && !if_branch.body
+        end
+
+        def empty_elsif_branch?(node)
+          return false unless (else_branch = node.else_branch)
+
+          else_branch.if_type? && !else_branch.body
+        end
+
+        def else_branch?(node)
+          node.else_branch && !node.else_branch.if_type?
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        def branch_range(node)
+          if empty_if_branch?(node) && else_branch?(node)
+            node.source_range.with(end_pos: node.loc.else.begin_pos)
+          elsif node.loc.else
+            node.source_range.with(end_pos: node.condition.loc.expression.end_pos)
+          elsif all_branches_body_missing?(node)
+            if_node = node.ancestors.detect(&:if?)
+            node.source_range.with(end_pos: if_node.loc.end.end_pos)
+          else
+            node.source_range
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        def all_branches_body_missing?(node)
+          return false unless node.parent&.if_type?
+
+          node.parent.branches.compact.empty?
+        end
+
+        def deletion_range(range)
+          # Collect a range between the start of the `if` node and the next relevant node,
+          # including final new line.
+          # Based on `RangeHelp#range_by_whole_lines` but allows the `if` to not start
+          # on the first column.
+          buffer = @processed_source.buffer
+
+          last_line = buffer.source_line(range.last_line)
+          end_offset = last_line.length - range.last_column + 1
 
-          add_offense(node, message: format(MSG, keyword: node.keyword))
+          range.adjust(end_pos: end_offset).intersect(buffer.source_range)
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for empty `ensure` blocks
+      # Checks for empty `ensure` blocks
       #
       # @example
       #

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for the presence of empty expressions.
+      # Checks for the presence of empty expressions.
       #
       # @example
       #

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop enforces that Ruby source files are not empty.
+      # Enforces that Ruby source files are not empty.
       #
       # @example
       #   # bad

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for the presence of `in` pattern branches without a body.
+      # Checks for the presence of `in` pattern branches without a body.
       #
       # @example
       #
@@ -44,6 +44,7 @@ module RuboCop
       #
       class EmptyInPattern < Base
         extend TargetRubyVersion
+        include CommentsHelp
 
         MSG = 'Avoid `in` branches without a body.'
 
@@ -51,7 +52,8 @@ module RuboCop
 
         def on_case_match(node)
           node.in_pattern_branches.each do |branch|
-            next if branch.body || (cop_config['AllowComments'] && comment_lines?(node))
+            next if branch.body
+            next if cop_config['AllowComments'] && contains_comments?(branch)
 
             add_offense(branch)
           end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for empty interpolation.
+      # Checks for empty interpolation.
       #
       # @example
       #

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for the presence of `when` branches without a body.
+      # Checks for the presence of `when` branches without a body.
       #
       # @example
       #
@@ -45,12 +45,14 @@ module RuboCop
       #   end
       #
       class EmptyWhen < Base
+        include CommentsHelp
+
         MSG = 'Avoid `when` branches without a body.'
 
         def on_case(node)
           node.each_when do |when_node|
             next if when_node.body
-            next if cop_config['AllowComments'] && comment_lines?(node)
+            next if cop_config['AllowComments'] && contains_comments?(when_node)
 
             add_offense(when_node)
           end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for `return` from an `ensure` block.
+      # Checks for `return` from an `ensure` block.
       # `return` from an ensure block is a dangerous code smell as it
       # will take precedence over any exception being raised,
       # and the exception will be silently thrown away as if it were rescued.

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

@@ -6,18 +6,18 @@ module RuboCop
       #
       # This cop emulates the following Ruby warnings in Ruby 2.6.
       #
+      # [source,console]
+      # ----
       # % cat example.rb
       # ERB.new('hi', nil, '-', '@output_buffer')
       # % ruby -rerb example.rb
-      # example.rb:1: warning: Passing safe_level with the 2nd argument of
-      # ERB.new is deprecated. Do not use it, and specify other arguments as
-      # keyword arguments.
-      # example.rb:1: warning: Passing trim_mode with the 3rd argument of
-      # ERB.new is deprecated. Use keyword argument like
-      # ERB.new(str, trim_mode:...) instead.
-      # example.rb:1: warning: Passing eoutvar with the 4th argument of ERB.new
-      # is deprecated. Use keyword argument like ERB.new(str, eoutvar: ...)
-      # instead.
+      # example.rb:1: warning: Passing safe_level with the 2nd argument of ERB.new is
+      # deprecated. Do not use it, and specify other arguments as keyword arguments.
+      # example.rb:1: warning: Passing trim_mode with the 3rd argument of ERB.new is
+      # deprecated. Use keyword argument like ERB.new(str, trim_mode:...) instead.
+      # example.rb:1: warning: Passing eoutvar with the 4th argument of ERB.new is
+      # deprecated. Use keyword argument like ERB.new(str, eoutvar: ...) instead.
+      # ----
       #
       # Now non-keyword arguments other than first one are softly deprecated
       # and will be removed when Ruby 2.5 becomes EOL.
@@ -61,8 +61,8 @@ module RuboCop
       #
       class ErbNewArguments < Base
         include RangeHelp
-        extend TargetRubyVersion
         extend AutoCorrector
+        extend TargetRubyVersion
 
         minimum_target_ruby_version 2.6
 

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop looks for uses of flip-flop operator
+      # Looks for uses of flip-flop operator
       # based on the Ruby Style Guide.
       #
       # Here is the history of flip-flops in Ruby.

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for the presence of precise comparison of floating point numbers.
+      # Checks for the presence of precise comparison of floating point numbers.
       #
       # Floating point values are inherently inaccurate, and comparing them for exact equality
       # is almost never the desired semantics. Comparison via the `==/!=` operators checks

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop identifies Float literals which are, like, really really really
+      # Identifies Float literals which are, like, really really really
       # really really really really really big. Too big. No-one needs Floats
       # that big. If you need a float that big, something is wrong with you.
       #

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

@@ -81,6 +81,10 @@ module RuboCop
 
           return false if num_of_format_args == :unknown
 
+          first_arg = node.first_argument
+          return false if num_of_expected_fields.zero? &&
+                          (first_arg.dstr_type? || first_arg.array_type?)
+
           matched_arguments_count?(num_of_expected_fields, num_of_format_args)
         end
 
@@ -94,8 +98,8 @@ module RuboCop
 
         # @!method called_on_string?(node)
         def_node_matcher :called_on_string?, <<~PATTERN
-          {(send {nil? const_type?} _ (str _) ...)
-           (send (str ...) ...)}
+          {(send {nil? const_type?} _ {str dstr} ...)
+           (send {str dstr} ...)}
         PATTERN
 
         def method_with_format_args?(node)
@@ -143,11 +147,11 @@ module RuboCop
           return false if node.const_receiver? && !node.receiver.loc.name.is?(KERNEL)
           return false unless node.method?(name)
 
-          node.arguments.size > 1 && node.first_argument.str_type?
+          node.arguments.size > 1 && string_type?(node.first_argument)
         end
 
         def expected_fields_count(node)
-          return :unknown unless node.str_type?
+          return :unknown unless string_type?(node)
 
           format_string = RuboCop::Cop::Utils::FormatString.new(node.source)
           return 1 if format_string.named_interpolation?
@@ -172,10 +176,9 @@ module RuboCop
         def percent?(node)
           receiver = node.receiver
 
-          percent = node.method?(:%) &&
-                    (STRING_TYPES.include?(receiver.type) || node.first_argument.array_type?)
+          percent = node.method?(:%) && (string_type?(receiver) || node.first_argument.array_type?)
 
-          return false if percent && STRING_TYPES.include?(receiver.type) && heredoc?(node)
+          return false if percent && string_type?(receiver) && heredoc?(node)
 
           percent
         end
@@ -188,6 +191,10 @@ module RuboCop
           format(MSG, arg_num: num_args_for_format, method: method_name,
                       field_num: num_expected_fields)
         end
+
+        def string_type?(node)
+          STRING_TYPES.include?(node.type)
+        end
       end
     end
   end

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

@@ -3,32 +3,30 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for the ordering of a method call where
+      # Checks for the ordering of a method call where
       # the receiver of the call is a HEREDOC.
       #
       # @example
       #   # bad
+      #   <<-SQL
+      #     bar
+      #   SQL
+      #   .strip_indent
       #
-      #      <<-SQL
-      #        bar
-      #      SQL
-      #      .strip_indent
-      #
-      #      <<-SQL
-      #        bar
-      #      SQL
-      #      .strip_indent
-      #      .trim
+      #   <<-SQL
+      #     bar
+      #   SQL
+      #   .strip_indent
+      #   .trim
       #
       #   # good
+      #   <<~SQL
+      #     bar
+      #   SQL
       #
-      #      <<~SQL
-      #        bar
-      #      SQL
-      #
-      #      <<~SQL.trim
-      #        bar
-      #      SQL
+      #   <<~SQL.trim
+      #     bar
+      #   SQL
       #
       class HeredocMethodCallPosition < Base
         include RangeHelp

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for implicit string concatenation of string literals
+      # Checks for implicit string concatenation of string literals
       # which are on the same line.
       #
       # @example
@@ -81,7 +81,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

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

@@ -6,6 +6,15 @@ module RuboCop
       #
       # This cop checks for `IO.select` that is incompatible with Fiber Scheduler since Ruby 3.0.
       #
+      # 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`.
+      # They are not autocorrected when assigning a return value because these types are different.
+      # It's up to user how to handle the return value.
+      #
+      # @safety
+      #   This cop's autocorrection is unsafe because `NoMethodError` occurs
+      #   if `require 'io/wait'` is not called.
+      #
       # @example
       #
       #   # bad
@@ -29,17 +38,20 @@ module RuboCop
         # @!method io_select(node)
         def_node_matcher :io_select, <<~PATTERN
           (send
-            (const {nil? cbase} :IO) :select $_ $_ {(array) nil} $...)
+            (const {nil? cbase} :IO) :select $...)
         PATTERN
 
         def on_send(node)
-          return unless (read, write, timeout = io_select(node))
+          read, write, _excepts, timeout = *io_select(node)
+          return unless read
           return unless scheduler_compatible?(read, write) || scheduler_compatible?(write, read)
 
           preferred = preferred_method(read, write, timeout)
           message = format(MSG, preferred: preferred, current: node.source)
 
           add_offense(node, message: message) do |corrector|
+            next if node.parent&.assignment?
+
             corrector.replace(node, preferred)
           end
         end
@@ -47,13 +59,13 @@ module RuboCop
         private
 
         def scheduler_compatible?(io1, io2)
-          return false unless io1.array_type? && io1.values.size == 1
+          return false unless io1&.array_type? && io1.values.size == 1
 
-          io2.array_type? ? io2.values.empty? : io2.nil_type?
+          io2&.array_type? ? io2.values.empty? : (io2.nil? || io2.nil_type?)
         end
 
         def preferred_method(read, write, timeout)
-          timeout_argument = timeout.empty? ? '' : "(#{timeout[0].source})"
+          timeout_argument = timeout.nil? ? '' : "(#{timeout.source})"
 
           if read.array_type? && read.values[0]
             "#{read.values[0].source}.wait_readable#{timeout_argument}"

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for `private` or `protected` access modifiers which are
+      # Checks for `private` or `protected` access modifiers which are
       # applied to a singleton method. These access modifiers do not make
       # singleton methods private/protected. `private_class_method` can be
       # used for that.