rubocop 0.93.1 → 1.79.2

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

@@ -3,21 +3,20 @@
 module RuboCop
   module Cop
     module Lint
+      # Emulates the following Ruby warnings in Ruby 2.6.
       #
-      # 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.
@@ -61,25 +60,24 @@ module RuboCop
       #
       class ErbNewArguments < Base
         include RangeHelp
-        extend TargetRubyVersion
         extend AutoCorrector
+        extend TargetRubyVersion
 
         minimum_target_ruby_version 2.6
 
-        MESSAGES = [
-          'Passing safe_level with the 2nd argument of `ERB.new` is ' \
-          'deprecated. Do not use it, and specify other arguments as ' \
-          'keyword arguments.',
-          'Passing trim_mode with the 3rd argument of `ERB.new` is ' \
-          'deprecated. Use keyword argument like ' \
-          '`ERB.new(str, trim_mode: %<arg_value>s)` instead.',
-          'Passing eoutvar with the 4th argument of `ERB.new` is ' \
-          'deprecated. Use keyword argument like ' \
-          '`ERB.new(str, eoutvar: %<arg_value>s)` instead.'
-        ].freeze
+        MESSAGE_SAFE_LEVEL = 'Passing safe_level with the 2nd argument of `ERB.new` is ' \
+                             'deprecated. Do not use it, and specify other arguments as ' \
+                             'keyword arguments.'
+        MESSAGE_TRIM_MODE =  'Passing trim_mode with the 3rd argument of `ERB.new` is ' \
+                             'deprecated. Use keyword argument like ' \
+                             '`ERB.new(str, trim_mode: %<arg_value>s)` instead.'
+        MESSAGE_EOUTVAR =    'Passing eoutvar with the 4th argument of `ERB.new` is ' \
+                             'deprecated. Use keyword argument like ' \
+                             '`ERB.new(str, eoutvar: %<arg_value>s)` instead.'
 
         RESTRICT_ON_SEND = %i[new].freeze
 
+        # @!method erb_new_with_non_keyword_arguments(node)
         def_node_matcher :erb_new_with_non_keyword_arguments, <<~PATTERN
           (send
             (const {nil? cbase} :ERB) :new $...)
@@ -92,10 +90,8 @@ module RuboCop
             arguments[1..3].each_with_index do |argument, i|
               next if !argument || argument.hash_type?
 
-              message = format(MESSAGES[i], arg_value: argument.source)
-
               add_offense(
-                argument.source_range, message: message
+                argument, message: message(i, argument.source)
               ) do |corrector|
                 autocorrect(corrector, node)
               end
@@ -105,30 +101,38 @@ module RuboCop
 
         private
 
+        def message(positional_argument_index, arg_value)
+          case positional_argument_index
+          when 0
+            MESSAGE_SAFE_LEVEL
+          when 1
+            format(MESSAGE_TRIM_MODE, arg_value: arg_value)
+          when 2
+            format(MESSAGE_EOUTVAR, arg_value: arg_value)
+          end
+        end
+
         def autocorrect(corrector, node)
-          str_arg = node.arguments[0].source
+          str_arg = node.first_argument.source
 
           kwargs = build_kwargs(node)
           overridden_kwargs = override_by_legacy_args(kwargs, node)
 
-          good_arguments = [
-            str_arg, overridden_kwargs
-          ].flatten.compact.join(', ')
+          good_arguments = [str_arg, overridden_kwargs].flatten.compact.join(', ')
 
           corrector.replace(arguments_range(node), good_arguments)
         end
 
         def correct_arguments?(arguments)
-          arguments.size == 1 ||
-            arguments.size == 2 && arguments[1].hash_type?
+          arguments.size == 1 || (arguments.size == 2 && arguments[1].hash_type?)
         end
 
         def build_kwargs(node)
-          return [nil, nil] unless node.arguments.last.hash_type?
+          return [nil, nil] unless node.last_argument.hash_type?
 
           trim_mode_arg, eoutvar_arg = nil
 
-          node.arguments.last.pairs.each do |pair|
+          node.last_argument.pairs.each do |pair|
             case pair.key.source
             when 'trim_mode'
               trim_mode_arg = "trim_mode: #{pair.value.source}"
@@ -152,13 +156,6 @@ module RuboCop
 
           overridden_kwargs
         end
