rubocop 0.42.0 → 0.52.1

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -8,27 +7,24 @@ module RuboCop
       #
       # @example
       #
-      #  # bad
-      #  if x == nil
+      #   # bad
+      #   if x == nil
+      #   end
       #
-      #  # good
-      #  if x.nil?
+      #   # good
+      #   if x.nil?
+      #   end
       class NilComparison < Cop
         MSG = 'Prefer the use of the `nil?` predicate.'.freeze
 
-        OPS = [:==, :===].freeze
-
-        NIL_NODE = s(:nil)
+        def_node_matcher :nil_comparison?, '(send _ {:== :===} nil)'
 
         def on_send(node)
-          _receiver, method, args = *node
-          return unless OPS.include?(method)
-
-          add_offense(node, :selector) if args == NIL_NODE
+          nil_comparison?(node) do
+            add_offense(node, location: :selector)
+          end
         end
 
-        private
-
         def autocorrect(node)
           new_code = node.source.sub(/\s*={2,3}\s*nil/, '.nil?')
           ->(corrector) { corrector.replace(node.source_range, new_code) }

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -8,109 +7,117 @@ module RuboCop
       #
       # @example
       #
-      #  # bad
-      #  if x != nil
+      #   # bad
+      #   if x != nil
+      #   end
       #
-      #  # good (when not allowing semantic changes)
-      #  # bad (when allowing semantic changes)
-      #  if !x.nil?
+      #   # good (when not allowing semantic changes)
+      #   # bad (when allowing semantic changes)
+      #   if !x.nil?
+      #   end
       #
-      #  # good (when allowing semantic changes)
-      #  if x
+      #   # good (when allowing semantic changes)
+      #   if x
+      #   end
       #
       # Non-nil checks are allowed if they are the final nodes of predicate.
       #
-      #  # good
-      #  def signed_in?
-      #    !current_user.nil?
-      #  end
+      #   # good
+      #   def signed_in?
+      #     !current_user.nil?
+      #   end
       class NonNilCheck < Cop
-        include OnMethodDef
-
-        NIL_NODE = s(:nil)
+        def_node_matcher :not_equal_to_nil?, '(send _ :!= nil)'
+        def_node_matcher :unless_check?, '(if (send _ :nil?) ...)'
+        def_node_matcher :nil_check?, '(send _ :nil?)'
+        def_node_matcher :not_and_nil_check?, '(send (send _ :nil?) :!)'
 
         def on_send(node)
           return if ignored_node?(node)
-          receiver, method, args = *node
 
-          if method == :!=
-            add_offense(node, :selector) if args == NIL_NODE
-          elsif method == :! && include_semantic_changes?
-            add_offense(node, :expression) if nil_check?(receiver)
+          if not_equal_to_nil?(node)
+            add_offense(node, location: :selector)
+          elsif include_semantic_changes? &&
+                (not_and_nil_check?(node) || unless_and_nil_check?(node))
+            add_offense(node)
           end
         end
 
-        private
+        def on_def(node)
+          body = node.body
 
-        def message(node)
-          _receiver, method, _args = *node
-          if method == :!=
-            'Prefer `!expression.nil?` over `expression != nil`.'
+          return unless node.predicate_method? && body
+
+          if body.begin_type?
+            ignore_node(body.children.last)
           else
-            'Explicit non-nil checks are usually redundant.'
+            ignore_node(body)
           end
         end
+        alias on_defs on_def
 
-        def include_semantic_changes?
-          cop_config['IncludeSemanticChanges']
-        end
-
-        def on_method_def(_node, name, _args, body)
-          # only predicate methods are handled differently
-          return unless name.to_s.end_with?('?')
-          return unless body
-
-          if body.type != :begin
-            ignore_node(body)
-          elsif body.type == :begin
-            ignore_node(body.children.last)
+        def autocorrect(node)
+          case node.method_name
+          when :!=
+            autocorrect_comparison(node)
+          when :!
+            autocorrect_non_nil(node, node.receiver)
+          when :nil?
+            autocorrect_unless_nil(node, node.receiver)
           end
         end
 
-        def nil_check?(node)
-          return false unless node && node.type == :send
+        private
 
-          _receiver, method, *_args = *node
-          method == :nil?
-        end
+        def unless_and_nil_check?(send_node)
+          parent = send_node.parent
 
-        def autocorrect(node)
-          receiver, method, _args = *node
+          nil_check?(send_node) && unless_check?(parent) && !parent.ternary? &&
+            parent.unless?
+        end
 
