rubocop 0.80.0 → 1.42.0

data/lib/rubocop/cop/style/double_negation.rb

@@ -3,31 +3,155 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for uses of double negation (!!) to convert something
-      # to a boolean value. As this is both cryptic and usually redundant, it
-      # should be avoided.
+      # Checks for uses of double negation (`!!`) to convert something to a boolean value.
       #
-      # @example
+      # When using `EnforcedStyle: allowed_in_returns`, allow double negation in contexts
+      # that use boolean as a return value. When using `EnforcedStyle: forbidden`, double negation
+      # should be forbidden always.
+      #
+      # NOTE: when `something` is a boolean value
+      # `!!something` and `!something.nil?` are not the same thing.
+      # As you're unlikely to write code that can accept values of any type
+      # this is rarely a problem in practice.
+      #
+      # @safety
+      #   Autocorrection is unsafe when the value is `false`, because the result
+      #   of the expression will change.
+      #
+      #   [source,ruby]
+      #   ----
+      #   !!false     #=> false
+      #   !false.nil? #=> true
+      #   ----
       #
+      # @example
       #   # bad
       #   !!something
       #
       #   # good
       #   !something.nil?
       #
-      # Please, note that when something is a boolean value
-      # !!something and !something.nil? are not the same thing.
-      # As you're unlikely to write code that can accept values of any type
-      # this is rarely a problem in practice.
-      class DoubleNegation < Cop
+      # @example EnforcedStyle: allowed_in_returns (default)
+      #   # good
+      #   def foo?
+      #     !!return_value
+      #   end
+      #
+      #   define_method :foo? do
+      #     !!return_value
+      #   end
+      #
+      #   define_singleton_method :foo? do
+      #     !!return_value
+      #   end
+      #
+      # @example EnforcedStyle: forbidden
+      #   # bad
+      #   def foo?
+      #     !!return_value
+      #   end
+      #
+      #   define_method :foo? do
+      #     !!return_value
+      #   end
+      #
+      #   define_singleton_method :foo? do
+      #     !!return_value
+      #   end
+      class DoubleNegation < Base
+        include ConfigurableEnforcedStyle
+        extend AutoCorrector
+
         MSG = 'Avoid the use of double negation (`!!`).'
+        RESTRICT_ON_SEND = %i[!].freeze
 
+        # @!method double_negative?(node)
         def_node_matcher :double_negative?, '(send (send _ :!) :!)'
 
         def on_send(node)
           return unless double_negative?(node) && node.prefix_bang?
+          return if style == :allowed_in_returns && allowed_in_returns?(node)
+
+          location = node.loc.selector
+          add_offense(location) do |corrector|
+            corrector.remove(location)
+            corrector.insert_after(node, '.nil?')
+          end
+        end
+
+        private
+
+        def allowed_in_returns?(node)
+          node.parent&.return_type? || end_of_method_definition?(node)
+        end
+
+        def end_of_method_definition?(node)
+          return false unless (def_node = find_def_node_from_ascendant(node))
+
+          conditional_node = find_conditional_node_from_ascendant(node)
+          last_child = find_last_child(def_node.send_type? ? def_node : def_node.body)
+
+          if conditional_node
+            double_negative_condition_return_value?(node, last_child, conditional_node)
+          elsif last_child.pair_type? || last_child.hash_type? || last_child.parent.array_type?
+            false
+          else
+            last_child.last_line <= node.last_line
+          end
+        end
+
+        def find_def_node_from_ascendant(node)
+          return unless (parent = node.parent)
+          return parent if parent.def_type? || parent.defs_type?
+          return node.parent.child_nodes.first if define_mehod?(parent)
+
+          find_def_node_from_ascendant(node.parent)
+        end
+
+        def define_mehod?(node)
+          return false unless node.block_type?
+
+          child = node.child_nodes.first
+          return false unless child.send_type?
+
+          child.method?(:define_method) || child.method?(:define_singleton_method)
+        end
+
+        def find_conditional_node_from_ascendant(node)
+          return unless (parent = node.parent)
+          return parent if parent.conditional?
+
+          find_conditional_node_from_ascendant(parent)
+        end
+
+        def find_last_child(node)
+          case node.type
+          when :rescue
+            find_last_child(node.body)
+          when :ensure
+            find_last_child(node.child_nodes.first)
+          else
+            node.child_nodes.last
+          end
+        end
+
+        def double_negative_condition_return_value?(node, last_child, conditional_node)
+          parent = find_parent_not_enumerable(node)
+          if parent.begin_type?
+            node.loc.line == parent.loc.last_line
+          else
+            last_child.last_line <= conditional_node.last_line
+          end
+        end
+
+        def find_parent_not_enumerable(node)
+          return unless (parent = node.parent)
 
