rubocop 0.45.0 → 0.46.0

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

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for the formatting of empty method definitions.
+      # By default it enforces empty method definitions to go on a single
+      # line (compact style), but it cah be configured to enforce the `end`
+      # to go on its own line (expanded style.)
+      #
+      # Note: A method definition is not considered empty if it contains
+      #       comments.
+      #
+      # @example
+      #
+      #   EnforcedStyle: compact (default)
+      #
+      #   @bad
+      #   def foo(bar)
+      #   end
+      #
+      #   @good
+      #   def foo(bar); end
+      #   def foo(bar)
+      #     # baz
+      #   end
+      #
+      #   EnforcedStyle: expanded
+      #
+      #   @bad
+      #   def foo(bar); end
+      #
+      #   @good
+      #   def foo(bar)
+      #   end
+      class EmptyMethod < Cop
+        include ConfigurableEnforcedStyle
+
+        MSG_COMPACT = 'Put empty method definitions on a single line.'.freeze
+        MSG_EXPANDED = 'Put the `end` of empty method definitions on the ' \
+                       'next line.'.freeze
+
+        def on_def(node)
+          _method_name, _args, body = *node
+
+          return if body || comment_lines?(node)
+          return if compact_style? && compact?(node)
+          return if expanded_style? && expanded?(node)
+
+          add_offense(node, node.source_range, message)
+        end
+
+        private
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.source_range, corrected(node))
+          end
+        end
+
+        def message
+          compact_style? ? MSG_COMPACT : MSG_EXPANDED
+        end
+
+        def corrected(node)
+          method_name, args, _body = *node
+
+          arguments = args.source unless args.children.empty?
+          joint = compact_style? ? '; ' : "\n"
+
+          ["def #{method_name}#{arguments}", 'end'].join(joint)
+        end
+
+        def comment_lines?(node)
+          processed_source[line_range(node)].any? { |line| comment_line?(line) }
+        end
+
+        def compact?(node)
+          node.single_line?
+        end
+
+        def expanded?(node)
+          node.multiline?
+        end
+
+        def compact_style?
+          style == :compact
+        end
+
+        def expanded_style?
+          style == :expanded
+        end
+      end
+    end
+  end
+end

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

@@ -16,71 +16,40 @@ module RuboCop
       class EvenOdd < Cop
         MSG = 'Replace with `Integer#%s?`.'.freeze
 
-        ZERO = s(:int, 0)
-        ONE = s(:int, 1)
-        TWO = s(:int, 2)
-
-        EQUALITY_OPERATORS = [:==, :!=].freeze
+        def_node_matcher :even_odd_candidate?, <<-PATTERN
+          (send
+            {(send $_ :% (int 2))
+             (begin (send $_ :% (int 2)))}
+            ${:== :!=}
+            (int ${0 1 2}))
+        PATTERN
 
         def on_send(node)
-          offense_type(node) do |replacement_method|
+          even_odd_candidate?(node) do |_base_number, method, arg|
+            replacement_method = replacement_method(arg, method)
             add_offense(node, :expression, format(MSG, replacement_method))
           end
         end
 
         def autocorrect(node)
-          offense_type(node) do |replacement_method|
-            correction = "#{base_number(node)}.#{replacement_method}?"
+          even_odd_candidate?(node) do |base_number, method, arg|
+            replacement_method = replacement_method(arg, method)
+
+            correction = "#{base_number.source}.#{replacement_method}?"
             ->(corrector) { corrector.replace(node.source_range, correction) }
           end
         end
 
         private
 
-        def base_number(node)
-          receiver, = *node
-          node = expression(receiver)
-          node.children.first.source
-        end
-
-        def offense_type(node)
-          receiver, method, args = *node
-
-          return unless equality_operator?(method)
-          return unless div_by_2?(receiver)
-
-          replacement_method(args, method) { |odd_or_even| yield odd_or_even }
-        end
-
-        def equality_operator?(method_name)
-          EQUALITY_OPERATORS.include?(method_name)
-        end
-
-        def div_by_2?(node)
-          node = expression(node)
-
-          _receiver, method, args = *node
-
-          method == :% && args == TWO
-        end
-
-        def replacement_method(args, method)
-          if args == ZERO
-            yield method == :== ? :even : :odd
-          elsif args == ONE
-            yield method == :== ? :odd : :even
+        def replacement_method(arg, method)
+          case arg
+          when 0
+            method == :== ? :even : :odd
+          when 1
+            method == :== ? :odd : :even
           end
         end
-
-        def expression(node)
-          return unless node
-
-          # check for scenarios like (x % 2) == 0
-          node = node.children.first if node.begin_type? && node.children.one?
-
-          return unless node.send_type?
-          node
-        end
       end
     end
   end

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

@@ -69,7 +69,10 @@ module RuboCop
         MSG_NO_MIXED_KEYS = "Don't mix styles in the same hash.".freeze
         MSG_HASH_ROCKETS = 'Use hash rockets syntax.'.freeze
 
-        @force_hash_rockets = false
+        def initialize(*)
+          @force_hash_rockets = false
+          super
+        end
 
         def on_hash(node)
           if cop_config['UseHashRocketsWithSymbolValues']

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

@@ -70,32 +70,22 @@ module RuboCop
           }
         }.freeze
 
-        TARGET = s(:send, nil, :lambda)
+        def_node_matcher :lambda_node?, '(block $(send nil :lambda) ...)'
 
         def on_block(node)