-          if method == :!=
-            autocorrect_comparison(node)
-          elsif method == :!
-            autocorrect_non_nil(node, receiver)
+        def message(node)
+          if node.method?(:!=)
+            'Prefer `!expression.nil?` over `expression != nil`.'
+          else
+            'Explicit non-nil checks are usually redundant.'
           end
         end
 
+        def include_semantic_changes?
+          cop_config['IncludeSemanticChanges']
+        end
+
         def autocorrect_comparison(node)
           expr = node.source
 
-          new_code =
-            if include_semantic_changes?
-              expr.sub(/\s*!=\s*nil/, '')
-            else
-              expr.sub(/^(\S*)\s*!=\s*nil/, '!\1.nil?')
-            end
+          new_code = if include_semantic_changes?
+                       expr.sub(/\s*!=\s*nil/, '')
+                     else
+                       expr.sub(/^(\S*)\s*!=\s*nil/, '!\1.nil?')
+                     end
 
           return if expr == new_code
 
-          lambda do |corrector|
-            corrector.replace(node.source_range, new_code)
-          end
+          ->(corrector) { corrector.replace(node.source_range, new_code) }
         end
 
         def autocorrect_non_nil(node, inner_node)
           lambda do |corrector|
-            receiver, _method, _args = *inner_node
-            if receiver
-              corrector.replace(node.source_range, receiver.source)
+            if inner_node.receiver
+              corrector.replace(node.source_range, inner_node.receiver.source)
             else
               corrector.replace(node.source_range, 'self')
             end
           end
         end
+
+        def autocorrect_unless_nil(node, receiver)
+          lambda do |corrector|
+            corrector.replace(node.parent.loc.keyword, 'if')
+            corrector.replace(node.source_range, receiver.source)
+          end
+        end
       end
     end
   end

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

@@ -1,13 +1,19 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Style
-      # This cop checks for uses if the keyword *not* instead of !.
+      # This cop checks for uses of the keyword `not` instead of `!`.
+      #
+      # @example
+      #
+      #   # bad - parentheses are required because of op precedence
+      #   x = (not something)
+      #
+      #   # good
+      #   x = !something
+      #
       class Not < Cop
-        include IfNode
-
         MSG = 'Use `!` instead of `not`.'.freeze
 
         OPPOSITE_METHODS = {
@@ -22,31 +28,31 @@ module RuboCop
         def on_send(node)
           return unless node.keyword_not?
 
-          add_offense(node, :selector)
+          add_offense(node, location: :selector)
         end
 
-        private
-
         def autocorrect(node)
-          range = range_with_surrounding_space(node.loc.selector, :right)
-          child = node.children.first
+          range = range_with_surrounding_space(range: node.loc.selector,
+                                               side: :right)
 
-          if opposite_method?(child)
-            correct_opposite_method(range, child)
-          elsif requires_parens?(child)
+          if opposite_method?(node.receiver)
+            correct_opposite_method(range, node.receiver)
+          elsif requires_parens?(node.receiver)
             correct_with_parens(range, node)
           else
             correct_without_parens(range)
           end
         end
 
+        private
+
         def opposite_method?(child)
           child.send_type? && OPPOSITE_METHODS.key?(child.method_name)
         end
 
         def requires_parens?(child)
           child.and_type? || child.or_type? || child.binary_operation? ||
-            ternary?(child)
+            child.if_type? && child.ternary?
         end
 
         def correct_opposite_method(range, child)

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -28,14 +27,12 @@ module RuboCop
 
         def on_int(node)
           type = literal_type(node)
+
           return unless type
 
-          msg = self.class.const_get("#{type.upcase}_MSG")
-          add_offense(node, :expression, msg)
+          add_offense(node)
         end
 
-        private
-
         def autocorrect(node)
           lambda do |corrector|
             type = literal_type(node)
@@ -44,15 +41,27 @@ module RuboCop
           end
         end
 
+        private
+
+        def message(node)
+          self.class.const_get("#{literal_type(node).upcase}_MSG")
+        end
+
         def literal_type(node)
           literal = integer_part(node)
 
+          octal_literal_type(literal) || hex_bin_dec_literal_type(literal)
+        end
+
+        def octal_literal_type(literal)
           if literal =~ OCTAL_ZERO_ONLY_REGEX && octal_zero_only?
-            return :octal_zero_only
+            :octal_zero_only
           elsif literal =~ OCTAL_REGEX && !octal_zero_only?
-            return :octal
+            :octal
           end
+        end
 
+        def hex_bin_dec_literal_type(literal)
           case literal
           when HEX_REGEX
             :hex

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -6,6 +5,24 @@ module RuboCop
     module Style
       # This cop checks for big numeric literals without _ between groups
       # of digits in them.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   1000000
+      #   1_00_000
+      #   1_0000
+      #
+      #   # good
+      #
+      #   1_000_000
+      #   1000
+      #
+      #   # good unless Strict is set
+      #
+      #   10_000_00 # typical representation of $10,000 in cents
+      #
       class NumericLiterals < Cop
         # The parameter is called MinDigits (meaning the minimum number of
         # digits for which an offense can be registered), but essentially it's
@@ -13,8 +30,8 @@ module RuboCop
         include ConfigurableMax
         include IntegerNode
 
-        MSG = 'Separate every 3 digits in the integer portion of a number ' \
-              'with underscores(_).'.freeze
+        MSG = 'Use underscores(_) as decimal mark and ' \
+              'separate every 3 digits with them.'.freeze
 
         def on_int(node)
           check(node)
@@ -24,9 +41,15 @@ module RuboCop
           check(node)
         end
 
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.source_range, format_number(node))
+          end
+        end
+
         private
 
