rubocop 0.75.1

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for expressions where there is a call to a predicate
+      # method with at least one argument, where no parentheses are used around
+      # the parameter list, and a boolean operator, && or ||, is used in the
+      # last argument.
+      #
+      # The idea behind warning for these constructs is that the user might
+      # be under the impression that the return value from the method call is
+      # an operand of &&/||.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   if day.is? :tuesday && month == :jan
+      #     # ...
+      #   end
+      #
+      # @example
+      #
+      #   # 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.'
+
+        def on_send(node)
+          return if !node.arguments? || node.parenthesized?
+
+          if node.first_argument.if_type? && node.first_argument.ternary?
+            check_ternary(node.first_argument, node)
+          elsif node.predicate_method?
+            check_predicate(node.last_argument, node)
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        def check_ternary(ternary, node)
+          return unless ternary.condition.operator_keyword?
+
+          range = range_between(node.source_range.begin_pos,
+                                ternary.condition.source_range.end_pos)
+
+          add_offense(range, location: range)
+        end
+
+        def check_predicate(predicate, node)
+          return unless predicate.operator_keyword?
+
+          add_offense(node)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for *rescue* blocks targeting the Exception class.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   begin
+      #     do_something
+      #   rescue Exception
+      #     handle_exception
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   begin
+      #     do_something
+      #   rescue ArgumentError
+      #     handle_exception
+      #   end
+      class RescueException < Cop
+        MSG = 'Avoid rescuing the `Exception` class. ' \
+              '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) }
+
+          add_offense(node)
+        end
+
+        def targets_exception?(rescue_arg_node)
+          rescue_arg_node.const_name == 'Exception'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Check for arguments to `rescue` that will result in a `TypeError`
+      # if an exception is raised.
+      #
+      # @example
+      #   # bad
+      #   begin
+      #     bar
+      #   rescue nil
+      #     baz
+      #   end
+      #
+      #   # bad
+      #   def foo
+      #     bar
+      #   rescue 1, 'a', "#{b}", 0.0, [], {}
+      #     baz
+      #   end
+      #
+      #   # good
+      #   begin
+      #     bar
+      #   rescue
+      #     baz
+      #   end
+      #
+      #   # good
+      #   def foo
+      #     bar
+      #   rescue NameError
+      #     baz
+      #   end
+      class RescueType < Cop
+        include RescueNode
+
+        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?
+
+          add_offense(
+            node,
+            location: node.loc.keyword.join(rescued.loc.expression),
+            message: format(
+              MSG, invalid_exceptions: invalid_exceptions.map(&:source)
+                                                         .join(', ')
+            )
+          )
+        end
+
+        def autocorrect(node)
+          rescued, _, _body = *node
+          range = Parser::Source::Range.new(node.loc.expression.source_buffer,
+                                            node.loc.keyword.end_pos,
+                                            rescued.loc.expression.end_pos)
+
+          lambda do |corrector|
+            corrector.replace(range, correction(*rescued))
+          end
+        end
+
+        private
+
+        def correction(*exceptions)
+          correction = valid_exceptions(exceptions).map(&:source).join(', ')
+          correction = " #{correction}" unless correction.empty?
+
+          correction
+        end
+
+        def valid_exceptions(exceptions)
+          exceptions - invalid_exceptions(exceptions)
+        end
+
+        def invalid_exceptions(exceptions)
+          exceptions.select do |exception|
+            INVALID_TYPES.include?(exception.type)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for the use of a return with a value in a context
+      # where the value will be ignored. (initialize and setter methods)
+      #
+      # @example
+      #
+      #   # bad
+      #   def initialize
+      #     foo
+      #     return :qux if bar?
+      #     baz
+      #   end
+      #
+      #   def foo=(bar)
+      #     return 42
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #   def initialize
+      #     foo
+      #     return if bar?
+      #     baz
+      #   end
+      #
+      #   def foo=(bar)
+      #     return
+      #   end
+      class ReturnInVoidContext < Cop
+        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&.def_type?
+
+          method_name = method_name(context_node)
+
+          return unless method_name && void_context_method?(method_name)
+
+          add_offense(return_node,
+                      location: :keyword,
+                      message: format(message, method: method_name))
+        end
+
+        private
+
+        def non_void_context(return_node)
+          return_node.each_ancestor(:block, :def, :defs).first
+        end
+
+        def method_name(context_node)
+          context_node.children.first
+        end
+
+        def void_context_method?(method_name)
+          method_name == :initialize || setter_method?(method_name)
+        end
+
+        def setter_method?(method_name)
+          method_name.to_s.end_with?('=') &&
+            !AST::Node::COMPARISON_OPERATORS.include?(method_name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+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
+      # safe navigation operator after a safe navigation operator.
+      # This cop checks for the problem outlined above.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   x&.foo.bar
+      #   x&.foo + bar
+      #   x&.foo[bar]
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   x&.foo&.bar
+      #   x&.foo || bar
+      class SafeNavigationChain < Cop
+        include NilMethods
+
+        MSG = 'Do not chain ordinary method call' \
+              ' after safe navigation operator.'
+
+        def_node_matcher :bad_method?, <<~PATTERN
+          {
+            (send $(csend ...) $_ ...)
+            (send $(block (csend ...) ...) $_ ...)
+          }
+        PATTERN
+
+        def on_send(node)
+          bad_method?(node) do |safe_nav, method|
+            return if nil_methods.include?(method)
+
+            method_chain = method_chain(node)
+            location =
+              Parser::Source::Range.new(node.loc.expression.source_buffer,
+                                        safe_nav.loc.expression.end_pos,
+                                        method_chain.loc.expression.end_pos)
+            add_offense(node, location: location)
+          end
+        end
+
+        private
+
+        def method_chain(node)
+          chain = node
+          while chain.send_type?
+            chain = chain.parent if chain.parent &&
+                                    %i[send csend].include?(chain.parent.type)
+            break
+          end
+          chain
+        end
+      end
+    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,38 @@
+# 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)
+        end
+      end
+    end
+  end
+end