rubocop 1.31.1 → 1.51.0

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

@@ -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)
@@ -77,7 +77,7 @@ module RuboCop
           return false unless processed_source.contains_comment?(node.source_range)
 
           line_comment = processed_source.comment_at_line(node.source_range.line)
-          !line_comment || !comment_disables_cop?(line_comment.loc.expression.source)
+          !line_comment || !comment_disables_cop?(line_comment.source)
         end
 
         def allow_empty_lambdas?
@@ -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

@@ -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

@@ -4,6 +4,14 @@ module RuboCop
   module Cop
     module Lint
       # 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,15 +61,115 @@ 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 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))
+          add_offense(node, message: format(MSG, keyword: node.keyword)) do |corrector|
+            next if node.parent&.call_type?
+
+            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.source_range, 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.source_range.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
+
+          range.adjust(end_pos: end_offset).intersect(buffer.source_range)
         end
       end
     end

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

@@ -25,7 +25,7 @@ module RuboCop
         def on_interpolation(begin_node)
           return unless begin_node.children.empty?
 
-          add_offense(begin_node) { |corrector| corrector.remove(begin_node.loc.expression) }
+          add_offense(begin_node) { |corrector| corrector.remove(begin_node) }
         end
       end
     end

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.
       #
-      # % cat example.rb
+      # [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.
+      # $ 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.
+      # ----
       #
       # Now non-keyword arguments other than first one are softly deprecated
       # and will be removed when Ruby 2.5 becomes EOL.

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

@@ -8,27 +8,25 @@ module RuboCop
       #
       # @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

@@ -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,9 @@ module RuboCop
       #
       # 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`.
       # They are not autocorrected when assigning a return value because these types are different.
@@ -42,8 +45,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

@@ -83,7 +83,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/interpolation_check.rb

@@ -6,9 +6,10 @@ module RuboCop
       # Checks for interpolation in a single quoted string.
       #
       # @safety
-      #   This cop is generally safe, but is marked as unsafe because
-      #   it is possible to actually intentionally have text inside
-      #   `#{...}` in a single quoted string.
+      #   This cop's autocorrection is unsafe because although it always replaces single quotes as
+      #   if it were miswritten double quotes, it is not always the case. For example,
+      #   `'#{foo} bar'` would be replaced by `"#{foo} bar"`, so the replaced code would evaluate
+      #   the expression `foo`.
       #
       # @example
       #

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_in_interpolation.rb

@@ -58,6 +58,7 @@ module RuboCop
           (node.str_type? && !node.loc.respond_to?(:begin)) || node.source_range.is?('__LINE__')
         end
 
+        # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity
         def autocorrected_value(node)
           case node.type
           when :int
@@ -70,10 +71,15 @@ module RuboCop
             autocorrected_value_for_symbol(node)
           when :array
             autocorrected_value_for_array(node)
+          when :hash
+            autocorrected_value_for_hash(node)
+          when :nil
+            ''
           else
             node.source.gsub('"', '\"')
           end
         end
+        # rubocop:enable Metrics/MethodLength, Metrics/CyclomaticComplexity
 
         def autocorrected_value_for_string(node)
           if node.source.start_with?("'", '%q')
@@ -85,9 +91,18 @@ module RuboCop
 
         def autocorrected_value_for_symbol(node)
           end_pos =
-            node.loc.end ? node.loc.end.begin_pos : node.loc.expression.end_pos
+            node.loc.end ? node.loc.end.begin_pos : node.source_range.end_pos
 
-          range_between(node.loc.begin.end_pos, end_pos).source
+          range_between(node.loc.begin.end_pos, end_pos).source.gsub('"', '\"')
+        end
+
+        def autocorrected_value_in_hash_for_symbol(node)
+          # TODO: We need to detect symbol unacceptable names more correctly
+          if / |"|'/.match?(node.value.to_s)
+            ":\\\"#{node.value.to_s.gsub('"') { '\\\\\"' }}\\\""
+          else
+            ":#{node.value}"
+          end
         end
 
         def autocorrected_value_for_array(node)
@@ -96,6 +111,37 @@ module RuboCop
           contents_range(node).source.split.to_s.gsub('"', '\"')
         end
 
+        def autocorrected_value_for_hash(node)
+          hash_string = node.children.map do |child|
+            key = autocorrected_value_in_hash(child.key)
+            value = autocorrected_value_in_hash(child.value)
+            "#{key}=>#{value}"
+          end.join(', ')
+
+          "{#{hash_string}}"
+        end
+
+        # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+        def autocorrected_value_in_hash(node)
+          case node.type
+          when :int
+            node.children.last.to_i.to_s
+          when :float
+            node.children.last.to_f.to_s
+          when :str
+            "\\\"#{node.value.to_s.gsub('"') { '\\\\\"' }}\\\""
+          when :sym
+            autocorrected_value_in_hash_for_symbol(node)
+          when :array
+            autocorrected_value_for_array(node)
+          when :hash
+            autocorrected_value_for_hash(node)
+          else
+            node.source.gsub('"', '\"')
+          end
+        end
+        # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+
         # Does node print its own source when converted to a string?
         def prints_as_self?(node)
           node.basic_literal? ||

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

@@ -50,9 +50,7 @@ module RuboCop
 
         def on_new_investigation
           each_missing_enable do |cop, line_range|
-            # This has to remain a strict inequality to handle
-            # the case when max_range is Float::INFINITY
-            next if line_range.max - line_range.min < max_range + 2
+            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)
@@ -69,6 +67,23 @@ module RuboCop
           end
         end
 
