rcap 2.4.1 → 2.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7884d08e11ec38241caeca586cff0238fb81bd54
-  data.tar.gz: b2ab2aa464a5d69917b75bf7f3550a2c0d795f0a
+  metadata.gz: 2b2493782c58861730c554776d6e5848e9b15728
+  data.tar.gz: ab89552659a96fc8130ff839734c61a255403030
 SHA512:
-  metadata.gz: 8dc12b2de19db14730392366b7e6b6e27a22158e939d28582aef7e7ac81691ae8bea37b83ba79aa8a0f6360f603c4d10a6101c8b8481a894b25f76e8fd15bf4c
-  data.tar.gz: 2027150b43a529be6ab6c778bf39b8d4ff4939894fa443cfa428c946a2749b247d27897c0ebdea04997ea3bf27b8303666b66e13ba1cd728fa1ccdce3d37202d
+  metadata.gz: c27d24fa3f957feb2f36ef8400d33a741c6e163ab79508a7c614f5dbaf7daf051bc81072132c04f985c31529fef475676165dddd4a386df5dc96b3e249e8cf00
+  data.tar.gz: d220753d7b59abb718ce149ba7e25fe74e12bd7bf0b73b9b3f8e0170a801d0d476ba596ec66c879eb3d5051268e371c3d8ba6e97fa55b0ab6ce130fa1c9dc15d

data/CHANGELOG.md

@@ -1,6 +1,10 @@
 Change Log
 ==========
 
+## 2.5.0 - 3 November 2014
+
+* Allow the values of parameters, area codes and event codes to be empty.
+
 ## 2.4.1 - 7 August 2013
 
 * Further integration of validations.

data/lib/rcap/alert.rb

@@ -1,11 +1,10 @@
 module RCAP
   module Alert
+    XMLNS_KEY            = 'xmlns'
+    YAML_CAP_VERSION_KEY = 'CAP Version'
+    JSON_CAP_VERSION_KEY = 'cap_version'
 
-    XMLNS_KEY            = "xmlns"
-    YAML_CAP_VERSION_KEY = "CAP Version"
-    JSON_CAP_VERSION_KEY = "cap_version"
-
-    CAP_NAMESPACES = [ RCAP::CAP_1_0::Alert::XMLNS, RCAP::CAP_1_1::Alert::XMLNS, RCAP::CAP_1_2::Alert::XMLNS ]
+    CAP_NAMESPACES = [RCAP::CAP_1_0::Alert::XMLNS, RCAP::CAP_1_1::Alert::XMLNS, RCAP::CAP_1_2::Alert::XMLNS]
 
     # Initialise a RCAP Alert from a XML document.
     #
@@ -14,19 +13,19 @@ module RCAP
     #  the namespace of the document is inspected and a CAP_1_0::Alert, CAP_1_1::Alert
     #  or CAP_1_2::Alert is instantiated accordingly. If no namespace can be detected
     #  a CAP 1.2 message will be assumed.
-    # @return [ RCAP::CAP_1_0::Alert, RCAP::CAP_1_1::Alert, RCAP::CAP_1_2::Alert ]
-    def self.from_xml( xml, namespace_key = nil )
-      xml_document = REXML::Document.new( xml )
+    # @return [RCAP::CAP_1_0::Alert, RCAP::CAP_1_1::Alert, RCAP::CAP_1_2::Alert ]
+    def self.from_xml(xml, namespace_key = nil)
+      xml_document = REXML::Document.new(xml)
       document_namespaces = xml_document.root.namespaces.invert
-      namespace = namespace_key || CAP_NAMESPACES.find{ |namepsace| document_namespaces[ namepsace ]}
+      namespace = namespace_key || CAP_NAMESPACES.find { |namepsace| document_namespaces[namepsace] }
 
       case namespace
       when CAP_1_0::Alert::XMLNS
-        CAP_1_0::Alert.from_xml_document( xml_document )
+        CAP_1_0::Alert.from_xml_document(xml_document)
       when CAP_1_1::Alert::XMLNS
-        CAP_1_1::Alert.from_xml_document( xml_document )
+        CAP_1_1::Alert.from_xml_document(xml_document)
       else
-        CAP_1_2::Alert.from_xml_document( xml_document )
+        CAP_1_2::Alert.from_xml_document(xml_document)
       end
     end
 
@@ -35,17 +34,17 @@ module RCAP
     # CAP 1.0, 1.1 or 1.2 Alert is instantiated accordingly.
     #
     # @param [IO, String] yaml CAP Alert in YAML format. Can be a String or any IO object.
-    # @return [ RCAP::CAP_1_0::Alert, RCAP::CAP_1_1::Alert, RCAP::CAP_1_2::Alert ]
-    def self.from_yaml( yaml )
-      yaml_data = YAML.load( yaml )
+    # @return [RCAP::CAP_1_0::Alert, RCAP::CAP_1_1::Alert, RCAP::CAP_1_2::Alert ]
+    def self.from_yaml(yaml)
+      yaml_data = YAML.load(yaml)
 