-          # We're looking for
-          # (block
-          #   (send nil :lambda)
-          #   ...)
-          block_method, _args, = *node
+          lambda_node?(node) do |block_method|
+            selector = block_method.source
 
-          return unless block_method == TARGET
+            return unless offending_selector?(node, selector)
 
-          check(node)
+            add_offense(node,
+                        block_method.source_range,
+                        message(node, selector))
+          end
         end
 
         private
 
-        def check(node)
-          block_method, _args, = *node
-
-          selector = block_method.source
-
-          return unless offending_selector?(node, selector)
-
-          add_offense(node, block_method.source_range, message(node, selector))
-        end
-
         def offending_selector?(node, selector)
           lines = node.multiline? ? :multiline : :single_line
 

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

@@ -27,13 +27,13 @@ module RuboCop
       class ModuleFunction < Cop
         include ConfigurableEnforcedStyle
 
-        MODULE_FUNCTION_MSG = 'Use `module_function` instead of `extend self`.'
-                              .freeze
-        EXTEND_SELF_MSG = 'Use `extend self` instead of `module_function`.'
-                          .freeze
+        MODULE_FUNCTION_MSG =
+          'Use `module_function` instead of `extend self`.'.freeze
+        EXTEND_SELF_MSG =
+          'Use `extend self` instead of `module_function`.'.freeze
 
-        MODULE_FUNCTION_NODE = s(:send, nil, :module_function)
-        EXTEND_SELF_NODE = s(:send, nil, :extend, s(:self))
+        def_node_matcher :module_function_node?, '(send nil :module_function)'
+        def_node_matcher :extend_self_node?, '(send nil :extend self)'
 
         def on_module(node)
           _name, body = *node
@@ -47,11 +47,14 @@ module RuboCop
         private
 
         def each_wrong_style(nodes)
-          nodes.each do |node|
-            if style == :module_function && node == EXTEND_SELF_NODE
-              yield node, MODULE_FUNCTION_MSG
-            elsif style == :extend_self && node == MODULE_FUNCTION_NODE
-              yield node, EXTEND_SELF_MSG
+          case style
+          when :module_function
+            nodes.each do |node|
+              yield node, MODULE_FUNCTION_MSG if extend_self_node?(node)
+            end
+          when :extend_self
+            nodes.each do |node|
+              yield node, EXTEND_SELF_MSG if module_function_node?(node)
             end
           end
         end

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

@@ -15,15 +15,12 @@ module RuboCop
       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, :selector)
+          end
         end
 
         private

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

@@ -27,36 +27,27 @@ module RuboCop
         include OnMethodDef
         include IfNode
 
-        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 not_equal_to_nil?(method, args)
+          if not_equal_to_nil?(node)
             add_offense(node, :selector)
           elsif include_semantic_changes? &&
-                (not_and_nil_check?(method, receiver) ||
-                 unless_and_nil_check?(node, method))
+                (not_and_nil_check?(node) || unless_and_nil_check?(node))
             add_offense(node, :expression)
           end
         end
 
         private
 
-        def not_equal_to_nil?(method, args)
-          method == :!= && args == NIL_NODE
-        end
-
-        def not_and_nil_check?(method, receiver)
-          method == :! && nil_check?(receiver)
-        end
-
-        def unless_and_nil_check?(send_node, method)
-          return unless method == :nil?
-
+        def unless_and_nil_check?(send_node)
           parent = send_node.parent
-          parent && parent.if_type? && !ternary?(parent) &&
+          nil_check?(send_node) && unless_check?(parent) && !ternary?(parent) &&
             parent.loc.keyword.is?('unless')
         end
 
@@ -84,21 +75,15 @@ module RuboCop
           end
         end
 
-        def nil_check?(node)
-          return false unless node && node.send_type?
-
-          _receiver, method, *_args = *node
-          method == :nil?
-        end
-
         def autocorrect(node)
           receiver, method, _args = *node
 
-          if method == :!=
+          case method
+          when :!=
             autocorrect_comparison(node)
-          elsif method == :!
+          when :!
             autocorrect_non_nil(node, receiver)
-          elsif method == :nil?
+          when :nil?
             autocorrect_unless_nil(node, receiver)
           end
         end
@@ -106,18 +91,15 @@ module RuboCop
         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)

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

@@ -3,11 +3,15 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for usage 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.
       #
+      # 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)
@@ -15,14 +19,12 @@ module RuboCop
       #   # bad
       #
       #   foo == 0
-      #   0 != bar.baz
       #   0 > foo
       #   bar.baz > 0
       #
       #   # good
       #
       #   foo.zero?
-      #   bar.baz.nonzero?
       #   foo.negative?
       #   bar.baz.positive?
       #
@@ -33,14 +35,12 @@ module RuboCop
       #   # 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
@@ -50,7 +50,6 @@ module RuboCop
 
         REPLACEMENTS = {
           'zero?' => '==',
-          'nonzero?' => '!=',
           'positive?' => '>',
           'negative?' => '<'
         }.freeze
@@ -125,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 $(...) ${:== :> :<} (int 0))
         PATTERN
 
         def_node_matcher :inverted_comparison, <<-PATTERN
-          (send (int 0) ${:== :!= :> :<} $(...))
+          (send (int 0) ${:== :> :<} $(...))
         PATTERN
       end
     end