rubocop 0.51.0 → 0.87.0

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

@@ -3,31 +3,71 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for comparison of something with nil using ==.
+      # This cop checks for comparison of something with nil using `==` and
+      # `nil?`.
       #
-      # @example
+      # Supported styles are: predicate, comparison.
       #
-      #  # bad
-      #  if x == nil
+      # @example EnforcedStyle: predicate (default)
+      #
+      #   # bad
+      #   if x == nil
+      #   end
+      #
+      #   # good
+      #   if x.nil?
+      #   end
+      #
+      # @example EnforcedStyle: comparison
+      #
+      #   # bad
+      #   if x.nil?
+      #   end
+      #
+      #   # good
+      #   if x == nil
+      #   end
       #
-      #  # good
-      #  if x.nil?
       class NilComparison < Cop
-        MSG = 'Prefer the use of the `nil?` predicate.'.freeze
+        include ConfigurableEnforcedStyle
+
+        PREDICATE_MSG = 'Prefer the use of the `nil?` predicate.'
+        EXPLICIT_MSG = 'Prefer the use of the `==` comparison.'
 
         def_node_matcher :nil_comparison?, '(send _ {:== :===} nil)'
+        def_node_matcher :nil_check?, '(send _ :nil?)'
 
         def on_send(node)
-          nil_comparison?(node) do
+          style_check?(node) do
             add_offense(node, location: :selector)
           end
         end
 
+        def autocorrect(node)
+          new_code = if prefer_comparison?
+                       node.source.sub('.nil?', ' == nil')
+                     else
+                       node.source.sub(/\s*={2,3}\s*nil/, '.nil?')
+                     end
+          ->(corrector) { corrector.replace(node, new_code) }
+        end
+
         private
 
-        def autocorrect(node)
-          new_code = node.source.sub(/\s*={2,3}\s*nil/, '.nil?')
-          ->(corrector) { corrector.replace(node.source_range, new_code) }
+        def message(_node)
+          prefer_comparison? ? EXPLICIT_MSG : PREDICATE_MSG
+        end
+
+        def style_check?(node, &block)
+          if prefer_comparison?
+            nil_check?(node, &block)
+          else
+            nil_comparison?(node, &block)
+          end
+        end
+
+        def prefer_comparison?
+          style == :comparison
         end
       end
     end

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

@@ -5,24 +5,39 @@ module RuboCop
     module Style
       # This cop checks for non-nil checks, which are usually redundant.
       #
+      # With `IncludeSemanticChanges` set to `false` by default, this cop
+      # does not report offenses for `!x.nil?` and does no changes that might
+      # change behavior.
+      #
+      # With `IncludeSemanticChanges` set to `true`, this cop reports offenses
+      # for `!x.nil?` and autocorrects that and `x != nil` to solely `x`, which
+      # is *usually* OK, but might change behavior.
+      #
       # @example
+      #   # bad
+      #   if x != nil
+      #   end
       #
-      #  # bad
-      #  if x != nil
+      #   # good
+      #   if x
+      #   end
       #
-      #  # good (when not allowing semantic changes)
-      #  # bad (when allowing semantic changes)
-      #  if !x.nil?
+      #   # Non-nil checks are allowed if they are the final nodes of predicate.
+      #   # good
+      #   def signed_in?
+      #     !current_user.nil?
+      #   end
       #
-      #  # good (when allowing semantic changes)
-      #  if x
+      # @example IncludeSemanticChanges: false (default)
+      #   # good
+      #   if !x.nil?
+      #   end
       #
-      # Non-nil checks are allowed if they are the final nodes of predicate.
+      # @example IncludeSemanticChanges: true
+      #   # bad
+      #   if !x.nil?
+      #   end
       #
-      #  # good
-      #  def signed_in?
-      #    !current_user.nil?
-      #  end
       class NonNilCheck < Cop
         def_node_matcher :not_equal_to_nil?, '(send _ :!= nil)'
         def_node_matcher :unless_check?, '(if (send _ :nil?) ...)'
