rubocop 1.8.0 → 1.11.0

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

@@ -19,6 +19,7 @@ module RuboCop
               ' rather than just a message.'
         RESTRICT_ON_SEND = %i[raise fail].freeze
 
+        # @!method implicit_runtime_error_raise_or_fail(node)
         def_node_matcher :implicit_runtime_error_raise_or_fail,
                          '(send nil? ${:raise :fail} {str dstr})'
 

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

@@ -48,6 +48,7 @@ module RuboCop
           [Style::Not, Style::SymbolProc]
         end
 
+        # @!method inverse_candidate?(node)
         def_node_matcher :inverse_candidate?, <<~PATTERN
           {
             (send $(send $(...) $_ $...) :!)
@@ -56,6 +57,7 @@ module RuboCop
           }
         PATTERN
 
+        # @!method inverse_block?(node)
         def_node_matcher :inverse_block?, <<~PATTERN
           (block $(send (...) $_) ... { $(send ... :!)
                                         $(send (...) {:!= :!~} ...)

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

@@ -34,6 +34,7 @@ module RuboCop
 
         private
 
+        # @!method min_max_candidate(node)
         def_node_matcher :min_max_candidate, <<~PATTERN
           ({array return} (send [$_receiver !nil?] :min) (send [$_receiver !nil?] :max))
         PATTERN

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

@@ -45,11 +45,13 @@ module RuboCop
               'or `module`.'
         RESTRICT_ON_SEND = %i[include extend prepend].freeze
 
+        # @!method include_statement(node)
         def_node_matcher :include_statement, <<~PATTERN
           (send nil? ${:include :extend :prepend}
             const)
         PATTERN
 
+        # @!method in_top_level_scope?(node)
         def_node_matcher :in_top_level_scope?, <<~PATTERN
           {
             root?                        # either at the top level

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

@@ -82,8 +82,13 @@ module RuboCop
         FORBIDDEN_MSG =
           'Do not use `module_function` or `extend self`.'
 
+        # @!method module_function_node?(node)
         def_node_matcher :module_function_node?, '(send nil? :module_function)'
+
+        # @!method extend_self_node?(node)
         def_node_matcher :extend_self_node?, '(send nil? :extend self)'
+
+        # @!method private_directive?(node)
         def_node_matcher :private_directive?, '(send nil? :private ...)'
 
         def on_module(node)

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

@@ -47,11 +47,12 @@ module RuboCop
           'in a conditional, use `Array#include?` instead.'
 
         def on_new_investigation
-          @compared_elements = []
-          @allowed_method_comparison = false
+          @last_comparison = nil
         end
 
         def on_or(node)
+          reset_comparison if switch_comparison?(node)
+
           root_of_or_node = root_of_or_node(node)
 
           return unless node == root_of_or_node
@@ -64,14 +65,21 @@ module RuboCop
 
             corrector.replace(node, prefer_method)
           end
+
+          @last_comparison = node
         end
 
         private
 
+        # @!method simple_double_comparison?(node)
         def_node_matcher :simple_double_comparison?, '(send $lvar :== $lvar)'
+
+        # @!method simple_comparison_lhs?(node)
         def_node_matcher :simple_comparison_lhs?, <<~PATTERN
           (send $lvar :== $_)
         PATTERN
+
+        # @!method simple_comparison_rhs?(node)
         def_node_matcher :simple_comparison_rhs?, <<~PATTERN
           (send $_ :== $lvar)
         PATTERN
@@ -131,6 +139,17 @@ module RuboCop
           end
         end
 
+        def switch_comparison?(node)
+          return true if @last_comparison.nil?
+
+          @last_comparison.descendants.none? { |descendant| descendant == node }
+        end
+
+        def reset_comparison
+          @compared_elements = []
+          @allowed_method_comparison = false
+        end
+
         def allow_method_comparison?
           cop_config.fetch('AllowMethodComparison', true)
         end

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

@@ -154,12 +154,14 @@ module RuboCop
           end
         end
 
+        # @!method splat_value(node)
         def_node_matcher :splat_value, <<~PATTERN
           (array (splat $_))
         PATTERN
 
         # Some of these patterns may not actually return an immutable object,
         # but we want to consider them immutable for this cop.
+        # @!method operation_produces_immutable_object?(node)
         def_node_matcher :operation_produces_immutable_object?, <<~PATTERN
           {
             (const _ _)
@@ -176,6 +178,7 @@ module RuboCop
           }
         PATTERN
 
+        # @!method range_enclosed_in_parentheses?(node)
         def_node_matcher :range_enclosed_in_parentheses?, <<~PATTERN
           (begin ({irange erange} _ _))
         PATTERN

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

@@ -35,6 +35,7 @@ module RuboCop
 
         NEGATED_EQUALITY_METHODS = %i[!= !~].freeze
 
+        # @!method double_negation?(node)
         def_node_matcher :double_negation?, '(send (send _ :!) :!)'
 
         def self.autocorrect_incompatible_with

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

@@ -37,7 +37,10 @@ module RuboCop
 
         RESTRICT_ON_SEND = %i[== === nil?].freeze
 
+        # @!method nil_comparison?(node)
         def_node_matcher :nil_comparison?, '(send _ {:== :===} nil)'
+
+        # @!method nil_check?(node)
         def_node_matcher :nil_check?, '(send _ :nil?)'
 
         def on_send(node)
@@ -50,6 +53,9 @@ module RuboCop
                          end
 
               corrector.replace(node, new_code)
+
+              parent = node.parent
+              corrector.wrap(node, '(', ')') if parent.respond_to?(:method?) && parent.method?(:!)
             end
           end
         end

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

@@ -28,6 +28,7 @@ module RuboCop
 
         MSG = 'Use an empty lambda instead of always returning nil.'
 
+        # @!method nil_return?(node)
         def_node_matcher :nil_return?, <<~PATTERN
           { ({return next break} nil) (nil) }
         PATTERN

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

@@ -8,6 +8,9 @@ module RuboCop
       # With `IncludeSemanticChanges` set to `false` by default, this cop
       # does not report offenses for `!x.nil?` and does no changes that might
       # change behavior.
+      # Also `IncludeSemanticChanges` set to `false` with `EnforcedStyle: comparison` of
+      # `Style/NilComparison` cop, this cop does not report offenses for `x != nil` and
+      # does no changes to `!x.nil?` style.
       #
       # With `IncludeSemanticChanges` set to `true`, this cop reports offenses
       # for `!x.nil?` and autocorrects that and `x != nil` to solely `x`, which
@@ -41,19 +44,30 @@ module RuboCop
       class NonNilCheck < Base
         extend AutoCorrector
 
+        MSG_FOR_REPLACEMENT = 'Prefer `%<prefer>s` over `%<current>s`.'
+        MSG_FOR_REDUNDANCY = 'Explicit non-nil checks are usually redundant.'
+
         RESTRICT_ON_SEND = %i[!= nil? !].freeze
 
+        # @!method not_equal_to_nil?(node)
         def_node_matcher :not_equal_to_nil?, '(send _ :!= nil)'
+
+        # @!method unless_check?(node)
         def_node_matcher :unless_check?, '(if (send _ :nil?) ...)'
+
+        # @!method nil_check?(node)
         def_node_matcher :nil_check?, '(send _ :nil?)'
+
+        # @!method not_and_nil_check?(node)
         def_node_matcher :not_and_nil_check?, '(send (send _ :nil?) :!)'
 
         def on_send(node)
-          return if ignored_node?(node)
-          return unless (offense_node = find_offense_node(node))
+          return if ignored_node?(node) ||
+                    !include_semantic_changes? && nil_comparison_style == 'comparison'
+          return unless register_offense?(node)
 
           message = message(node)
-          add_offense(offense_node, message: message) do |corrector|
+          add_offense(node, message: message) do |corrector|
             autocorrect(corrector, node)
           end
         end
@@ -73,13 +87,9 @@ module RuboCop
 
         private
 
-        def find_offense_node(node)
-          if not_equal_to_nil?(node)
-            node.loc.selector
-          elsif include_semantic_changes? &&
-                (not_and_nil_check?(node) || unless_and_nil_check?(node))
-            node
-          end
+        def register_offense?(node)
+          not_equal_to_nil?(node) ||
+            include_semantic_changes? && (not_and_nil_check?(node) || unless_and_nil_check?(node))
         end
 
         def autocorrect(corrector, node)
@@ -101,10 +111,11 @@ module RuboCop
         end
 
         def message(node)
-          if node.method?(:!=)
-            'Prefer `!expression.nil?` over `expression != nil`.'
+          if node.method?(:!=) && !include_semantic_changes?
+            prefer = "!#{node.receiver.source}.nil?"
+            format(MSG_FOR_REPLACEMENT, prefer: prefer, current: node.source)
           else
-            'Explicit non-nil checks are usually redundant.'
+            MSG_FOR_REDUNDANCY
           end
         end
 
@@ -138,6 +149,12 @@ module RuboCop
           corrector.replace(node.parent.loc.keyword, 'if')
           corrector.replace(node, receiver.source)
         end
+
+        def nil_comparison_style
+          nil_comparison_conf = config.for_cop('Style/NilComparison')
+
+          nil_comparison_conf['Enabled'] && nil_comparison_conf['EnforcedStyle']
+        end
       end
     end
   end

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

@@ -28,10 +28,6 @@ module RuboCop
       #   10_000_00 # typical representation of $10,000 in cents
       #
       class NumericLiterals < Base
-        # The parameter is called MinDigits (meaning the minimum number of
-        # digits for which an offense can be registered), but essentially it's
-        # a Max parameter (the maximum number of something that's allowed).
-        include ConfigurableMax
         include IntegerNode
         extend AutoCorrector
 
@@ -39,6 +35,11 @@ module RuboCop
               'separate every 3 digits with them.'
         DELIMITER_REGEXP = /[eE.]/.freeze
 
+        # The parameter is called MinDigits (meaning the minimum number of
+        # digits for which an offense can be registered), but essentially it's
+        # a Max parameter (the maximum number of something that's allowed).
+        exclude_limit 'MinDigits'
+
         def on_int(node)
           check(node)
         end
@@ -49,10 +50,6 @@ module RuboCop
 
         private
 
-        def max_parameter_name
-          'MinDigits'
-        end
-
         def check(node)
           int = integer_part(node)
 
@@ -62,7 +59,7 @@ module RuboCop
 
           case int
           when /^\d+$/
-            return unless (self.max = int.size + 1)
+            return unless (self.min_digits = int.size + 1)
 
             register_offense(node)
           when /\d{4}/, short_group_regex

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

@@ -8,7 +8,7 @@ module RuboCop
       # These can be replaced by their respective predicate methods.
       # The cop can also be configured to do the reverse.
       #
-      # The cop disregards `#nonzero?` as it its value is truthy or falsey,
+      # The cop disregards `#nonzero?` as its value is truthy or falsey,
       # but not `true` and `false`, and thus not always interchangeable with
       # `!= 0`.
       #
@@ -115,14 +115,17 @@ module RuboCop
           end
         end
 
+        # @!method predicate(node)
         def_node_matcher :predicate, <<~PATTERN
           (send $(...) ${:zero? :positive? :negative?})
         PATTERN
 
+        # @!method comparison(node)
         def_node_matcher :comparison, <<~PATTERN
           (send [$(...) !gvar_type?] ${:== :> :<} (int 0))
         PATTERN
 
+        # @!method inverted_comparison(node)
         def_node_matcher :inverted_comparison, <<~PATTERN
           (send (int 0) ${:== :> :<} [$(...) !gvar_type?])
         PATTERN

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

@@ -22,6 +22,7 @@ module RuboCop
       class OptionHash < Base
         MSG = 'Prefer keyword arguments to options hashes.'
 
+        # @!method option_hash(node)
         def_node_matcher :option_hash, <<~PATTERN
           (args ... $(optarg [#suspicious_name? _] (hash)))
         PATTERN

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

@@ -31,6 +31,7 @@ module RuboCop
 
         MSG = 'Use the double pipe equals operator `||=` instead.'
 
+        # @!method ternary_assignment?(node)
         def_node_matcher :ternary_assignment?, <<~PATTERN
           ({lvasgn ivasgn cvasgn gvasgn} _var
             (if
@@ -39,6 +40,7 @@ module RuboCop
               $_))
         PATTERN
 
+        # @!method unless_assignment?(node)
         def_node_matcher :unless_assignment?, <<~PATTERN
           (if
             ({lvar ivar cvar gvar} _var) nil?

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

@@ -115,6 +115,7 @@ module RuboCop
           end
         end
 
+        # @!method implicit_self_getter?(node)
         def_node_matcher :implicit_self_getter?, '(send nil? $_)'
 
         # Helper class necessitated by silly design of TSort prior to Ruby 2.1
@@ -123,8 +124,13 @@ module RuboCop
           include TSort
           extend RuboCop::NodePattern::Macros
 
+          # @!method var_name(node)
           def_node_matcher :var_name, '{(casgn _ $_) (_ $_)}'
+
+          # @!method uses_var?(node)
           def_node_search :uses_var?, '{({lvar ivar cvar gvar} %) (const _ %)}'
+
+          # @!method matching_calls(node, receiver, method_name)
           def_node_search :matching_calls, '(send %1 %2 $...)'
 
           def initialize(assignments)

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

@@ -71,6 +71,7 @@ module RuboCop
 
         private
 
+        # @!method control_op_condition(node)
         def_node_matcher :control_op_condition, <<~PATTERN
           (begin $_ ...)
         PATTERN

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

@@ -18,6 +18,7 @@ module RuboCop
 
         MSG = 'Use `proc` instead of `Proc.new`.'
 
+        # @!method proc_new?(node)
         def_node_matcher :proc_new?,
                          '(block $(send (const {nil? cbase} :Proc) :new) ...)'
 

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

@@ -30,6 +30,7 @@ module RuboCop
           'integers with offsets.'
         RESTRICT_ON_SEND = %i[+ - succ pred next].freeze
 
+        # @!method integer_op_rand?(node)
         def_node_matcher :integer_op_rand?, <<~PATTERN
           (send
             int {:+ :-}
@@ -39,6 +40,7 @@ module RuboCop
               {int (irange int int) (erange int int)}))
         PATTERN
 
+        # @!method rand_op_integer?(node)
         def_node_matcher :rand_op_integer?, <<~PATTERN
           (send
             (send
@@ -49,6 +51,7 @@ module RuboCop
             int)
         PATTERN
 
+        # @!method rand_modified?(node)
         def_node_matcher :rand_modified?, <<~PATTERN
           (send
             (send
@@ -71,6 +74,7 @@ module RuboCop
 
         private
 
+        # @!method random_call(node)
         def_node_matcher :random_call, <<~PATTERN
           {(send (send $_ _ $_) ...)
            (send _ _ (send $_ _ $_))}
@@ -144,6 +148,7 @@ module RuboCop
           end
         end
 
+        # @!method to_int(node)
         def_node_matcher :to_int, <<~PATTERN
           (int $_)
         PATTERN