rubocop 1.0.0 → 1.3.0

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

@@ -34,6 +34,7 @@ module RuboCop
       # this is rarely a problem in practice.
       class DoubleNegation < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         MSG = 'Avoid the use of double negation (`!!`).'
         RESTRICT_ON_SEND = %i[!].freeze
@@ -44,7 +45,11 @@ module RuboCop
           return unless double_negative?(node) && node.prefix_bang?
           return if style == :allowed_in_returns && allowed_in_returns?(node)
 
-          add_offense(node.loc.selector)
+          location = node.loc.selector
+          add_offense(location) do |corrector|
+            corrector.remove(location)
+            corrector.insert_after(node, '.nil?')
+          end
         end
 
         private

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

@@ -97,10 +97,10 @@ module RuboCop
         end
 
         def no_mixed_keys_check(pairs)
-          if !sym_indices?(pairs)
-            check(pairs, ':', MSG_NO_MIXED_KEYS)
-          else
+          if sym_indices?(pairs)
             check(pairs, pairs.first.inverse_delimiter, MSG_NO_MIXED_KEYS)
+          else
+            check(pairs, ':', MSG_NO_MIXED_KEYS)
           end
         end
 

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

@@ -3,8 +3,13 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for identical lines at the beginning or end of
-      # each branch of a conditional statement.
+      # This cop checks for identical expressions at the beginning or end of
+      # each branch of a conditional expression. Such expressions should normally
+      # be placed outside the conditional expression - before or after it.
+      #
+      # NOTE: The cop is poorly named and some people might think that it actually
+      # checks for duplicated conditional branches. The name will probably be changed
+      # in a future major RuboCop release.
       #
       # @example
       #   # bad

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

@@ -59,6 +59,9 @@ module RuboCop
       #   end
       #
       class IfInsideElse < Base
+        include RangeHelp
+        extend AutoCorrector
+
         MSG = 'Convert `if` nested inside `else` to `elsif`.'
 
         def on_if(node)
@@ -69,11 +72,44 @@ module RuboCop
           return unless else_branch&.if_type? && else_branch&.if?
           return if allow_if_modifier_in_else_branch?(else_branch)
 
-          add_offense(else_branch.loc.keyword)
+          add_offense(else_branch.loc.keyword) do |corrector|
+            autocorrect(corrector, else_branch)
+          end
         end
 
         private
 
+        def autocorrect(corrector, node)
+          if node.modifier_form?
+            correct_to_elsif_from_modifier_form(corrector, node)
+            end_range = node.parent.loc.end
+          else
+            correct_to_elsif_from_if_inside_else_form(corrector, node, node.condition)
+            end_range = node.loc.end
+          end
+          corrector.remove(range_by_whole_lines(end_range, include_final_newline: true))
+          corrector.remove(
+            range_by_whole_lines(node.if_branch.source_range, include_final_newline: true)
+          )
+        end
+
+        def correct_to_elsif_from_modifier_form(corrector, node)
+          corrector.replace(node.parent.loc.else, <<~RUBY.chop)
+            elsif #{node.condition.source}
+            #{indent(node.if_branch)}#{node.if_branch.source}
+            end
+          RUBY
+        end
+
+        def correct_to_elsif_from_if_inside_else_form(corrector, node, condition)
+          corrector.replace(node.parent.loc.else, "elsif #{condition.source}")
+          if_condition_range = range_between(
+            node.loc.keyword.begin_pos, condition.source_range.end_pos
+          )
+          corrector.replace(if_condition_range, node.if_branch.source)
+          corrector.remove(condition)
+        end
+
         def allow_if_modifier_in_else_branch?(else_branch)
           allow_if_modifier? && else_branch&.modifier_form?
         end

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

@@ -21,14 +21,18 @@ module RuboCop
       #     Foo.do_something
       #   end
       #
-      #   do_something_in_a_method_with_a_long_name(arg) if long_condition
+      #   do_something_with_a_long_name(arg) if long_condition_that_prevents_code_fit_on_single_line
       #
       #   # good
       #   do_stuff(bar) if condition
       #   Foo.do_something unless qux.empty?
       #
-      #   if long_condition
-      #     do_something_in_a_method_with_a_long_name(arg)
+      #   if long_condition_that_prevents_code_fit_on_single_line
+      #     do_something_with_a_long_name(arg)
+      #   end
+      #
+      #   if short_condition # a long comment that makes it too long if it were just a single line
+      #     do_something
       #   end
       class IfUnlessModifier < Base
         include StatementModifier

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

@@ -5,6 +5,10 @@ module RuboCop
     module Style
       # Use `Kernel#loop` for infinite loops.
       #
