Ruby classes d'erreur personnalisées: l'héritage de l'attribut message

Compte tenu de ce que le rubis de la documentation de base de Exception, à partir de laquelle toutes les autres erreurs hériter, unis au sujet de #message

Retourne le résultat de l'appel d'exception.to_s. Normalement, ce qui renvoie
le message de l'exception ou de nom. En fournissant une to_str méthode,
les exceptions sont d'accord pour être utilisé là où les Chaînes sont attendus.

http://ruby-doc.org/core-1.9.3/Exception.html#method-i-message

J'opterais pour la redéfinition de to_s/to_str ou l'initialiseur. Voici un exemple où nous voulons savoir, principalement de l'homme lisible, quand un service n'a pas à faire quelque chose.

REMARQUE: La deuxième stratégie ci-dessous utilise les rails jolie chaîne de méthodes, telles que demodualize, qui peut être un peu compliqué, et donc potentiellement pas judicieux de faire une exception. Vous pouvez également ajouter d'autres arguments à la signature de la méthode, si vous avez besoin d'.

Primordial #to_s Stratégie pas #to_str, il fonctionne différemment

module ExternalService

  class FailedCRUDError < ::StandardError
    def to_s
      'failed to crud with external service'
    end
  end

  class FailedToCreateError < FailedCRUDError; end
  class FailedToReadError < FailedCRUDError; end
  class FailedToUpdateError < FailedCRUDError; end
  class FailedToDeleteError < FailedCRUDError; end
end

Sortie De La Console

begin; raise ExternalService::FailedToCreateError; rescue => e; e.message; end
# => "failed to crud with external service"

begin; raise ExternalService::FailedToCreateError, 'custom message'; rescue => e; e.message; end
# => "failed to crud with external service"

begin; raise ExternalService::FailedToCreateError.new('custom message'); rescue => e; e.message; end
# => "failed to crud with external service"

raise ExternalService::FailedToCreateError
# ExternalService::FailedToCreateError: failed to crud with external service

Primordial #initialiser Stratégie

C'est la stratégie la plus proche pour les implémentations je l'ai utilisé dans les rails. Comme indiqué ci-dessus, il utilise le demodualize, underscore, et humanize ActiveSupport méthodes. Mais cela pourrait facilement être retiré, comme dans la stratégie précédente.

module ExternalService
  class FailedCRUDError < ::StandardError
    def initialize(service_model=nil)
      super("#{self.class.name.demodulize.underscore.humanize} using #{service_model.class}")
    end
  end

  class FailedToCreateError < FailedCRUDError; end
  class FailedToReadError < FailedCRUDError; end
  class FailedToUpdateError < FailedCRUDError; end
  class FailedToDeleteError < FailedCRUDError; end
end

Sortie De La Console

begin; raise ExternalService::FailedToCreateError; rescue => e; e.message; end
# => "Failed to create error using NilClass"

begin; raise ExternalService::FailedToCreateError, Object.new; rescue => e; e.message; end
# => "Failed to create error using Object"

begin; raise ExternalService::FailedToCreateError.new(Object.new); rescue => e; e.message; end
# => "Failed to create error using Object"

raise ExternalService::FailedCRUDError
# ExternalService::FailedCRUDError: Failed crud error using NilClass

raise ExternalService::FailedCRUDError.new(Object.new)
# RuntimeError: ExternalService::FailedCRUDError using Object

De Démonstration De L'Outil De

C'est une démo pour montrer sauvetage et à la messagerie de ce qui précède la mise en œuvre. La classe de soulever les exceptions est un faux API pour Cloudinary. Juste dump l'une des stratégies ci-dessus dans votre console rails, suivie par les ce.

require 'rails' # only needed for second strategy 
module ExternalService
class FailedCRUDError < ::StandardError
def initialize(service_model=nil)
@service_model = service_model
super("#{self.class.name.demodulize.underscore.humanize} using #{@service_model.class}")
end
end
class FailedToCreateError < FailedCRUDError; end
class FailedToReadError < FailedCRUDError; end
class FailedToUpdateError < FailedCRUDError; end
class FailedToDeleteError < FailedCRUDError; end
end
# Stub service representing 3rd party cloud storage
class Cloudinary
def initialize(*error_args)
@error_args = error_args.flatten
end
def create_read_update_or_delete
begin
try_and_fail
rescue ExternalService::FailedCRUDError => e
e.message
end
end
private def try_and_fail
raise *@error_args
end
end
errors_map = [
# Without an arg
ExternalService::FailedCRUDError,
ExternalService::FailedToCreateError,
ExternalService::FailedToReadError,
ExternalService::FailedToUpdateError,
ExternalService::FailedToDeleteError,
# Instantiated without an arg
ExternalService::FailedCRUDError.new,
ExternalService::FailedToCreateError.new,
ExternalService::FailedToReadError.new,
ExternalService::FailedToUpdateError.new,
ExternalService::FailedToDeleteError.new,
# With an arg
[ExternalService::FailedCRUDError, Object.new],
[ExternalService::FailedToCreateError, Object.new],
[ExternalService::FailedToReadError, Object.new],
[ExternalService::FailedToUpdateError, Object.new],
[ExternalService::FailedToDeleteError, Object.new],
# Instantiated with an arg
ExternalService::FailedCRUDError.new(Object.new),
ExternalService::FailedToCreateError.new(Object.new),
ExternalService::FailedToReadError.new(Object.new),
ExternalService::FailedToUpdateError.new(Object.new),
ExternalService::FailedToDeleteError.new(Object.new),
].inject({}) do |errors, args|
begin 
errors.merge!( args => Cloudinary.new(args).create_read_update_or_delete)
rescue => e
binding.pry
end
end
if defined?(pp) || require('pp')
pp errors_map
else
errors_map.each{ |set| puts set.inspect }
end

Je voulais faire quelque chose de similaire. Je voulais passer un objet à #nouveauté et de l'ensemble de message basé sur un traitement de l'objet passé. Les œuvres suivantes.

class FooError < StandardError
attr_accessor :message # this is critical!
def initialize(stuff)
@message = stuff.reverse
end
end
begin
raise FooError.new("!dlroW olleH")
rescue FooError => e
puts e.message #=> Hello World!
end

Notez que si vous ne déclarez pas attr_accessor :message alors il ne fonctionnera pas. Abordant le cas des OP problème, vous pouvez aussi passer le message comme un argument supplémentaire et stocker tout ce que vous voulez. La partie cruciale semble être primordial #message.