@@ -53,6 +68,17 @@ module RuboCop
         end
         alias on_defs on_def
 
+        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
+
         private
 
         def unless_and_nil_check?(send_node)
@@ -74,17 +100,6 @@ module RuboCop
           cop_config['IncludeSemanticChanges']
         end
 
-        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 autocorrect_comparison(node)
           expr = node.source
 
@@ -96,15 +111,15 @@ module RuboCop
 
           return if expr == new_code
 
-          ->(corrector) { corrector.replace(node.source_range, new_code) }
+          ->(corrector) { corrector.replace(node, new_code) }
         end
 
         def autocorrect_non_nil(node, inner_node)
           lambda do |corrector|
             if inner_node.receiver
-              corrector.replace(node.source_range, inner_node.receiver.source)
+              corrector.replace(node, inner_node.receiver.source)
             else
-              corrector.replace(node.source_range, 'self')
+              corrector.replace(node, 'self')
             end
           end
         end
@@ -112,7 +127,7 @@ module RuboCop
         def autocorrect_unless_nil(node, receiver)
           lambda do |corrector|
             corrector.replace(node.parent.loc.keyword, 'if')
-            corrector.replace(node.source_range, receiver.source)
+            corrector.replace(node, receiver.source)
           end
         end
       end

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

@@ -3,9 +3,20 @@
 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
-        MSG = 'Use `!` instead of `not`.'.freeze
+        include RangeHelp
+
+        MSG = 'Use `!` instead of `not`.'
 
         OPPOSITE_METHODS = {
           :== => :!=,
@@ -17,15 +28,14 @@ module RuboCop
         }.freeze
 
         def on_send(node)
-          return unless node.keyword_not?
+          return unless node.prefix_not?
 
           add_offense(node, location: :selector)
         end
 
-        private
-
         def autocorrect(node)
-          range = range_with_surrounding_space(node.loc.selector, :right)
+          range = range_with_surrounding_space(range: node.loc.selector,
+                                               side: :right)
 
           if opposite_method?(node.receiver)
             correct_opposite_method(range, node.receiver)
@@ -36,12 +46,15 @@ module RuboCop
           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? ||
+          child.and_type? || child.or_type? ||
+            child.send_type? && child.binary_operation? ||
             child.if_type? && child.ternary?
         end
 
@@ -56,7 +69,7 @@ module RuboCop
         def correct_with_parens(range, node)
           lambda do |corrector|
             corrector.replace(range, '!(')
-            corrector.insert_after(node.source_range, ')')
+            corrector.insert_after(node, ')')
           end
         end
 

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

@@ -3,27 +3,50 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for octal, hex, binary and decimal literals using
+      # This cop checks for octal, hex, binary, and decimal literals using
       # uppercase prefixes and corrects them to lowercase prefix
       # or no prefix (in case of decimals).
-      # eg. for octal use `0o` instead of `0` or `0O`.
       #
-      # Can be configured to use `0` only for octal literals using
-      # `EnforcedOctalStyle` => `zero_only`
+      # @example EnforcedOctalStyle: zero_with_o (default)
+      #   # bad - missing octal prefix
+      #   num = 01234
+      #
+      #   # bad - uppercase prefix
+      #   num = 0O1234
+      #   num = 0X12AB
+      #   num = 0B10101
+      #
+      #   # bad - redundant decimal prefix
+      #   num = 0D1234
+      #   num = 0d1234
+      #
+      #   # good
+      #   num = 0o1234
+      #   num = 0x12AB
+      #   num = 0b10101
+      #   num = 1234
+      #
+      # @example EnforcedOctalStyle: zero_only
+      #   # bad
+      #   num = 0o1234
+      #   num = 0O1234
+      #
+      #   # good
+      #   num = 01234
       class NumericLiteralPrefix < Cop
         include IntegerNode
 
