rubocop 0.50.0 → 0.51.0

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

@@ -15,11 +15,11 @@ module RuboCop
       class NilComparison < Cop
         MSG = 'Prefer the use of the `nil?` predicate.'.freeze
 
-        def_node_matcher :nil_comparison?, '(send _ {:== :===} (:nil))'
+        def_node_matcher :nil_comparison?, '(send _ {:== :===} nil)'
 
         def on_send(node)
           nil_comparison?(node) do
-            add_offense(node, :selector)
+            add_offense(node, location: :selector)
           end
         end
 

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

@@ -24,7 +24,7 @@ module RuboCop
       #    !current_user.nil?
       #  end
       class NonNilCheck < Cop
-        def_node_matcher :not_equal_to_nil?, '(send _ :!= (: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?) :!)'
@@ -33,7 +33,7 @@ module RuboCop
           return if ignored_node?(node)
 
           if not_equal_to_nil?(node)
-            add_offense(node, :selector)
+            add_offense(node, location: :selector)
           elsif include_semantic_changes? &&
                 (not_and_nil_check?(node) || unless_and_nil_check?(node))
             add_offense(node)

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

@@ -19,7 +19,7 @@ module RuboCop
         def on_send(node)
           return unless node.keyword_not?
 
-          add_offense(node, :selector)
+          add_offense(node, location: :selector)
         end
 
         private

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

@@ -63,8 +63,8 @@ module RuboCop
 
           return unless numeric
 
-          add_offense(node, :expression,
-                      format(MSG, replacement, node.source))
+          add_offense(node,
+                      message: format(MSG, replacement, node.source))
         end
 
         private

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

@@ -35,17 +35,6 @@ module RuboCop
           add_offense(last_arg)
         end
 
-        def validate_config
-          return unless target_ruby_version < 2.0
-
-          raise ValidationError, 'The `Style/OptionHash` cop is only ' \
-                                'compatible with Ruby 2.0 and up, but the ' \
-                                'target Ruby version for your project is ' \
-                                "1.9.\nPlease disable this cop or adjust " \
-                                'the `TargetRubyVersion` parameter in your ' \
-                                'configuration.'
-        end
-
         private
 
         def suspicious_name?(arg_name)

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

@@ -39,7 +39,7 @@ module RuboCop
 
         def_node_matcher :unless_assignment?, <<-PATTERN
           (if
-            ({lvar ivar cvar gvar} _var) nil
+            ({lvar ivar cvar gvar} _var) nil?
             ({lvasgn ivasgn cvasgn gvasgn} _var
               _))
         PATTERN

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

@@ -115,7 +115,7 @@ module RuboCop
           end
         end
 
-        def_node_matcher :implicit_self_getter?, '(send nil $_)'
+        def_node_matcher :implicit_self_getter?, '(send nil? $_)'
 
         # Helper class necessitated by silly design of TSort prior to Ruby 2.1
         # Newer versions have a better API, but that doesn't help us

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

@@ -25,7 +25,7 @@ module RuboCop
           # i.e., if the string would become dynamic or has special characters.
           return if node.children != parse(corrected(node.source)).ast.children
 
-          add_offense(node, :begin)
+          add_offense(node, location: :begin)
         end
 
         def correct_literal_style?(node)

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

@@ -45,7 +45,7 @@ module RuboCop
           return unless node.arguments.one? &&
                         offending_selector?(node.method_name)
 
-          add_offense(node, :selector)
+          add_offense(node, location: :selector)
         end
 
         def autocorrect(node)

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

@@ -9,7 +9,7 @@ module RuboCop
         MSG = 'Use `proc` instead of `Proc.new`.'.freeze
 
         def_node_matcher :proc_new?,
-                         '(block $(send (const nil :Proc) :new) ...)'
+                         '(block $(send (const nil? :Proc) :new) ...)'
 
         def on_block(node)
           proc_new?(node) do |block_method|

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

@@ -30,7 +30,7 @@ module RuboCop
         def on_def(node)
           return unless node.body && node.body.kwbegin_type?
 
-          add_offense(node.body, :begin)
+          add_offense(node.body, location: :begin)
         end
         alias on_defs on_def
 

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

@@ -22,8 +22,8 @@ module RuboCop
                 'just the message.'.freeze
 
         def on_send(node)
-          exploded?(node) { return add_offense(node, :expression, MSG_1) }
-          compact?(node) { add_offense(node, :expression, MSG_2) }
+          exploded?(node) { return add_offense(node, message: MSG_1) }
+          compact?(node) { add_offense(node, message: MSG_2) }
         end
 
         # Switch `raise RuntimeError, 'message'` to `raise 'message'`, and
@@ -43,11 +43,11 @@ module RuboCop
         end
 
         def_node_matcher :exploded?, <<-PATTERN