-      case yaml_data[ YAML_CAP_VERSION_KEY ]
+      case yaml_data[YAML_CAP_VERSION_KEY]
       when CAP_1_0::Alert::CAP_VERSION
-        CAP_1_0::Alert.from_yaml_data( yaml_data )
+        CAP_1_0::Alert.from_yaml_data(yaml_data)
       when CAP_1_1::Alert::CAP_VERSION
-        CAP_1_1::Alert.from_yaml_data( yaml_data )
+        CAP_1_1::Alert.from_yaml_data(yaml_data)
       else
-        CAP_1_2::Alert.from_yaml_data( yaml_data )
+        CAP_1_2::Alert.from_yaml_data(yaml_data)
       end
     end
 
@@ -54,10 +53,10 @@ module RCAP
     # CAP 1.0, 1.1 or 1.2 Alert is instantiated accordingly.
     #
     # @param [#to_s] json Alert in JSON format
-    # @return [ RCAP::CAP_1_0::Alert, RCAP::CAP_1_1::Alert, RCAP::CAP_1_2::Alert ]
-    def self.from_json( json )
-      json_hash = JSON.parse( json.to_s )
-      self.from_h( json_hash )
+    # @return [RCAP::CAP_1_0::Alert, RCAP::CAP_1_1::Alert, RCAP::CAP_1_2::Alert ]
+    def self.from_json(json)
+      json_hash = JSON.parse(json.to_s)
+      from_h(json_hash)
     end
 
     # Initialise a RCAP Alert from a Ruby hash produced by
@@ -65,15 +64,15 @@ module RCAP
     # CAP 1.0, 1.1 or 1.2 Alert is instantiated accordingly.
     #
     # @param [Hash] hash Alert as a Ruby hash.
-    # @return [ RCAP::CAP_1_0::Alert, RCAP::CAP_1_1::Alert, RCAP::CAP_1_2::Alert ]
-    def self.from_h( hash )
-      case hash[ JSON_CAP_VERSION_KEY ]
+    # @return [RCAP::CAP_1_0::Alert, RCAP::CAP_1_1::Alert, RCAP::CAP_1_2::Alert ]
+    def self.from_h(hash)
+      case hash[JSON_CAP_VERSION_KEY]
       when CAP_1_0::Alert::CAP_VERSION
-        CAP_1_0::Alert.from_h( hash )
+        CAP_1_0::Alert.from_h(hash)
       when CAP_1_1::Alert::CAP_VERSION
-        CAP_1_1::Alert.from_h( hash )
+        CAP_1_1::Alert.from_h(hash)
       else
-        CAP_1_2::Alert.from_h( hash )
+        CAP_1_2::Alert.from_h(hash)
       end
     end
   end

data/lib/rcap/base/alert.rb

@@ -3,71 +3,71 @@ module RCAP
     class Alert
       include Validation
 
-      STATUS_ACTUAL   = "Actual"
-      STATUS_EXERCISE = "Exercise"
-      STATUS_SYSTEM   = "System"
-      STATUS_TEST     = "Test"
+      STATUS_ACTUAL   = 'Actual'
+      STATUS_EXERCISE = 'Exercise'
+      STATUS_SYSTEM   = 'System'
+      STATUS_TEST     = 'Test'
       # Valid values for status
-      VALID_STATUSES = [ STATUS_ACTUAL, STATUS_EXERCISE, STATUS_SYSTEM, STATUS_TEST ]
+      VALID_STATUSES = [STATUS_ACTUAL, STATUS_EXERCISE, STATUS_SYSTEM, STATUS_TEST]
 
-      MSG_TYPE_ALERT  = "Alert"
-      MSG_TYPE_UPDATE = "Update"
-      MSG_TYPE_CANCEL = "Cancel"
-      MSG_TYPE_ACK    = "Ack"
-      MSG_TYPE_ERROR  = "Error"
+      MSG_TYPE_ALERT  = 'Alert'
+      MSG_TYPE_UPDATE = 'Update'
+      MSG_TYPE_CANCEL = 'Cancel'
+      MSG_TYPE_ACK    = 'Ack'
+      MSG_TYPE_ERROR  = 'Error'
       # Valid values for msg_type
-      VALID_MSG_TYPES = [ MSG_TYPE_ALERT, MSG_TYPE_UPDATE, MSG_TYPE_CANCEL, MSG_TYPE_ACK, MSG_TYPE_ERROR ]
+      VALID_MSG_TYPES = [MSG_TYPE_ALERT, MSG_TYPE_UPDATE, MSG_TYPE_CANCEL, MSG_TYPE_ACK, MSG_TYPE_ERROR]
 
-      SCOPE_PUBLIC     = "Public"
-      SCOPE_RESTRICTED = "Restricted"
-      SCOPE_PRIVATE    = "Private"
+      SCOPE_PUBLIC     = 'Public'
+      SCOPE_RESTRICTED = 'Restricted'
+      SCOPE_PRIVATE    = 'Private'
       # Valid values for scope
