lib/rubocop/cop/style/raise_args.rb
# frozen_string_literal: true
module RuboCop
module Cop
module Style
# Checks the args passed to `fail` and `raise`. For exploded
# style (default), it recommends passing the exception class and message
# to `raise`, rather than construct an instance of the error. It will
# still allow passing just a message, or the construction of an error
# with more than one argument.
#
# The exploded style works identically, but with the addition that it
# will also suggest constructing error objects when the exception is
# passed multiple arguments.
#
# The exploded style has an `AllowedCompactTypes` configuration
# option that takes an Array of exception name Strings.
#
# @safety
# This cop is unsafe because `raise Foo` calls `Foo.exception`, not `Foo.new`.
#
# @example EnforcedStyle: exploded (default)
# # bad
# raise StandardError.new('message')
#
# # good
# raise StandardError, 'message'
# fail 'message'
# raise MyCustomError
# raise MyCustomError.new(arg1, arg2, arg3)
# raise MyKwArgError.new(key1: val1, key2: val2)
#
# # With `AllowedCompactTypes` set to ['MyWrappedError']
# raise MyWrappedError.new(obj)
# raise MyWrappedError.new(obj), 'message'
#
# @example EnforcedStyle: compact
# # bad
# raise StandardError, 'message'
# raise RuntimeError, arg1, arg2, arg3
#
# # good
# raise StandardError.new('message')
# raise MyCustomError
# raise MyCustomError.new(arg1, arg2, arg3)
# fail 'message'
class RaiseArgs < Base
include ConfigurableEnforcedStyle
extend AutoCorrector
EXPLODED_MSG = 'Provide an exception class and message as arguments to `%<method>s`.'
COMPACT_MSG = 'Provide an exception object as an argument to `%<method>s`.'
RESTRICT_ON_SEND = %i[raise fail].freeze
def on_send(node)
return unless node.command?(:raise) || node.command?(:fail)
case style
when :compact
check_compact(node)
when :exploded
check_exploded(node)
end
end
private
def correction_compact_to_exploded(node)
exception_node, _new, message_node = *node.first_argument
arguments = [exception_node, message_node].compact.map(&:source).join(', ')
if node.parent && requires_parens?(node.parent)
"#{node.method_name}(#{arguments})"
else
"#{node.method_name} #{arguments}"
end
end
def correction_exploded_to_compact(node)
exception_node, *message_nodes = *node.arguments
return if message_nodes.size > 1
argument = message_nodes.first.source
exception_class = exception_node.receiver&.source || exception_node.source
if node.parent && requires_parens?(node.parent)
"#{node.method_name}(#{exception_class}.new(#{argument}))"
else
"#{node.method_name} #{exception_class}.new(#{argument})"
end
end
def check_compact(node)
if node.arguments.size > 1
exception = node.first_argument
return if exception.send_type? && exception.first_argument&.hash_type?
add_offense(node, message: format(COMPACT_MSG, method: node.method_name)) do |corrector|
replacement = correction_exploded_to_compact(node)
corrector.replace(node, replacement)
opposite_style_detected
end
else
correct_style_detected
end
end
def check_exploded(node)
return correct_style_detected unless node.arguments.one?
first_arg = node.first_argument
return if !use_new_method?(first_arg) || acceptable_exploded_args?(first_arg.arguments)
return if allowed_non_exploded_type?(first_arg)
add_offense(node, message: format(EXPLODED_MSG, method: node.method_name)) do |corrector|
replacement = correction_compact_to_exploded(node)
corrector.replace(node, replacement)
opposite_style_detected
end
end
def use_new_method?(first_arg)
first_arg.send_type? && first_arg.receiver && first_arg.method?(:new)
end
def acceptable_exploded_args?(args)
# Allow code like `raise Ex.new(arg1, arg2)`.
return true if args.size > 1
# Disallow zero arguments.
return false if args.empty?
arg = args.first
# Allow code like `raise Ex.new(kw: arg)`.
# Allow code like `raise Ex.new(*args)`.
arg.hash_type? || arg.splat_type?
end
def allowed_non_exploded_type?(arg)
type = arg.receiver.const_name
Array(cop_config['AllowedCompactTypes']).include?(type)
end
def requires_parens?(parent)
parent.and_type? || parent.or_type? || (parent.if_type? && parent.ternary?)
end
end
end
end
end