rubocop 0.51.0 → 0.87.0

data/lib/rubocop/cop/lint/redundant_with_index.rb

@@ -27,13 +27,15 @@ module RuboCop
       #   end
       #
       class RedundantWithIndex < Cop
-        MSG_EACH_WITH_INDEX = 'Use `each` instead of `each_with_index`.'.freeze
-        MSG_WITH_INDEX = 'Remove redundant `with_index`.'.freeze
+        include RangeHelp
 
-        def_node_matcher :redundant_with_index?, <<-PATTERN
+        MSG_EACH_WITH_INDEX = 'Use `each` instead of `each_with_index`.'
+        MSG_WITH_INDEX = 'Remove redundant `with_index`.'
+
+        def_node_matcher :redundant_with_index?, <<~PATTERN
           (block
             $(send
-              _ {:each_with_index :with_index})
+              _ {:each_with_index :with_index} ...)
             (args
               (arg _))
             ...)
@@ -48,10 +50,10 @@ module RuboCop
         def autocorrect(node)
           lambda do |corrector|
             redundant_with_index?(node) do |send|
-              if send.method_name == :each_with_index
+              if send.method?(:each_with_index)
                 corrector.replace(send.loc.selector, 'each')
               else
-                corrector.remove(send.loc.selector)
+                corrector.remove(with_index_range(send))
                 corrector.remove(send.loc.dot)
               end
             end
@@ -61,7 +63,7 @@ module RuboCop
         private
 
         def message(node)
-          if node.method_name == :each_with_index
+          if node.method?(:each_with_index)
             MSG_EACH_WITH_INDEX
           else
             MSG_WITH_INDEX
@@ -69,7 +71,10 @@ module RuboCop
         end
 
         def with_index_range(send)
-          range_between(send.loc.selector.begin_pos, send.loc.selector.end_pos)
+          range_between(
+            send.loc.selector.begin_pos,
+            send.loc.expression.end_pos
+          )
         end
       end
     end

data/lib/rubocop/cop/lint/redundant_with_object.rb

@@ -27,14 +27,16 @@ module RuboCop
       #   end
       #
       class RedundantWithObject < Cop
+        include RangeHelp
+
         MSG_EACH_WITH_OBJECT = 'Use `each` instead of `each_with_object`.'
-                               .freeze
-        MSG_WITH_OBJECT = 'Remove redundant `with_object`.'.freeze
 
-        def_node_matcher :redundant_with_object?, <<-PATTERN
+        MSG_WITH_OBJECT = 'Remove redundant `with_object`.'
+
+        def_node_matcher :redundant_with_object?, <<~PATTERN
           (block
             $(send _ {:each_with_object :with_object}
-              (_))
+              _)
             (args
               (arg _))
             ...)
@@ -49,7 +51,7 @@ module RuboCop
         def autocorrect(node)
           lambda do |corrector|
             redundant_with_object?(node) do |send|
-              if send.method_name == :each_with_object
+              if send.method?(:each_with_object)
                 corrector.replace(with_object_range(send), 'each')
               else
                 corrector.remove(with_object_range(send))
@@ -62,7 +64,7 @@ module RuboCop
         private
 
         def message(node)
-          if node.method_name == :each_with_object
+          if node.method?(:each_with_object)
             MSG_EACH_WITH_OBJECT
           else
             MSG_WITH_OBJECT
@@ -72,7 +74,7 @@ module RuboCop
         def with_object_range(send)
           range_between(
             send.loc.selector.begin_pos,
-            send.source.length
+            send.loc.expression.end_pos
           )
         end
       end

data/lib/rubocop/cop/lint/regexp_as_condition.rb

@@ -18,11 +18,17 @@ module RuboCop
       #   end
       class RegexpAsCondition < Cop
         MSG = 'Do not use regexp literal as a condition.' \
-              ' The regexp literal matches `$_` implicitly.'.freeze
+              ' The regexp literal matches `$_` implicitly.'
 
         def on_match_current_line(node)
           add_offense(node)
         end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node, "#{node.source} =~ $_")
+          end
+        end
       end
     end
   end

data/lib/rubocop/cop/lint/require_parentheses.rb

@@ -17,7 +17,7 @@ module RuboCop
       #   # bad
       #
       #   if day.is? :tuesday && month == :jan
-      #     ...
+      #     # ...
       #   end
       #
       # @example
@@ -25,9 +25,13 @@ module RuboCop
       #   # good
       #
       #   if day.is?(:tuesday) && month == :jan
+      #     # ...
+      #   end
       class RequireParentheses < Cop
+        include RangeHelp
+
         MSG = 'Use parentheses in the method call to avoid confusion about ' \
-              'precedence.'.freeze
+              'precedence.'
 
         def on_send(node)
           return if !node.arguments? || node.parenthesized?