-      VALID_SCOPES = [ SCOPE_PUBLIC, SCOPE_PRIVATE, SCOPE_RESTRICTED ]
+      VALID_SCOPES = [SCOPE_PUBLIC, SCOPE_PRIVATE, SCOPE_RESTRICTED]
 
       # @return [String] If not set a UUID will be set by default on object initialisation
-      attr_accessor( :identifier)
+      attr_accessor(:identifier)
       # @return [String]
-      attr_accessor( :sender )
+      attr_accessor(:sender)
       # @return [DateTime] If not set will be time of creation.
-      attr_accessor( :sent )
+      attr_accessor(:sent)
       # @return [String] Can only be one of {VALID_STATUSES}
-      attr_accessor( :status )
+      attr_accessor(:status)
       # @return [String] Can only be one of {VALID_MSG_TYPES}
-      attr_accessor( :msg_type )
+      attr_accessor(:msg_type)
       # @return [String] Can only be one of {VALID_SCOPES}
-      attr_accessor( :scope )
+      attr_accessor(:scope)
       # @return [String]
-      attr_accessor( :source )
+      attr_accessor(:source)
       # @return [String ] Required if scope is {SCOPE_RESTRICTED}
-      attr_accessor( :restriction )
+      attr_accessor(:restriction)
       # @return [String]
-      attr_accessor( :note )
+      attr_accessor(:note)
 
       # @return [Array<String>] Collection of address strings. Depends on scope being {SCOPE_PRIVATE}
-      attr_reader( :addresses )
+      attr_reader(:addresses)
       # @return [Array<String>]
-      attr_reader( :codes )
+      attr_reader(:codes)
       # @return [Array<String>] Collection of references to previous alerts
       # @see #to_reference
-      attr_reader( :references)
+      attr_reader(:references)
       # @return [Array<String>] Collection of incident strings
-      attr_reader( :incidents )
+      attr_reader(:incidents)
       # @return [Array<Info>]
-      attr_reader( :infos )
+      attr_reader(:infos)
 
-      validates_presence_of( :identifier, :sender, :sent, :status, :msg_type, :scope )
+      validates_presence_of(:identifier, :sender, :sent, :status, :msg_type, :scope)
 
-      validates_inclusion_of( :status,   :in => VALID_STATUSES )
-      validates_inclusion_of( :msg_type, :in => VALID_MSG_TYPES )
-      validates_inclusion_of( :scope,    :in => VALID_SCOPES )
+      validates_inclusion_of(:status,   in: VALID_STATUSES)
+      validates_inclusion_of(:msg_type, in: VALID_MSG_TYPES)
+      validates_inclusion_of(:scope,    in: VALID_SCOPES)
 
-      validates_format_of( :identifier, :with => ALLOWED_CHARACTERS )
-      validates_format_of( :sender ,    :with => ALLOWED_CHARACTERS )
+      validates_format_of(:identifier, with: ALLOWED_CHARACTERS)
+      validates_format_of(:sender,     with: ALLOWED_CHARACTERS)
 
-      validates_conditional_presence_of( :addresses,   :when => :scope, :is => SCOPE_PRIVATE )
-      validates_conditional_presence_of( :restriction, :when => :scope, :is => SCOPE_RESTRICTED )
+      validates_conditional_presence_of(:addresses,   when: :scope, is: SCOPE_PRIVATE)
+      validates_conditional_presence_of(:restriction, when: :scope, is: SCOPE_RESTRICTED)
 
-      validates_collection_of( :infos )
+      validates_collection_of(:infos)
 
       # Initialises a new Alert object. Yields the initialised alert to a block.
       #
@@ -87,7 +87,7 @@ module RCAP
         @references  = []
         @incidents   = []
         @infos       = []
-        yield( self ) if block_given?
+        yield(self) if block_given?
       end
 
       # Creates a new {Info} object and adds it to the {#infos} array.
@@ -96,8 +96,8 @@ module RCAP
       # @yield [Info] The newly initialised Info object.
       # @return [Info] The initialised Info object after being yielded to the block
       def add_info
-        self.info_class.new.tap do |info|
-          yield( info ) if block_given?
+        info_class.new.tap do |info|
+          yield(info) if block_given?
           @infos << info
         end
       end
@@ -119,31 +119,31 @@ module RCAP
 
       # @return [REXML::Element]
       def to_xml_element