+      # This cop is marked as unsafe as the rule does not necessarily
+      # apply if the body might raise a `StopIteration` exception; contrary to
+      # other infinite loops, `Kernel#loop` silently rescues that and returns `nil`.
+      #
       # @example
       #   # bad
       #   while true

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

@@ -34,6 +34,10 @@ module RuboCop
           add_offense(node) do |corrector|
             if node.parent.find(&:kwoptarg_type?) == node
               corrector.insert_before(node, "#{kwarg_nodes.map(&:source).join(', ')}, ")
+
+              arguments = node.each_ancestor(:def, :defs).first.arguments
+              append_newline_to_last_kwoptarg(arguments, corrector) unless parentheses?(arguments)
+
               remove_kwargs(kwarg_nodes, corrector)
             end
           end
@@ -41,6 +45,14 @@ module RuboCop
 
         private
 
+        def append_newline_to_last_kwoptarg(arguments, corrector)
+          last_argument = arguments.last
+          return if last_argument.kwrestarg_type? || last_argument.blockarg_type?
+
+          last_kwoptarg = arguments.reverse.find(&:kwoptarg_type?)
+          corrector.insert_after(last_kwoptarg, "\n")
+        end
+
         def remove_kwargs(kwarg_nodes, corrector)
           kwarg_nodes.each do |kwarg|
             with_space = range_with_surrounding_space(range: kwarg.source_range)

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

@@ -135,10 +135,6 @@ module RuboCop
 
           "#{node.method_name} #{mixin_names.join(', ')}"
         end
-
-        def indent(node)
-          ' ' * node.loc.column
-        end
       end
     end
   end

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

@@ -4,7 +4,10 @@ module RuboCop
   module Cop
     module Style
       # This cop checks against comparing a variable with multiple items, where
-      # `Array#include?` could be used instead to avoid code repetition.
+      # `Array#include?`, `Set#include?` or a `case` could be used instead
+      # to avoid code repetition.
+      # It accepts comparisons of multiple method calls to avoid unnecessary method calls
+      # by default. It can be configured by `AllowMethodComparison` option.
       #
       # @example
       #   # bad
@@ -14,25 +17,63 @@ module RuboCop
       #   # good
       #   a = 'a'
       #   foo if ['a', 'b', 'c'].include?(a)
+      #
+      #   VALUES = Set['a', 'b', 'c'].freeze
+      #   # elsewhere...
+      #   foo if VALUES.include?(a)
+      #
+      #   case foo
+      #   when 'a', 'b', 'c' then foo
+      #   # ...
+      #   end
+      #
+      #   # accepted (but consider `case` as above)
+      #   foo if a == b.lightweight || a == b.heavyweight
+      #
+      # @example AllowMethodComparison: true (default)
+      #   # good
+      #   foo if a == b.lightweight || a == b.heavyweight
+      #
+      # @example AllowMethodComparison: false
+      #   # bad
+      #   foo if a == b.lightweight || a == b.heavyweight
+      #
+      #   # good
+      #   foo if [b.lightweight, b.heavyweight].include?(a)
       class MultipleComparison < Base
+        extend AutoCorrector
+
         MSG = 'Avoid comparing a variable with multiple items ' \
           'in a conditional, use `Array#include?` instead.'
 
+        def on_new_investigation
+          @compared_elements = []
+          @allowed_method_comparison = false
+        end
+
         def on_or(node)
           root_of_or_node = root_of_or_node(node)
 
           return unless node == root_of_or_node
           return unless nested_variable_comparison?(root_of_or_node)
+          return if @allowed_method_comparison
 
-          add_offense(node)
+          add_offense(node) do |corrector|
+            elements = @compared_elements.join(', ')
+            prefer_method = "[#{elements}].include?(#{variables_in_node(node).first})"
+
+            corrector.replace(node, prefer_method)
+          end
         end
 
         private
 
         def_node_matcher :simple_double_comparison?, '(send $lvar :== $lvar)'
-        def_node_matcher :simple_comparison?, <<~PATTERN
-          {(send $lvar :== _)
-           (send _ :== $lvar)}
+        def_node_matcher :simple_comparison_lhs?, <<~PATTERN
+          (send $lvar :== $_)
+        PATTERN
+        def_node_matcher :simple_comparison_rhs?, <<~PATTERN
+          (send $_ :== $lvar)
         PATTERN
 
         def nested_variable_comparison?(node)
@@ -55,9 +96,12 @@ module RuboCop
           simple_double_comparison?(node) do |var1, var2|
             return [variable_name(var1), variable_name(var2)]
           end