-          add_offense(node, location: :selector)
+          if parent.pair_type? || parent.hash_type? || parent.array_type?
+            find_parent_not_enumerable(parent)
+          else
+            parent
+          end
         end
       end
     end

data/lib/rubocop/cop/style/each_for_simple_loop.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for loops which iterate a constant number of times,
+      # Checks for loops which iterate a constant number of times,
       # using a Range literal and `#each`. This can be done more readably using
       # `Integer#times`.
       #
@@ -22,35 +22,67 @@ module RuboCop
       #
       #   # good
       #   10.times {}
-      class EachForSimpleLoop < Cop
-        MSG = 'Use `Integer#times` for a simple loop which iterates a fixed ' \
-              'number of times.'
+      class EachForSimpleLoop < Base
+        extend AutoCorrector
 
-        def on_block(node)
-          return unless offending_each_range(node)
+        MSG = 'Use `Integer#times` for a simple loop which iterates a fixed number of times.'
+
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+          return unless offending?(node)
 
           send_node = node.send_node
 
           range = send_node.receiver.source_range.join(send_node.loc.selector)
 
-          add_offense(node, location: range)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            range_type, min, max = offending_each_range(node)
+          add_offense(range) do |corrector|
+            range_type, min, max = each_range(node)
 
             max += 1 if range_type == :irange
 
-            corrector.replace(node.send_node.source_range,
-                              "#{max - min}.times")
+            corrector.replace(node.send_node, "#{max - min}.times")
           end
         end
 
         private
 
-        def_node_matcher :offending_each_range, <<~PATTERN
-          (block (send (begin (${irange erange} (int $_) (int $_))) :each) (args) ...)
+        def offending?(node)
+          each_range_with_zero_origin?(node) || each_range_without_block_argument?(node)
+        end
+
+        # @!method each_range(node)
+        def_node_matcher :each_range, <<~PATTERN
+          (block
+            (send
+              (begin
+                (${irange erange}
+                  (int $_) (int $_)))
+              :each)
+            (args ...)
+            ...)
+        PATTERN
+
+        # @!method each_range_with_zero_origin?(node)
+        def_node_matcher :each_range_with_zero_origin?, <<~PATTERN
+          (block
+            (send
+              (begin
+                ({irange erange}
+                  (int 0) (int _)))
+              :each)
+            (args ...)
+            ...)
+        PATTERN
+
+        # @!method each_range_without_block_argument?(node)
+        def_node_matcher :each_range_without_block_argument?, <<~PATTERN
+          (block
+            (send
+              (begin
+                ({irange erange}
+                  (int _) (int _)))
+              :each)
+            (args)
+            ...)
         PATTERN
       end
     end

data/lib/rubocop/cop/style/each_with_object.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop looks for inject / reduce calls where the passed in object is
+      # Looks for inject / reduce calls where the passed in object is
       # returned at the end and so could be replaced by each_with_object without
       # the need to return the object at the end.
       #
@@ -16,18 +16,15 @@ module RuboCop
       #
       #   # good
       #   [1, 2].each_with_object({}) { |e, a| a[e] = e }
-      class EachWithObject < Cop
+      class EachWithObject < Base
+        extend AutoCorrector
         include RangeHelp
 
         MSG = 'Use `each_with_object` instead of `%<method>s`.'
         METHODS = %i[inject reduce].freeze
 