-        xml_element = REXML::Element.new( XML_ELEMENT_NAME )
-        xml_element.add_namespace( self.class::XMLNS )
-        xml_element.add_element( IDENTIFIER_ELEMENT_NAME ).add_text( @identifier )   if @identifier
-        xml_element.add_element( SENDER_ELEMENT_NAME ).add_text( @sender )           if @sender
-        xml_element.add_element( SENT_ELEMENT_NAME ).add_text( @sent.to_s_for_cap )  if @sent
-        xml_element.add_element( STATUS_ELEMENT_NAME ).add_text( @status )           if @status
-        xml_element.add_element( MSG_TYPE_ELEMENT_NAME ).add_text( @msg_type )       if @msg_type
-        xml_element.add_element( SOURCE_ELEMENT_NAME ).add_text( @source )           if @source
-        xml_element.add_element( SCOPE_ELEMENT_NAME ).add_text( @scope )             if @scope
-        xml_element.add_element( RESTRICTION_ELEMENT_NAME ).add_text( @restriction ) if @restriction
+        xml_element = REXML::Element.new(XML_ELEMENT_NAME)
+        xml_element.add_namespace(self.class::XMLNS)
+        xml_element.add_element(IDENTIFIER_ELEMENT_NAME).add_text(@identifier)   if @identifier
+        xml_element.add_element(SENDER_ELEMENT_NAME).add_text(@sender)           if @sender
+        xml_element.add_element(SENT_ELEMENT_NAME).add_text(@sent.to_s_for_cap)  if @sent
+        xml_element.add_element(STATUS_ELEMENT_NAME).add_text(@status)           if @status
+        xml_element.add_element(MSG_TYPE_ELEMENT_NAME).add_text(@msg_type)       if @msg_type
+        xml_element.add_element(SOURCE_ELEMENT_NAME).add_text(@source)           if @source
+        xml_element.add_element(SCOPE_ELEMENT_NAME).add_text(@scope)             if @scope
+        xml_element.add_element(RESTRICTION_ELEMENT_NAME).add_text(@restriction) if @restriction
         if @addresses.any?
-          xml_element.add_element( ADDRESSES_ELEMENT_NAME ).add_text( @addresses.to_s_for_cap )
+          xml_element.add_element(ADDRESSES_ELEMENT_NAME).add_text(@addresses.to_s_for_cap)
         end
         @codes.each do |code|
-          xml_element.add_element( CODE_ELEMENT_NAME ).add_text( code )
+          xml_element.add_element(CODE_ELEMENT_NAME).add_text(code)
         end
-        xml_element.add_element( NOTE_ELEMENT_NAME ).add_text( @note ) if @note
+        xml_element.add_element(NOTE_ELEMENT_NAME).add_text(@note) if @note
         if @references.any?
-          xml_element.add_element( REFERENCES_ELEMENT_NAME ).add_text( @references.join( ' ' ))
+          xml_element.add_element(REFERENCES_ELEMENT_NAME).add_text(@references.join(' '))
         end
         if @incidents.any?
-          xml_element.add_element( INCIDENTS_ELEMENT_NAME ).add_text( @incidents.join( ' ' ))
+          xml_element.add_element(INCIDENTS_ELEMENT_NAME).add_text(@incidents.join(' '))
         end
         @infos.each do |info|
-          xml_element.add_element( info.to_xml_element )
+          xml_element.add_element(info.to_xml_element)
         end
         xml_element
       end
@@ -151,8 +151,8 @@ module RCAP
       # @return [REXML::Document]
       def to_xml_document
         xml_document = REXML::Document.new
-        xml_document.add( REXML::XMLDecl.new )
-        xml_document.add( self.to_xml_element )
+        xml_document.add(REXML::XMLDecl.new)
+        xml_document.add(to_xml_element)
         xml_document
       end
 
@@ -160,13 +160,13 @@ module RCAP
       #
       # @param [true,false] pretty_print Pretty print output
       # @return [String]
-      def to_xml( pretty_print = false )
+      def to_xml(pretty_print = false)
         if pretty_print
-          xml_document = ""
-          RCAP::XML_PRETTY_PRINTER.write( self.to_xml_document, xml_document )
+          xml_document = ''
+          RCAP::XML_PRETTY_PRINTER.write(to_xml_document, xml_document)
           xml_document
         else
-          self.to_xml_document.to_s
+          to_xml_document.to_s
         end
       end
 
@@ -175,29 +175,29 @@ module RCAP
       #
       # @return [String]
       def to_reference
-        "#{ @sender },#{ @identifier },#{ RCAP.to_s_for_cap( @sent )}"
+        "#{ @sender },#{ @identifier },#{ RCAP.to_s_for_cap(@sent)}"
       end
 
       # @return [String]
       def inspect