-          simple_comparison?(node) do |var|
+          if (var, obj = simple_comparison_lhs?(node)) || (obj, var = simple_comparison_rhs?(node))
+            @allowed_method_comparison = true if allow_method_comparison? && obj.send_type?
+            @compared_elements << obj.source
             return [variable_name(var)]
           end
+
           []
         end
 
@@ -74,7 +118,7 @@ module RuboCop
         end
 
         def comparison?(node)
-          simple_comparison?(node) || nested_comparison?(node)
+          simple_comparison_lhs?(node) || simple_comparison_rhs?(node) || nested_comparison?(node)
         end
 
         def root_of_or_node(or_node)
@@ -86,6 +130,10 @@ module RuboCop
             or_node
           end
         end
+
+        def allow_method_comparison?
+          cop_config.fetch('AllowMethodComparison', true)
+        end
       end
     end
   end

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

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for uses of `if-else` and ternary operators with a negated condition
+      # which can be simplified by inverting condition and swapping branches.
+      #
+      # @example
+      #   # bad
+      #   if !x
+      #     do_something
+      #   else
+      #     do_something_else
+      #   end
+      #
+      #   # good
+      #   if x
+      #     do_something_else
+      #   else
+      #     do_something
+      #   end
+      #
+      #   # bad
+      #   !x ? do_something : do_something_else
+      #
+      #   # good
+      #   x ? do_something_else : do_something
+      #
+      class NegatedIfElseCondition < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Invert the negated condition and swap the %<type>s branches.'
+
+        NEGATED_EQUALITY_METHODS = %i[!= !~].freeze
+
+        def self.autocorrect_incompatible_with
+          [Style::InverseMethods, Style::Not]
+        end
+
+        def on_new_investigation
+          @corrected_nodes = nil
+        end
+
+        def on_if(node)
+          return unless if_else?(node)
+
+          condition = node.condition
+          return unless negated_condition?(condition)
+
+          type = node.ternary? ? 'ternary' : 'if-else'
+          add_offense(node, message: format(MSG, type: type)) do |corrector|
+            unless corrected_ancestor?(node)
+              correct_negated_condition(corrector, condition)
+              swap_branches(corrector, node)
+
+              @corrected_nodes ||= Set.new.compare_by_identity
+              @corrected_nodes.add(node)
+            end
+          end
+        end
+
+        private
+
+        def if_else?(node)
+          else_branch = node.else_branch
+          !node.elsif? && else_branch && (!else_branch.if_type? || !else_branch.elsif?)
+        end
+
+        def negated_condition?(node)
+          node.send_type? &&
+            (node.negation_method? || NEGATED_EQUALITY_METHODS.include?(node.method_name))
+        end
+
+        def corrected_ancestor?(node)
+          node.each_ancestor(:if).any? { |ancestor| @corrected_nodes&.include?(ancestor) }
+        end
+
+        def correct_negated_condition(corrector, node)
+          receiver, method_name, rhs = *node
+          replacement =
+            if node.negation_method?
+              receiver.source
+            else
+              inverted_method = method_name.to_s.sub('!', '=')
+              "#{receiver.source} #{inverted_method} #{rhs.source}"
+            end
+
+          corrector.replace(node, replacement)
+        end
+
+        def swap_branches(corrector, node)
+          if node.if_branch.nil?
+            corrector.remove(range_by_whole_lines(node.loc.else, include_final_newline: true))
+          else
+            corrector.replace(node.if_branch, node.else_branch.source)
+            corrector.replace(node.else_branch, node.if_branch.source)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for lambdas that always return nil, which can be replaced
+      # with an empty lambda instead.
+      #
+      # @example
+      #   # bad
+      #   -> { nil }
+      #
+      #   lambda do
+      #     next nil
+      #   end
+      #
+      #   # good
+      #   -> {}
+      #
+      #   lambda do
+      #   end
+      #
+      #   -> (x) { nil if x }
+      #
+      class NilLambda < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = 'Use an empty lambda instead of always returning nil.'
+
+        def_node_matcher :nil_return?, <<~PATTERN
+          { ({return next break} nil) (nil) }
+        PATTERN
+
+        def on_block(node)
+          return unless node.lambda?
+          return unless nil_return?(node.body)
+
+          add_offense(node) do |corrector|
+            range = if node.single_line?
+                      range_with_surrounding_space(range: node.body.loc.expression)
+                    else
+                      range_by_whole_lines(node.body.loc.expression, include_final_newline: true)
+                    end
+
+            corrector.remove(range)
+          end
+        end
+      end
+    end
+  end
+end