-          (send nil ${:raise :fail} (const nil :RuntimeError) $_)
+          (send nil? ${:raise :fail} (const nil? :RuntimeError) $_)
         PATTERN
 
         def_node_matcher :compact?, <<-PATTERN
-          (send nil {:raise :fail} $(send (const nil :RuntimeError) :new $_))
+          (send nil? {:raise :fail} $(send (const nil? :RuntimeError) :new $_))
         PATTERN
       end
     end

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

@@ -110,7 +110,7 @@ module RuboCop
         end
 
         def offense(node, msg)
-          add_offense(node, :expression, "Don't use parentheses around #{msg}.")
+          add_offense(node, message: "Don't use parentheses around #{msg}.")
         end
 
         def keyword_ancestor?(node)

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

@@ -83,7 +83,7 @@ module RuboCop
           return if cop_config['AllowMultipleReturnValues'] &&
                     node.children.size > 1
 
-          add_offense(node, :keyword)
+          add_offense(node, location: :keyword)
         end
 
         def check_case_node(node)

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

@@ -47,13 +47,13 @@ module RuboCop
         def check_slash_literal(node)
           return if allowed_slash_literal?(node)
 
-          add_offense(node, :expression, MSG_USE_PERCENT_R)
+          add_offense(node, message: MSG_USE_PERCENT_R)
         end
 
         def check_percent_r_literal(node)
           return if allowed_percent_r_literal?(node)
 
-          add_offense(node, :expression, MSG_USE_SLASHES)
+          add_offense(node, message: MSG_USE_SLASHES)
         end
 
         def allowed_slash_literal?(node)

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

@@ -39,8 +39,7 @@ module RuboCop
         RETURN_NIL_MSG = 'Use `return nil` instead of `return`.'.freeze
 
         def_node_matcher :return_node?, '(return)'
-        # TODO: fix (return nil) on the NodePattern class
-        # def_node_matcher :return_nil_node?, '(return nil)'
+        def_node_matcher :return_nil_node?, '(return nil)'
 
         def on_return(node)
           # Check Lint/NonLocalExitFromIterator first before this cop
@@ -80,15 +79,11 @@ module RuboCop
             style == :return_nil && !return_node?(node)
         end
 
-        def return_nil_node?(node)
-          !node.children.empty? && node.children.first.nil_type?
-        end
-
         def scoped_node?(node)
           node.def_type? || node.defs_type? || node.lambda?
         end
 
-        def_node_matcher :chained_send?, '(send !nil ...)'
+        def_node_matcher :chained_send?, '(send !nil? ...)'
         def_node_matcher :define_method?, <<-PATTERN
           (send _ {:define_method :define_singleton_method} _)
         PATTERN

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

@@ -48,7 +48,7 @@ module RuboCop
 
         MSG = 'Use safe navigation (`&.`) instead of checking if an object ' \
               'exists before calling the method.'.freeze
-        NIL_METHODS = nil.methods.map(&:to_s).freeze
+        NIL_METHODS = nil.methods.freeze
 
         minimum_target_ruby_version 2.3
 
@@ -59,12 +59,12 @@ module RuboCop
             (if {
                   (send $_ {:nil? :!})
                   $_
-                } nil $_)
+                } nil? $_)
 
             (if {
                   (send (send $_ :nil?) :!)
                   $_
-                } $_ nil)
+                } $_ nil?)
           }
         PATTERN
 
@@ -119,14 +119,7 @@ module RuboCop
           checked_variable, receiver =
             modifier_if_safe_navigation_candidate?(node)
 
-          matching_receiver =
-            find_matching_receiver_invocation(receiver, checked_variable)
-
-          if matching_receiver
-            method = matching_receiver.parent.loc.selector.source
-          end
-
-          [checked_variable, matching_receiver, method]
+          extract_common_parts(receiver, checked_variable)
         end
 
         def extract_parts_from_and(node)
@@ -136,45 +129,49 @@ module RuboCop
               not_nil_check?(checked_variable) || checked_variable
           end
 
+          extract_common_parts(rhs, checked_variable)
+        end
+
+        def extract_common_parts(continuation, checked_variable)
           matching_receiver =
-            find_matching_receiver_invocation(rhs, checked_variable)
+            find_matching_receiver_invocation(continuation, checked_variable)
 
-          if matching_receiver
-            method = matching_receiver.parent.loc.selector.source
-          end
+          method = matching_receiver.parent if matching_receiver
 
           [checked_variable, matching_receiver, method]
         end
 
         def find_matching_receiver_invocation(node, checked_variable)
-          return nil if node.nil?
+          return nil unless node
 