-        def parameter_name
+        def max_parameter_name
           'MinDigits'
         end
 
@@ -39,18 +62,16 @@ module RuboCop
 
           case int
           when /^\d+$/
-            add_offense(node, :expression) { self.max = int.size + 1 }
-          when /\d{4}/, /_\d{1,2}_/
-            add_offense(node, :expression) do
+            add_offense(node) { self.max = int.size + 1 }
+          when /\d{4}/, short_group_regex
+            add_offense(node) do
               self.config_to_allow_offenses = { 'Enabled' => false }
             end
           end
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.source_range, format_number(node))
-          end
+        def short_group_regex
+          cop_config['Strict'] ? /_\d{1,2}(_|$)/ : /_\d{1,2}_/
         end
 
         def format_number(node)
@@ -65,7 +86,7 @@ module RuboCop
           formatted_int.insert(0, '-') if int_part < 0
 
           if float_part
-            format('%s.%s', formatted_int, float_part)
+            format('%<int>s.%<float>s', int: formatted_int, float: float_part)
           else
             formatted_int
           end

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

@@ -1,57 +1,53 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Style
-      # This cop checks for using of comparison operators (`==`, `!=`,
-      # `>`, `<`), to test numbers as zero, nonzero, positive, or negative.
+      # This cop checks for usage of comparison operators (`==`,
+      # `>`, `<`) to test numbers as zero, positive, or negative.
       # These can be replaced by their respective predicate methods.
       # The cop can also be configured to do the reverse.
       #
-      # @example
+      # The cop disregards `#nonzero?` as it its value is truthy or falsey,
+      # but not `true` and `false`, and thus not always interchangeable with
+      # `!= 0`.
       #
-      #   # EnforcedStyle: predicate (default)
+      # The cop ignores comparisons to global variables, since they are often
+      # populated with objects which can be compared with integers, but are
+      # not themselves `Interger` polymorphic.
       #
+      # @example EnforcedStyle: predicate (default)
       #   # bad
       #
       #   foo == 0
-      #   0 != bar.baz
       #   0 > foo
       #   bar.baz > 0
       #
       #   # good
       #
       #   foo.zero?
-      #   bar.baz.nonzero?
       #   foo.negative?
       #   bar.baz.positive?
       #
-      # @example
-      #
-      #   # EnforcedStyle: comparison
-      #
+      # @example EnforcedStyle: comparison
       #   # bad
       #
       #   foo.zero?
-      #   bar.baz.nonzero?
       #   foo.negative?
       #   bar.baz.positive?
       #
       #   # good
       #
       #   foo == 0
-      #   0 != bar.baz
       #   0 > foo
       #   bar.baz > 0
       class NumericPredicate < Cop
         include ConfigurableEnforcedStyle
 
-        MSG = 'Use `%s` instead of `%s`.'.freeze
+        MSG = 'Use `%<prefer>s` instead of `%<current>s`.'.freeze
 
         REPLACEMENTS = {
           'zero?' => '==',
-          'nonzero?' => '!=',
           'positive?' => '>',
           'negative?' => '<'
         }.freeze
