rubocop 1.42.0 → 1.64.1

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.to_a.last
+            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 AST::Node::EQUALS_ASSIGNMENTS.include?(node.type)
+
+          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

@@ -34,7 +34,7 @@ module RuboCop
           # interpolation should not be removed if the expanded value
           # contains a space character.
           expanded_value = autocorrected_value(final_node)
-          return if in_array_percent_literal?(begin_node) && /\s/.match?(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
@@ -58,7 +58,7 @@ module RuboCop
           (node.str_type? && !node.loc.respond_to?(:begin)) || node.source_range.is?('__LINE__')
         end
 
-        # rubocop:disable Metrics/MethodLength
+        # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity
         def autocorrected_value(node)
           case node.type
           when :int
@@ -71,13 +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
+        # rubocop:enable Metrics/MethodLength, Metrics/CyclomaticComplexity
 
         def autocorrected_value_for_string(node)
           if node.source.start_with?("'", '%q')
@@ -89,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)
@@ -100,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_super.rb

@@ -11,6 +11,16 @@ module RuboCop
       # missing method. In other cases, the theoretical ideal handling could be
       # challenging or verbose for no actual gain.
       #
+      # Autocorrection is not supported because the position of `super` cannot be
+      # determined automatically.
+      #
+      # `Object` and `BasicObject` are allowed by this cop because of their
+      # stateless nature. However, sometimes you might want to allow other parent
+      # classes from this cop, for example in the case of an abstract class that is
+      # not meant to be called with `super`. In those cases, you can use the
+      # `AllowedParentClasses` option to specify which classes should be allowed
+      # *in addition to* `Object` and `BasicObject`.
+      #
       # @example
       #   # bad
       #   class Employee < Person
@@ -28,6 +38,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
@@ -42,6 +67,21 @@ module RuboCop
       #     end
       #   end
       #
+      #   # good
+      #   class ClassWithNoParent
+      #     def initialize
+      #       do_something
+      #     end
+      #   end
+      #
+      # @example AllowedParentClasses: [MyAbstractClass]
+      #   # good
+      #   class MyConcreteClass < MyAbstractClass
+      #     def initialize
+      #       do_something
+      #     end
+      #   end
+      #
       class MissingSuper < Base
         CONSTRUCTOR_MSG = 'Call `super` to initialize state of the parent class.'
         CALLBACK_MSG    = 'Call `super` to invoke callback defined in the parent class.'
@@ -55,6 +95,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)
 
@@ -78,7 +125,7 @@ module RuboCop
         end
 
         def callback_method_def?(node)
-          return unless CALLBACKS.include?(node.method_name)
+          return false unless CALLBACKS.include?(node.method_name)
 
           node.each_ancestor(:class, :sclass, :module).first
         end
@@ -88,12 +135,23 @@ 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))
+
+            !allowed_class?(super_class)
+          elsif (class_node = node.each_ancestor(:class).first)
+            class_node.parent_class && !allowed_class?(class_node.parent_class)
+          else
+            false
+          end
+        end
+
+        def allowed_class?(node)
+          allowed_classes.include?(node.const_name)
         end
 
