rubocop 0.88.0 → 0.91.1

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

@@ -16,18 +16,17 @@ module RuboCop
       #   # good
       #
       #   "result is #{some_result}"
-      class EmptyInterpolation < Cop
+      class EmptyInterpolation < Base
         include Interpolation
+        extend AutoCorrector
 
         MSG = 'Empty interpolation detected.'
 
         def on_interpolation(begin_node)
-          add_offense(begin_node) if begin_node.children.empty?
-        end
+          return unless begin_node.children.empty?
 
-        def autocorrect(node)
-          lambda do |collector|
-            collector.remove(node.loc.expression)
+          add_offense(begin_node) do |corrector|
+            corrector.remove(begin_node.loc.expression)
           end
         end
       end

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

@@ -44,7 +44,7 @@ module RuboCop
       #     # do nothing
       #   end
       #
-      class EmptyWhen < Cop
+      class EmptyWhen < Base
         MSG = 'Avoid `when` branches without a body.'
 
         def on_case(node)
@@ -52,7 +52,7 @@ module RuboCop
             next if when_node.body
             next if cop_config['AllowComments'] && comment_lines?(node)
 
-            add_offense(when_node, location: when_node.source_range)
+            add_offense(when_node)
           end
         end
       end

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

@@ -4,57 +4,55 @@ module RuboCop
   module Cop
     module Lint
       # This cop checks for `return` from an `ensure` block.
-      # Explicit return from an ensure block alters the control flow
-      # as the return will take precedence over any exception being raised,
+      # `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.
       #
+      # If you want to rescue some (or all) exceptions, best to do it explicitly
+      #
       # @example
       #
       #   # bad
       #
-      #   begin
+      #   def foo
       #     do_something
       #   ensure
-      #     do_something_else
-      #     return
+      #     cleanup
+      #     return self
       #   end
       #
       # @example
       #
       #   # good
       #
-      #   begin
+      #   def foo
       #     do_something
+      #     self
+      #   ensure
+      #     cleanup
+      #   end
+      #
+      #   # also good
+      #
+      #   def foo
+      #     begin
+      #       do_something
+      #     rescue SomeException
+      #       # Let's ignore this exception
+      #     end
+      #     self
       #   ensure
-      #     do_something_else
+      #     cleanup
       #   end
-      class EnsureReturn < Cop
+      class EnsureReturn < Base
+        extend AutoCorrector
         include RangeHelp
 
         MSG = 'Do not return from an `ensure` block.'
 
         def on_ensure(node)
-          ensure_body = node.body
-
-          return unless ensure_body
-
-          ensure_body.each_node(:return) do |return_node|
-            next if return_node.arguments.size >= 2
-
-            add_offense(return_node, location: :keyword)
-          end
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            if node.arguments?
-              corrector.replace(node, node.source.gsub(/return\s*/, ''))
-            else
-              range = range_by_whole_lines(
-                node.loc.expression, include_final_newline: true
-              )
-              corrector.remove(range)
-            end
+          node.body&.each_node(:return) do |return_node|
+            add_offense(return_node)
           end
         end
       end

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

@@ -59,9 +59,10 @@ module RuboCop
       #     ERB.new(str, nil, '-', '@output_buffer')
       #   end
       #
-      class ErbNewArguments < Cop
-        extend TargetRubyVersion
+      class ErbNewArguments < Base
         include RangeHelp
+        extend TargetRubyVersion
+        extend AutoCorrector
 
         minimum_target_ruby_version 2.6
 
@@ -77,6 +78,8 @@ module RuboCop
           '`ERB.new(str, eoutvar: %<arg_value>s)` instead.'
         ].freeze
 
+        RESTRICT_ON_SEND = %i[new].freeze
+
         def_node_matcher :erb_new_with_non_keyword_arguments, <<~PATTERN
           (send
             (const {nil? cbase} :ERB) :new $...)
