rubocop 1.1.0 → 1.4.1

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/method_call_with_args_parentheses/omit_parentheses.rb

@@ -74,7 +74,7 @@ module RuboCop
             parent &&
               (logical_operator?(parent) ||
               parent.send_type? &&
-              parent.arguments.any?(&method(:logical_operator?)))
+              parent.arguments.any? { |argument| logical_operator?(argument) })
           end
 
           def call_in_optional_arguments?(node)
@@ -110,7 +110,7 @@ module RuboCop
           def hash_literal_in_arguments?(node)
             node.arguments.any? do |n|
               hash_literal?(n) ||
-                n.send_type? && node.descendants.any?(&method(:hash_literal?))
+                n.send_type? && node.descendants.any? { |descendant| hash_literal?(descendant) }
             end
           end
 

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

@@ -48,6 +48,7 @@ module RuboCop
 
         def on_new_investigation
           @compared_elements = []
+          @allowed_method_comparison = false
         end
 
         def on_or(node)
@@ -55,6 +56,7 @@ module RuboCop
 
           return unless node == root_of_or_node
           return unless nested_variable_comparison?(root_of_or_node)
+          return if @allowed_method_comparison
 
           add_offense(node) do |corrector|
             elements = @compared_elements.join(', ')
@@ -95,8 +97,7 @@ module RuboCop
             return [variable_name(var1), variable_name(var2)]
           end
           if (var, obj = simple_comparison_lhs?(node)) || (obj, var = simple_comparison_rhs?(node))
-            return [] if allow_method_comparison? && obj.send_type?
-
+            @allowed_method_comparison = true if allow_method_comparison? && obj.send_type?
             @compared_elements << obj.source
             return [variable_name(var)]
           end

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

@@ -0,0 +1,106 @@
+# 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_node_matcher :double_negation?, '(send (send _ :!) :!)'
+
+        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 if double_negation?(condition) || !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

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

@@ -13,25 +13,32 @@ module RuboCop
       # will also suggest constructing error objects when the exception is
       # passed multiple arguments.
       #
+      # The exploded style has an `AllowedCompactTypes` configuration
+      # option that takes an Array of exception name Strings.
+      #
       # @example EnforcedStyle: exploded (default)
       #   # bad
-      #   raise StandardError.new("message")
+      #   raise StandardError.new('message')
       #
       #   # good
-      #   raise StandardError, "message"
-      #   fail "message"
+      #   raise StandardError, 'message'
+      #   fail 'message'
       #   raise MyCustomError.new(arg1, arg2, arg3)
       #   raise MyKwArgError.new(key1: val1, key2: val2)
       #
+      #   # With `AllowedCompactTypes` set to ['MyWrappedError']
+      #   raise MyWrappedError.new(obj)
+      #   raise MyWrappedError.new(obj), 'message'
+      #
       # @example EnforcedStyle: compact
       #   # bad
-      #   raise StandardError, "message"
+      #   raise StandardError, 'message'
       #   raise RuntimeError, arg1, arg2, arg3
       #
       #   # good
-      #   raise StandardError.new("message")
+      #   raise StandardError.new('message')
       #   raise MyCustomError.new(arg1, arg2, arg3)
-      #   fail "message"
+      #   fail 'message'
       class RaiseArgs < Base
         include ConfigurableEnforcedStyle
         extend AutoCorrector
@@ -102,6 +109,8 @@ module RuboCop
           return unless first_arg.send_type? && first_arg.method?(:new)
           return if acceptable_exploded_args?(first_arg.arguments)
 
+          return if allowed_non_exploded_type?(first_arg)
+
           add_offense(node, message: format(EXPLODED_MSG, method: node.method_name)) do |corrector|
             replacement = correction_compact_to_exploded(node)
 
@@ -123,6 +132,12 @@ module RuboCop
           arg.hash_type? || arg.splat_type?
         end
 
+        def allowed_non_exploded_type?(arg)
+          type = arg.receiver.const_name
+
+          Array(cop_config['AllowedCompactTypes']).include?(type)
+        end
+
         def requires_parens?(parent)
           parent.and_type? || parent.or_type? ||
             parent.if_type? && parent.ternary?

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'parser/current'
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for a redundant argument passed to certain methods.
+      #
+      # Limitations:
+      #
+      # 1. This cop matches for method names only and hence cannot tell apart
+      #    methods with same name in different classes.
+      # 2. This cop is limited to methods with single parameter.
+      # 3. This cop is unsafe if certain special global variables (e.g. `$;`) are set.
+      #    That depends on the nature of the target methods, of course.
+      #
+      # Method names and their redundant arguments can be configured like this:
+      #
+      # Methods:
+      #   join: ''
+      #   split: ' '
+      #   foo: 2
+      #
+      # @example
+      #   # bad
+      #   array.join('')
+      #   [1, 2, 3].join("")
+      #   string.split(" ")
+      #   "first\nsecond".split(" ")
+      #   A.foo(2)
+      #
+      #   # good
+      #   array.join
+      #   [1, 2, 3].join
+      #   string.split
+      #   "first second".split
+      #   A.foo
+      class RedundantArgument < Cop
+        MSG = 'Argument %<arg>s is redundant because it is implied by default.'
+
+        def on_send(node)
+          return unless redundant_argument?(node)
+
+          add_offense(node, message: format(MSG, arg: node.arguments.first.source))
+        end
+
+        private
+
+        def redundant_argument?(node)
+          redundant_argument = redundant_arg_for_method(node.method_name.to_s)
+          return false if redundant_argument.nil?
+
+          node.arguments.first == redundant_argument
+        end
+
+        def redundant_arg_for_method(method_name)
+          return nil unless cop_config['Methods'].key?(method_name)
+
+          @mem ||= {}
+          @mem[method_name] ||=
+            begin
+              arg = cop_config['Methods'].fetch(method_name)
+              buffer = Parser::Source::Buffer.new('(string)', 1)
+              buffer.source = arg.inspect
+              builder = RuboCop::AST::Builder.new
+              Parser::CurrentRuby.new(builder).parse(buffer)
+            end
+        end
+      end
+    end
+  end
+end