-        alert_inspect = [ "CAP Version:  #{ self.class::CAP_VERSION }",
-                          "Identifier:   #{ @identifier }",
-                          "Sender:       #{ @sender }",
-                          "Sent:         #{ @sent }",
-                          "Status:       #{ @status }",
-                          "Message Type: #{ @msg_type }",
-                          "Source:       #{ @source }",
-                          "Scope:        #{ @scope }",
-                          "Restriction:  #{ @restriction }",
-                          "Addresses:    #{ @addresses.to_s_for_cap }",
-                          "Codes:",
-                          @codes.map{ |code| "  " + code }.join("\n")+"",
-                          "Note:         #{ @note }",
-                          "References:   #{ @references.join( ' ' )}",
-                          "Incidents:    #{ @incidents.join( ' ')}",
-                          "Information:",
-                          @infos.map{ |info| "  " + info.to_s }.join( "\n" )].join( "\n" )
-        RCAP.format_lines_for_inspect( 'ALERT', alert_inspect )
+        alert_inspect = ["CAP Version:  #{ self.class::CAP_VERSION }",
+                         "Identifier:   #{ @identifier }",
+                         "Sender:       #{ @sender }",
+                         "Sent:         #{ @sent }",
+                         "Status:       #{ @status }",
+                         "Message Type: #{ @msg_type }",
+                         "Source:       #{ @source }",
+                         "Scope:        #{ @scope }",
+                         "Restriction:  #{ @restriction }",
+                         "Addresses:    #{ @addresses.to_s_for_cap }",
+                         'Codes:',
+                         @codes.map { |code| '  ' + code }.join("\n") + '',
+                         "Note:         #{ @note }",
+                         "References:   #{ @references.join(' ')}",
+                         "Incidents:    #{ @incidents.join(' ')}",
+                         'Information:',
+                         @infos.map { |info| '  ' + info.to_s }.join("\n")].join("\n")
+        RCAP.format_lines_for_inspect('ALERT', alert_inspect)
       end
 
       # Returns a string representation of the alert of the form
@@ -206,7 +206,7 @@ module RCAP
       #
       # @return [String]
       def to_s
-        "#{ @sender }/#{ @identifier }/#{ RCAP.to_s_for_cap( @sent )}"
+        "#{ @sender }/#{ @identifier }/#{ RCAP.to_s_for_cap(@sent)}"
       end
 
       XPATH             = 'cap:alert'
@@ -226,129 +226,129 @@ module RCAP
 
       # @param [REXML::Element] alert_xml_element
       # @return [RCAP::CAP_1_0::Alert]
-      def self.from_xml_element( alert_xml_element )
-        self.new do |alert|
-          alert.identifier  = RCAP.xpath_text( alert_xml_element, IDENTIFIER_XPATH, alert.xmlns )
-          alert.sender      = RCAP.xpath_text( alert_xml_element, SENDER_XPATH, alert.xmlns )
-          alert.sent        = RCAP.parse_datetime( RCAP.xpath_text( alert_xml_element, SENT_XPATH, alert.xmlns ))
-          alert.status      = RCAP.xpath_text( alert_xml_element, STATUS_XPATH, alert.xmlns )
-          alert.msg_type    = RCAP.xpath_text( alert_xml_element, MSG_TYPE_XPATH, alert.xmlns )
-          alert.source      = RCAP.xpath_text( alert_xml_element, SOURCE_XPATH, alert.xmlns )
-          alert.scope       = RCAP.xpath_text( alert_xml_element, SCOPE_XPATH, alert.xmlns )
-          alert.restriction = RCAP.xpath_text( alert_xml_element, RESTRICTION_XPATH, alert.xmlns )
-
-          RCAP.unpack_if_given( RCAP.xpath_text( alert_xml_element, ADDRESSES_XPATH, alert.xmlns )).each do |address|
+      def self.from_xml_element(alert_xml_element)
+        new do |alert|
+          alert.identifier  = RCAP.xpath_text(alert_xml_element, IDENTIFIER_XPATH, alert.xmlns)
+          alert.sender      = RCAP.xpath_text(alert_xml_element, SENDER_XPATH, alert.xmlns)
+          alert.sent        = RCAP.parse_datetime(RCAP.xpath_text(alert_xml_element, SENT_XPATH, alert.xmlns))
+          alert.status      = RCAP.xpath_text(alert_xml_element, STATUS_XPATH, alert.xmlns)
+          alert.msg_type    = RCAP.xpath_text(alert_xml_element, MSG_TYPE_XPATH, alert.xmlns)
+          alert.source      = RCAP.xpath_text(alert_xml_element, SOURCE_XPATH, alert.xmlns)
+          alert.scope       = RCAP.xpath_text(alert_xml_element, SCOPE_XPATH, alert.xmlns)
+          alert.restriction = RCAP.xpath_text(alert_xml_element, RESTRICTION_XPATH, alert.xmlns)
+
+          RCAP.unpack_if_given(RCAP.xpath_text(alert_xml_element, ADDRESSES_XPATH, alert.xmlns)).each do |address|
             alert.addresses << address.strip
           end
 
-          RCAP.xpath_match( alert_xml_element, CODE_XPATH, alert.xmlns ).each do |element|
+          RCAP.xpath_match(alert_xml_element, CODE_XPATH, alert.xmlns).each do |element|
             alert.codes << element.text.strip
           end
 
-          alert.note = RCAP.xpath_text( alert_xml_element, NOTE_XPATH, alert.xmlns )
+          alert.note = RCAP.xpath_text(alert_xml_element, NOTE_XPATH, alert.xmlns)
 