@@ -92,13 +95,17 @@ module RuboCop
               message = format(MESSAGES[i], arg_value: argument.source)
 
               add_offense(
-                node, location: argument.source_range, message: message
-              )
+                argument.source_range, message: message
+              ) do |corrector|
+                autocorrect(corrector, node)
+              end
             end
           end
         end
 
-        def autocorrect(node)
+        private
+
+        def autocorrect(corrector, node)
           str_arg = node.arguments[0].source
 
           kwargs = build_kwargs(node)
@@ -108,13 +115,9 @@ module RuboCop
             str_arg, overridden_kwargs
           ].flatten.compact.join(', ')
 
-          lambda do |corrector|
-            corrector.replace(arguments_range(node), good_arguments)
-          end
+          corrector.replace(arguments_range(node), good_arguments)
         end
 
-        private
-
         def correct_arguments?(arguments)
           arguments.size == 1 ||
             arguments.size == 2 && arguments[1].hash_type?

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

@@ -16,7 +16,7 @@ module RuboCop
       #   (1..20).each do |x|
       #     puts x if (x >= 5) && (x <= 10)
       #   end
-      class FlipFlop < Cop
+      class FlipFlop < Base
         MSG = 'Avoid the use of flip-flop operators.'
 
         def on_iflipflop(node)

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop 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
+      # floating-point value representation to be exactly the same, which is very unlikely
+      # if you perform any arithmetic operations involving precision loss.
+      #
+      # @example
+      #   # bad
+      #   x == 0.1
+      #   x != 0.1
+      #
+      #   # good - using BigDecimal
+      #   x.to_d == 0.1.to_d
+      #
+      #   # good
+      #   (x - 0.1).abs < Float::EPSILON
+      #
+      #   # good
+      #   tolerance = 0.0001
+      #   (x - 0.1).abs < tolerance
+      #
+      #   # 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.'
+
+        EQUALITY_METHODS = %i[== != eql? equal?].freeze
+        FLOAT_RETURNING_METHODS = %i[to_f Float fdiv].freeze
+        FLOAT_INSTANCE_METHODS = %i[@- abs magnitude modulo next_float prev_float quo].to_set.freeze
+
+        RESTRICT_ON_SEND = EQUALITY_METHODS
+
+        def on_send(node)
+          lhs, _method, rhs = *node
+          add_offense(node) if float?(lhs) || float?(rhs)
+        end
+
+        private
+
+        def float?(node)
+          return false unless node
+
+          case node.type
+          when :float
+            true
+          when :send
+            check_send(node)
+          when :begin
+            float?(node.children.first)
+          else
+            false
+          end
+        end
+
+        # rubocop:disable Metrics/PerceivedComplexity
+        def check_send(node)
+          if node.arithmetic_operation?
+            lhs, _operation, rhs = *node
+            float?(lhs) || float?(rhs)
+          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
+          end
+        end
+        # rubocop:enable Metrics/PerceivedComplexity
+
+        def check_numeric_returning_method(node)
+          return false unless node.receiver
+
+          case node.method_name
+          when :angle, :arg, :phase
+            Float(node.receiver.source).negative?
+          when :ceil, :floor, :round, :truncate
+            precision = node.first_argument
+            precision&.int_type? && Integer(precision.source).positive?
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -18,7 +18,7 @@ module RuboCop
       #   # good
       #
       #   float = 42.9
-      class FloatOutOfRange < Cop
+      class FloatOutOfRange < Base
         MSG = 'Float out of range.'
 
         def on_float(node)

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

@@ -34,7 +34,7 @@ module RuboCop
       #   # good
       #
       #   format('Numbered format: %1$s and numbered %2$s', a_value, another)
-      class FormatParameterMismatch < Cop
+      class FormatParameterMismatch < Base
         # http://rubular.com/r/CvpbxkcTzy
         MSG = "Number of arguments (%<arg_num>i) to `%<method>s` doesn't " \
               'match the number of fields (%<field_num>i).'