@@ -38,6 +42,7 @@ module RuboCop
             check_predicate(node.last_argument, node)
           end
         end
+        alias on_csend on_send
 
         private
 

data/lib/rubocop/cop/lint/rescue_exception.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for *rescue* blocks targeting the Exception class.
+      # This cop checks for `rescue` blocks targeting the Exception class.
       #
       # @example
       #
@@ -26,10 +26,11 @@ module RuboCop
       #   end
       class RescueException < Cop
         MSG = 'Avoid rescuing the `Exception` class. ' \
-              'Perhaps you meant to rescue `StandardError`?'.freeze
+              'Perhaps you meant to rescue `StandardError`?'
 
         def on_resbody(node)
           return unless node.children.first
+
           rescue_args = node.children.first.children
           return unless rescue_args.any? { |a| targets_exception?(a) }
 

data/lib/rubocop/cop/lint/rescue_type.rb

@@ -37,13 +37,14 @@ module RuboCop
       class RescueType < Cop
         include RescueNode
 
-        MSG = 'Rescuing from `%s` will raise a `TypeError` instead of ' \
-              'catching the actual exception.'.freeze
+        MSG = 'Rescuing from `%<invalid_exceptions>s` will raise a ' \
+              '`TypeError` instead of catching the actual exception.'
         INVALID_TYPES = %i[array dstr float hash nil int str sym].freeze
 
         def on_resbody(node)
           rescued, _, _body = *node
           return if rescued.nil?
+
           exceptions = *rescued
           invalid_exceptions = invalid_exceptions(exceptions)
           return if invalid_exceptions.empty?
@@ -51,15 +52,16 @@ module RuboCop
           add_offense(
             node,
             location: node.loc.keyword.join(rescued.loc.expression),
-            message: format(MSG, invalid_exceptions.map(&:source).join(', '))
+            message: format(
+              MSG, invalid_exceptions: invalid_exceptions.map(&:source)
+                                                         .join(', ')
+            )
           )
         end
 
-        private
-
         def autocorrect(node)
           rescued, _, _body = *node
-          range = Parser::Source::Range.new(node.loc.expression,
+          range = Parser::Source::Range.new(node.loc.expression.source_buffer,
                                             node.loc.keyword.end_pos,
                                             rescued.loc.expression.end_pos)
 
@@ -68,6 +70,8 @@ module RuboCop
           end
         end
 
+        private
+
         def correction(*exceptions)
           correction = valid_exceptions(exceptions).map(&:source).join(', ')
           correction = " #{correction}" unless correction.empty?

data/lib/rubocop/cop/lint/return_in_void_context.rb

@@ -32,14 +32,14 @@ module RuboCop
       #     return
       #   end
       class ReturnInVoidContext < Cop
-        MSG = 'Do not return a value in `%s`.'.freeze
+        MSG = 'Do not return a value in `%<method>s`.'
 
         def on_return(return_node)
           return unless return_node.descendants.any?
 
           context_node = non_void_context(return_node)
 
-          return unless context_node && context_node.def_type?
+          return unless context_node&.def_type?
 
           method_name = method_name(context_node)
 
@@ -47,7 +47,7 @@ module RuboCop
 
           add_offense(return_node,
                       location: :keyword,
-                      message: format(message, method_name))
+                      message: format(message, method: method_name))
         end
 
         private

data/lib/rubocop/cop/lint/safe_navigation_chain.rb

@@ -4,8 +4,8 @@ module RuboCop
   module Cop
     module Lint
       # The safe navigation operator returns nil if the receiver is
-      # nil.  If you chain an ordinary method call after a safe
-      # navigation operator, it raises NoMethodError.  We should use a
+      # nil. If you chain an ordinary method call after a safe
+      # navigation operator, it raises NoMethodError. We should use a
       # safe navigation operator after a safe navigation operator.
       # This cop checks for the problem outlined above.
       #
@@ -24,45 +24,40 @@ module RuboCop
       #   x&.foo&.bar
       #   x&.foo || bar
       class SafeNavigationChain < Cop
-        extend TargetRubyVersion
+        include NilMethods
 
         MSG = 'Do not chain ordinary method call' \
-              ' after safe navigation operator.'.freeze
+              ' after safe navigation operator.'
 
-        def_node_matcher :bad_method?, <<-PATTERN
-          (send (csend ...) $_ ...)
+        def_node_matcher :bad_method?, <<~PATTERN
+          {
+            (send $(csend ...) $_ ...)
+            (send $({block numblock} (csend ...) ...) $_ ...)
+          }
         PATTERN
 
-        minimum_target_ruby_version 2.3
-
         def on_send(node)