@@ -59,9 +55,19 @@ module RuboCop
         def on_send(node)
           numeric, replacement = check(node)
 
-          if numeric
-            add_offense(node, node.loc.expression,
-                        format(MSG, replacement, node.source))
+          return unless numeric
+
+          add_offense(node,
+                      message: format(MSG,
+                                      prefer: replacement,
+                                      current: node.source))
+        end
+
+        def autocorrect(node)
+          _, replacement = check(node)
+
+          lambda do |corrector|
+            corrector.replace(node.loc.expression, replacement)
           end
         end
 
@@ -75,17 +81,9 @@ module RuboCop
               predicate(node)
             end
 
-          if numeric && operator && replacement_supported?(operator)
-            return numeric, replacement(numeric, operator)
-          end
-        end
+          return unless numeric && operator && replacement_supported?(operator)
 
-        def autocorrect(node)
-          _, replacement = check(node)
-
-          lambda do |corrector|
-            corrector.replace(node.loc.expression, replacement)
-          end
+          [numeric, replacement(numeric, operator)]
         end
 
         def replacement(numeric, operation)
@@ -110,7 +108,7 @@ module RuboCop
         end
 
         def replacement_supported?(operator)
-          if [:>, :<].include?(operator)
+          if %i[> <].include?(operator)
             target_ruby_version >= 2.3
           else
             true
@@ -126,15 +124,15 @@ module RuboCop
         end
 
         def_node_matcher :predicate, <<-PATTERN
-          (send $(...) ${:zero? :nonzero? :positive? :negative?})
+          (send $(...) ${:zero? :positive? :negative?})
         PATTERN
 
         def_node_matcher :comparison, <<-PATTERN
-          (send $(...) ${:== :!= :> :<} (int 0))
+          (send [$(...) !gvar_type?] ${:== :> :<} (int 0))
         PATTERN
 
         def_node_matcher :inverted_comparison, <<-PATTERN
-          (send (int 0) ${:== :!= :> :<} $(...))
+          (send (int 0) ${:== :> :<} [$(...) !gvar_type?])
         PATTERN
       end
     end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -10,15 +9,12 @@ module RuboCop
         include OnNormalIfUnless
 
         MSG = 'Favor the ternary operator (`?:`) ' \
-              'over `%s/then/else/end` constructs.'.freeze
+              'over `%<keyword>s/then/else/end` constructs.'.freeze
 
         def on_normal_if_unless(node)
-          exp = node.source
-          return if exp.include?("\n")
-          return unless node.loc.respond_to?(:else) && node.loc.else
-          condition = exp.include?('if') ? 'if' : 'unless'
+          return unless node.single_line? && node.else_branch
 
-          add_offense(node, :expression, format(MSG, condition))
+          add_offense(node)
         end
 
         def autocorrect(node)
@@ -27,21 +23,30 @@ module RuboCop
           end
         end
 
+        private
+
+        def message(node)
+          format(MSG, keyword: node.keyword)
+        end
+
         def replacement(node)
-          return ternary(node) unless node.parent
-          return "(#{ternary(node)})" if [:and, :or].include?(node.parent.type)
+          return to_ternary(node) unless node.parent
+
+          if %i[and or].include?(node.parent.type)
+            return "(#{to_ternary(node)})"
+          end
 
           if node.parent.send_type? && operator?(node.parent.method_name)
-            return "(#{ternary(node)})"
+            return "(#{to_ternary(node)})"
           end
 
-          ternary(node)
+          to_ternary(node)
         end
 
-        def ternary(node)
+        def to_ternary(node)
           cond, body, else_clause = *node
-          "#{expr_replacement(cond)} ? #{expr_replacement(body)} : " +
-            expr_replacement(else_clause)
+          "#{expr_replacement(cond)} ? #{expr_replacement(body)} : " \
+            "#{expr_replacement(else_clause)}"
         end
 
         def expr_replacement(node)
@@ -49,7 +54,7 @@ module RuboCop
         end
 
         def requires_parentheses?(node)
-          return true if [:and, :or, :if].include?(node.type)
+          return true if %i[and or if].include?(node.type)
           return true if node.assignment?
           return true if method_call_with_changed_precedence?(node)
 
@@ -57,8 +62,7 @@ module RuboCop
         end
 
         def method_call_with_changed_precedence?(node)
-          return false unless node.send_type?
-          return false if node.method_args.empty?
+          return false unless node.send_type? && node.arguments?
           return false if parenthesized_call?(node)
 
           !operator?(node.method_name)