-        def_node_matcher :each_with_object_candidate?, <<~PATTERN
-          (block $(send _ {:inject :reduce} _) $_ $_)
-        PATTERN
-
         def on_block(node)
-          each_with_object_candidate?(node) do |method, args, body|
+          each_with_object_block_candidate?(node) do |method, args, body|
             _, method_name, method_arg = *method
             return if simple_method_arg?(method_arg)
 
@@ -36,34 +33,66 @@ module RuboCop
             return unless first_argument_returned?(args, return_value)
             return if accumulator_param_assigned_to?(body, args)
 
-            add_offense(node, location: method.loc.selector,
-                              message: format(MSG, method: method_name))
+            message = format(MSG, method: method_name)
+            add_offense(method.loc.selector, message: message) do |corrector|
+              autocorrect_block(corrector, node, return_value)
+            end
           end
         end
 
-        # rubocop:disable Metrics/AbcSize
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.send_node.loc.selector, 'each_with_object')
-
-            first_arg, second_arg = *node.arguments
-
-            corrector.replace(first_arg.loc.expression, second_arg.source)
-            corrector.replace(second_arg.loc.expression, first_arg.source)
+        def on_numblock(node)
+          each_with_object_numblock_candidate?(node) do |method, body|
+            _, method_name, method_arg = *method
+            return if simple_method_arg?(method_arg)
 
-            return_value = return_value(node.body)
+            return unless return_value(body)&.source == '_1'
 
-            if return_value_occupies_whole_line?(return_value)
-              corrector.remove(whole_line_expression(return_value))
-            else
-              corrector.remove(return_value.loc.expression)
+            message = format(MSG, method: method_name)
+            add_offense(method.loc.selector, message: message) do |corrector|
+              autocorrect_numblock(corrector, node)
             end
           end
         end
-        # rubocop:enable Metrics/AbcSize
 
         private
 
+        # @!method each_with_object_block_candidate?(node)
+        def_node_matcher :each_with_object_block_candidate?, <<~PATTERN
+          (block $(send _ {:inject :reduce} _) $_ $_)
+        PATTERN
+
+        # @!method each_with_object_numblock_candidate?(node)
+        def_node_matcher :each_with_object_numblock_candidate?, <<~PATTERN
+          (numblock $(send _ {:inject :reduce} _) 2 $_)
+        PATTERN
+
+        def autocorrect_block(corrector, node, return_value)
+          corrector.replace(node.send_node.loc.selector, 'each_with_object')
+
+          first_arg, second_arg = *node.arguments
+
+          corrector.replace(first_arg, second_arg.source)
+          corrector.replace(second_arg, first_arg.source)
+
+          if return_value_occupies_whole_line?(return_value)
+            corrector.remove(whole_line_expression(return_value))
+          else
+            corrector.remove(return_value)
+          end
+        end
+
+        def autocorrect_numblock(corrector, node)
+          corrector.replace(node.send_node.loc.selector, 'each_with_object')
+
+          # We don't remove the return value to avoid a clobbering error.
+          node.body.each_descendant do |var|
+            next unless var.lvar_type?
+
+            corrector.replace(var, '_2') if var.source == '_1'
+            corrector.replace(var, '_1') if var.source == '_2'
+          end
+        end
+
         def simple_method_arg?(method_arg)
           method_arg&.basic_literal?
         end

data/lib/rubocop/cop/style/empty_block_parameter.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for pipes for empty block parameters. Pipes for empty
+      # Checks for pipes for empty block parameters. Pipes for empty
       # block parameters do not cause syntax errors, but they are redundant.
       #
       # @example
@@ -21,26 +21,25 @@ module RuboCop
       #
       #   # good
       #   a { do_something }
-      class EmptyBlockParameter < Cop
+      class EmptyBlockParameter < Base
         include EmptyParameter
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Omit pipes for the empty block parameters.'
 