-          RCAP.unpack_if_given( RCAP.xpath_text( alert_xml_element, REFERENCES_XPATH, alert.xmlns )).each do |reference|
+          RCAP.unpack_if_given(RCAP.xpath_text(alert_xml_element, REFERENCES_XPATH, alert.xmlns)).each do |reference|
             alert.references << reference.strip
           end
 
-          RCAP.unpack_if_given( RCAP.xpath_text( alert_xml_element, INCIDENTS_XPATH, alert.xmlns )).each do |incident|
+          RCAP.unpack_if_given(RCAP.xpath_text(alert_xml_element, INCIDENTS_XPATH, alert.xmlns)).each do |incident|
             alert.incidents << incident.strip
           end
 
-          RCAP.xpath_match( alert_xml_element, Info::XPATH, alert.xmlns ).each do |element|
-            alert.infos << alert.info_class.from_xml_element( element )
+          RCAP.xpath_match(alert_xml_element, Info::XPATH, alert.xmlns).each do |element|
+            alert.infos << alert.info_class.from_xml_element(element)
           end
         end
       end
 
       # @param [REXML::Document] xml_document
       # @return [Alert]
-      def self.from_xml_document( xml_document )
-        self.from_xml_element( xml_document.root )
+      def self.from_xml_document(xml_document)
+        from_xml_element(xml_document.root)
       end
 
       # Initialise an Alert object from an XML string. Any object that is a subclass of IO (e.g. File) can be passed in.
       #
       # @param [String] xml
       # @return [Alert]
-      def self.from_xml( xml )
-        self.from_xml_document( REXML::Document.new( xml ))
+      def self.from_xml(xml)
+        from_xml_document(REXML::Document.new(xml))
       end
 
-      CAP_VERSION_YAML = "CAP Version"
-      IDENTIFIER_YAML  = "Identifier"
-      SENDER_YAML      = "Sender"
-      SENT_YAML        = "Sent"
-      STATUS_YAML      = "Status"
-      MSG_TYPE_YAML    = "Message Type"
-      SOURCE_YAML      = "Source"
-      SCOPE_YAML       = "Scope"
-      RESTRICTION_YAML = "Restriction"
-      ADDRESSES_YAML   = "Addresses"
-      CODES_YAML       = "Codes"
-      NOTE_YAML        = "Note"
-      REFERENCES_YAML  = "References"
-      INCIDENTS_YAML   = "Incidents"
-      INFOS_YAML       = "Information"
+      CAP_VERSION_YAML = 'CAP Version'
+      IDENTIFIER_YAML  = 'Identifier'
+      SENDER_YAML      = 'Sender'
+      SENT_YAML        = 'Sent'
+      STATUS_YAML      = 'Status'
+      MSG_TYPE_YAML    = 'Message Type'
+      SOURCE_YAML      = 'Source'
+      SCOPE_YAML       = 'Scope'
+      RESTRICTION_YAML = 'Restriction'
+      ADDRESSES_YAML   = 'Addresses'
+      CODES_YAML       = 'Codes'
+      NOTE_YAML        = 'Note'
+      REFERENCES_YAML  = 'References'
+      INCIDENTS_YAML   = 'Incidents'
+      INFOS_YAML       = 'Information'
 
       # Returns a string containing the YAML representation of the alert.
       #
       # @return [String]
-      def to_yaml( options = {} )
-        RCAP.attribute_values_to_hash( [ CAP_VERSION_YAML, self.class::CAP_VERSION ],
-                                       [ IDENTIFIER_YAML,  @identifier ],
-                                       [ SENDER_YAML,      @sender ],
-                                       [ SENT_YAML,        @sent ],
-                                       [ STATUS_YAML,      @status ],
-                                       [ MSG_TYPE_YAML,    @msg_type ],
-                                       [ SOURCE_YAML,      @source ],
-                                       [ SCOPE_YAML,       @scope ],
-                                       [ RESTRICTION_YAML, @restriction ],
-                                       [ ADDRESSES_YAML,   @addresses ],
-                                       [ CODES_YAML,       @codes ],
-                                       [ NOTE_YAML,        @note ],
-                                       [ REFERENCES_YAML,  @references ],
-                                       [ INCIDENTS_YAML,   @incidents ],
-                                       [ INFOS_YAML,       @infos.map( &:to_yaml_data )]).to_yaml( options )
+      def to_yaml(options = {})
+        RCAP.attribute_values_to_hash([CAP_VERSION_YAML, self.class::CAP_VERSION],
+                                      [IDENTIFIER_YAML,  @identifier],
+                                      [SENDER_YAML,      @sender],
+                                      [SENT_YAML,        @sent],
+                                      [STATUS_YAML,      @status],
+                                      [MSG_TYPE_YAML,    @msg_type],
+                                      [SOURCE_YAML,      @source],
+                                      [SCOPE_YAML,       @scope],
+                                      [RESTRICTION_YAML, @restriction],
+                                      [ADDRESSES_YAML,   @addresses],
+                                      [CODES_YAML,       @codes],
+                                      [NOTE_YAML,        @note],
+                                      [REFERENCES_YAML,  @references],
+                                      [INCIDENTS_YAML,   @incidents],
+                                      [INFOS_YAML,       @infos.map(&:to_yaml_data)]).to_yaml(options)
       end
 
       # Initialise an Alert object from a YAML string. Any object that is a subclass of IO (e.g. File) can be passed in.
       #
       # @param [String] yaml
       # @return [Alert]