-
-        def arguments_range(node)
-          arguments = node.arguments
-
-          range_between(arguments.first.source_range.begin_pos,
-                        arguments.last.source_range.end_pos)
-        end
       end
     end
   end

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

@@ -3,8 +3,14 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop looks for uses of flip-flop operator.
-      # flip-flop operator is deprecated since Ruby 2.6.0.
+      # Looks for uses of flip-flop operator
+      # based on the Ruby Style Guide.
+      #
+      # Here is the history of flip-flops in Ruby.
+      # flip-flop operator is deprecated in Ruby 2.6.0 and
+      # the deprecation has been reverted by Ruby 2.7.0 and
+      # backported to Ruby 2.6.
+      # See: https://bugs.ruby-lang.org/issues/5400
       #
       # @example
       #   # bad

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
@@ -15,9 +15,21 @@ module RuboCop
       #   x == 0.1
       #   x != 0.1
       #
+      #   # bad
+      #   case value
+      #   when 1.0
+      #     foo
+      #   when 2.0
+      #     bar
+      #   end
+      #
       #   # good - using BigDecimal
       #   x.to_d == 0.1.to_d
       #
+      #   # good - comparing against zero
+      #   x == 0.0
+      #   x != 0.0
+      #
       #   # good
       #   (x - 0.1).abs < Float::EPSILON
       #
@@ -25,11 +37,24 @@ module RuboCop
       #   tolerance = 0.0001
       #   (x - 0.1).abs < tolerance
       #
+      #   # good - comparing against nil
+      #   Float(x, exception: false) == nil
+      #
+      #   # good - using epsilon comparison in case expression
+      #   case
+      #   when (value - 1.0).abs < Float::EPSILON
+      #     foo
+      #   when (value - 2.0).abs < Float::EPSILON
+      #     bar
+      #   end
+      #
       #   # Or some other epsilon based type of comparison:
       #   # https://www.embeddeduse.com/2019/08/26/qt-compare-two-floats/
       #
       class FloatComparison < Base
-        MSG = 'Avoid (in)equality comparisons of floats as they are unreliable.'
+        MSG_EQUALITY = 'Avoid equality comparisons of floats as they are unreliable.'
+        MSG_INEQUALITY = 'Avoid inequality comparisons of floats as they are unreliable.'
+        MSG_CASE = 'Avoid float literal comparisons in case statements as they are unreliable.'
 
         EQUALITY_METHODS = %i[== != eql? equal?].freeze
         FLOAT_RETURNING_METHODS = %i[to_f Float fdiv].freeze
@@ -38,8 +63,26 @@ module RuboCop
         RESTRICT_ON_SEND = EQUALITY_METHODS
 
         def on_send(node)
-          lhs, _method, rhs = *node
-          add_offense(node) if float?(lhs) || float?(rhs)
+          return unless node.arguments.one?
+
+          lhs = node.receiver
+          rhs = node.first_argument
+
+          return if literal_safe?(lhs) || literal_safe?(rhs)
+
+          message = node.method?(:!=) ? MSG_INEQUALITY : MSG_EQUALITY
+          add_offense(node, message: message) if float?(lhs) || float?(rhs)
+        end
+        alias on_csend on_send
+
+        def on_case(node)
+          node.when_branches.each do |when_branch|
+            when_branch.each_condition do |condition|
+              next if !float?(condition) || literal_safe?(condition)
+
+              add_offense(condition, message: MSG_CASE)
+            end
+          end
         end
 
         private
@@ -51,7 +94,7 @@ module RuboCop
           when :float
             true
           when :send
-            check_send(node)
+            float_send?(node)
           when :begin
             float?(node.children.first)
           else
@@ -59,24 +102,24 @@ module RuboCop
           end
         end
 
-        # rubocop:disable Metrics/PerceivedComplexity
-        def check_send(node)
+        def literal_safe?(node)
+          return false unless node
+
+          (node.numeric_type? && node.value.zero?) || node.nil_type?
+        end
+
+        def float_send?(node)
           if node.arithmetic_operation?
-            lhs, _operation, rhs = *node
-            float?(lhs) || float?(rhs)
+            float?(node.receiver) || float?(node.first_argument)
           elsif FLOAT_RETURNING_METHODS.include?(node.method_name)
             true
           elsif node.receiver&.float_type?
