Is there a way to rescue all exceptions under a certain namespace?
For example, I want to rescue all of the Errno::* exceptions (Errno::ECONNRESET, Errno::ETIMEDOUT). I can go ahead and list them all out on my exception line, but I was wondering if I can do something like.
begin # my code rescue Errno # handle exception end The above idea doesn't seem to work, thus is there something similar that can work?
All the Errno exceptions subclass SystemCallError:
Module
Errnois created dynamically to map these operating system errors to Ruby classes, with each error number generating its own subclass ofSystemCallError. As the subclass is created in moduleErrno, its name will startErrno::.
So you could trap SystemCallError and then do a simple name check:
rescue SystemCallError => e raise e if(e.class.name.start_with?('Errno::')) # do your thing... end Here is another interesting alternative. Can be adapted to what you want.
Pasting most interesting part:
def match_message(regexp) lambda{ |error| regexp === error.message } end begin raise StandardError, "Error message about a socket." rescue match_message(/socket/) => error puts "Error #{error} matches /socket/; ignored." end See the original site for ruby 1.8.7 solution.
It turns out lambda not accepted my more recent ruby versions. It seems the option is to use what worked in 1.8.7 but that's IM slower (to create a new class in all comparisons. So I don't recommend using it and have not even tried it:
def exceptions_matching(&block) Class.new do def self.===(other) @block.call(other) end end.tap do |c| c.instance_variable_set(:@block, block) end end begin raise "FOOBAR: We're all doomed!" rescue exceptions_matching { |e| e.message =~ /^FOOBAR/ } puts "rescued!" end If somebody knows when ruby removed lambda support in rescue please comment.
class or module required for rescue clause (TypeError) looks like it doesn't work?
lambda === something calls lambda.call(something) under the hood I assume that type checking was implemented at some point without regard to this use case. If anybody knows when this changed, please let me know.All classes under Errno are subclasses of SystemCallError. And all subclasses of SystemCallError are classes under Errno. The 2 sets are identical, so just rescue SystemCallError. This assumes that you're not using an external lib that adds to one and not the other.
Verify the identity of the 2 sets (using active_support):
Errno.constants.map {|name| Errno.const_get(name) }.select{|const| Class === const }.uniq.map(&:to_s).sort == SystemCallError.subclasses.map(&:to_s).sort This returns true for me.
So, applied to your example:
begin # my code rescue SystemCallError # handle exception end 
ObjectSpace is sufficient for discovering undocumented classes. Unless some built-in ruby lib has adds more subclasses.true for me" part and in particular, the for me. A gem (or even the application itself) could provide a subclass of SystemCallError that isn't an Errno.Here is a more generic solution, in the case you wanted to rescue some Errno types and not others.
Create a custom module to be included by all the error classes we want to rescue
module MyErrnoModule; end Customize this array to your liking, up to the "each" call.
Errno.constants.map {|name| Errno.const_get(name) }.select{|const| Class === const }.uniq.each {|klass| klass.class_eval { include MyErrnoModule } } Test:
begin raise Errno::EPERM rescue MyErrnoModule p "rescued #{$!.inspect}" end Test result:
"rescued #<Errno::EPERM: Operation not permitted>" I would guess this performs slightly better than a solution that needs to check the name of the exception.
Errnonamespace specifically, or 2) unaccept the answer.