-      def self.from_yaml( yaml )
-        self.from_yaml_data( YAML.load( yaml ))
+      def self.from_yaml(yaml)
+        from_yaml_data(YAML.load(yaml))
       end
 
       # Initialise an Alert object from a hash reutrned from YAML.load.
       #
       # @param [hash] alert_yaml_data
       # @return [Alert]
-      def self.from_yaml_data( alert_yaml_data )
-        self.new do |alert|
-          alert.identifier  = RCAP.strip_if_given( alert_yaml_data[ IDENTIFIER_YAML ])
-          alert.sender      = RCAP.strip_if_given( alert_yaml_data[ SENDER_YAML ])
-          alert.sent        = RCAP.parse_datetime( alert_yaml_data[ SENT_YAML ])
-          alert.status      = RCAP.strip_if_given( alert_yaml_data[ STATUS_YAML ])
-          alert.msg_type    = RCAP.strip_if_given( alert_yaml_data[ MSG_TYPE_YAML ])
-          alert.source      = RCAP.strip_if_given( alert_yaml_data[ SOURCE_YAML ])
-          alert.scope       = RCAP.strip_if_given( alert_yaml_data[ SCOPE_YAML ])
-          alert.restriction = RCAP.strip_if_given( alert_yaml_data[ RESTRICTION_YAML ])
-          Array( alert_yaml_data[ ADDRESSES_YAML ]).each do |address|
+      def self.from_yaml_data(alert_yaml_data)
+        new do |alert|
+          alert.identifier  = RCAP.strip_if_given(alert_yaml_data[ IDENTIFIER_YAML])
+          alert.sender      = RCAP.strip_if_given(alert_yaml_data[ SENDER_YAML])
+          alert.sent        = RCAP.parse_datetime(alert_yaml_data[ SENT_YAML])
+          alert.status      = RCAP.strip_if_given(alert_yaml_data[ STATUS_YAML])
+          alert.msg_type    = RCAP.strip_if_given(alert_yaml_data[ MSG_TYPE_YAML])
+          alert.source      = RCAP.strip_if_given(alert_yaml_data[ SOURCE_YAML])
+          alert.scope       = RCAP.strip_if_given(alert_yaml_data[ SCOPE_YAML])
+          alert.restriction = RCAP.strip_if_given(alert_yaml_data[ RESTRICTION_YAML])
+          Array(alert_yaml_data[ ADDRESSES_YAML]).each do |address|
             alert.addresses << address.strip
           end
-          Array( alert_yaml_data[ CODES_YAML ]).each do |code|
+          Array(alert_yaml_data[ CODES_YAML]).each do |code|
             alert.codes << code.strip
           end
-          alert.note        = alert_yaml_data[ NOTE_YAML ]
-          Array( alert_yaml_data[ REFERENCES_YAML ]).each do |reference|
+          alert.note        = alert_yaml_data[ NOTE_YAML]
+          Array(alert_yaml_data[ REFERENCES_YAML]).each do |reference|
             alert.references << reference.strip
           end
-          Array( alert_yaml_data[ INCIDENTS_YAML ]).each do |incident|
+          Array(alert_yaml_data[ INCIDENTS_YAML]).each do |incident|
             alert.incidents << incident.strip
           end
-          Array( alert_yaml_data[ INFOS_YAML ]).each do |info_yaml_data|
-            alert.infos <<  alert.info_class.from_yaml_data( info_yaml_data )
+          Array(alert_yaml_data[ INFOS_YAML]).each do |info_yaml_data|
+            alert.infos <<  alert.info_class.from_yaml_data(info_yaml_data)
           end
         end
       end
@@ -373,54 +373,54 @@ module RCAP
       #
       # @return [Hash]
       def to_h