-            if FLOAT_INSTANCE_METHODS.include?(node.method_name)
-              true
-            else
-              check_numeric_returning_method(node)
-            end
+            FLOAT_INSTANCE_METHODS.include?(node.method_name) ||
+              numeric_returning_method?(node)
           end
         end
-        # rubocop:enable Metrics/PerceivedComplexity
 
-        def check_numeric_returning_method(node)
+        def numeric_returning_method?(node)
           return false unless node.receiver
 
           case node.method_name

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

@@ -3,29 +3,22 @@
 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.
       #
       # @example
       #
       #   # bad
-      #
       #   float = 3.0e400
       #
-      # @example
-      #
       #   # good
-      #
       #   float = 42.9
       class FloatOutOfRange < Base
         MSG = 'Float out of range.'
 
         def on_float(node)
-          value, = *node
-
-          return unless value.infinite? ||
-                        value.zero? && /[1-9]/.match?(node.source)
+          return unless node.value.infinite? || (node.value.zero? && /[1-9]/.match?(node.source))
 
           add_offense(node)
         end

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

@@ -7,32 +7,22 @@ module RuboCop
       # expected fields for format/sprintf/#% and what is actually
       # passed as arguments.
       #
-      # In addition it checks whether different formats are used in the same
+      # In addition, it checks whether different formats are used in the same
       # format string. Do not mix numbered, unnumbered, and named formats in
       # the same format string.
       #
       # @example
       #
       #   # bad
-      #
       #   format('A value: %s and another: %i', a_value)
       #
-      # @example
-      #
       #   # good
-      #
       #   format('A value: %s and another: %i', a_value, another)
       #
-      # @example
-      #
       #   # bad
-      #
       #   format('Unnumbered format: %s and numbered: %2$s', a_value, another)
       #
-      # @example
-      #
       #   # good
-      #
       #   format('Numbered format: %1$s and numbered %2$s', a_value, another)
       class FormatParameterMismatch < Base
         # http://rubular.com/r/CvpbxkcTzy
@@ -81,6 +71,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.type?(:dstr, :array)
+
           matched_arguments_count?(num_of_expected_fields, num_of_format_args)
         end
 
@@ -92,9 +86,10 @@ module RuboCop
           end
         end
 
+        # @!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)
@@ -139,15 +134,14 @@ module RuboCop
         end
 
         def format_method?(name, node)
-          return false if node.const_receiver? &&
-                          !node.receiver.loc.name.is?(KERNEL)
+          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,12 +166,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
@@ -190,6 +181,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/hash_compare_by_identity.rb

@@ -3,10 +3,19 @@
 module RuboCop
   module Cop
     module Lint
-      # Prefer using `Hash#compare_by_identity` than using `object_id` for hash keys.
+      # Prefer using `Hash#compare_by_identity` rather than using `object_id`
+      # for hash keys.
       #
-      # This cop is marked as unsafe as a hash possibly can contain other keys
-      # besides `object_id`s.
+      # This cop looks for hashes being keyed by objects' `object_id`, using
+      # one of these methods: `key?`, `has_key?`, `fetch`, `[]` and `[]=`.
+      #
+      # @safety
+      #   This cop is unsafe. Although unlikely, the hash could store both object
+      #   ids and other values that need be compared by value, and thus
+      #   could be a false positive.
+      #
+      #   Furthermore, this cop cannot guarantee that the receiver of one of the
+      #   methods (`key?`, etc.) is actually a hash.
       #
       # @example
       #   # bad
@@ -24,13 +33,15 @@ module RuboCop
 
         MSG = 'Use `Hash#compare_by_identity` instead of using `object_id` for keys.'
 
+        # @!method id_as_hash_key?(node)
         def_node_matcher :id_as_hash_key?, <<~PATTERN
-          (send _ {:key? :has_key? :fetch :[] :[]=} (send _ :object_id) ...)
+          (call _ {:key? :has_key? :fetch :[] :[]=} (send _ :object_id) ...)
         PATTERN
 
         def on_send(node)
           add_offense(node) if id_as_hash_key?(node)
         end
+        alias on_csend on_send
       end
     end
   end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for the deprecated use of keyword arguments as a default in `Hash.new`.
