RubyGems - rcap - Versions diffs - 0.1 → 0.2 - Mend

rcap 0.1 → 0.2

Files changed (17) hide show

data/CHANGELOG.rdoc ADDED Viewed

@@ -0,0 +1,11 @@
+= Change Log
+== 0.2 - 20th November 2009
+* Implemented to_s/inspect methods for all classes
+* Implemented YAML generation and parsing
+* Documentation improvements
+== 0.1 - 5th November 2009
+* Initial release

data/{README → README.rdoc} RENAMED Viewed

@@ -4,29 +4,49 @@
 The Common Alerting Protocol is a lightweight standard to facilitate the distribution of alerting data. RCAP is an implementation of the CAP in Ruby. It allows for the creation of RCAP messages from Ruby applications and the parsing of external messages.
-RCAP supports CAP Version 1.1.
+RCAP currently supports only CAP Version 1.1.
-== Usage
+== Version
-To include RCAP into your application add the following require
+0.2
- require 'rcap/rcap'
+== Dependencies
-=== Creating an Alert
+RCAP depends on the following gems
-==== From XML
+* {Assistance}[http://assistance.rubyforge.org]
+* {UUIDTools}[http://uuidtools.rubyforge.org]
-RCAP allows for the parsing of a CAP XML string into a collection of RCAP objects
+RCAP uses the REXML API, included in Ruby, to parse and generate XML.
- alert = RCAP::Alert.from_xml( xml_string )
+== Installation
-Currently RCAP only supports version 1.1 of the CAP standard and the parser is as strict as possible when parsing data.
+RCAP is distributed as a Ruby gem and is available from {Gemcutter}[http://gemcutter.org]. If you have Gemcutter set as a source of your gems then RCAP can be installed from the command line
+ gem install rcap
+The gem is also available for download and manual installtion at http://www.aimred.com/gems .
-==== Programatically
+== Web resources
-Alerts can also be created programatically by initialising the various RCAP classes manually
+* The RCAP project page can be found at http://www.aimred.com/projects/rcap
+* The RCAP API docs can be fount at http://www.aimred.com/projects/rcap/api
+* A public git repository can be found at http:///www.aimred.com/git/rcap.git
+== Usage
+To include RCAP into your application add the following require
+ require 'rcap'
+All RCAP classes reside in the RCAP namespace but including the RCAP module makes the classes available at the top level without the RCAP prefix.
+ alert = RCAP::Alert.new(...
  include RCAP # Include RCAP module into namespace
+ alert = Alert.new(...
+=== Creating an Alert
  alert = Alert.new( :sender   => 'cape_town_disaster_relief@capetown.municipal.za',
                     :status   => Alert::STATUS_ACTUAL,
@@ -49,6 +69,12 @@ Alerts can also be created programatically by initialising the various RCAP clas
  puts alert.infos[0].language               # Print out "en-ZA"
  puts alert.infos[0].categories.join( ' ' ) # Print out "Transport Fire"
+=== Exporting an Alert
+==== To XML
+Using the alert message created above
  puts alert.to_xml # Print out CAP XML message
 Will print the following CAP XML
@@ -57,7 +83,7 @@ Will print the following CAP XML
   <alert xmlns='urn:oasis:names:tc:emergency:cap:1.1'>
     <identifier>494207a7-f86b-4060-8318-a4b2a3ce565e</identifier>
     <sender>cape_town_disaster_relief@capetown.municipal.za</sender>
-    <sent>2009-10-26T21:04:51+2:00</sent>
+    <sent>2009-10-26T21:04:51+02:00</sent>
     <status>Actual</status>
     <msgType>Alert</msgType>
     <scope>Public</scope>
@@ -79,36 +105,56 @@ Will print the following CAP XML
     </info>
   </alert>
+==== To YAML
-You can also create the various message elements seperately and then combine them later:
+YAML is a plain text serialization format designed to be easily readable and editable by both human and machine. RCAP has custom YAML generation and parsing methods to produce a YAML document that is as human friednly as possible. The following code
- # Setting attributes at initialisation
- alert = Alert.new( :sender   => 'cape_town_disaster_relief@capetown.municipal.za',
-                    :status   => Alert::STATUS_ACTUAL,
-                    :msg_type => Alert::MSG_TYPE_ALERT,
-                    :scope    => Alert::SCOPE_PUBLIC )
- # Setting attributes after initialisation
- info = Info.new
- info.event      = 'Liquid Petroleoum Tanker Fire'
- info.language   = 'en-ZA'
- info.categories = [ Info::CATEGORY_TRANSPORT, Info::CATEGORY_FIRE ]
- info.urgency    = Info::URGENCY_IMMEDIATE
- info.severity   = Info::SEVERITY_SEVERE
- info.certainty  = Info::CERTAINTY_OBSERVED
+ alert.to_yaml
+will produce the following YAML document
+ ---
+ Identifier: 2a1ba96d-16e4-4f52-85ea-0258c1440bd5
+ Sender: cape_town_disaster_relief@capetown.municipal.za
+ Sent: 2009-11-19T02:41:29+02:00
+ Status: Actual
+ Message Type: Alert
+ Scope: Public
+ Information:
+ - Language: en-ZA
+   Categories: [Transport, Fire]
+   Event: Liquid Petroleoum Tanker Fire
+   Urgency: Immediate
+   Severity: Severe
+   Certainty: Observed
+   Headline: LIQUID PETROLEOUM TANKER FIRE ON N2 INCOMING FREEWAY
+   Description: |-
+     A liquid petroleoum tanker has caught fire on the N2 incoming freeway 1km
+     after the R300 interchange.  Municipal fire fighting crews have been dispatched.
+     Traffic control officers are on the scene and have diverted traffic onto
+     alternate routes.
- resource  = Resource.new( :resource_desc => 'Cape Town Municipal Traffic Management Guidelines',
-                           :uri           => 'http://capetown.municipal.za/traffic/management_guidelines.pdf',
-                           :mime_type     => 'application/pdf')
+Note: If you use Ruby 1.8 the order of the attributes is jumbled due to hashes being unorderd (Ruby 1.9 implements ordered hashes). This does not affect the ability to parse documents generated from RCAP::Alert#to_yaml, it just makes things the output slightly messy.
- # Combining all elements
- info.resources << resource
- alert.infos << info
+=== Parsing an Alert From An External Source
+==== From XML
+RCAP allows for the parsing of a CAP XML string
+ alert = RCAP::Alert.from_xml( xml_string )
+Currently RCAP only supports version 1.1 of the CAP standard and the parser is as strict as possible when parsing data.
+==== From YAML
+Alert messgaes can be read in from text files containing data formatted in YAML as generated by Alert#to_yaml.
+ alert = RCAP::Alert.from_yaml( yaml_string )
 === Validating an alert
-The RCAP API aims to codify as many of the rules of the CAP XML format into validation rules that can be checked using the Assistance API (http://assistance.rubyforge.org). The following Info object has two attributes ('severity' and 'certainty') set to incorrect values.
+The RCAP API aims to codify as many of the rules of the CAP XML format into validation rules that can be checked using the Assistance API. The following Info object has two attributes ('severity' and 'certainty') set to incorrect values.
  info = Info.new( :event      => 'Liquid Petroleoum Tanker Fire',
                   :language   => 'en-ZA',
@@ -125,19 +171,14 @@ Will produce the folling output:
  severity is not present
  certainty can only be assigned the following values: Observed, Likely, Possible, Unlikely, Unknown
-A full spec suite using RSpec (http://www.rspec.info) was used to test the validations and currently numbers over 140 tests.
+All RCAP classes include the Validation module.
-== Version
+A full spec suite using {RSpec}[http://www.rspec.info] was used to test the validations and currently numbers over 150 tests.
-0.1
+=== DateTime and Time
-== Dependencies
+It is highly recommended that when dealing with date and time fields (onset, expires etc) that the DateTime class is used to ensure the correct formatting of dates. The Time class can be used when generating a CAP alert XML message however any CAP alert that is parsed from an external XML source will use DateTime by default.
-RCAP depends on the following gems
-* Assistance - http://assistance.rubyforge.org
-* UUIDTools - http://uuidtools.rubyforge.org
 == Authors
 Farrel Lifson - farrel.lifson@aimred.com
@@ -148,4 +189,4 @@ RCAP is released under the BSD License.
 == Copyright
-2009 Aimred CC
+2009-2010 Aimred CC

data/lib/rcap/alert.rb CHANGED Viewed

@@ -10,24 +10,27 @@ module RCAP
 	class Alert
 		include Validation
-		STATUS_ACTUAL   = "Actual"
-		STATUS_EXERCISE = "Exercise"
-		STATUS_SYSTEM   = "System"
-		STATUS_TEST     = "Test"
-		STATUS_DRAFT    = "Draft"
-		ALL_STATUSES = [ STATUS_ACTUAL, STATUS_EXERCISE, STATUS_SYSTEM, STATUS_TEST, STATUS_DRAFT ] #:nodoc:
-		MSG_TYPE_ALERT  = "Alert"
-		MSG_TYPE_UPDATE = "Update"
-		MSG_TYPE_CANCEL = "Cancel"
-		MSG_TYPE_ACK    = "Ack"
-		MSG_TYPE_ERROR  = "Error"
-		ALL_MSG_TYPES = [ MSG_TYPE_ALERT, MSG_TYPE_UPDATE, MSG_TYPE_CANCEL, MSG_TYPE_ACK, MSG_TYPE_ERROR ] #:nodoc:
-		SCOPE_PUBLIC     = "Public"
-		SCOPE_RESTRICTED = "Restricted"
-		SCOPE_PRIVATE    = "Private"
-		ALL_SCOPES = [ SCOPE_PUBLIC, SCOPE_PRIVATE, SCOPE_RESTRICTED ] #:nodoc:
+		STATUS_ACTUAL   = "Actual"   # :nodoc:
+		STATUS_EXERCISE = "Exercise" # :nodoc:
+		STATUS_SYSTEM   = "System"   # :nodoc:
+		STATUS_TEST     = "Test"     # :nodoc:
+		STATUS_DRAFT    = "Draft"    # :nodoc:
+    # Valid values for status
+		VALID_STATUSES = [ STATUS_ACTUAL, STATUS_EXERCISE, STATUS_SYSTEM, STATUS_TEST, STATUS_DRAFT ]
+		MSG_TYPE_ALERT  = "Alert"  # :nodoc:
+		MSG_TYPE_UPDATE = "Update" # :nodoc:
+		MSG_TYPE_CANCEL = "Cancel" # :nodoc:
+		MSG_TYPE_ACK    = "Ack"    # :nodoc:
+		MSG_TYPE_ERROR  = "Error"  # :nodoc:
+    # Valid values for msg_type
+		VALID_MSG_TYPES = [ MSG_TYPE_ALERT, MSG_TYPE_UPDATE, MSG_TYPE_CANCEL, MSG_TYPE_ACK, MSG_TYPE_ERROR ]
+		SCOPE_PUBLIC     = "Public"     # :nodoc:
+		SCOPE_RESTRICTED = "Restricted" # :nodoc:
+		SCOPE_PRIVATE    = "Private"    # :nodoc:
+    # Valid values for scope
+		VALID_SCOPES = [ SCOPE_PUBLIC, SCOPE_PRIVATE, SCOPE_RESTRICTED ]
     XML_ELEMENT_NAME         = 'alert'       # :nodoc:
     IDENTIFIER_ELEMENT_NAME  = 'identifier'  # :nodoc:
@@ -64,9 +67,11 @@ module RCAP
     attr_accessor( :sender )
     # Sent Time - If not set will value will be time of creation.
     attr_accessor( :sent )
+    # Value can only be one of VALID_STATUSES
     attr_accessor( :status )
-    # Message Type
+    # Value can only be one of VALID_MSG_TYPES
     attr_accessor( :msg_type )
+    # Value can only be one of VALID_SCOPES
     attr_accessor( :scope )
     attr_accessor( :source )
     # Depends on scope being SCOPE_RESTRICTED.
@@ -85,9 +90,9 @@ module RCAP
 		validates_presence_of( :identifier, :sender, :sent, :status, :msg_type, :scope )
-    validates_inclusion_of( :status,   :in => ALL_STATUSES )
-    validates_inclusion_of( :msg_type, :in => ALL_MSG_TYPES )
-    validates_inclusion_of( :scope,    :in => ALL_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 )
@@ -152,35 +157,123 @@ module RCAP
       self.to_xml_document.to_s
     end
-    # Returns a string of the format 'sender,identifier,sent' suitable for usage as a reference in a CAP message.
+    # Returns a string representation of the alert suitable for usage as a reference in a CAP message of the form
+    #  sender,identifier,sent
     def to_reference
       "#{ self.sender },#{ self.identifier },#{ self.sent }"
     end
+    def inspect # :nodoc:
+      alert_inspect = <<EOF
+Identifier:   #{ self.identifier }
+Sender:       #{ self.sender }
+Sent:         #{ self.sent }
+Status:       #{ self.status }
+Message Type: #{ self.msg_type }
+Source:       #{ self.source }
+Scope:        #{ self.scope }
+Restriction:  #{ self.restriction }
+Addresses:    #{ self.addresses.to_s_for_cap }
+Code:         #{ self.code }
+Note:         #{ self.note }
+References:   #{ self.references.join( ' ' )}
+Incidents:    #{ self.incidents.join( ' ')}
+Information:
+#{ self.infos.map{ |info| "  " + info.to_s }.join( "\n" )}
+EOF
+    RCAP.format_lines_for_inspect( 'ALERT', alert_inspect )
+    end
+    # Returns a string representation of the alert of the form
+    #  sender/identifier/sent
+    # See Alert#to_reference for another string representation suitable as a CAP reference.
+    def to_s
+      "#{ self.sender }/#{ self.identifier }/#{ self.sent }"
+    end
     def self.from_xml_element( alert_xml_element ) # :nodoc:
-      alert = RCAP::Alert.new( :identifier  => RCAP.xpath_text( alert_xml_element, RCAP::Alert::IDENTIFIER_XPATH ),
-                               :sender      => RCAP.xpath_text( alert_xml_element, SENDER_XPATH ),
-                               :sent        => (( sent = RCAP.xpath_first( alert_xml_element, SENT_XPATH )) ? DateTime.parse( sent.text ) : nil ),
-                               :status      => RCAP.xpath_text( alert_xml_element, STATUS_XPATH ),
-                               :msg_type    => RCAP.xpath_text( alert_xml_element, MSG_TYPE_XPATH ),
-                               :source      => RCAP.xpath_text( alert_xml_element, SOURCE_XPATH ),
-                               :scope       => RCAP.xpath_text( alert_xml_element, SCOPE_XPATH ),
-                               :restriction => RCAP.xpath_text( alert_xml_element, RESTRICTION_XPATH ),
-                               :addresses   => (( address = RCAP.xpath_text( alert_xml_element, ADDRESSES_XPATH )) ? address.unpack_cap_list : nil ),
-                               :code        => RCAP.xpath_text( alert_xml_element, CODE_XPATH ),
-                               :note        => RCAP.xpath_text( alert_xml_element, NOTE_XPATH ),
-                               :references  => (( references = RCAP.xpath_text( alert_xml_element, REFERENCES_XPATH )) ? references.split( ' ' ) : nil ),
-                               :incidents   => (( incidents = RCAP.xpath_text( alert_xml_element, INCIDENTS_XPATH )) ? incidents.split( ' ' ) : nil ),
-                               :infos       => RCAP.xpath_match( alert_xml_element, RCAP::Info::XPATH ).map{ |element| RCAP::Info.from_xml_element( element )})
+      RCAP::Alert.new( :identifier  => RCAP.xpath_text( alert_xml_element, RCAP::Alert::IDENTIFIER_XPATH ),
+                       :sender      => RCAP.xpath_text( alert_xml_element, SENDER_XPATH ),
+                       :sent        => (( sent = RCAP.xpath_first( alert_xml_element, SENT_XPATH )) ? DateTime.parse( sent.text ) : nil ),
+                       :status      => RCAP.xpath_text( alert_xml_element, STATUS_XPATH ),
+                       :msg_type    => RCAP.xpath_text( alert_xml_element, MSG_TYPE_XPATH ),
+                       :source      => RCAP.xpath_text( alert_xml_element, SOURCE_XPATH ),
+                       :scope       => RCAP.xpath_text( alert_xml_element, SCOPE_XPATH ),
+                       :restriction => RCAP.xpath_text( alert_xml_element, RESTRICTION_XPATH ),
+                       :addresses   => (( address = RCAP.xpath_text( alert_xml_element, ADDRESSES_XPATH )) ? address.unpack_cap_list : nil ),
+                       :code        => RCAP.xpath_text( alert_xml_element, CODE_XPATH ),
+                       :note        => RCAP.xpath_text( alert_xml_element, NOTE_XPATH ),
+                       :references  => (( references = RCAP.xpath_text( alert_xml_element, REFERENCES_XPATH )) ? references.split( ' ' ) : nil ),
+                       :incidents   => (( incidents = RCAP.xpath_text( alert_xml_element, INCIDENTS_XPATH )) ? incidents.split( ' ' ) : nil ),
+                       :infos       => RCAP.xpath_match( alert_xml_element, RCAP::Info::XPATH ).map{ |element| RCAP::Info.from_xml_element( element )})
     end
     def self.from_xml_document( xml_document ) # :nodoc:
       self.from_xml_element( xml_document.root )
     end
-    # Initialised an Alert object from the XML string.
-    def self.from_xml( xml_string )
-      self.from_xml_document( REXML::Document.new( xml_string ))
+    # Initialise an Alert object from an XML string. Any object that is a subclass of IO (e.g. File) can be passed in.
+    def self.from_xml( xml )
+      self.from_xml_document( REXML::Document.new( xml ))
     end
-	end
+     IDENTIFIER_YAML  = "Identifier"    # :nodoc:
+     SENDER_YAML      = "Sender"        # :nodoc:
+     SENT_YAML        = "Sent"          # :nodoc:
+     STATUS_YAML      = "Status"        # :nodoc:
+     MSG_TYPE_YAML    = "Message Type"  # :nodoc:
+     SOURCE_YAML      = "Source"        # :nodoc:
+     SCOPE_YAML       = "Scope"         # :nodoc:
+     RESTRICTION_YAML = "Restriction"   # :nodoc:
+     ADDRESSES_YAML   = "Addresses"     # :nodoc:
+     CODE_YAML        = "Code"          # :nodoc:
+     NOTE_YAML        = "Note"          # :nodoc:
+     REFERENCES_YAML  = "References"    # :nodoc:
+     INCIDENTS_YAML   = "Incidents"     # :nodoc:
+     INFOS_YAML       = "Information"   # :nodoc:
+    # Returns a string containing the YAML representation of the alert.
+     def to_yaml( options = {} )
+       RCAP.attribute_values_to_yaml_hash(
+				 [ IDENTIFIER_YAML,    self.identifier ],
+				 [ SENDER_YAML,        self.sender ],
+				 [ SENT_YAML,          self.sent ],
+				 [ STATUS_YAML,        self.status ],
+				 [ MSG_TYPE_YAML,      self.msg_type ],
+				 [ SOURCE_YAML,        self.source ],
+				 [ SCOPE_YAML,         self.scope ],
+				 [ RESTRICTION_YAML,   self.restriction ],
+				 [ ADDRESSES_YAML,     self.addresses ],
+				 [ CODE_YAML,          self.code ],
+				 [ NOTE_YAML,          self.note ],
+				 [ REFERENCES_YAML,    self.references ],
+				 [ INCIDENTS_YAML,     self.incidents ],
+				 [ INFOS_YAML,         self.infos ]
+       ).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.
+     def self.from_yaml( yaml )
+       self.from_yaml_data( YAML.load( yaml ))
+     end
+     def self.from_yaml_data( alert_yaml_data ) # :nodoc:
+       Alert.new(
+				 :identifier  => alert_yaml_data[ IDENTIFIER_YAML ],
+				 :sender      => alert_yaml_data[ SENDER_YAML ],
+				 :sent        => ( sent = alert_yaml_data[ SENT_YAML ]).blank? ? nil : DateTime.parse( sent.to_s ),
+				 :status      => alert_yaml_data[ STATUS_YAML ],
+				 :msg_type    => alert_yaml_data[ MSG_TYPE_YAML ],
+				 :source      => alert_yaml_data[ SOURCE_YAML ],
+				 :scope       => alert_yaml_data[ SCOPE_YAML ],
+				 :restriction => alert_yaml_data[ RESTRICTION_YAML ],
+				 :addresses   => alert_yaml_data[ ADDRESSES_YAML ],
+				 :code        => alert_yaml_data[ CODE_YAML ],
+				 :note        => alert_yaml_data[ NOTE_YAML ],
+				 :references  => alert_yaml_data[ REFERENCES_YAML ],
+				 :incidents   => alert_yaml_data[ INCIDENTS_YAML ],
+				 :infos       => Array( alert_yaml_data[ INFOS_YAML ]).map{ |info_yaml_data| RCAP::Info.from_yaml_data( info_yaml_data )}
+       )
+     end
+  end
 end

data/lib/rcap/area.rb CHANGED Viewed

@@ -55,7 +55,7 @@ module RCAP
       @circles.inject( xml_element, &add_to_xml_element )
       @geocodes.inject( xml_element, &add_to_xml_element )
       xml_element.add_element( ALTITUDE_ELEMENT_NAME ).add_text( @altitude.to_s ) unless self.altitude.blank?
-      xml_element.add_element( CEILING_ELEMENT_NAME ).add_text( @ceiling.to_s ) unless self.altitude.blank?
+      xml_element.add_element( CEILING_ELEMENT_NAME ).add_text( @ceiling.to_s )   unless self.altitude.blank?
       xml_element
     end
@@ -69,14 +69,62 @@ module RCAP
 			comparison_attributes.call( self ) == comparison_attributes.call( other )
 		end
+		def inspect # :nodoc:
+      area_inspect =  <<EOF
+Area Description: #{ self.area_desc }
+Polygons:
+#{ self.polygons.map{ |polygon| "  " + polygon.inspect }.join("\n" )}
+Circles:          #{ self.circles.inspect }
+Geocodes:         #{ self.geocodes.inspect }
+EOF
+      RCAP.format_lines_for_inspect( 'AREA', area_inspect )
+		end
+		# Returns a string representation of the area of the form
+		#  area_desc
+    def to_s
+      self.area_desc
+    end
     def self.from_xml_element( area_xml_element ) # :nodoc:
-      area = RCAP::Area.new( :area_desc => RCAP.xpath_text( area_xml_element, AREA_DESC_XPATH ),
-														 :altitude  => (( alt = RCAP.xpath_text( area_xml_element, ALTITUDE_XPATH )) ? alt.to_f : nil ),
-														 :ceiling   => (( ceil = RCAP.xpath_text( area_xml_element, CEILING_XPATH )) ? ceil.to_f : nil ),
-														 :circles   => RCAP.xpath_match( area_xml_element, RCAP::Circle::XPATH ).map{ |circle_element| RCAP::Circle.from_xml_element( circle_element )},
-														 :geocodes  => RCAP.xpath_match( area_xml_element, RCAP::Geocode::XPATH ).map{ |geocode_element| RCAP::Geocode.from_xml_element( geocode_element )},
-														 :polygons  => RCAP.xpath_match( area_xml_element, RCAP::Polygon::XPATH ).map{ |polygon_element| RCAP::Polygon.from_xml_element( polygon_element )})
-			area
+      RCAP::Area.new( :area_desc => RCAP.xpath_text( area_xml_element, AREA_DESC_XPATH ),
+											:altitude  => (( alt = RCAP.xpath_text( area_xml_element, ALTITUDE_XPATH )) ? alt.to_f : nil ),
+											:ceiling   => (( ceil = RCAP.xpath_text( area_xml_element, CEILING_XPATH )) ? ceil.to_f : nil ),
+											:circles   => RCAP.xpath_match( area_xml_element, RCAP::Circle::XPATH ).map{ |circle_element| RCAP::Circle.from_xml_element( circle_element )},
+											:geocodes  => RCAP.xpath_match( area_xml_element, RCAP::Geocode::XPATH ).map{ |geocode_element| RCAP::Geocode.from_xml_element( geocode_element )},
+											:polygons  => RCAP.xpath_match( area_xml_element, RCAP::Polygon::XPATH ).map{ |polygon_element| RCAP::Polygon.from_xml_element( polygon_element )})
     end
+     AREA_DESC_YAML = 'Area Description' # :nodoc:
+     ALTITUDE_YAML  = 'Altitude'         # :nodoc:
+     CEILING_YAML   = 'Ceiling'          # :nodoc:
+     CIRCLES_YAML   = 'Circles'          # :nodoc:
+     GEOCODES_YAML  = 'Geocodes'         # :nodoc:
+     POLYGONS_YAML  = 'Polygons'         # :nodoc:
+     def to_yaml( options = {} ) # :nodoc:
+       circles_yaml = self.circles.map{ |circle| [[ circle.point.lattitude, circle.point.longitude ], circle.radius ]}
+       def circles_yaml.to_yaml_style; :inline; end
+       RCAP.attribute_values_to_yaml_hash(
+         [ AREA_DESC_YAML,  self.area_desc ],
+         [ ALTITUDE_YAML,   self.altitude ],
+         [ CEILING_YAML,    self.ceiling ],
+         [ CIRCLES_YAML,    circles_yaml ],
+         [ GEOCODES_YAML,   self.geocodes.inject({}){|h,geocode| h.merge( geocode.name => geocode.value )}],
+         [ POLYGONS_YAML,   self.polygons ]
+       ).to_yaml( options )
+     end
+     def from_yaml_data( area_yaml_data )  # :nodoc:
+       Area.new(
+         :area_desc => area_yaml_data[ AREA_DESC_YAML ],
+         :altitude  => area_yaml_data[ ALTITUDE_YAML ],
+         :ceiling   => area_yaml_data[ CEILING_YAML ],
+         :circles   => Array( area_yaml_data[ CIRCLES_YAML ]).map{ |circle_yaml_data| RCAP::Circle.from_yaml_data( circle_yaml_data )},
+         :geocodes  => Array( area_yaml_data[ GEOCODES_YAML ]).map{ |name, value| RCAP::Geocode.new( :name => name, :value => value )},
+         :polygons  => Array( area_yaml_data[ POLYGONS_YAML ]).map{ |polyon_yaml_data| RCAP::Polygon.from_yaml_data( polyon_yaml_data )}
+       )
+     end
   end
 end

data/lib/rcap/circle.rb CHANGED Viewed

@@ -23,6 +23,8 @@ module RCAP
       @radius = attributes[ :radius ]
     end
+		# Returns a string representation of the circle of the form
+		#  point radius
     def to_s  # :nodoc:
       "#{ self.point.to_s } #{ self.radius }"
     end
@@ -58,5 +60,11 @@ module RCAP
     def ==( other )
       self.point == other.point && self.radius == other.radius
     end
+    def self.from_yaml_data( circle_yaml_data ) # :nodoc:
+      point_yaml_data, radius = circle_yaml_data
+      self.new( :point => RCAP::Point.new( :lattitude => point_yaml_data[ 0 ], longitude => point_yaml_data[ 1 ]),
+                :radius => radius )
+    end
   end
 end

data/lib/rcap/geocode.rb CHANGED Viewed

@@ -13,8 +13,8 @@ module RCAP
     end
     def self.from_xml_element( geocode_xml_element ) # :nodoc:
-      self.new( :name => RCAP.xpath_text( geocode_xml_element, NAME_XPATH ),
-               :value => RCAP.xpath_text( geocode_xml_element, VALUE_XPATH ))
+      self.new( :name  => RCAP.xpath_text( geocode_xml_element, NAME_XPATH ),
+                :value => RCAP.xpath_text( geocode_xml_element, VALUE_XPATH ))
     end
   end
 end

data/lib/rcap/info.rb CHANGED Viewed

@@ -11,57 +11,62 @@ module RCAP
   class Info
     include Validation
-    CATEGORY_GEO       = "Geo"
-    CATEGORY_MET       = "Met"
-    CATEGORY_SAFETY    = "Safety"
-    CATEGORY_SECURITY  = "Security"
-    CATEGORY_RESCUE    = "Rescue"
-    CATEGORY_FIRE      = "Fire"
-    CATEGORY_HEALTH    = "Health"
-    CATEGORY_ENV       = "Env"
-    CATEGORY_TRANSPORT = "Transport"
-    CATEGORY_INFRA     = "Infra"
-    CATEGORY_CBRNE     = "CBRNE"
-    CATEGORY_OTHER     = "Other"
-    ALL_CATEGORIES = [ CATEGORY_GEO, CATEGORY_MET, CATEGORY_SAFETY,
+    CATEGORY_GEO       = "Geo"       # :nodoc:
+    CATEGORY_MET       = "Met"       # :nodoc:
+    CATEGORY_SAFETY    = "Safety"    # :nodoc:
+    CATEGORY_SECURITY  = "Security"  # :nodoc:
+    CATEGORY_RESCUE    = "Rescue"    # :nodoc:
+    CATEGORY_FIRE      = "Fire"      # :nodoc:
+    CATEGORY_HEALTH    = "Health"    # :nodoc:
+    CATEGORY_ENV       = "Env"       # :nodoc:
+    CATEGORY_TRANSPORT = "Transport" # :nodoc:
+    CATEGORY_INFRA     = "Infra"     # :nodoc:
+    CATEGORY_CBRNE     = "CBRNE"     # :nodoc:
+    CATEGORY_OTHER     = "Other"     # :nodoc:
+		# Valid values for categories
+    VALID_CATEGORIES = [ CATEGORY_GEO, CATEGORY_MET, CATEGORY_SAFETY,
       CATEGORY_SECURITY, CATEGORY_RESCUE,   CATEGORY_FIRE, CATEGORY_HEALTH,
       CATEGORY_ENV, CATEGORY_TRANSPORT, CATEGORY_INFRA, CATEGORY_CBRNE,
-      CATEGORY_OTHER ] # :nodoc:
-    RESPONSE_TYPE_SHELTER  = "Shelter"
-    RESPONSE_TYPE_EVACUATE = "Evacuate"
-    RESPONSE_TYPE_PREPARE  = "Prepare"
-    RESPONSE_TYPE_EXECUTE  = "Execute"
-    RESPONSE_TYPE_MONITOR  = "Monitor"
-    RESPONSE_TYPE_ASSESS   = "Assess"
-    RESPONSE_TYPE_NONE     = "None"
-    ALL_RESPONSE_TYPES = [ RESPONSE_TYPE_SHELTER, RESPONSE_TYPE_EVACUATE,
+      CATEGORY_OTHER ]
+    RESPONSE_TYPE_SHELTER  = "Shelter"  # :nodoc:
+    RESPONSE_TYPE_EVACUATE = "Evacuate" # :nodoc:
+    RESPONSE_TYPE_PREPARE  = "Prepare"  # :nodoc:
+    RESPONSE_TYPE_EXECUTE  = "Execute"  # :nodoc:
+    RESPONSE_TYPE_MONITOR  = "Monitor"  # :nodoc:
+    RESPONSE_TYPE_ASSESS   = "Assess"   # :nodoc:
+    RESPONSE_TYPE_NONE     = "None"     # :nodoc:
+		# Valid values for response_type
+    VALID_RESPONSE_TYPES = [ RESPONSE_TYPE_SHELTER, RESPONSE_TYPE_EVACUATE,
       RESPONSE_TYPE_PREPARE, RESPONSE_TYPE_EXECUTE, RESPONSE_TYPE_MONITOR,
-      RESPONSE_TYPE_ASSESS, RESPONSE_TYPE_NONE ] # :nodoc:
-    URGENCY_IMMEDIATE = "Immediate"
-    URGENCY_EXPECTED  = "Expected"
-    URGENCY_FUTURE    = "Future"
-    URGENCY_PAST      = "Past"
-    URGENCY_UNKNOWN   = "Unknown"
-    ALL_URGENCIES = [ URGENCY_IMMEDIATE, URGENCY_EXPECTED, URGENCY_FUTURE,
-      URGENCY_PAST, URGENCY_UNKNOWN ] # :nodoc:
-    SEVERITY_EXTREME  = "Extreme"
-    SEVERITY_SEVERE   = "Severe"
-    SEVERITY_MODERATE = "Moderate"
-    SEVERITY_MINOR    = "Minor"
-    SEVERITY_UNKNOWN  = "Unknown"
-    ALL_SEVERITIES = [ SEVERITY_EXTREME, SEVERITY_SEVERE, SEVERITY_MODERATE,
-      SEVERITY_MINOR, SEVERITY_UNKNOWN ] # :nodoc:
-    CERTAINTY_OBSERVED = "Observed"
-    CERTAINTY_LIKELY   = "Likely"
-    CERTAINTY_POSSIBLE = "Possible"
-    CERTAINTY_UNLIKELY = "Unlikely"
-    CERTAINTY_UNKNOWN  = "Unknown"
-    ALL_CERTAINTIES = [ CERTAINTY_OBSERVED, CERTAINTY_LIKELY,
-      CERTAINTY_POSSIBLE, CERTAINTY_UNLIKELY, CERTAINTY_UNKNOWN ] # :nodoc:
+      RESPONSE_TYPE_ASSESS, RESPONSE_TYPE_NONE ]
+    URGENCY_IMMEDIATE = "Immediate" # :nodoc:
+    URGENCY_EXPECTED  = "Expected"  # :nodoc:
+    URGENCY_FUTURE    = "Future"    # :nodoc:
+    URGENCY_PAST      = "Past"      # :nodoc:
+    URGENCY_UNKNOWN   = "Unknown"   # :nodoc:
+		# Valid values for urgency
+    VALID_URGENCIES = [ URGENCY_IMMEDIATE, URGENCY_EXPECTED, URGENCY_FUTURE,
+      URGENCY_PAST, URGENCY_UNKNOWN ]
+    SEVERITY_EXTREME  = "Extreme"  # :nodoc:
+    SEVERITY_SEVERE   = "Severe"   # :nodoc:
+    SEVERITY_MODERATE = "Moderate" # :nodoc:
+    SEVERITY_MINOR    = "Minor"    # :nodoc:
+    SEVERITY_UNKNOWN  = "Unknown"  # :nodoc:
+		# Valid values for severity
+    VALID_SEVERITIES = [ SEVERITY_EXTREME, SEVERITY_SEVERE, SEVERITY_MODERATE,
+      SEVERITY_MINOR, SEVERITY_UNKNOWN ]
+    CERTAINTY_OBSERVED = "Observed" # :nodoc:
+    CERTAINTY_LIKELY   = "Likely"   # :nodoc:
+    CERTAINTY_POSSIBLE = "Possible" # :nodoc:
+    CERTAINTY_UNLIKELY = "Unlikely" # :nodoc:
+    CERTAINTY_UNKNOWN  = "Unknown"  # :nodoc:
+		# Valid valies for certainty
+    VALID_CERTAINTIES = [ CERTAINTY_OBSERVED, CERTAINTY_LIKELY,
+      CERTAINTY_POSSIBLE, CERTAINTY_UNLIKELY, CERTAINTY_UNKNOWN ]
     XML_ELEMENT_NAME           = 'info'         # :nodoc:
     LANGUAGE_ELEMENT_NAME      = 'language'     # :nodoc:
@@ -107,16 +112,19 @@ module RCAP
     validates_presence_of( :event, :urgency, :severity, :certainty )
     validates_length_of( :categories, :minimum => 1 )
-    validates_inclusion_of( :certainty, :allow_nil => true, :in => ALL_CERTAINTIES, :message => "can only be assigned the following values: #{ ALL_CERTAINTIES.join(', ') }")
-    validates_inclusion_of( :severity, :allow_nil  => true, :in => ALL_SEVERITIES, :message  => "can only be assigned the following values: #{ ALL_SEVERITIES.join(', ') }" )
-    validates_inclusion_of( :urgency, :allow_nil   => true, :in => ALL_URGENCIES, :message   => "can only be assigned the following values: #{ ALL_URGENCIES.join(', ') }" )
-    validates_inclusion_of_members_of( :response_types, :in => ALL_RESPONSE_TYPES, :allow_blank => true )
-		validates_inclusion_of_members_of( :categories, :in => ALL_CATEGORIES, :allow_blank => true )
+    validates_inclusion_of( :certainty, :allow_nil => true, :in => VALID_CERTAINTIES, :message => "can only be assigned the following values: #{ VALID_CERTAINTIES.join(', ') }")
+    validates_inclusion_of( :severity, :allow_nil  => true, :in => VALID_SEVERITIES, :message  => "can only be assigned the following values: #{ VALID_SEVERITIES.join(', ') }" )
+    validates_inclusion_of( :urgency, :allow_nil   => true, :in => VALID_URGENCIES, :message   => "can only be assigned the following values: #{ VALID_URGENCIES.join(', ') }" )
+    validates_inclusion_of_members_of( :response_types, :in  => VALID_RESPONSE_TYPES, :allow_blank => true )
+    validates_inclusion_of_members_of( :categories,     :in  => VALID_CATEGORIES,     :allow_blank => true )
     validates_collection_of( :resources, :areas )
     attr_accessor( :event )
+		# Value can only be one of VALID_URGENCIES
 		attr_accessor( :urgency )
+		# Value can only be one of VALID_SEVERITIES
 		attr_accessor( :severity )
+		# Value can only be one of VALID_CERTAINTIES
 		attr_accessor( :certainty )
 		attr_accessor( :language )
 		attr_accessor( :audience )
@@ -124,7 +132,7 @@ module RCAP
 		attr_accessor( :effective )
 		# Expected start of event
 		attr_accessor( :onset )
-		# Effected expiry time of information
+		# Effective expiry time of information
 		attr_accessor( :expires )
 		attr_accessor( :sender_name )
 		attr_accessor( :headline )
@@ -133,7 +141,7 @@ module RCAP
 		attr_accessor( :web )
 		attr_accessor( :contact )
-		# Collection of textual categories
+		# Collection of textual categories; elements can be one of VALID_CATEGORIES
     attr_reader( :categories )
 		#  Collection of textual response types
 		attr_reader( :response_types )
@@ -186,15 +194,15 @@ module RCAP
       @event_codes.each do |event_code|
         xml_element.add_element( event_code.to_xml_element )
       end
-      xml_element.add_element( EFFECTIVE_ELEMENT_NAME ).add_text( self.effective.to_s ) if self.effective
-      xml_element.add_element( ONSET_ELEMENT_NAME ).add_text( self.onset.to_s )         if self.onset
-      xml_element.add_element( EXPIRES_ELEMENT_NAME ).add_text( self.expires.to_s )     if self.expires
-      xml_element.add_element( SENDER_NAME_ELEMENT_NAME ).add_text( self.sender_name )  if self.sender_name
-      xml_element.add_element( HEADLINE_ELEMENT_NAME ).add_text( self.headline )        if self.headline
-      xml_element.add_element( DESCRIPTION_ELEMENT_NAME ).add_text( self.description )  if self.description
-      xml_element.add_element( INSTRUCTION_ELEMENT_NAME ).add_text( self.instruction )  if self.instruction
-      xml_element.add_element( WEB_ELEMENT_NAME ).add_text( self.web )                  if self.web
-      xml_element.add_element( CONTACT_ELEMENT_NAME ).add_text( self.contact )          if self.contact
+      xml_element.add_element( EFFECTIVE_ELEMENT_NAME ).add_text( self.effective.to_s_for_cap ) if self.effective
+      xml_element.add_element( ONSET_ELEMENT_NAME ).add_text( self.onset.to_s_for_cap )         if self.onset
+      xml_element.add_element( EXPIRES_ELEMENT_NAME ).add_text( self.expires.to_s_for_cap )     if self.expires
+      xml_element.add_element( SENDER_NAME_ELEMENT_NAME ).add_text( self.sender_name )          if self.sender_name
+      xml_element.add_element( HEADLINE_ELEMENT_NAME ).add_text( self.headline )                if self.headline
+      xml_element.add_element( DESCRIPTION_ELEMENT_NAME ).add_text( self.description )          if self.description
+      xml_element.add_element( INSTRUCTION_ELEMENT_NAME ).add_text( self.instruction )          if self.instruction
+      xml_element.add_element( WEB_ELEMENT_NAME ).add_text( self.web )                          if self.web
+      xml_element.add_element( CONTACT_ELEMENT_NAME ).add_text( self.contact )                  if self.contact
       @parameters.each do |parameter|
         xml_element.add_element( parameter.to_xml_element )
       end
@@ -211,6 +219,43 @@ module RCAP
       self.to_xml_element.to_s
     end
+		def inspect # :nodoc:
+			info_inspect = <<EOF
+Language:       #{ self.language }
+Categories:     #{ self.categories.to_s_for_cap }
+Event:          #{ self.event }
+Response Types: #{ self.response_types.to_s_for_cap }
+Urgency:        #{ self.urgency }
+Severity:       #{ self.severity }
+Certainty:      #{ self.certainty }
+Audience:       #{ self.audience }
+Event Codes:    #{ self.event_codes.inspect }
+Effective:      #{ self.effective }
+Onset:          #{ self.onset }
+Expires:        #{ self.expires }
+Sender Name:    #{ self.sender_name }
+Headline:       #{ self.headline }
+Description:
+#{ self.description.to_s.lines.map{ |line| "  " + line }.join }
+Instruction:    #{ self.instruction }
+Web:            #{ self.web }
+Contact:        #{ self.contact }
+Parameters:
+#{ self.parameters.map{ |parameter| parameter.inspect }.join( "\n" )}
+Resources:
+#{ self.resources.map{ |resource| "  " + resource.inspect }.join( "\n" )}
+Area:
+#{ self.areas.map{ |area| "  #{ area }" }.join( "\n" )}
+EOF
+      RCAP.format_lines_for_inspect( 'INFO', info_inspect )
+		end
+		# Returns a string representation of the event of the form
+		#  event(urgency/severity/certainty)
+    def to_s
+      "#{ self.event }(#{ self.urgency }/#{ self.severity }/#{ self.certainty })"
+    end
     def self.from_xml_element( info_xml_element ) # :nodoc:
       self.new(
         :language       => RCAP.xpath_text( info_xml_element, LANGUAGE_XPATH ) || DEFAULT_LANGUAGE,
@@ -230,9 +275,92 @@ module RCAP
         :instruction    => RCAP.xpath_text( info_xml_element, INSTRUCTION_XPATH ),
         :web            => RCAP.xpath_text( info_xml_element, WEB_XPATH ),
         :contact        => RCAP.xpath_text( info_xml_element, CONTACT_XPATH ),
-				:event_codes    => RCAP.xpath_match( info_xml_element, RCAP::EventCode::XPATH ).map{ |element| RCAP::EventCode.from_xml_element( element )},
-				:parameters => RCAP.xpath_match( info_xml_element, RCAP::Parameter::XPATH ).map{ |element| RCAP::Parameter.from_xml_element( element )},
-				:areas => RCAP.xpath_match( info_xml_element, RCAP::Area::XPATH ).map{ |element| RCAP::Area.from_xml_element( element )}
+        :event_codes    => RCAP.xpath_match( info_xml_element, RCAP::EventCode::XPATH ).map{ |element| RCAP::EventCode.from_xml_element( element )},
+        :parameters     => RCAP.xpath_match( info_xml_element, RCAP::Parameter::XPATH ).map{ |element| RCAP::Parameter.from_xml_element( element )},
+        :resources      => RCAP.xpath_match( info_xml_element, RCAP::Resource::XPATH ).map{ |element| RCAP::Resource.from_xml_element( element )},
+        :areas          => RCAP.xpath_match( info_xml_element, RCAP::Area::XPATH ).map{ |element| RCAP::Area.from_xml_element( element )}
+      )
+    end
+    LANGUAGE_YAML       = 'Language'
+    CATEGORIES_YAML     = 'Categories'
+    EVENT_YAML          = 'Event'
+    RESPONSE_TYPES_YAML = 'Response Types'
+    URGENCY_YAML        = 'Urgency'
+    SEVERITY_YAML       = 'Severity'
+    CERTAINTY_YAML      = 'Certainty'
+    AUDIENCE_YAML       = 'Audience'
+    EFFECTIVE_YAML      = 'Effective'
+    ONSET_YAML          = 'Onset'
+    EXPIRES_YAML        = 'Expires'
+    SENDER_NAME_YAML    = 'Sender Name'
+    HEADLINE_YAML       = 'Headline'
+    DESCRIPTION_YAML    = 'Description'
+    INSTRUCTION_YAML    = 'Instruction'
+    WEB_YAML            = 'Web'
+    CONTACT_YAML        = 'Contact'
+    EVENT_CODES_YAML    = 'Event Codes'
+    PARAMETERS_YAML     = 'Parameters'
+    RESOURCES_YAML      = 'Resources'
+    AREAS_YAML          = 'Areas'
+    def to_yaml( options = {} ) # :nodoc:
+      response_types_yaml = self.response_types
+      def response_types_yaml.to_yaml_style; :inline; end
+      categories_yaml = self.categories
+      def categories_yaml.to_yaml_style; :inline; end
+      parameter_to_hash = lambda{ |hash, parameter| hash.merge( parameter.name => parameter.value )}
+      RCAP.attribute_values_to_yaml_hash(
+        [ LANGUAGE_YAML,       self.language ],
+        [ CATEGORIES_YAML,     categories_yaml ],
+        [ EVENT_YAML,          self.event ],
+        [ RESPONSE_TYPES_YAML, response_types_yaml ],
+        [ URGENCY_YAML,        self.urgency ],
+        [ SEVERITY_YAML,       self.severity ],
+        [ CERTAINTY_YAML,      self.certainty ],
+        [ AUDIENCE_YAML,       self.audience ],
+        [ EFFECTIVE_YAML,      self.effective ],
+        [ ONSET_YAML,          self.onset ],
+        [ EXPIRES_YAML,        self.expires ],
+        [ SENDER_NAME_YAML,    self.sender_name ],
+        [ HEADLINE_YAML,       self.headline ],
+        [ DESCRIPTION_YAML,    self.description ],
+        [ INSTRUCTION_YAML,    self.instruction ],
+        [ WEB_YAML,            self.web ],
+        [ CONTACT_YAML,        self.contact ],
+        [ EVENT_CODES_YAML,    self.event_codes.inject({}, &parameter_to_hash )],
+        [ PARAMETERS_YAML,     self.parameters.inject({}, &parameter_to_hash )],
+        [ RESOURCES_YAML,      self.resources ],
+        [ AREAS_YAML,          self.areas ]
+      ).to_yaml( options )
+    end
+    def self.from_yaml_data( info_yaml_data ) # :nodoc:
+      self.new(
+        :language       => info_yaml_data [ LANGUAGE_YAML ],
+        :categories     => info_yaml_data [ CATEGORIES_YAML ],
+        :event          => info_yaml_data [ EVENT_YAML ],
+        :response_types => info_yaml_data [ RESPONSE_TYPES_YAML ],
+        :urgency        => info_yaml_data [ URGENCY_YAML ],
+        :severity       => info_yaml_data [ SEVERITY_YAML ],
+        :certainty      => info_yaml_data [ CERTAINTY_YAML ],
+        :audience       => info_yaml_data [ AUDIENCE_YAML ],
+        :effective      => ( effective = info_yaml_data[ EFFECTIVE_YAML ]).blank? ? nil : DateTime.parse( effective.to_s ),
+        :onset          => ( onset = info_yaml_data[ ONSET_YAML ]).blank? ? nil : DateTime.parse( onset.to_s ),
+        :expires        => ( expires = info_yaml_data[ EXPIRES_YAML ]).blank? ? nil : DateTime.parse( expires.to_s ),
+        :sender_name    => info_yaml_data [ SENDER_NAME_YAML ],
+        :headline       => info_yaml_data [ HEADLINE_YAML ],
+        :description    => info_yaml_data [ DESCRIPTION_YAML ],
+        :instruction    => info_yaml_data [ INSTRUCTION_YAML ],
+        :web            => info_yaml_data [ WEB_YAML ],
+        :contact        => info_yaml_data [ CONTACT_YAML ],
+        :event_codes    => Array( info_yaml_data [ EVENT_CODES_YAML ]).map{ |name,value| RCAP::EventCode.new( :name => name, :value => value )},
+        :parameters     => Array( info_yaml_data [ PARAMETERS_YAML ]).map{ |parameter_yaml_data| RCAP::Parameter.new( :name => name, :value => value )},
+        :resources      => Array( info_yaml_data [ RESOURCES_YAML ]).map{ |resource_yaml_data| RCAP::Resource.from_yaml_data( resource_yaml_data )},
+        :areas          => Array( info_yaml_data [ AREAS_YAML ]).map{ |area_yaml_data| RCAP::Area.from_yaml_data( area_yaml_data )}
       )
     end
   end

data/lib/rcap/parameter.rb CHANGED Viewed

@@ -34,10 +34,12 @@ module RCAP
 		end
     def inspect # :nodoc:
-      "#{ self.name }: #{ self.value }"
+			"#{ self.name }: #{ self.value }"
     end
-    def to_s # :nodoc:
+		# Returns a string representation of the parameter of the form
+		#  name: value
+    def to_s
       self.inspect
 		end

data/lib/rcap/point.rb CHANGED Viewed

@@ -22,7 +22,9 @@ module RCAP
       @longitude = attributes[ :longitude ]
     end
-    def to_s # :nodoc:
+		# Returns a string representation of the point of the form
+		#  lattitude,longitude
+    def to_s
       "#{ self.lattitude },#{ self.longitude }"
     end
@@ -32,8 +34,7 @@ module RCAP
 		# Two points are equivalent if they have the same lattitude and longitude
 		def ==( other )
-			self.lattitude == other.lattitude &&
-				self.longitude == other.longitude
+			[ self.lattitude, self.longitude ] == [ other.lattitude, other.longitude ]
 		end
   end
 end

data/lib/rcap/polygon.rb CHANGED Viewed

@@ -18,7 +18,10 @@ module RCAP
       @points = Array( attributes[ :points ])
     end
-    def to_s # :nodoc:
+		# Returns a string representation of the polygon of the form
+		#  points[0] points[1] points[2] ... points[n-1] points[0]
+    # where each point is formatted with RCAP::Point#to_s
+    def to_s
       (@points.map{ |point| point.to_s } + [ @points.first ]).join( ' ' )
     end
@@ -46,5 +49,19 @@ module RCAP
       points = coordinates.map{ |lattitude, longitude| RCAP::Point.new( :lattitude => lattitude, :longitude => longitude )}[0..-2]
       polygon = self.new( :points => points )
     end
+    def to_yaml( options = {} ) # :nodoc:
+      yaml_points = self.points.map{ |point| [ point.lattitude, point.longitude ]}
+      def yaml_points.to_yaml_style; :inline; end
+      yaml_points.to_yaml( options )
+    end
+    def self.from_yaml_data( polyon_yaml_data ) # :nodoc:
+      self.new(
+        :points => Array( polygon_yaml_data ).map{ |lattitude, longitude| Point.new( :lattitude => lattitude, :longitude => longitude )}
+      )
+    end
   end
 end

data/lib/rcap/resource.rb CHANGED Viewed

@@ -69,13 +69,48 @@ module RCAP
       [ self.resource_desc, self.uri, self.mime_type, self.size ? format( "%.1fKB", self.size_in_kb ) : nil ].compact.join(' - ')
     end
+		# Returns a string representation of the resource of the form
+		#  resource_desc
+    def to_s
+      self.resource_desc
+    end
     def self.from_xml_element( resource_xml_element ) # :nodoc:
       resource = self.new( :resource_desc => RCAP.xpath_text( resource_xml_element, RESOURCE_DESC_XPATH ),
-                           :uri           => RCAP.xpath_text( resource_xml_element, URI_XPATH ),
-                           :mime_type     => RCAP.xpath_text( resource_xml_element, MIME_TYPE_XPATH ),
-                           :deref_uri     => RCAP.xpath_text( resource_xml_element, DEREF_URI_XPATH ),
-                           :size          => RCAP.xpath_text( resource_xml_element, SIZE_XPATH ),
-                           :digest        => RCAP.xpath_text( resource_xml_element, DIGEST_XPATH ))
+                          :uri           => RCAP.xpath_text( resource_xml_element, URI_XPATH ),
+                          :mime_type     => RCAP.xpath_text( resource_xml_element, MIME_TYPE_XPATH ),
+                          :deref_uri     => RCAP.xpath_text( resource_xml_element, DEREF_URI_XPATH ),
+                          :size          => RCAP.xpath_text( resource_xml_element, SIZE_XPATH ),
+                          :digest        => RCAP.xpath_text( resource_xml_element, DIGEST_XPATH ))
+    end
+    RESOURCE_DESC_YAML = "Resource Description" # :nodoc:
+    URI_YAML           = "URI"                  # :nodoc:
+    MIME_TYPE_YAML     = "Mime Type"            # :nodoc:
+    DEREF_URI_YAML     = "Derefrenced URI Data" # :nodoc:
+    SIZE_YAML          = "Size"                 # :nodoc:
+    DIGEST_YAML        = "Digest"               # :nodoc:
+    def to_yaml( options ) # :nodoc:
+      RCAP.attribute_values_to_yaml_hash(
+        [ RESOURCE_DESC_YAML, self.resource_desc ],
+        [ URI_YAML,           self.uri ],
+        [ MIME_TYPE_YAML,     self.mime_type ],
+        [ DEREF_URI_YAML,     self.deref_uri ],
+        [ SIZE_YAML,          self.size ],
+        [ DIGEST_YAML,        self.digest ]
+      ).to_yaml( options )
+    end
+    def self.from_yaml_data( resource_yaml_data ) # :nodoc:
+      self.new(
+        :resource_desc => reource_yaml_data[ RESOURCE_DESC_YAML ],
+        :uri           => reource_yaml_data[ URI_YAML ],
+        :mime_type     => reource_yaml_data[ MIME_TYPE_YAML ],
+        :deref_uri     => reource_yaml_data[ DEREF_URI_YAML ],
+        :size          => reource_yaml_data[ SIZE_YAML ],
+        :digest        => reource_yaml_data[ DIGEST_YAML ]
+      )
     end
   end
 end

data/lib/rcap/utilities.rb CHANGED Viewed

@@ -29,8 +29,11 @@ class DateTime # :nodoc:
 end
 class Time # :nodoc:
-  def to_s_for_cap
+	RCAP_TIME_FORMAT = "%Y-%m-%dT%H:%M:%S"
+	RCAP_ZONE_FORMAT = "%+02i:00"
+	def to_s_for_cap
+	  self.strftime( RCAP_TIME_FORMAT ) + format( RCAP_ZONE_FORMAT , self.utc_hours_offset )
   end
 end
@@ -47,4 +50,17 @@ module RCAP # :nodoc:
 	def self.xpath_match( xml_element, xpath )
 		REXML::XPath.match( xml_element, xpath, { 'cap' => RCAP::XMLNS })
 	end
+  def self.format_lines_for_inspect( header, inspect_string )
+    max_line_length = inspect_string.lines.inject( 0 ){ |max_length, line| line.chomp.length > max_length ? line.chomp.length : max_length }
+    "\n." + '-' * max_line_length + ".\n"+
+    '|' + header.ljust( max_line_length ) + "|\n"+
+    '|' + '-' * max_line_length + "|\n"+
+    inspect_string.lines.map{ |line| '|' + line.chomp.ljust( max_line_length ) +'|'}.join( "\n" ) + "\n" +
+    "'" + '-' * max_line_length + "'\n"
+  end
+  def self.attribute_values_to_yaml_hash( *attribute_values )
+    Hash[ *attribute_values.reject{ |key, value| value.blank? }.flatten( 1 )]
+  end
 end

data/lib/rcap/validations.rb CHANGED Viewed

@@ -1,8 +1,8 @@
 module Validation  # :nodoc:
   module ClassMethods # :nodoc:
-		NUMBER_RE  = /^-{0,1}\d*\.{0,1}\d+$/
-		INTEGER_RE = /\-{0,1}A[+-]?\d+\Z/
+		CAP_NUMBER_RE  = /^-{0,1}\d*\.{0,1}\d+$/
+		CAP_INTEGER_RE = /\-{0,1}A[+-]?\d+\Z/
     def validates_inclusion_of( *attributes )
       options = {
@@ -88,7 +88,7 @@ module Validation  # :nodoc:
 				:message => 'is not a number',
 			}.merge!(attributes.extract_options!)
-			re = options[:only_integer] ? INTEGER_RE : NUMBER_RE
+			re = options[:only_integer] ? CAP_INTEGER_RE : CAP_NUMBER_RE
 			validates_each( *attributes ) do |object, attribute, value|
 				next if (value.nil? && options[ :allow_nil ]) || (value.blank? && options[ :allow_blank ])

data/lib/rcap.rb CHANGED Viewed

@@ -17,5 +17,5 @@ require 'rcap/area'
 module RCAP
 	XMLNS = "urn:oasis:names:tc:emergency:cap:1.1"
-	VERSION = "0.1"
+	VERSION = "0.2"
 end

data/spec/alert_spec.rb CHANGED Viewed

@@ -20,6 +20,26 @@ describe( RCAP::Alert ) do
     it( 'should not have any incidents' ){ @alert.incidents.should( be_empty )}
     it( 'should not have any infos' ){ @alert.infos.should( be_empty )}
+		shared_examples_for( "a successfully parsed alert" ) do
+			it( 'should parse identifier correctly' ){ @alert.identifier.should == @original_alert.identifier }
+			it( 'should parse sender correctly' ){ @alert.sender.should == @original_alert.sender }
+			it( 'should parse sent correctly' ){ @alert.sent.should( be_close( @original_alert.sent, Rational( 1, 86400 )))}
+			it( 'should parse status correctly' ){ @alert.status.should == @original_alert.status }
+			it( 'should parse msg_type correctly' ){ @alert.msg_type.should == @original_alert.msg_type }
+			it( 'should parse source correctly' ){ @alert.source.should == @original_alert.source }
+			it( 'should parse scope correctly' ){ @alert.scope.should == @original_alert.scope }
+			it( 'should parse restriction correctly' ){ @alert.restriction.should == @original_alert.restriction }
+			it( 'should parse addresses correctly' ){ @alert.addresses.should == @original_alert.addresses }
+			it( 'should parse code correctly' ){ @alert.code.should == @original_alert.code }
+			it( 'should parse note correctly' ){ @alert.note.should == @original_alert.note }
+			it( 'should parse references correctly' ){ @alert.references.should == @original_alert.references }
+			it( 'should parse incidents correctly' ){ @alert.incidents.should == @original_alert.incidents }
+			it( 'should parse infos correctly' ) do
+				@alert.infos.size.should == @original_alert.infos.size
+				@alert.infos.each{ |info| info.class.should == RCAP::Info }
+			end
+		end
 		context( 'from XML' ) do
 			before( :each ) do
 				@original_alert = RCAP::Alert.new( :sender => 'Sender',
@@ -39,24 +59,28 @@ describe( RCAP::Alert ) do
 				@alert = RCAP::Alert.from_xml_element( @alert_element )
 			end
-			it( 'should parse identifier correctly' ){ @alert.identifier.should == @original_alert.identifier }
-			it( 'should parse sender correctly' ){ @alert.sender.should == @original_alert.sender }
-			it( 'should parse sent correctly' ){ @alert.sent.should( be_close( @original_alert.sent, Rational( 1, 86400 )))}
-			it( 'should parse status correctly' ){ @alert.status.should == @original_alert.status }
-			it( 'should parse msg_type correctly' ){ @alert.msg_type.should == @original_alert.msg_type }
-			it( 'should parse source correctly' ){ @alert.source.should == @original_alert.source }
-			it( 'should parse scope correctly' ){ @alert.scope.should == @original_alert.scope }
-			it( 'should parse restriction correctly' ){ @alert.restriction.should == @original_alert.restriction }
-			it( 'should parse addresses correctly' ){ @alert.addresses.should == @original_alert.addresses }
-			it( 'should parse code correctly' ){ @alert.code.should == @original_alert.code }
-			it( 'should parse note correctly' ){ @alert.note.should == @original_alert.note }
-			it( 'should parse references correctly' ){ @alert.references.should == @original_alert.references }
-      it( 'should parse incidents correctly' ){ @alert.incidents.should == @original_alert.incidents }
-      it( 'should parse infos correctly' ) do
-        @alert.infos.size.should == @original_alert.infos.size
-        @alert.infos.each{ |info| info.class.should == RCAP::Info }
-      end
+			it_should_behave_like( "a successfully parsed alert" )
     end
+		context( 'from YAML' ) do
+			before( :each ) do
+				@original_alert = RCAP::Alert.new( :sender => 'Sender',
+													 :status => RCAP::Alert::STATUS_TEST,
+													 :scope => RCAP::Alert::SCOPE_PUBLIC,
+													 :source => 'Source',
+													 :restriction => 'No Restriction',
+													 :addresses => [ 'Address 1', 'Address 2'],
+													 :code => 'Code',
+													 :note => 'Note',
+													 :references => [ RCAP::Alert.new( :sender => 'Sender1' ).to_reference, RCAP::Alert.new( :sender => 'Sender2' ).to_reference ],
+													 :incidents => [ 'Incident1', 'Incident2' ],
+													 :infos => [ RCAP::Info.new, RCAP::Info.new ])
+				@yaml_string = @original_alert.to_yaml
+				@alert = RCAP::Alert.from_yaml( @yaml_string )
+			end
+			it_should_behave_like( "a successfully parsed alert" )
+		end
   end
   describe( 'is not valid if it' ) do

metadata CHANGED Viewed

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rcap
 version: !ruby/object:Gem::Version
-  version: "0.1"
+  version: "0.2"
 platform: ruby
 authors:
 - Farrel Lifson
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
-date: 2009-11-03 00:00:00 +02:00
+date: 2009-11-20 00:00:00 +02:00
 default_executable:
 dependencies:
 - !ruby/object:Gem::Dependency
@@ -39,8 +39,8 @@ executables: []
 extensions: []
 extra_rdoc_files:
-- README
-- CHANGELOG
+- README.rdoc
+- CHANGELOG.rdoc
 files:
 - lib/rcap.rb
 - lib/rcap/area.rb
@@ -55,8 +55,8 @@ files:
 - lib/rcap/parameter.rb
 - lib/rcap/event_code.rb
 - lib/rcap/info.rb
-- README
-- CHANGELOG
+- README.rdoc
+- CHANGELOG.rdoc
 has_rdoc: true
 homepage: http://www.aimred.com/projects/rcap
 licenses: []

data/CHANGELOG DELETED Viewed

	@@ -1,2 +0,0 @@
1	- 0.1 - 5th November 2009
2	- * Initial release