-        def on_block(node)
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
           send_node = node.send_node
           check(node) unless send_node.send_type? && send_node.lambda_literal?
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            block = node.parent
-            range = range_between(
-              block.loc.begin.end_pos,
-              node.loc.expression.end_pos
-            )
-            corrector.remove(range)
-          end
+        private
+
+        def autocorrect(corrector, node)
+          block = node.parent
+          range = range_between(block.loc.begin.end_pos, node.loc.expression.end_pos)
+
+          corrector.remove(range)
         end
       end
     end

data/lib/rubocop/cop/style/empty_case_condition.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for case statements with an empty condition.
+      # Checks for case statements with an empty condition.
       #
       # @example
       #
@@ -35,45 +35,41 @@ module RuboCop
       #   else
       #     puts 'more'
       #   end
-      class EmptyCaseCondition < Cop
+      class EmptyCaseCondition < Base
         include RangeHelp
+        extend AutoCorrector
 
-        MSG = 'Do not use empty `case` condition, instead use an `if` '\
-              'expression.'
+        MSG = 'Do not use empty `case` condition, instead use an `if` expression.'
 
         def on_case(case_node)
           return if case_node.condition
-          return if case_node.when_branches.any? do |when_branch|
-            when_branch.each_descendant.any?(&:return_type?)
-          end
 
-          if (else_branch = case_node.else_branch)
-            return if else_branch.return_type? ||
-                      else_branch.each_descendant.any?(&:return_type?)
+          branch_bodies = [*case_node.when_branches.map(&:body), case_node.else_branch].compact
+
+          return if branch_bodies.any? do |body|
+            body.return_type? || body.each_descendant.any?(&:return_type?)
           end
 
-          add_offense(case_node, location: :keyword)
+          add_offense(case_node.loc.keyword) { |corrector| autocorrect(corrector, case_node) }
         end
 
-        def autocorrect(case_node)
+        private
+
+        def autocorrect(corrector, case_node)
           when_branches = case_node.when_branches
 
-          lambda do |corrector|
-            correct_case_when(corrector, case_node, when_branches)
-            correct_when_conditions(corrector, when_branches)
-          end
+          correct_case_when(corrector, case_node, when_branches)
+          correct_when_conditions(corrector, when_branches)
         end
 
-        private
-
         def correct_case_when(corrector, case_node, when_nodes)
           case_range = case_node.loc.keyword.join(when_nodes.first.loc.keyword)
 
           corrector.replace(case_range, 'if')
 
-          keep_first_when_comment(case_node, when_nodes.first, corrector)
+          keep_first_when_comment(case_range, corrector)
 
-          when_nodes[1..-1].each do |when_node|
+          when_nodes[1..].each do |when_node|
             corrector.replace(when_node.loc.keyword, 'elsif')
           end
         end
@@ -82,6 +78,8 @@ module RuboCop
           when_nodes.each do |when_node|
             conditions = when_node.conditions
 