-        OCTAL_ZERO_ONLY_REGEX = /^0[Oo][0-7]+$/
-        OCTAL_REGEX = /^0O?[0-7]+$/
-        HEX_REGEX = /^0X[0-9A-F]+$/
-        BINARY_REGEX = /^0B[01]+$/
-        DECIMAL_REGEX = /^0[dD][0-9]+$/
+        OCTAL_ZERO_ONLY_REGEX = /^0[Oo][0-7]+$/.freeze
+        OCTAL_REGEX = /^0O?[0-7]+$/.freeze
+        HEX_REGEX = /^0X[0-9A-F]+$/.freeze
+        BINARY_REGEX = /^0B[01]+$/.freeze
+        DECIMAL_REGEX = /^0[dD][0-9]+$/.freeze
 
-        OCTAL_ZERO_ONLY_MSG = 'Use 0 for octal literals.'.freeze
-        OCTAL_MSG = 'Use 0o for octal literals.'.freeze
-        HEX_MSG = 'Use 0x for hexadecimal literals.'.freeze
-        BINARY_MSG = 'Use 0b for binary literals.'.freeze
-        DECIMAL_MSG = 'Do not use prefixes for decimal literals.'.freeze
+        OCTAL_ZERO_ONLY_MSG = 'Use 0 for octal literals.'
+        OCTAL_MSG = 'Use 0o for octal literals.'
+        HEX_MSG = 'Use 0x for hexadecimal literals.'
+        BINARY_MSG = 'Use 0b for binary literals.'
+        DECIMAL_MSG = 'Do not use prefixes for decimal literals.'
 
         def on_int(node)
           type = literal_type(node)
@@ -33,20 +56,20 @@ module RuboCop
           add_offense(node)
         end
 
-        private
-
-        def message(node)
-          self.class.const_get("#{literal_type(node).upcase}_MSG")
-        end
-
         def autocorrect(node)
           lambda do |corrector|
             type = literal_type(node)
-            corrector.replace(node.source_range,
+            corrector.replace(node,
                               send(:"format_#{type}", node.source))
           end
         end
 
+        private
+
+        def message(node)
+          self.class.const_get("#{literal_type(node).upcase}_MSG")
+        end
+
         def literal_type(node)
           literal = integer_part(node)
 
@@ -54,9 +77,9 @@ module RuboCop
         end
 
         def octal_literal_type(literal)
-          if literal =~ OCTAL_ZERO_ONLY_REGEX && octal_zero_only?
+          if OCTAL_ZERO_ONLY_REGEX.match?(literal) && octal_zero_only?
             :octal_zero_only
-          elsif literal =~ OCTAL_REGEX && !octal_zero_only?
+          elsif OCTAL_REGEX.match?(literal) && !octal_zero_only?
             :octal
           end
         end

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

@@ -9,18 +9,22 @@ module RuboCop
       # @example
       #
       #   # bad
-      #
       #   1000000
       #   1_00_000
       #   1_0000
       #
       #   # good
-      #
       #   1_000_000
       #   1000
       #
-      #   # good unless Strict is set
+      # @example Strict: false (default)
+      #
+      #   # good
+      #   10_000_00 # typical representation of $10,000 in cents
+      #
+      # @example Strict: true
       #
+      #   # bad
       #   10_000_00 # typical representation of $10,000 in cents
       #
       class NumericLiterals < Cop
@@ -30,8 +34,9 @@ module RuboCop
         include ConfigurableMax
         include IntegerNode
 
-        MSG = 'Use underscores(_) as decimal mark and ' \
-              'separate every 3 digits with them.'.freeze
+        MSG = 'Use underscores(_) as thousands separator and ' \
+              'separate every 3 digits with them.'
+        DELIMITER_REGEXP = /[eE.]/.freeze
 
         def on_int(node)
           check(node)
@@ -41,6 +46,12 @@ module RuboCop
           check(node)
         end
 
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node, format_number(node))
+          end
+        end
+
         private
 
         def max_parameter_name
