使用动态生成的类进行Ruby异常继承

我是 Ruby的新手,所以我在理解我遇到的这个奇怪的异常问题时遇到了一些麻烦.我正在使用ruby-aaws gem访问Amazon ECS： http://www.caliban.org/ruby/ruby-aws/.这定义了一个类Amazon :: AWS：错误：

module Amazon
  module AWS
    # All dynamically generated exceptions occur within this namespace.
    #
    module Error
      # An exception generator class.
      #
      class AWSError
        attr_reader :exception

        def initialize(xml)
          err_class = xml.elements['Code'].text.sub( /^AWS.*./,'' )
          err_msg = xml.elements['Message'].text

          unless Amazon::AWS::Error.const_defined?( err_class )
            Amazon::AWS::Error.const_set( err_class,Class.new( StandardError ) )
          end

          ex_class = Amazon::AWS::Error.const_get( err_class )
          @exception = ex_class.new( err_msg )
        end
      end
    end
  end
end

这意味着如果您获得类似AWS.InvalidParameterValue的错误代码,则会生成(在其异??常变量中)新类Amazon :: AWS :: Error :: InvalidParameterValue,它是StandardError的子类.

现在这里变得奇怪了.我有一些看起来像这样的代码：

begin
  do_aws_stuff
rescue Amazon::AWS::Error => error
  puts "Got an AWS error"
end

现在,如果do_aws_stuff抛出NameError,我的救援块就会被触发.似乎Amazon :: AWS :: Error不是生成错误的超类 – 我猜是因为它是一个模块,所有东西都是它的子类？当然如果我这样做：

irb(main):007:0> NameError.new.kind_of?(Amazon::AWS::Error)
=> true

它说的是真的,我觉得很困惑,特别是考虑到这一点：

irb(main):009:0> NameError.new.kind_of?(Amazon::AWS)
=> false

发生了什么,以及我如何将AWS错误与其他类型的错误分开？我应该这样做：

begin
  do_aws_stuff
rescue => error
  if error.class.to_s =~ /^Amazon::AWS::Error/
    puts "Got an AWS error"
  else
    raise error
  end
end

这看起来格格不入.抛出的错误也不是类AWSError – 它们是这样引发的：

error = Amazon::AWS::Error::AWSError.new( xml )
raise error.exception

所以我想要解决的例外是生成的异常类型,它们只继承自StandardError.

澄清一下,我有两个问题：

>为什么NameError是一个内置异常的Ruby,一个kind_of？(Amazon :: AWS :: Error),它是一个模块？
答：我曾说过在我的文件顶部包含Amazon :: AWS :: Error,认为它有点像Java导入或C包含.这实际上做的是将Amazon :: AWS :: Error(现在和将来)中定义的所有内容添加到隐式内核类,它是每个类的祖先.这意味着任何东西都会通过kind_of？(Amazon :: AWS :: Error).
>我如何才能最好地区分Amazon :: AWS :: Error中动态创建的异常与其他地方的随机异常？

module A
  module B
    module Error
      def foobar
        puts "foo"
      end
    end
  end
end

class StandardError
  include A::B::Error
end

StandardError.new.kind_of?(A::B::Error)
StandardError.new.kind_of?(A::B)
StandardError.included_modules #=> [A::B::Error,Kernel]

class Class
  def has_module?(module_ref)
    if self.included_modules.include?(module_ref) and not self.superclass.included_modules.include?(module_ref)                      
        puts self.name+" has module "+ module_ref.name          
    else
      self.superclass.nil? ? false : self.superclass.has_module?(module_ref)
    end        
  end
end
StandardError.has_module?(A::B::Error)
NameError.has_module?(A::B::Error)

begin 
#do AWS error prone stuff
rescue Exception => e
  if Amazon::AWS::Error.constants.include?(e.class.name)
    #awsError
  else
    whatever
  end 
end