+            replace_then_with_line_break(corrector, conditions, when_node)
+
             next unless conditions.size > 1
 
             range = range_between(conditions.first.source_range.begin_pos,
@@ -91,15 +89,22 @@ module RuboCop
           end
         end
 
-        def keep_first_when_comment(case_node, first_when_node, corrector)
-          comment = processed_source.comments_before_line(
-            first_when_node.loc.keyword.line
-          ).map(&:text).join("\n")
+        def keep_first_when_comment(case_range, corrector)
+          indent = ' ' * case_range.column
+          comments = processed_source.each_comment_in_lines(
+            case_range.first_line...case_range.last_line
+          ).map { |comment| "#{indent}#{comment.text}\n" }.join
+
+          line_beginning = case_range.adjust(begin_pos: -case_range.column)
+          corrector.insert_before(line_beginning, comments)
+        end
+
+        def replace_then_with_line_break(corrector, conditions, when_node)
+          return unless when_node.parent.parent && when_node.then?
 
-          line = range_by_whole_lines(case_node.source_range)
+          range = range_between(conditions.last.source_range.end_pos, when_node.loc.begin.end_pos)
 
-          corrector.insert_before(line, "#{comment}\n") if !comment.empty? &&
-                                                           !case_node.parent
+          corrector.replace(range, "\n")
         end
       end
     end

data/lib/rubocop/cop/style/empty_else.rb

@@ -6,6 +6,34 @@ module RuboCop
       # Checks for empty else-clauses, possibly including comments and/or an
       # explicit `nil` depending on the EnforcedStyle.
       #
+      # @example EnforcedStyle: both (default)
+      #   # warn on empty else and else with nil in it
+      #
+      #   # bad
+      #   if condition
+      #     statement
+      #   else
+      #     nil
+      #   end
+      #
+      #   # bad
+      #   if condition
+      #     statement
+      #   else
+      #   end
+      #
+      #   # good
+      #   if condition
+      #     statement
+      #   else
+      #     statement
+      #   end
+      #
+      #   # good
+      #   if condition
+      #     statement
+      #   end
+      #
       # @example EnforcedStyle: empty
       #   # warn only on empty else
       #
@@ -62,13 +90,13 @@ module RuboCop
       #     statement
       #   end
       #
-      # @example EnforcedStyle: both (default)
-      #   # warn on empty else and else with nil in it
+      # @example AllowComments: false (default)
       #
       #   # bad
       #   if condition
       #     statement
       #   else
+      #     # something comment
       #     nil
       #   end
       #
@@ -76,23 +104,31 @@ module RuboCop
       #   if condition
       #     statement
       #   else
+      #     # something comment
       #   end
       #
+      # @example AllowComments: true
+      #
       #   # good
       #   if condition
       #     statement
       #   else
-      #     statement
+      #     # something comment
+      #     nil
       #   end
       #
       #   # good
       #   if condition
       #     statement
+      #   else
+      #     # something comment
       #   end
-      class EmptyElse < Cop
+      #
+      class EmptyElse < Base
         include OnNormalIfUnless
         include ConfigurableEnforcedStyle
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Redundant `else`-clause.'
 
@@ -104,19 +140,11 @@ module RuboCop
           check(node)
         end
 
-        def autocorrect(node)
-          return false if autocorrect_forbidden?(node.type.to_s)
-          return false if comment_in_else?(node)
-
-          lambda do |corrector|
-            end_pos = base_node(node).loc.end.begin_pos
-            corrector.remove(range_between(node.loc.else.begin_pos, end_pos))
-          end
-        end
-
         private
 
         def check(node)
+          return if cop_config['AllowComments'] && comment_in_else?(node.loc)
+
           empty_check(node) if empty_style?
           nil_check(node) if nil_style?
         end
@@ -132,33 +160,34 @@ module RuboCop
         def empty_check(node)
           return unless node.else? && !node.else_branch
 
-          add_offense(node, location: :else)
+          add_offense(node.loc.else) { |corrector| autocorrect(corrector, node) }
         end
 
         def nil_check(node)
           return unless node.else_branch&.nil_type?
 
-          add_offense(node, location: :else)
+          add_offense(node.loc.else) { |corrector| autocorrect(corrector, node) }
         end
 
-        def comment_in_else?(node)
-          range = else_line_range(node.loc)
-          processed_source.find_comment { |c| range.include?(c.loc.line) }
+        def autocorrect(corrector, node)
+          return false if autocorrect_forbidden?(node.type.to_s)
+          return false if comment_in_else?(node.loc)
+
+          end_pos = base_node(node).loc.end.begin_pos
+          corrector.remove(range_between(node.loc.else.begin_pos, end_pos))
         end
 
-        def else_line_range(loc)
-          return 0..0 if loc.else.nil? || loc.end.nil?
+        def comment_in_else?(loc)
+          return false if loc.else.nil? || loc.end.nil?
 
-          loc.else.first_line..loc.end.first_line
+          processed_source.contains_comment?(loc.else.join(loc.end))
         end
 
         def base_node(node)
           return node if node.case_type?
           return node unless node.elsif?
 
-          node.each_ancestor(:if, :case, :when).find(-> { node }) do |parent|
-            parent.loc.end
-          end
+          node.each_ancestor(:if, :case, :when).find(-> { node }) { |parent| parent.loc.end }
         end
 
         def autocorrect_forbidden?(type)