@@ -68,28 +79,30 @@ module RuboCop
           cop_config['Strict'] ? /_\d{1,2}(_|$)/ : /_\d{1,2}_/
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.source_range, format_number(node))
+        def format_number(node)
+          source = node.source.gsub(/\s+/, '')
+          int_part, additional_part = source.split(DELIMITER_REGEXP, 2)
+          formatted_int = format_int_part(int_part)
+          delimiter = source[DELIMITER_REGEXP]
+
+          if additional_part
+            formatted_int + delimiter + additional_part
+          else
+            formatted_int
           end
         end
 
-        def format_number(node)
-          int_part, float_part = node.source.split('.')
-          int_part = int_part.to_i
+        # @param int_part [String]
+        def format_int_part(int_part)
+          int_part = Integer(int_part)
           formatted_int = int_part
                           .abs
                           .to_s
                           .reverse
                           .gsub(/...(?=.)/, '\&_')
                           .reverse
-          formatted_int.insert(0, '-') if int_part < 0
-
-          if float_part
-            format('%s.%s', formatted_int, float_part)
-          else
-            formatted_int
-          end
+          formatted_int.insert(0, '-') if int_part.negative?
+          formatted_int
         end
 
         def min_digits

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

@@ -14,12 +14,9 @@ module RuboCop
       #
       # 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)
+      # not themselves `Integer` polymorphic.
       #
+      # @example EnforcedStyle: predicate (default)
       #   # bad
       #
       #   foo == 0
@@ -32,10 +29,7 @@ module RuboCop
       #   foo.negative?
       #   bar.baz.positive?
       #
-      # @example
-      #
-      #   # EnforcedStyle: comparison
-      #
+      # @example EnforcedStyle: comparison
       #   # bad
       #
       #   foo.zero?
@@ -49,8 +43,9 @@ module RuboCop
       #   bar.baz > 0
       class NumericPredicate < Cop
         include ConfigurableEnforcedStyle
+        include IgnoredMethods
 
-        MSG = 'Use `%s` instead of `%s`.'.freeze
+        MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
 
         REPLACEMENTS = {
           'zero?' => '==',
@@ -59,12 +54,27 @@ module RuboCop
         }.freeze
 
         def on_send(node)
+          return if ignored_method?(node.method_name) ||
+                    node.each_ancestor(:send, :block).any? do |ancestor|
+                      ignored_method?(ancestor.method_name)
+                    end
+
           numeric, replacement = check(node)
 
           return unless numeric
 
           add_offense(node,
-                      message: format(MSG, replacement, node.source))
+                      message: format(MSG,
+                                      prefer: replacement,
+                                      current: node.source))
+        end
+
+        def autocorrect(node)
+          _, replacement = check(node)
+
+          lambda do |corrector|
+            corrector.replace(node, replacement)
+          end
         end
 
         private
@@ -77,19 +87,11 @@ module RuboCop
               predicate(node)
             end
 
-          return unless numeric && operator && replacement_supported?(operator)
+          return unless numeric && operator
 
           [numeric, replacement(numeric, operator)]
         end
 