-          bad_method?(node) do |method|
+          bad_method?(node) do |safe_nav, method|
             return if nil_methods.include?(method)
 
-            loc = node.loc.dot || :selector
-
-            add_offense(node, location: loc)
-          end
-        end
-
-        def autocorrect(node)
-          dot = node.loc.dot
-
-          return unless dot
-
-          lambda do |corrector|
-            corrector.insert_before(dot, '&')
+            method_chain = method_chain(node)
+            location =
+              Parser::Source::Range.new(node.source_range.source_buffer,
+                                        safe_nav.source_range.end_pos,
+                                        method_chain.source_range.end_pos)
+            add_offense(node, location: location)
           end
         end
 
         private
 
-        def nil_methods
-          nil.methods + whitelist
-        end
-
-        def whitelist
-          cop_config['Whitelist'].map(&:to_sym)
+        def method_chain(node)
+          chain = node
+          while chain.send_type?
+            chain = chain.parent if chain.parent&.call_type?
+            break # FIXME: Unconditional break. Why while "loop" then?
+          end
+          chain
         end
       end
     end

data/lib/rubocop/cop/lint/safe_navigation_consistency.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop check to make sure that if safe navigation is used for a method
+      # call in an `&&` or `||` condition that safe navigation is used for all
+      # method calls on that same object.
+      #
+      # @example
+      #   # bad
+      #   foo&.bar && foo.baz
+      #
+      #   # bad
+      #   foo.bar || foo&.baz
+      #
+      #   # bad
+      #   foo&.bar && (foobar.baz || foo.baz)
+      #
+      #   # good
+      #   foo.bar && foo.baz
+      #
+      #   # good
+      #   foo&.bar || foo&.baz
+      #
+      #   # good
+      #   foo&.bar && (foobar.baz || foo&.baz)
+      #
+      class SafeNavigationConsistency < Cop
+        include IgnoredNode
+        include NilMethods
+
+        MSG = 'Ensure that safe navigation is used consistently ' \
+          'inside of `&&` and `||`.'
+
+        def on_csend(node)
+          return unless node.parent&.operator_keyword?
+
+          check(node)
+        end
+
+        def check(node)
+          ancestor = top_conditional_ancestor(node)
+          conditions = ancestor.conditions
+          safe_nav_receiver = node.receiver
+
+          method_calls = conditions.select(&:send_type?)
+          unsafe_method_calls =
+            unsafe_method_calls(method_calls, safe_nav_receiver)
+
+          unsafe_method_calls.each do |unsafe_method_call|
+            location =
+              node.loc.expression.join(unsafe_method_call.loc.expression)
+            add_offense(unsafe_method_call,
+                        location: location)
+
+            ignore_node(unsafe_method_call)
+          end
+        end
+
+        def autocorrect(node)
+          return unless node.dot?
+
+          lambda do |corrector|
+            corrector.insert_before(node.loc.dot, '&')
+          end
+        end
+
+        private
+
+        def top_conditional_ancestor(node)
+          parent = node.parent
+          unless parent &&
+                 (parent.operator_keyword? ||
+                  (parent.begin_type? &&
+                   parent.parent &&
+                   parent.parent.operator_keyword?))
+            return node
+          end
+
+          top_conditional_ancestor(parent)
+        end
+
+        def unsafe_method_calls(method_calls, safe_nav_receiver)
+          method_calls.select do |method_call|
+            safe_nav_receiver == method_call.receiver &&
+              !nil_methods.include?(method_call.method_name) &&
+              !ignored_node?(method_call)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/safe_navigation_with_empty.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks to make sure safe navigation isn't used with `empty?` in
+      # a conditional.
+      #
+      # While the safe navigation operator is generally a good idea, when
+      # checking `foo&.empty?` in a conditional, `foo` being `nil` will actually
+      # do the opposite of what the author intends.
+      #
+      # @example
+      #   # bad
+      #   return if foo&.empty?
+      #   return unless foo&.empty?
+      #
+      #   # good
+      #   return if foo && foo.empty?
+      #   return unless foo && foo.empty?
+      #
+      class SafeNavigationWithEmpty < Cop
+        MSG = 'Avoid calling `empty?` with the safe navigation operator ' \
+          'in conditionals.'
+
+        def_node_matcher :safe_navigation_empty_in_conditional?, <<~PATTERN
+          (if (csend (send ...) :empty?) ...)
+        PATTERN
+
+        def on_if(node)
+          return unless safe_navigation_empty_in_conditional?(node)
+
+          add_offense(node.condition)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            receiver = node.receiver.source
+
+            corrector.replace(node, "#{receiver} && #{receiver}.#{node.method_name}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/script_permission.rb

@@ -5,14 +5,41 @@ module RuboCop
     module Lint
       # This cop checks if a file which has a shebang line as
       # its first line is granted execute permission.
+      #
+      # @example
+      #   # bad
+      #
+      #   # A file which has a shebang line as its first line is not
+      #   # granted execute permission.
+      #
+      #   #!/usr/bin/env ruby
+      #   puts 'hello, world'
+      #
+      #   # good
+      #
+      #   # A file which has a shebang line as its first line is
+      #   # granted execute permission.
+      #
+      #   #!/usr/bin/env ruby
+      #   puts 'hello, world'
+      #
+      #   # good
+      #
+      #   # A file which has not a shebang line as its first line is not
+      #   # granted execute permission.
+      #
+      #   puts 'hello, world'
+      #
       class ScriptPermission < Cop
-        MSG = "Script file %s doesn't have execute permission.".freeze
-        SHEBANG = '#!'.freeze
+        MSG = "Script file %<file>s doesn't have execute permission."
+        SHEBANG = '#!'
 
         def investigate(processed_source)
+          return if @options.key?(:stdin)
           return if Platform.windows?
-          return unless start_with_shebang?(processed_source)
+          return unless processed_source.start_with?(SHEBANG)
           return if executable?(processed_source)
+
           comment = processed_source.comments[0]
           message = format_message_from(processed_source)
           add_offense(comment, message: message)
@@ -26,21 +53,16 @@ module RuboCop
 
         private
 
-        def start_with_shebang?(processed_source)
-          return false if processed_source[0].nil?
-          processed_source[0].start_with?(SHEBANG)
-        end
-
         def executable?(processed_source)
           # Returns true if stat is executable or if the operating system
           # doesn't distinguish executable files from nonexecutable files.
           # See at: https://github.com/ruby/ruby/blob/ruby_2_4/file.c#L5362
-          File.stat(processed_source.buffer.name).executable?
+          File.stat(processed_source.file_path).executable?
         end
 
         def format_message_from(processed_source)
-          basename = File.basename(processed_source.buffer.name)
-          format(MSG, basename)
+          basename = File.basename(processed_source.file_path)
+          format(MSG, file: basename)
         end
       end
     end

data/lib/rubocop/cop/lint/send_with_mixin_argument.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      #
+      # This cop checks for `send`, `public_send`, and `__send__` methods
+      # when using mix-in.
+      #
+      # `include` and `prepend` methods were private methods until Ruby 2.0,
+      # they were mixed-in via `send` method. This cop uses Ruby 2.1 or
+      # higher style that can be called by public methods.
+      # And `extend` method that was originally a public method is also targeted
+      # for style unification.
+      #
+      # @example
+      #   # bad
+      #   Foo.send(:include, Bar)
+      #   Foo.send(:prepend, Bar)
+      #   Foo.send(:extend, Bar)
+      #
+      #   # bad
+      #   Foo.public_send(:include, Bar)
+      #   Foo.public_send(:prepend, Bar)
+      #   Foo.public_send(:extend, Bar)
+      #
+      #   # bad
+      #   Foo.__send__(:include, Bar)
+      #   Foo.__send__(:prepend, Bar)
+      #   Foo.__send__(:extend, Bar)
+      #
+      #   # good
+      #   Foo.include Bar
+      #   Foo.prepend Bar
+      #   Foo.extend Bar
+      #
+      class SendWithMixinArgument < Cop
+        include RangeHelp
+
+        MSG = 'Use `%<method>s %<module_name>s` instead of `%<bad_method>s`.'
+        MIXIN_METHODS = %i[include prepend extend].freeze
+
+        def_node_matcher :send_with_mixin_argument?, <<~PATTERN
+          (send
+            (const _ _) {:send :public_send :__send__}
+            ({sym str} $#mixin_method?)
+              $(const _ _))
+        PATTERN
+
+        def on_send(node)
+          send_with_mixin_argument?(node) do |method, module_name|
+            message = message(
+              method, module_name.source, bad_location(node).source
+            )
+
+            add_offense(node, location: bad_location(node), message: message)
+          end
+        end
+
+        def autocorrect(node)
+          send_with_mixin_argument?(node) do |method, module_name|
+            lambda do |corrector|
+              corrector.replace(
+                bad_location(node), "#{method} #{module_name.source}"
+              )
+            end
+          end
+        end
+
+        private
+
+        def bad_location(node)
+          loc = node.loc
+
+          range_between(loc.selector.begin_pos, loc.expression.end_pos)
+        end
+
+        def message(method, module_name, bad_method)
+          format(
+            MSG,
+            method: method, module_name: module_name, bad_method: bad_method
+          )
+        end
+
+        def mixin_method?(node)
+          MIXIN_METHODS.include?(node.to_sym)
+        end
+      end
+    end
+  end
+end