@@ -44,18 +44,19 @@ module RuboCop
         KERNEL = 'Kernel'
         SHOVEL = '<<'
         STRING_TYPES = %i[str dstr].freeze
+        RESTRICT_ON_SEND = %i[format sprintf %].freeze
 
         def on_send(node)
           return unless format_string?(node)
 
           if invalid_format_string?(node)
-            add_offense(node, location: :selector, message: MSG_INVALID)
+            add_offense(node.loc.selector, message: MSG_INVALID)
             return
           end
 
           return unless offending_node?(node)
 
-          add_offense(node, location: :selector)
+          add_offense(node.loc.selector, message: message(node))
         end
 
         private

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

@@ -30,8 +30,9 @@ module RuboCop
       #        bar
       #      SQL
       #
-      class HeredocMethodCallPosition < Cop
+      class HeredocMethodCallPosition < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Put a method call with a HEREDOC receiver on the ' \
         'same line as the HEREDOC opening.'
@@ -41,25 +42,23 @@ module RuboCop
           return unless heredoc
           return if correctly_positioned?(node, heredoc)
 
-          add_offense(node, location: call_after_heredoc_range(heredoc))
+          add_offense(call_after_heredoc_range(heredoc)) do |corrector|
+            autocorrect(corrector, node, heredoc)
+          end
         end
         alias on_csend on_send
 
-        def autocorrect(node)
-          heredoc = heredoc_node_descendent_receiver(node)
+        private
 
-          lambda do |corrector|
-            call_range = call_range_to_safely_reposition(node, heredoc)
-            return if call_range.nil?
+        def autocorrect(corrector, node, heredoc)
+          call_range = call_range_to_safely_reposition(node, heredoc)
+          return if call_range.nil?
 
-            call_source = call_range.source.strip
-            corrector.remove(call_range)
-            corrector.insert_after(heredoc_begin_line_range(node), call_source)
-          end
+          call_source = call_range.source.strip
+          corrector.remove(call_range)
+          corrector.insert_after(heredoc_begin_line_range(node), call_source)
         end
 
-        private
-
         def heredoc_node_descendent_receiver(node)
           while send_node?(node)
             return node.receiver if heredoc_node?(node.receiver)
@@ -148,7 +147,7 @@ module RuboCop
         end
 
         def trailing_comma?(call_source, call_line_source)
-          call_source + ',' == call_line_source
+          "#{call_source}," == call_line_source
         end
       end
     end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+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
+      # `Object#==` is provided for the purpose of doing value comparison.
+      #
+      # @example
+      #   # bad
+      #   foo.object_id == bar.object_id
+      #
+      #   # good
+      #   foo.equal?(bar)
+      #
+      class IdentityComparison < Base
+        extend AutoCorrector
+
+        MSG = 'Use `equal?` instead `==` when comparing `object_id`.'
+        RESTRICT_ON_SEND = %i[==].freeze
+
+        def on_send(node)
+          return unless compare_between_object_id_by_double_equal?(node)
+
+          add_offense(node) do |corrector|
+            receiver = node.receiver.receiver
+            argument = node.first_argument.receiver
+            return unless receiver && argument
+
+            replacement = "#{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
+end

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

@@ -22,7 +22,7 @@ module RuboCop
       #     'Item 1' \
       #     'Item 2'
       #   ]
-      class ImplicitStringConcatenation < Cop
+      class ImplicitStringConcatenation < Base
         MSG = 'Combine %<string1>s and %<string2>s into a single string ' \
               'literal, rather than using implicit string concatenation.'
         FOR_ARRAY = ' Or, if they were intended to be separate array ' \
@@ -41,7 +41,7 @@ module RuboCop
             elsif node.parent&.send_type?
               message << FOR_METHOD
             end
-            add_offense(node, location: range, message: message)
+            add_offense(range, message: message)
           end
         end