+        def acceptable_range?(cop, line_range)
+          # This has to remain a strict inequality to handle
+          # the case when max_range is Float::INFINITY
+          return true if line_range.max - line_range.min < max_range + 2
+          # This cop is disabled in the config, it is not expected to be re-enabled
+          return true if line_range.min == CommentConfig::CONFIG_DISABLED_LINE_RANGE_MIN
+
+          cop_class = RuboCop::Cop::Registry.global.find_by_cop_name cop
+          if cop_class &&
+             !processed_source.registry.enabled?(cop_class, config) &&
+             line_range.max == Float::INFINITY
+            return true
+          end
+
+          false
+        end
+
         def max_range
           @max_range ||= cop_config['MaximumRangeSize']
         end

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

@@ -28,6 +28,21 @@ module RuboCop
       #   end
       #
       #   # bad
+      #   Employee = Class.new(Person) do
+      #     def initialize(name, salary)
+      #       @salary = salary
+      #     end
+      #   end
+      #
+      #   # good
+      #   Employee = Class.new(Person) do
+      #     def initialize(name, salary)
+      #       super(name)
+      #       @salary = salary
+      #     end
+      #   end
+      #
+      #   # bad
       #   class Parent
       #     def self.inherited(base)
       #       do_something
@@ -55,6 +70,13 @@ module RuboCop
 
         CALLBACKS = (CLASS_LIFECYCLE_CALLBACKS + METHOD_LIFECYCLE_CALLBACKS).to_set.freeze
 
+        # @!method class_new_block(node)
+        def_node_matcher :class_new_block, <<~RUBY
+          ({block numblock}
+            (send
+              (const {nil? cbase} :Class) :new $_) ...)
+        RUBY
+
         def on_def(node)
           return unless offender?(node)
 
@@ -88,8 +110,15 @@ module RuboCop
         end
 
         def inside_class_with_stateful_parent?(node)
-          class_node = node.each_ancestor(:class).first
-          class_node&.parent_class && !stateless_class?(class_node.parent_class)
+          if (block_node = node.each_ancestor(:block, :numblock).first)
+            return false unless (super_class = class_new_block(block_node))
+
+            !stateless_class?(super_class)
+          elsif (class_node = node.each_ancestor(:class).first)
+            class_node.parent_class && !stateless_class?(class_node.parent_class)
+          else
+            false
+          end
         end
 
         def stateless_class?(node)

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

@@ -8,6 +8,7 @@ module RuboCop
       # Replace numbered captures with non-capturing groupings or
       # named captures.
       #
+      # @example
       #   # bad
       #   /(?<foo>FOO)(BAR)/
       #

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

@@ -30,6 +30,9 @@ module RuboCop
       #
       #   # good
       #
+      #   # `class_eval`, `instance_eval`, `module_eval`, `class_exec`, `instance_exec`, and
+      #   # `module_exec` blocks are allowed by default.
+      #
       #   def foo
       #     self.class.class_eval do
       #       def bar
@@ -54,7 +57,47 @@ module RuboCop
       #       end
       #     end
       #   end
+      #
+      # @example AllowedMethods: [] (default)
+      #   # bad
+      #   def do_something
+      #     has_many :articles do
+      #       def find_or_create_by_name(name)
+      #       end
+      #     end
+      #   end
+      #
+      # @example AllowedMethods: ['has_many']
+      #   # bad
+      #   def do_something
+      #     has_many :articles do
+      #       def find_or_create_by_name(name)
+      #       end
+      #     end
+      #   end
+      #
+      # @example AllowedPatterns: [] (default)
+      #   # bad
+      #   def foo(obj)
+      #     obj.do_baz do
+      #       def bar
+      #       end
+      #     end
+      #   end
+      #
+      # @example AllowedPatterns: ['baz']
+      #   # good
+      #   def foo(obj)
+      #     obj.do_baz do
+      #       def bar
+      #       end
+      #     end
+      #   end
+      #
       class NestedMethodDefinition < Base
+        include AllowedMethods
+        include AllowedPattern
+
         MSG = 'Method definitions must not be nested. Use `lambda` instead.'
 
         def on_def(node)
@@ -65,7 +108,7 @@ module RuboCop
           return unless def_ancestor
 
           within_scoping_def =
-            node.each_ancestor(:block, :sclass).any? do |ancestor|
+            node.each_ancestor(:block, :numblock, :sclass).any? do |ancestor|
               scoping_method_call?(ancestor)
             end
 
@@ -77,22 +120,23 @@ module RuboCop
 
         def scoping_method_call?(child)
           child.sclass_type? || eval_call?(child) || exec_call?(child) ||
-            class_or_module_or_struct_new_call?(child)
+            child.class_constructor? || allowed_method_name?(child)
+        end
+
+        def allowed_method_name?(node)
+          name = node.method_name
+
+          allowed_method?(name) || matches_allowed_pattern?(name)
         end
 
         # @!method eval_call?(node)
         def_node_matcher :eval_call?, <<~PATTERN
-          (block (send _ {:instance_eval :class_eval :module_eval} ...) ...)
+          ({block numblock} (send _ {:instance_eval :class_eval :module_eval} ...) ...)
         PATTERN
 
         # @!method exec_call?(node)
         def_node_matcher :exec_call?, <<~PATTERN
-          (block (send _ {:instance_exec :class_exec :module_exec} ...) ...)
-        PATTERN
-
-        # @!method class_or_module_or_struct_new_call?(node)
-        def_node_matcher :class_or_module_or_struct_new_call?, <<~PATTERN
-          (block (send (const {nil? cbase} {:Class :Module :Struct}) :new ...) ...)
+          ({block numblock} (send _ {:instance_exec :class_exec :module_exec} ...) ...)
         PATTERN
       end
     end