rubbycop 0.49.0

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop checks for comparison of something with nil using ==.
+      #
+      # @example
+      #
+      #  # bad
+      #  if x == nil
+      #
+      #  # good
+      #  if x.nil?
+      class NilComparison < Cop
+        MSG = 'Prefer the use of the `nil?` predicate.'.freeze
+
+        def_node_matcher :nil_comparison?, '(send _ {:== :===} (:nil))'
+
+        def on_send(node)
+          nil_comparison?(node) do
+            add_offense(node, :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) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop checks for non-nil checks, which are usually redundant.
+      #
+      # @example
+      #
+      #  # bad
+      #  if x != nil
+      #
+      #  # good (when not allowing semantic changes)
+      #  # bad (when allowing semantic changes)
+      #  if !x.nil?
+      #
+      #  # good (when allowing semantic changes)
+      #  if x
+      #
+      # Non-nil checks are allowed if they are the final nodes of predicate.
+      #
+      #  # good
+      #  def signed_in?
+      #    !current_user.nil?
+      #  end
+      class NonNilCheck < Cop
+        include OnMethodDef
+
+        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)
+
+          if not_equal_to_nil?(node)
+            add_offense(node, :selector)
+          elsif include_semantic_changes? &&
+                (not_and_nil_check?(node) || unless_and_nil_check?(node))
+            add_offense(node, :expression)
+          end
+        end
+
+        private
+
+        def unless_and_nil_check?(send_node)
+          parent = send_node.parent
+
+          nil_check?(send_node) && unless_check?(parent) && !parent.ternary? &&
+            parent.unless?
+        end
+
+        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 on_method_def(_node, name, _args, body)
+          # only predicate methods are handled differently
+          return unless name.to_s.end_with?('?') && body
+
+          if body.begin_type?
+            ignore_node(body.children.last)
+          else
+            ignore_node(body)
+          end
+        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
+
+          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
+
+          ->(corrector) { corrector.replace(node.source_range, 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)
+            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
+end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop checks for uses if the keyword *not* instead of !.
+      class Not < Cop
+        MSG = 'Use `!` instead of `not`.'.freeze
+
+        OPPOSITE_METHODS = {
+          :== => :!=,
+          :!= => :==,
+          :<= => :>,
+          :> => :<=,
+          :< => :>=,
+          :>= => :<
+        }.freeze
+
+        def on_send(node)
+          return unless node.keyword_not?
+
+          add_offense(node, :selector)
+        end
+
+        private
+
+        def autocorrect(node)
+          range = range_with_surrounding_space(node.loc.selector, :right)
+
+          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
+
+        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.if_type? && child.ternary?
+        end
+
+        def correct_opposite_method(range, child)
+          lambda do |corrector|
+            corrector.remove(range)
+            corrector.replace(child.loc.selector,
+                              OPPOSITE_METHODS[child.method_name].to_s)
+          end
+        end
+
+        def correct_with_parens(range, node)
+          lambda do |corrector|
+            corrector.replace(range, '!(')
+            corrector.insert_after(node.source_range, ')')
+          end
+        end
+
+        def correct_without_parens(range)
+          ->(corrector) { corrector.replace(range, '!') }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # 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`
+      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_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
+
+        def on_int(node)
+          type = literal_type(node)
+          return unless type
+
+          msg = self.class.const_get("#{type.upcase}_MSG")
+          add_offense(node, :expression, msg)
+        end
+
+        private
+
+        def autocorrect(node)
+          lambda do |corrector|
+            type = literal_type(node)
+            corrector.replace(node.source_range,
+                              send(:"format_#{type}", node.source))
+          end
+        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?
+            :octal_zero_only
+          elsif literal =~ OCTAL_REGEX && !octal_zero_only?
+            :octal
+          end
+        end
+
+        def hex_bin_dec_literal_type(literal)
+          case literal
+          when HEX_REGEX
+            :hex
+          when BINARY_REGEX
+            :binary
+          when DECIMAL_REGEX
+            :decimal
+          end
+        end
+
+        def octal_zero_only?
+          cop_config['EnforcedOctalStyle'] == 'zero_only'
+        end
+
+        def format_octal(source)
+          source.sub(/^0O?/, '0o')
+        end
+
+        def format_octal_zero_only(source)
+          source.sub(/^0[Oo]?/, '0')
+        end
+
+        def format_hex(source)
+          source.sub(/^0X/, '0x')
+        end
+
+        def format_binary(source)
+          source.sub(/^0B/, '0b')
+        end
+
+        def format_decimal(source)
+          source.sub(/^0[dD]/, '')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    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
+        # a Max parameter (the maximum number of something that's allowed).
+        include ConfigurableMax
+        include IntegerNode
+
+        MSG = 'Use underscores(_) as decimal mark and ' \
+              'separate every 3 digits with them.'.freeze
+
+        def on_int(node)
+          check(node)
+        end
+
+        def on_float(node)
+          check(node)
+        end
+
+        private
+
+        def max_parameter_name
+          'MinDigits'
+        end
+
+        def check(node)
+          int = integer_part(node)
+
+          # TODO: handle non-decimal literals as well
+          return if int.start_with?('0')
+          return unless int.size >= min_digits
+
+          case int
+          when /^\d+$/
+            add_offense(node, :expression) { self.max = int.size + 1 }
+          when /\d{4}/, short_group_regex
+            add_offense(node, :expression) do
+              self.config_to_allow_offenses = { 'Enabled' => false }
+            end
+          end
+        end
+
+        def short_group_regex
+          cop_config['Strict'] ? /_\d{1,2}(_|$)/ : /_\d{1,2}_/
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.source_range, format_number(node))
+          end
+        end
+
+        def format_number(node)
+          int_part, float_part = node.source.split('.')
+          int_part = int_part.to_i
+          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
+        end
+
+        def min_digits
+          cop_config['MinDigits']
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # 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.
+      #
+      # The cop disregards `nonzero?` as it its value is truthy or falsey,
+      # but not `true` and `false`, and thus not always interchangeable with
+      # `!= 0`.
+      #
+      # @example
+      #
+      #   # EnforcedStyle: predicate (default)
+      #
+      #   # bad
+      #
+      #   foo == 0
+      #   0 > foo
+      #   bar.baz > 0
+      #
+      #   # good
+      #
+      #   foo.zero?
+      #   foo.negative?
+      #   bar.baz.positive?
+      #
+      # @example
+      #
+      #   # EnforcedStyle: comparison
+      #
+      #   # bad
+      #
+      #   foo.zero?
+      #   foo.negative?
+      #   bar.baz.positive?
+      #
+      #   # good
+      #
+      #   foo == 0
+      #   0 > foo
+      #   bar.baz > 0
+      class NumericPredicate < Cop
+        include ConfigurableEnforcedStyle
+
+        MSG = 'Use `%s` instead of `%s`.'.freeze
+
+        REPLACEMENTS = {
+          'zero?' => '==',
+          'positive?' => '>',
+          'negative?' => '<'
+        }.freeze
+
+        def on_send(node)
+          numeric, replacement = check(node)
+
+          return unless numeric
+
+          add_offense(node, node.loc.expression,
+                      format(MSG, replacement, node.source))
+        end
+
+        private
+
+        def check(node)
+          numeric, operator =
+            if style == :predicate
+              comparison(node) || inverted_comparison(node, &invert)
+            else
+              predicate(node)
+            end
+
+          return unless numeric && operator && replacement_supported?(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),
+             REPLACEMENTS.invert[operation.to_s]].join('.')
+          else
+            [numeric.source, REPLACEMENTS[operation.to_s], 0].join(' ')
+          end
+        end
+
+        def parenthesized_source(node)
+          if require_parentheses?(node)
+            "(#{node.source})"
+          else
+            node.source
+          end
+        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
+        end
+
+        def invert
+          lambda do |comparison, numeric|
+            comparison = { :> => :<, :< => :> }[comparison] || comparison
+
+            [numeric, comparison]
+          end
+        end
+
+        def_node_matcher :predicate, <<-PATTERN
+          (send $(...) ${:zero? :positive? :negative?})
+        PATTERN
+
+        def_node_matcher :comparison, <<-PATTERN
+          (send $(...) ${:== :> :<} (int 0))
+        PATTERN
+
+        def_node_matcher :inverted_comparison, <<-PATTERN
+          (send (int 0) ${:== :> :<} $(...))
+        PATTERN
+      end
+    end
+  end
+end