Onde definir tipos de erro personalizados em Ruby e / ou Rails?

Existe uma prática recomendada para definir tipos de erro personalizados em uma biblioteca Ruby (gem) ou aplicativo Ruby on Rails? Especificamente:

1. Onde eles pertencem estruturalmente ao projeto? Um arquivo separado, alinhado com a definição de módulo / classe relevante, em outro lugar?
2. Existem quaisquer convenções que estabelecem quando para e quando para não criar um novo tipo de erro?

Bibliotecas diferentes têm maneiras diferentes de fazer as coisas, e eu não notei nenhum padrão real. Algumas bibliotecas sempre usam tipos de erro personalizados, enquanto outras não os usam; alguns têm todos os erros que estendem o StandardError enquanto outros têm hierarquias aninhadas; alguns são apenas definições de classe vazias, outros têm todo tipo de truques inteligentes.

Ah, e só porque sinto que chamar esses "tipos de erro" é meio ambíguo, o que quero dizer é o seguinte:

class AuthenticationError < StandardError; end
class InvalidUsername < AuthenticationError; end

Para gemas

Já vi muitas vezes que você define exceções dessa maneira:

gem_dir / lib / gem_name / exceptions.rb

e definido como:

module GemName

  class AuthenticationError < StandardError; end
  class InvalidUsername < AuthenticationError; end

end

um exemplo disso seria algo parecido com isto em enableparty

Para Ruby on Rails

Coloque-os na sua pasta lib / em um arquivo chamado exceptions.rb, que seria algo como isto:

module Exceptions
  class AuthenticationError < StandardError; end
  class InvalidUsername < AuthenticationError; end
end

e você usaria assim:

raise Exceptions::InvalidUsername

Eu acho que, para ter arquivos de origem coesos em seu projeto, você deve definir erros na classe em que os podem ser lançados e em nenhum outro lugar.

Alguma hierarquia pode ser útil - os namespaces são bons para manter seqüências redundantes de nomes de tipo - mas isso é mais uma questão de gosto - não há necessidade de exagerar, desde que você tenha pelo menos um tipo de exceção personalizado no aplicativo que você usa para diferenciar entre casos de exceção 'intencional' e 'acidental'.

nos trilhos você pode criar app/errorsdiretório

# app/errors/foo_error.rb
class FooError < StandardError; end

reinicie o spring / server e deve buscá-lo

Essa é uma pergunta antiga, mas eu gostaria de compartilhar como estou lidando com erros personalizados no Rails, incluindo anexar mensagens de erro, testes e como lidar com isso com ActiveRecordmodelos.

Criando erro personalizado

class MyClass
  # create a custome error
  class MissingRequirement < StandardError; end

  def my_instance_method
    raise MyClass::MissingRequirement, "My error msg" unless true   
  end
end

Teste (miniteste)

test "should raise MissingRequirement if ____ is missing"
  # should raise an error
  error = assert_raises(MyClass::MissingRequirement) {
    MyClass.new.my_instance_method
  }

  assert error.message = "My error msg"
end

Com o ActiveRecord

Eu acho que vale a pena notar que, se estiver trabalhando com um ActiveRecordmodelo, um padrão popular é adicionar um erro ao modelo, conforme descrito abaixo, para que suas validações falhem:

def MyModel < ActiveRecord::Base
  validate :code_does_not_contain_hyphens

  def code_does_not_contain_hyphens
    errors.add(:code, "cannot contain hyphens") if code.include?("-")
  end
end

Quando as validações são executadas, esse método retorna à ActiveRecord::RecordInvalidclasse de erro do ActiveRecord e causa falhas nas validações.

Espero que isto ajude!

Para garantir que o carregamento automático funcione conforme o esperado no Rails 4.1.10 para várias classes de erro personalizadas, você deve especificar arquivos separados para cada uma. Isso deve funcionar no desenvolvimento com seu recarregamento dinâmico.

É assim que eu configuro erros em um projeto recente:

No lib/app_name/error/base.rb

module AppName
    module Error
        class Base < StandardError; end
    end
end

e em erros personalizados subsequentes, como em lib/app_name/error/bad_stuff.rb

module AppName
    module Error
        class BadStuff < ::AppName::Error::Base; end
    end
end

Você poderá chamar seus erros por meio de:

 raise AppName::Error::BadStuff.new("Bad stuff just happened")