-        def autocorrect(node)
-          _, replacement = check(node)
-
-          lambda do |corrector|
-            corrector.replace(node.loc.expression, replacement)
-          end
-        end
-
         def replacement(numeric, operation)
           if style == :predicate
             [parenthesized_source(numeric),
@@ -108,15 +110,7 @@ module RuboCop
         end
 
         def require_parentheses?(node)
-          node.binary_operation? && node.source !~ /^\(.*\)$/
-        end
-
-        def replacement_supported?(operator)
-          if %i[> <].include?(operator)
-            target_ruby_version >= 2.3
-          else
-            true
-          end
+          node.send_type? && node.binary_operation? && !node.parenthesized?
         end
 
         def invert
@@ -127,15 +121,15 @@ module RuboCop
           end
         end
 
-        def_node_matcher :predicate, <<-PATTERN
+        def_node_matcher :predicate, <<~PATTERN
           (send $(...) ${:zero? :positive? :negative?})
         PATTERN
 
-        def_node_matcher :comparison, <<-PATTERN
+        def_node_matcher :comparison, <<~PATTERN
           (send [$(...) !gvar_type?] ${:== :> :<} (int 0))
         PATTERN
 
-        def_node_matcher :inverted_comparison, <<-PATTERN
+        def_node_matcher :inverted_comparison, <<~PATTERN
           (send (int 0) ${:== :> :<} [$(...) !gvar_type?])
         PATTERN
       end

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

@@ -5,11 +5,28 @@ module RuboCop
     module Style
       # TODO: Make configurable.
       # Checks for uses of if/then/else/end on a single line.
+      #
+      # @example
+      #   # bad
+      #   if foo then boo else doo end
+      #   unless foo then boo else goo end
+      #
+      #   # good
+      #   foo ? boo : doo
+      #   boo if foo
+      #   if foo then boo end
+      #
+      #   # good
+      #   if foo
+      #     boo
+      #   else
+      #     doo
+      #   end
       class OneLineConditional < Cop
         include OnNormalIfUnless
 
         MSG = 'Favor the ternary operator (`?:`) ' \
-              'over `%s/then/else/end` constructs.'.freeze
+              'over `%<keyword>s/then/else/end` constructs.'
 
         def on_normal_if_unless(node)
           return unless node.single_line? && node.else_branch
@@ -17,39 +34,39 @@ module RuboCop
           add_offense(node)
         end
 
-        private
-
         def autocorrect(node)
           lambda do |corrector|
-            corrector.replace(node.source_range, replacement(node))
+            corrector.replace(node, replacement(node))
           end
         end
 
+        private
+
         def message(node)
-          format(MSG, node.keyword)
+          format(MSG, keyword: node.keyword)
         end
 
         def replacement(node)
           return to_ternary(node) unless node.parent
 
-          if %i[and or].include?(node.parent.type)
-            return "(#{to_ternary(node)})"
-          end
+          return "(#{to_ternary(node)})" if %i[and or].include?(node.parent.type)
 
-          if node.parent.send_type? && operator?(node.parent.method_name)
-            return "(#{to_ternary(node)})"
-          end
+          return "(#{to_ternary(node)})" if node.parent.send_type? && node.parent.operator_method?
 
           to_ternary(node)
         end
 
         def to_ternary(node)
-          cond, body, else_clause = *node
-          "#{expr_replacement(cond)} ? #{expr_replacement(body)} : " \
-            "#{expr_replacement(else_clause)}"
+          condition, if_branch, else_branch = *node
+
+          "#{expr_replacement(condition)} ? " \
+            "#{expr_replacement(if_branch)} : " \
+            "#{expr_replacement(else_branch)}"
         end
 
         def expr_replacement(node)
+          return 'nil' if node.nil?
+
           requires_parentheses?(node) ? "(#{node.source})" : node.source
         end
 
@@ -63,16 +80,17 @@ module RuboCop
 
         def method_call_with_changed_precedence?(node)
           return false unless node.send_type? && node.arguments?
-          return false if parenthesized_call?(node)
+          return false if node.parenthesized_call?
 
-          !operator?(node.method_name)
+          !node.operator_method?
         end
 
         def keyword_with_changed_precedence?(node)
           return false unless node.keyword?
-          return true if node.keyword_not?
+          return true if node.respond_to?(:prefix_not?) && node.prefix_not?
 
-          !parenthesized_call?(node)
+          node.respond_to?(:arguments?) && node.arguments? &&
+            !node.parenthesized_call?
         end
       end
     end