rubocop 0.87.1 → 0.89.1

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks that there are no repeated exceptions
+      # used in 'rescue' expressions.
+      #
+      # @example
+      #   # bad
+      #   begin
+      #     something
+      #   rescue FirstException
+      #     handle_exception
+      #   rescue FirstException
+      #     handle_other_exception
+      #   end
+      #
+      #   # good
+      #   begin
+      #     something
+      #   rescue FirstException
+      #     handle_exception
+      #   rescue SecondException
+      #     handle_other_exception
+      #   end
+      #
+      class DuplicateRescueException < Base
+        include RescueNode
+
+        MSG = 'Duplicate `rescue` exception detected.'
+
+        def on_rescue(node)
+          return if rescue_modifier?(node)
+
+          _body, *resbodies, _else = *node
+
+          resbodies.each_with_object(Set.new) do |resbody, previous|
+            rescued_exceptions = rescued_exceptions(resbody)
+
+            rescued_exceptions.each do |exception|
+              add_offense(exception) unless previous.add?(exception)
+            end
+          end
+        end
+
+        private
+
+        def rescued_exceptions(resbody)
+          rescue_group, = *resbody
+          if rescue_group
+            rescue_group.values
+          else
+            []
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -21,7 +21,7 @@ module RuboCop
       #
       #   num = 0
       #   sum = numbers.each_with_object(num) { |e, a| a += e }
-      class EachWithObjectArgument < Cop
+      class EachWithObjectArgument < Base
         MSG = 'The argument to each_with_object cannot be immutable.'
 
         def_node_matcher :each_with_object?, <<~PATTERN

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

@@ -27,7 +27,7 @@ module RuboCop
       #     do_this
       #     do_that
       #   end
-      class ElseLayout < Cop
+      class ElseLayout < Base
         MSG = 'Odd `else` layout detected. Did you mean to use `elsif`?'
 
         def on_if(node)

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for the presence of `if`, `elsif` and `unless` branches without a body.
+      # @example
+      #   # bad
+      #   if condition
+      #   end
+      #
+      #   # bad
+      #   unless condition
+      #   end
+      #
+      #   # bad
+      #   if condition
+      #     do_something
+      #   elsif other_condition
+      #   end
+      #
+      #   # good
+      #   if condition
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   unless condition
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   if condition
+      #     do_something
+      #   elsif other_condition
+      #     do_something_else
+      #   end
+      #
+      # @example AllowComments: true (default)
+      #   # good
+      #   if condition
+      #     do_something
+      #   elsif other_condition
+      #     # noop
+      #   end
+      #
+      # @example AllowComments: false
+      #   # bad
+      #   if condition
+      #     do_something
+      #   elsif other_condition
+      #     # noop
+      #   end
+      #
+      class EmptyConditionalBody < Base
+        MSG = 'Avoid `%<keyword>s` branches without a body.'
+
+        def on_if(node)
+          return if node.body
+          return if cop_config['AllowComments'] && comment_lines?(node)
+
+          add_offense(node, message: format(MSG, keyword: node.keyword))
+        end
+      end
+    end
+  end
+end

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

@@ -42,15 +42,15 @@ module RuboCop
       #   ensure
       #     do_something_else
       #   end
-      class EmptyEnsure < Cop
+      class EmptyEnsure < Base
+        extend AutoCorrector
+
         MSG = 'Empty `ensure` block detected.'
 
         def on_ensure(node)
-          add_offense(node, location: :keyword) unless node.body
-        end
+          return if node.body
 
-        def autocorrect(node)
-          lambda do |corrector|
+          add_offense(node.loc.keyword) do |corrector|
             corrector.remove(node.loc.keyword)
           end
         end

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

@@ -22,13 +22,13 @@ module RuboCop
       #   if (some_expression)
       #     bar
       #   end
-      class EmptyExpression < Cop
+      class EmptyExpression < Base
         MSG = 'Avoid empty expressions.'
 
         def on_begin(node)
           return unless empty_expression?(node)
 
-          add_offense(node, location: node.source_range)
+          add_offense(node)
         end
 
         private

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
 
@@ -92,13 +93,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 +113,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
+
+        def on_send(node)
+          return unless EQUALITY_METHODS.include?(node.method_name)
+
+          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