-        def stateless_class?(node)
-          STATELESS_CLASSES.include?(node.const_name)
+        def allowed_classes
+          @allowed_classes ||= STATELESS_CLASSES + cop_config.fetch('AllowedParentClasses', [])
         end
       end
     end

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

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for mixed-case character ranges since they include likely unintended characters.
+      #
+      # Offenses are registered for regexp character classes like `/[A-z]/`
+      # as well as range objects like `('A'..'z')`.
+      #
+      # NOTE: Range objects cannot be autocorrected.
+      #
+      # @safety
+      #   The cop autocorrects regexp character classes
+      #   by replacing one character range with two: `A-z` becomes `A-Za-z`.
+      #   In most cases this is probably what was originally intended
+      #   but it changes the regexp to no longer match symbols it used to include.
+      #   For this reason, this cop's autocorrect is unsafe (it will
+      #   change the behavior of the code).
+      #
+      # @example
+      #
+      #   # bad
+      #   r = /[A-z]/
+      #
+      #   # good
+      #   r = /[A-Za-z]/
+      class MixedCaseRange < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = 'Ranges from upper to lower case ASCII letters may include unintended ' \
+              'characters. Instead of `A-z` (which also includes several symbols) ' \
+              'specify each range individually: `A-Za-z` and individually specify any symbols.'
+        RANGES = [('a'..'z').freeze, ('A'..'Z').freeze].freeze
+
+        def on_irange(node)
+          return unless node.children.compact.all?(&:str_type?)
+
+          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)
+        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, replacement)
+            end
+          end
+        end
+
+        def each_unsafe_regexp_range(node)
+          node.parsed_tree&.each_expression do |expr|
+            next if skip_expression?(expr)
+
+            range_pairs(expr).reject do |range_start, range_end|
+              next if skip_range?(range_start, range_end)
+
+              next unless unsafe_range?(range_start.text, range_end.text)
+
+              yield(build_source_range(range_start, range_end))
+            end
+          end
+        end
+
+        private
+
+        def build_source_range(range_start, range_end)
+          range_between(range_start.expression.begin_pos, range_end.expression.end_pos)
+        end
+
+        def range_for(char)
+          RANGES.detect do |range|
+            range.include?(char)
+          end
+        end
+
+        def range_pairs(expr)
+          RuboCop::Cop::Utils::RegexpRanges.new(expr).pairs
+        end
+
+        def unsafe_range?(range_start, range_end)
+          return false if range_start.length != 1 || range_end.length != 1
+
+          range_for(range_start) != range_for(range_end)
+        end
+
+        def skip_expression?(expr)
+          !(expr.type == :set && expr.token == :character)
+        end
+
+        def skip_range?(range_start, range_end)
+          [range_start, range_end].any? do |bound|
+            bound.type != :literal
+          end
+        end
+
+        def regexp_range(source)
+          open, close = source.split('-')
+          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
+    end
+  end
+end

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

@@ -108,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
 
@@ -120,7 +120,7 @@ module RuboCop
 
         def scoping_method_call?(child)
           child.sclass_type? || eval_call?(child) || exec_call?(child) ||
-            class_or_module_or_struct_new_call?(child) || allowed_method_name?(child)
+            child.class_constructor? || allowed_method_name?(child)
         end
 
         def allowed_method_name?(node)
@@ -131,17 +131,12 @@ module RuboCop
 
         # @!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

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

@@ -34,35 +34,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(:block, :numblock).first
         end
       end
     end

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

@@ -43,7 +43,6 @@ module RuboCop
       #
       class NonAtomicFileOperation < Base
         extend AutoCorrector
-        include Alignment
 
         MSG_REMOVE_FILE_EXIST_CHECK = 'Remove unnecessary existence check ' \
                                       '`%<receiver>s.%<method_name>s`.'
@@ -51,18 +50,20 @@ module RuboCop
         MAKE_FORCE_METHODS = %i[makedirs mkdir_p mkpath].freeze
         MAKE_METHODS = %i[mkdir].freeze
         REMOVE_FORCE_METHODS = %i[rm_f rm_rf].freeze
-        REMOVE_METHODS = %i[remove remove_dir remove_entry remove_entry_secure
-                            delete unlink remove_file rm rmdir safe_unlink].freeze
-        RESTRICT_ON_SEND = (MAKE_METHODS + MAKE_FORCE_METHODS + REMOVE_METHODS +
-          REMOVE_FORCE_METHODS).freeze
+        REMOVE_METHODS = %i[remove delete unlink remove_file rm rmdir safe_unlink].freeze
+        RECURSIVE_REMOVE_METHODS = %i[remove_dir remove_entry remove_entry_secure].freeze
+        RESTRICT_ON_SEND = (
+          MAKE_METHODS + MAKE_FORCE_METHODS + REMOVE_METHODS + RECURSIVE_REMOVE_METHODS +
+          REMOVE_FORCE_METHODS
+        ).freeze
 
         # @!method send_exist_node(node)
-        def_node_search :send_exist_node, <<-PATTERN
+        def_node_search :send_exist_node, <<~PATTERN
           $(send (const nil? {:FileTest :File :Dir :Shell}) {:exist? :exists?} ...)
         PATTERN
 
         # @!method receiver_and_method_name(node)
-        def_node_matcher :receiver_and_method_name, <<-PATTERN
+        def_node_matcher :receiver_and_method_name, <<~PATTERN
           (send (const nil? $_) $_ ...)
         PATTERN
 
@@ -140,6 +141,8 @@ module RuboCop
             'mkdir_p'
           elsif REMOVE_METHODS.include?(node.method_name)
             'rm_f'
+          elsif RECURSIVE_REMOVE_METHODS.include?(node.method_name)
+            'rm_rf'
           else
             node.method_name
           end

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