-          if node.block_type?
-            method_call, = *node
-            receiver, _method = *method_call
-          elsif node.send_type?
-            receiver, _method = *node
-          end
+          receiver = if node.block_type?
+                       node.send_node.receiver
+                     else
+                       node.receiver
+                     end
 
           return receiver if receiver == checked_variable
 
           find_matching_receiver_invocation(receiver, checked_variable)
         end
 
-        def unsafe_method?(method)
-          NIL_METHODS.include?(method) || method !~ /\w+[=!?]?/
+        def unsafe_method?(send_node)
+          NIL_METHODS.include?(send_node.method_name) ||
+            negated?(send_node) || !send_node.dot?
+        end
+
+        def negated?(send_node)
+          send_node.parent.send_type? && send_node.parent.method?(:!)
         end
 
         def begin_range(node, method_call)
-          Parser::Source::Range.new(node.loc.expression.source_buffer,
-                                    node.loc.expression.begin_pos,
-                                    method_call.loc.expression.begin_pos)
+          range_between(node.loc.expression.begin_pos,
+                        method_call.loc.expression.begin_pos)
         end
 
         def end_range(node, method_call)
-          Parser::Source::Range.new(node.loc.expression,
-                                    method_call.loc.expression.end_pos,
-                                    node.loc.expression.end_pos)
+          range_between(method_call.loc.expression.end_pos,
+                        node.loc.expression.end_pos)
         end
       end
     end

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

@@ -52,7 +52,7 @@ module RuboCop
           target_node = s(var_type, var_name)
           return unless receiver == target_node
 
-          add_offense(node, :expression, format(MSG, method_name))
+          add_offense(node, message: format(MSG, method_name))
         end
 
         def check_boolean_node(node, rhs, var_name, var_type)
@@ -62,7 +62,7 @@ module RuboCop
           return unless first_operand == target_node
 
           operator = rhs.loc.operator.source
-          add_offense(node, :expression, format(MSG, operator))
+          add_offense(node, message: format(MSG, operator))
         end
 
         def autocorrect(node)

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

@@ -57,7 +57,7 @@ module RuboCop
           range = source_range(@processed_source.buffer, line, column)
           # Don't attempt to autocorrect if semicolon is separating statements
           # on the same line
-          add_offense(autocorrect ? range : nil, range)
+          add_offense(autocorrect ? range : nil, location: range)
         end
 
         def autocorrect(range)

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

@@ -13,7 +13,7 @@ module RuboCop
         def on_send(node)
           return unless sending?(node) && node.arguments?
 
-          add_offense(node, :selector)
+          add_offense(node, location: :selector)
         end
       end
     end

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

@@ -11,7 +11,7 @@ module RuboCop
         RAISE_MSG = 'Use `raise` instead of `fail` to ' \
                     'rethrow exceptions.'.freeze
 
-        def_node_matcher :kernel_call?, '(send (const nil :Kernel) %1 ...)'
+        def_node_matcher :kernel_call?, '(send (const nil? :Kernel) %1 ...)'
         def_node_search :custom_fail_methods,
                         '{(def :fail ...) (defs _ :fail ...)}'
 
@@ -77,7 +77,8 @@ module RuboCop
           each_command_or_kernel_call(method_name, node) do |send_node|
             next if ignored_node?(send_node)
 
-            add_offense(send_node, :selector, message(method_name))
+            add_offense(send_node,
+                        location: :selector, message: message(method_name))
             ignore_node(send_node)
           end
         end
@@ -85,7 +86,7 @@ module RuboCop
         def check_send(method_name, node)
           return unless node && command_or_kernel_call?(method_name, node)
 
-          add_offense(node, :selector, message(method_name))
+          add_offense(node, location: :selector, message: message(method_name))
         end
 
         def command_or_kernel_call?(name, node)

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop identifies places where `$stderr.puts`
+      # can be replaced by `warn`.
+      #
+      # @example
+      #   # bad
+      #   $stderr.puts('hello')
+      #
+      #   # good
+      #   warn('hello')
+      #
+      class StderrPuts < Cop
+        MSG = 'Use `warn` instead of `$stderr.puts`.'.freeze
+
+        def_node_matcher :stderr_puts?, <<-PATTERN
+          (send
+            (gvar #stderr_gvar?) :puts
+            ...)
+        PATTERN
+
+        def on_send(node)
+          return unless stderr_puts?(node)
+
+          add_offense(node, location: stderr_puts_range(node))
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(stderr_puts_range(node), 'warn')
+          end
+        end
+
+        private
+
+        def stderr_gvar?(sym)
+          sym == :$stderr
+        end
+
+        def stderr_puts_range(send)
+          range_between(
+            send.loc.expression.begin_pos,
+            send.loc.selector.end_pos
+          )
+        end
+      end
+    end
+  end
+end