+      #
+      # This usage raises a warning in Ruby 3.3 and results in an error in Ruby 3.4.
+      # In Ruby 3.4, keyword arguments will instead be used to change the behavior of a hash.
+      # For example, the capacity option can be passed to create a hash with a certain size
+      # if you know it in advance, for better performance.
+      #
+      # NOTE: The following corner case may result in a false negative when upgrading from Ruby 3.3
+      # or earlier, but it is intentionally not detected to respect the expected usage in Ruby 3.4.
+      #
+      # [source,ruby]
+      # ----
+      # Hash.new(capacity: 42)
+      # ----
+      #
+      # @example
+      #
+      #   # bad
+      #   Hash.new(key: :value)
+      #
+      #   # good
+      #   Hash.new({key: :value})
+      #
+      class HashNewWithKeywordArgumentsAsDefault < Base
+        extend AutoCorrector
+
+        MSG = 'Use a hash literal instead of keyword arguments.'
+        RESTRICT_ON_SEND = %i[new].freeze
+
+        # @!method hash_new(node)
+        def_node_matcher :hash_new, <<~PATTERN
+          (send (const {nil? (cbase)} :Hash) :new $[hash !braces?])
+        PATTERN
+
+        def on_send(node)
+          return unless (first_argument = hash_new(node))
+
+          if first_argument.pairs.one?
+            key = first_argument.pairs.first.key
+            return if key.respond_to?(:value) && key.value == :capacity
+          end
+
+          add_offense(first_argument) do |corrector|
+            corrector.wrap(first_argument, '{', '}')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,39 +3,36 @@
 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
         extend AutoCorrector
 
-        MSG = 'Put a method call with a HEREDOC receiver on the ' \
-        'same line as the HEREDOC opening.'
+        MSG = 'Put a method call with a HEREDOC receiver on the same line as the HEREDOC opening.'
 
         def on_send(node)
           heredoc = heredoc_node_descendent_receiver(node)
@@ -68,7 +65,7 @@ module RuboCop
         end
 
         def send_node?(node)
-          return nil unless node
+          return false unless node
 
           node.call_type?
         end

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

@@ -3,7 +3,6 @@
 module RuboCop
   module Cop
     module Lint
-      #
       # Prefer `equal?` over `==` when comparing `object_id`.
       #
       # `Object#equal?` is provided to compare objects for identity, and in contrast
@@ -12,39 +11,43 @@ module RuboCop
       # @example
       #   # bad
       #   foo.object_id == bar.object_id
+      #   foo.object_id != baz.object_id
       #
       #   # good
       #   foo.equal?(bar)
+      #   !foo.equal?(baz)
       #
       class IdentityComparison < Base
         extend AutoCorrector
 
-        MSG = 'Use `equal?` instead `==` when comparing `object_id`.'
-        RESTRICT_ON_SEND = %i[==].freeze
+        MSG = 'Use `%<bang>sequal?` instead of `%<comparison_method>s` when comparing `object_id`.'
+        RESTRICT_ON_SEND = %i[== !=].freeze
+
+        # @!method object_id_comparison(node)
+        def_node_matcher :object_id_comparison, <<~PATTERN
+          (send
+            (send
+              _lhs_receiver :object_id) ${:== :!=}
+            (send
+              _rhs_receiver :object_id))
+        PATTERN
 
         def on_send(node)
-          return unless compare_between_object_id_by_double_equal?(node)
+          return unless (comparison_method = object_id_comparison(node))
 
-          add_offense(node) do |corrector|
+          bang = comparison_method == :== ? '' : '!'
+          add_offense(node,
+                      message: format(MSG, comparison_method: comparison_method,
+                                           bang: bang)) do |corrector|
             receiver = node.receiver.receiver
             argument = node.first_argument.receiver
             return unless receiver && argument
 
-            replacement = "#{receiver.source}.equal?(#{argument.source})"
+            replacement = "#{bang}#{receiver.source}.equal?(#{argument.source})"
 
             corrector.replace(node, replacement)
           end
         end
-
-        private
-
-        def compare_between_object_id_by_double_equal?(node)
-          object_id_method?(node.receiver) && object_id_method?(node.first_argument)
-        end
-
-        def object_id_method?(node)
-          node.send_type? && node.method?(:object_id)
-        end
       end
     end
   end