rubocop 0.88.0 → 0.89.0

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

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
+        FORMAT_METHODS = %i[format sprintf %].freeze
 
         def on_send(node)
-          return unless format_string?(node)
+          return unless FORMAT_METHODS.include?(node.method_name) && 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/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
 

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

@@ -45,7 +45,7 @@ module RuboCop
       #       end
       #     end
       #   end
-      class IneffectiveAccessModifier < Cop
+      class IneffectiveAccessModifier < Base
         MSG = '`%<modifier>s` (on line %<line>d) does not make singleton ' \
               'methods %<modifier>s. Use %<alternative>s instead.'
         ALTERNATIVE_PRIVATE = '`private_class_method` or `private` inside a ' \
@@ -70,12 +70,8 @@ module RuboCop
         def check_node(node)
           return unless node&.begin_type?
 
-          ignored_methods = private_class_method_names(node)
-
-          ineffective_modifier(node, ignored_methods) do |defs_node, modifier|
-            add_offense(defs_node,
-                        location: :keyword,
-                        message: format_message(modifier))
+          ineffective_modifier(node) do |defs_node, modifier|
+            add_offense(defs_node.loc.keyword, message: format_message(modifier))
           end
         end
 
@@ -97,20 +93,24 @@ module RuboCop
                       alternative: alternative)
         end
 
-        def ineffective_modifier(node, ignored_methods, modifier = nil, &block)
+        # rubocop:disable Metrics/CyclomaticComplexity
+        def ineffective_modifier(node, ignored_methods = nil, modifier = nil, &block)
           node.each_child_node do |child|
             case child.type
             when :send
               modifier = child if access_modifier?(child)
             when :defs
+              ignored_methods ||= private_class_method_names(node)
               next if correct_visibility?(child, modifier, ignored_methods)
 
               yield child, modifier
             when :kwbegin
+              ignored_methods ||= private_class_method_names(node)
               ineffective_modifier(child, ignored_methods, modifier, &block)
             end
           end
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
 
         def access_modifier?(node)
           node.bare_access_modifier? && !node.method?(:module_function)

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

@@ -33,8 +33,9 @@ module RuboCop
       #   class C < StandardError; end
       #
       #   C = Class.new(StandardError)
-      class InheritException < Cop
+      class InheritException < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         MSG = 'Inherit from `%<prefer>s` instead of `%<current>s`.'
         PREFERRED_BASE_CLASS = {
@@ -65,19 +66,23 @@ module RuboCop
           return unless node.parent_class &&
                         illegal_class_name?(node.parent_class)
 
-          add_offense(node.parent_class)
+          message = message(node.parent_class)
+
+          add_offense(node.parent_class, message: message) do |corrector|
+            corrector.replace(node.parent_class, preferred_base_class)
+          end
         end
 
         def on_send(node)
+          return unless node.method?(:new)
+
           constant = class_new_call?(node)
           return unless constant && illegal_class_name?(constant)
 
-          add_offense(constant)
-        end
+          message = message(constant)
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node, preferred_base_class)
+          add_offense(constant, message: message) do |corrector|
+            corrector.replace(constant, preferred_base_class)
           end
         end