-        RCAP.attribute_values_to_hash( [ CAP_VERSION_KEY, self.class::CAP_VERSION ],
-                                       [ IDENTIFIER_KEY,  @identifier ],
-                                       [ SENDER_KEY,      @sender ],
-                                       [ SENT_KEY,        RCAP.to_s_for_cap( @sent )],
-                                       [ STATUS_KEY,      @status ],
-                                       [ MSG_TYPE_KEY,    @msg_type ],
-                                       [ SOURCE_KEY,      @source ],
-                                       [ SCOPE_KEY,       @scope ],
-                                       [ RESTRICTION_KEY, @restriction ],
-                                       [ ADDRESSES_KEY,   @addresses ],
-                                       [ CODES_KEY,       @codes ],
-                                       [ NOTE_KEY,        @note ],
-                                       [ REFERENCES_KEY,  @references ],
-                                       [ INCIDENTS_KEY,   @incidents ],
-                                       [ INFOS_KEY,       @infos.map{ |info| info.to_h  }])
+        RCAP.attribute_values_to_hash([CAP_VERSION_KEY, self.class::CAP_VERSION],
+                                      [IDENTIFIER_KEY,  @identifier],
+                                      [SENDER_KEY,      @sender],
+                                      [SENT_KEY,        RCAP.to_s_for_cap(@sent)],
+                                      [STATUS_KEY,      @status],
+                                      [MSG_TYPE_KEY,    @msg_type],
+                                      [SOURCE_KEY,      @source],
+                                      [SCOPE_KEY,       @scope],
+                                      [RESTRICTION_KEY, @restriction],
+                                      [ADDRESSES_KEY,   @addresses],
+                                      [CODES_KEY,       @codes],
+                                      [NOTE_KEY,        @note],
+                                      [REFERENCES_KEY,  @references],
+                                      [INCIDENTS_KEY,   @incidents],
+                                      [INFOS_KEY,       @infos.map { |info| info.to_h  }])
       end
 
       # Initialises an Alert object from a Hash produced by Alert#to_h
       #
       # @param [Hash] alert_hash
       # @return [RCAP::CAP_1_0::Alert]
-      def self.from_h( alert_hash )
-        self.new do |alert|
-          alert.identifier  = RCAP.strip_if_given( alert_hash[ IDENTIFIER_KEY ])
-          alert.sender      = RCAP.strip_if_given( alert_hash[ SENDER_KEY ])
-          alert.sent        = RCAP.parse_datetime( alert_hash[ SENT_KEY ])
-          alert.status      = RCAP.strip_if_given( alert_hash[ STATUS_KEY ])
-          alert.msg_type    = RCAP.strip_if_given( alert_hash[ MSG_TYPE_KEY ])
-          alert.source      = RCAP.strip_if_given( alert_hash[ SOURCE_KEY ])
-          alert.scope       = RCAP.strip_if_given( alert_hash[ SCOPE_KEY ])
-          alert.restriction = RCAP.strip_if_given( alert_hash[ RESTRICTION_KEY ])
-          Array( alert_hash[ ADDRESSES_KEY ]).each do |address|
+      def self.from_h(alert_hash)
+        new do |alert|
+          alert.identifier  = RCAP.strip_if_given(alert_hash[IDENTIFIER_KEY])
+          alert.sender      = RCAP.strip_if_given(alert_hash[SENDER_KEY])
+          alert.sent        = RCAP.parse_datetime(alert_hash[SENT_KEY])
+          alert.status      = RCAP.strip_if_given(alert_hash[STATUS_KEY])
+          alert.msg_type    = RCAP.strip_if_given(alert_hash[MSG_TYPE_KEY])
+          alert.source      = RCAP.strip_if_given(alert_hash[SOURCE_KEY])
+          alert.scope       = RCAP.strip_if_given(alert_hash[SCOPE_KEY])
+          alert.restriction = RCAP.strip_if_given(alert_hash[RESTRICTION_KEY])
+          Array(alert_hash[ ADDRESSES_KEY]).each do |address|
             alert.addresses << address.strip
           end
-          Array( alert_hash[ CODES_KEY ]).each do |code|
+          Array(alert_hash[ CODES_KEY]).each do |code|
             alert.codes << code.strip
           end
-          alert.note = alert_hash[ NOTE_KEY ]
-          Array( alert_hash[ REFERENCES_KEY ]).each do |reference|
+          alert.note = alert_hash[ NOTE_KEY]
+          Array(alert_hash[ REFERENCES_KEY]).each do |reference|
             alert.references << reference.strip
           end
 
-          Array( alert_hash[ INCIDENTS_KEY ]).each do |incident|
+          Array(alert_hash[ INCIDENTS_KEY]).each do |incident|
             alert.incidents << incident.strip
           end
 
-          Array( alert_hash[ INFOS_KEY ]).each do |info_hash|
-            alert.infos << alert.info_class.from_h( info_hash )
+          Array(alert_hash[ INFOS_KEY]).each do |info_hash|
+            alert.infos << alert.info_class.from_h(info_hash)
           end
         end
       end
@@ -429,11 +429,11 @@ module RCAP
       #
       # @param [true,false] pretty_print
       # @return [String]
-      def to_json( pretty_print = false )
+      def to_json(pretty_print = false)
         if pretty_print
-          JSON.pretty_generate( self.to_h )
+          JSON.pretty_generate(to_h)
         else
-          self.to_h.to_json
+          to_h.to_json
         end
       end
 
@@ -441,8 +441,8 @@ module RCAP
       #
       # @param [String] json_string
       # @return [Alert]
-      def self.from_json( json_string )
-        self.from_h( JSON.parse( json_string ))
+      def self.from_json(json_string)
+        from_h(JSON.parse(json_string))
       end
     end
   end