@@ -94,7 +94,7 @@ module RuboCop
           parent_node = node.parent
 
           add_offense(parent_node) do |corrector|
-            if parent_node.arguments.last&.block_pass_type?
+            if parent_node.last_argument&.block_pass_type?
               correct_block_pass(corrector, parent_node)
             else
               correct_block(corrector, parent_node)
@@ -116,7 +116,7 @@ module RuboCop
 
         def correct_block_pass(corrector, node)
           if unsorted_dir_glob_pass?(node)
-            block_arg = node.arguments.last
+            block_arg = node.last_argument
 
             corrector.remove(last_arg_range(node))
             corrector.insert_after(node, ".sort.each(#{block_arg.source})")
@@ -130,9 +130,7 @@ module RuboCop
         # @return [Parser::Source::Range]
         #
         def last_arg_range(node)
-          node.arguments.last.source_range.with(
-            begin_pos: node.arguments[-2].source_range.end_pos
-          )
+          node.last_argument.source_range.join(node.arguments[-2].source_range.end)
         end
 
         def unsorted_dir_loop?(node)

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

@@ -9,7 +9,7 @@ module RuboCop
       #
       # Conversion with `Integer`, `Float`, etc. will raise an `ArgumentError`
       # if given input that is not numeric (eg. an empty string), whereas
-      # `to_i`, etc. will try to convert regardless of input (`''.to_i => 0`).
+      # `to_i`, etc. will try to convert regardless of input (``''.to_i => 0``).
       # As such, this cop is disabled by default because it's not necessarily
       # always correct to raise if a value is not numeric.
       #
@@ -74,6 +74,7 @@ module RuboCop
         extend AutoCorrector
         include AllowedMethods
         include AllowedPattern
+        include IgnoredNode
 
         CONVERSION_METHOD_CLASS_MAPPING = {
           to_i: "#{Integer.name}(%<number_object>s, 10)",
@@ -90,19 +91,24 @@ module RuboCop
 
         # @!method to_method(node)
         def_node_matcher :to_method, <<~PATTERN
-          (send $_ ${#{METHODS}})
+          (call $_ ${#{METHODS}})
         PATTERN
 
         # @!method to_method_symbol(node)
         def_node_matcher :to_method_symbol, <<~PATTERN
-          {(send _ $_ ${(sym ${#{METHODS}})} ...)
-           (send _ $_ ${(block_pass (sym ${#{METHODS}}))} ...)}
+          (call _ $_ ${
+            {
+              (sym ${#{METHODS}})
+              (block_pass (sym ${#{METHODS}}))
+            }
+          } ...)
         PATTERN
 
         def on_send(node)
           handle_conversion_method(node)
           handle_as_symbol(node)
         end
+        alias on_csend on_send
 
         private
 
@@ -116,7 +122,11 @@ module RuboCop
               corrected_method: correct_method(node, receiver)
             )
             add_offense(node, message: message) do |corrector|
+              next if part_of_ignored_node?(node)
+
               corrector.replace(node, correct_method(node, node.receiver))
+
+              ignore_node(node)
             end
           end
         end

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

@@ -6,13 +6,13 @@ module RuboCop
       # Checks for uses of numbered parameter assignment.
       # It emulates the following warning in Ruby 2.7:
       #
-      #   % ruby -ve '_1 = :value'
+      #   $ ruby -ve '_1 = :value'
       #   ruby 2.7.2p137 (2020-10-01 revision 5445e04352) [x86_64-darwin19]
       #   -e:1: warning: `_1' is reserved for numbered parameter; consider another name
       #
       # Assigning to a numbered parameter (from `_1` to `_9`) causes an error in Ruby 3.0.
       #
-      #   % ruby -ve '_1 = :value'
+      #   $ ruby -ve '_1 = :value'
       #   ruby 3.0.0p0 (2020-12-25 revision 95aff21468) [x86_64-darwin19]
       #   -e:1: _1 is reserved for numbered parameter
       #

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

@@ -31,6 +31,8 @@ module RuboCop
           return unless lhs&.casgn_type?
 
           add_offense(node.loc.operator) do |corrector|
+            next if node.each_ancestor(:def, :defs).any?
+
             corrector.replace(node.loc.operator, '=')
           end
         end

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

@@ -3,7 +3,6 @@
 module RuboCop
   module Cop
     module Lint
-      #
       # Checks the proper ordering of magic comments and whether
       # a magic comment is not placed before a shebang.
       #