rcap 1.3.0 → 1.3.1

data/lib/rcap/cap_1_2/area.rb

@@ -9,33 +9,42 @@ module RCAP
     class Area
       include Validation
 
-      # Area Description - Textual description of area.
+      # @return [String] Textual description of area. 
       attr_accessor( :area_desc )
-      # Expressed in feet above sea level
+      # @return [Numeric] Expressed in feet above sea level 
       attr_accessor( :altitude )
-      # Expressed in feet above sea level.
+      # @return [Numeric] Expressed in feet above sea level. 
       attr_accessor( :ceiling )
-      # Collection of Circle objects
+      # @return [Array<Circle>]
       attr_reader( :circles )
-      # Collection of Geocode objects
+      # @return [Array<Geocode>]
       attr_reader( :geocodes )
-      # Collection of Polygon objects
+      # @return [Array<Polygon>]
       attr_reader( :polygons )
 
       validates_presence_of( :area_desc )
       validates_collection_of( :circles, :geocodes, :polygons, allow_empty: true )
       validates_dependency_of( :ceiling, on: :altitude )
 
-      XML_ELEMENT_NAME       = 'area'     # :nodoc:
-      AREA_DESC_ELEMENT_NAME = 'areaDesc' # :nodoc:
-      ALTITUDE_ELEMENT_NAME  = 'altitude' # :nodoc:
-      CEILING_ELEMENT_NAME   = 'ceiling'  # :nodoc:
-
-      XPATH           = "cap:#{ XML_ELEMENT_NAME }"       # :nodoc:
-      AREA_DESC_XPATH = "cap:#{ AREA_DESC_ELEMENT_NAME }" # :nodoc:
-      ALTITUDE_XPATH  = "cap:#{ ALTITUDE_ELEMENT_NAME }"  # :nodoc:
-      CEILING_XPATH   = "cap:#{ CEILING_ELEMENT_NAME }"   # :nodoc:
-
+      XML_ELEMENT_NAME       = 'area'     
+      AREA_DESC_ELEMENT_NAME = 'areaDesc' 
+      ALTITUDE_ELEMENT_NAME  = 'altitude' 
+      CEILING_ELEMENT_NAME   = 'ceiling'  
+
+      XPATH           = "cap:#{ XML_ELEMENT_NAME }"       
+      AREA_DESC_XPATH = "cap:#{ AREA_DESC_ELEMENT_NAME }" 
+      ALTITUDE_XPATH  = "cap:#{ ALTITUDE_ELEMENT_NAME }"  
+      CEILING_XPATH   = "cap:#{ CEILING_ELEMENT_NAME }"   
+
+      # @example
+      #   Area.new( area_desc: 'Cape Town CBD' )
+      # @param [Hash] attributes Area attributes
+      # @option attributes [String] :area_desc Area description
+      # @option attributes [Numeric] :altitude Altitude above sea level (in feet)
+      # @option attributes [Numeric] :ceiling Ceiling above sea level (in feet)
+      # @option attributes [Array<Circle>] :circles Collection of {Circle} 
+      # @option attributes [Array<Geocode>] :geocodes Collection of {Geocode} 
+      # @option attributes [Array<Polygon>] :polygons Collection of {Polygon}
       def initialize( attributes = {})
         @area_desc = attributes[ :area_desc ]
         @altitude  = attributes[ :altitude ]
@@ -45,31 +54,41 @@ module RCAP
         @polygons  = Array( attributes[ :polygons ])
       end
 
-      # Creates a new Polygon object and adds it to the polygons array. The
-      # polygon_attributes are passed as a parameter to Polygon.new.
+      # Creates a new {Polygon} object and adds it to the {#polygons} array.
+      #
+      # @see Polygon#initialize
+      # @param [Hash] polygon_attributes see {Polygon#initialize}
+      # @return [Polygon]
       def add_polygon( polygon_attributes = {})
         polygon = Polygon.new( polygon_attributes )
-        self.polygons << polygon
+        @polygons << polygon
         polygon
       end
 
-      # Creates a new Circle object and adds it to the circles array. The
-      # circle_attributes are passed as a parameter to Circle.new.
+      # Creates a new {Circle} object and adds it to the {#circles} array.
+      #
+      # @see Circle#initialize
+      # @param [Hash] circle_attributes see {Circle#initialize}
+      # @return [Circle]
       def add_circle( circle_attributes = {})
         circle = Circle.new( circle_attributes )
-        self.circles << circle
+        @circles << circle
         circle
       end
 
-      # Creates a new Geocode object and adds it to the geocodes array. The
-      # geocode_attributes are passed as a parameter to Geocode.new.
+      # Creates a new {Geocode} object and adds it to the {#geocodes} array.
+      #
+      # @see Geocode#initialize
+      # @param [Hash] geocode_attributes see {Geocode#initialize}
+      # @return [Geocode]
       def add_geocode( geocode_attributes = {})
         geocode = Geocode.new( geocode_attributes )
-        self.geocodes << geocode
+        @geocodes << geocode
         geocode
       end
 
-      def to_xml_element # :nodoc:
+      # @return [REXML::Element]
+      def to_xml_element 
         xml_element = REXML::Element.new( XML_ELEMENT_NAME )
         xml_element.add_element( AREA_DESC_ELEMENT_NAME ).add_text( @area_desc.to_s )
         add_to_xml_element = lambda do |element, object|
@@ -79,37 +98,45 @@ module RCAP
         @polygons.inject( xml_element, &add_to_xml_element )
         @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( ALTITUDE_ELEMENT_NAME ).add_text( @altitude.to_s ) unless @altitude.blank?
+        xml_element.add_element( CEILING_ELEMENT_NAME ).add_text( @ceiling.to_s )   unless @altitude.blank?
         xml_element
       end
 
-      def to_xml # :nodoc:
+      # @return [String] XML representation of the Area
+      def to_xml 
         self.to_xml_element.to_s
       end
 
       # Implements an equality operator for the Area object. Two Area objects are equal if all their attributes are equal.
+      #
+      # @param [Area] other Area object to compare
+      # @return [true,false]
       def ==( other )
         comparison_attributes = lambda{ |area| [ area.area_desc, area.altitude, area.ceiling, area.circles, area.geocodes, area.polygons ]}
         comparison_attributes.call( self ) == comparison_attributes.call( other )
       end
 
-      def inspect # :nodoc:
-        area_inspect = "Area Description: #{ self.area_desc }\n"+
+      # @return [String]
+      def inspect 
+        area_inspect = "Area Description: #{ @area_desc }\n"+
                        "Polygons:\n"+
-                       self.polygons.map{ |polygon| "  " + polygon.inspect }.join("\n" )+"\n"+
-                       "Circles:          #{ self.circles.inspect }\n"+
-                       "Geocodes:         #{ self.geocodes.inspect }\n"
+                       @polygons.map{ |polygon| "  " + polygon.inspect }.join("\n" )+"\n"+
+                       "Circles:          #{ @circles.inspect }\n"+
+                       "Geocodes:         #{ @geocodes.inspect }\n"
         RCAP.format_lines_for_inspect( 'AREA', area_inspect )
       end
 
-      # Returns a string representation of the area of the form
-      #  area_desc
+      # Returns the area description
+      #
+      # @return [String]
       def to_s
-        self.area_desc
+        @area_desc
       end
 
-      def self.from_xml_element( area_xml_element ) # :nodoc:
+      # @param [REXML::Element] area_xml_element
+      # @return [Area]
+      def self.from_xml_element( area_xml_element ) 
         self.new( :area_desc => RCAP.xpath_text( area_xml_element, AREA_DESC_XPATH, Alert::XMLNS ),
                   :altitude  => (( alt = RCAP.xpath_text( area_xml_element, ALTITUDE_XPATH, Alert::XMLNS )) ? alt.to_f : nil ),
                   :ceiling   => (( ceil = RCAP.xpath_text( area_xml_element, CEILING_XPATH, Alert::XMLNS )) ? ceil.to_f : nil ),
@@ -118,25 +145,28 @@ module RCAP
                   :polygons  => RCAP.xpath_match( area_xml_element, Polygon::XPATH, Alert::XMLNS ).map{ |polygon_element| 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:
+      AREA_DESC_YAML = 'Area Description' 
+      ALTITUDE_YAML  = 'Altitude'         
+      CEILING_YAML   = 'Ceiling'          
+      CIRCLES_YAML   = 'Circles'          
+      GEOCODES_YAML  = 'Geocodes'         
+      POLYGONS_YAML  = 'Polygons'         
 
-      def to_yaml( options = {} ) # :nodoc:
+      # @return [String] YAML representation of object
+      def to_yaml( options = {} ) 
         RCAP.attribute_values_to_hash(
-          [ AREA_DESC_YAML,  self.area_desc ],
-          [ ALTITUDE_YAML,   self.altitude ],
-          [ CEILING_YAML,    self.ceiling ],
-          [ CIRCLES_YAML,    self.circles.map{ |circle| [ circle.lattitude, circle.longitude, circle.radius ]} ],
-          [ GEOCODES_YAML,   self.geocodes.inject({}){|h,geocode| h.merge( geocode.name => geocode.value )}],
-          [ POLYGONS_YAML,   self.polygons ]
+          [ AREA_DESC_YAML,  @area_desc ],
+          [ ALTITUDE_YAML,   @altitude ],
+          [ CEILING_YAML,    @ceiling ],
+          [ CIRCLES_YAML,    @circles.map{ |circle| [ circle.lattitude, circle.longitude, circle.radius ]} ],
+          [ GEOCODES_YAML,   @geocodes.inject({}){|h,geocode| h.merge( geocode.name => geocode.value )}],
+          [ POLYGONS_YAML,   @polygons ]
         ).to_yaml( options )
       end
 
-      def self.from_yaml_data( area_yaml_data )  # :nodoc:
+      # @param [Hash] area_yaml_data
+      # @return [Area]
+      def self.from_yaml_data( area_yaml_data )  
         self.new( :area_desc => area_yaml_data[ AREA_DESC_YAML ],
                   :altitude  => area_yaml_data[ ALTITUDE_YAML ],
                   :ceiling   => area_yaml_data[ CEILING_YAML ],
@@ -145,23 +175,26 @@ module RCAP
                   :polygons  => Array( area_yaml_data[ POLYGONS_YAML ]).map{ |polyon_yaml_data| Polygon.from_yaml_data( polyon_yaml_data )})
       end
 
-      AREA_DESC_KEY = 'area_desc'  # :nodoc:
-      ALTITUDE_KEY  = 'altitude'   # :nodoc:
-      CEILING_KEY   = 'ceiling'    # :nodoc:
-      CIRCLES_KEY   = 'circles'    # :nodoc:
-      GEOCODES_KEY  = 'geocodes'   # :nodoc:
-      POLYGONS_KEY  = 'polygons'   # :nodoc:
-
-      def to_h # :nodoc:
-        RCAP.attribute_values_to_hash( [ AREA_DESC_KEY, self.area_desc ],
-                                       [ ALTITUDE_KEY, self.altitude ],
-                                       [ CEILING_KEY, self.ceiling ],
-                                       [ CIRCLES_KEY, self.circles.map{ |circle| circle.to_h } ],
-                                       [ GEOCODES_KEY, self.geocodes.map{ |geocode| geocode.to_h } ],
-                                       [ POLYGONS_KEY, self.polygons.map{ |polygon| polygon.to_h } ])
+      AREA_DESC_KEY = 'area_desc'  
+      ALTITUDE_KEY  = 'altitude'   
+      CEILING_KEY   = 'ceiling'    
+      CIRCLES_KEY   = 'circles'    
+      GEOCODES_KEY  = 'geocodes'   
+      POLYGONS_KEY  = 'polygons'   
+
+      # @return [Hash]
+      def to_h 
+        RCAP.attribute_values_to_hash( [ AREA_DESC_KEY, @area_desc ],
+                                       [ ALTITUDE_KEY, @altitude ],
+                                       [ CEILING_KEY, @ceiling ],
+                                       [ CIRCLES_KEY, @circles.map{ |circle| circle.to_h } ],
+                                       [ GEOCODES_KEY, @geocodes.map{ |geocode| geocode.to_h } ],
+                                       [ POLYGONS_KEY, @polygons.map{ |polygon| polygon.to_h } ])
       end
 
-      def self.from_h( area_hash ) # :nodoc:
+      # @param [Hash] area_hash
+      # @return [Area]
+      def self.from_h( area_hash ) 
         self.new(
           :area_desc => area_hash[ AREA_DESC_KEY ],
           :altitude  => area_hash[ ALTITUDE_KEY ],

data/lib/rcap/cap_1_2/circle.rb

@@ -6,75 +6,100 @@ module RCAP
     class Circle < Point
       include Validation
 
-      # Expresed in kilometers
+      # @return [Numeric] Expresed in kilometers 
       attr_accessor( :radius )
 
       validates_presence_of( :radius )
       validates_numericality_of( :radius , greater_than_or_equal: 0 )
 
-      XML_ELEMENT_NAME = 'circle' # :nodoc:
+      XML_ELEMENT_NAME = 'circle' 
 
-      XPATH = 'cap:circle' # :nodoc:
+      XPATH = 'cap:circle' 
 
+      # @param [Hash] attributes
+      # @option attributes [Numeric] :lattitude
+      # @option attributes [Numeric] :longitude
+      # @option attributes [Numeric] :radius
       def initialize( attributes = {} )
         super( attributes )
         @radius = attributes[ :radius ]
       end
 
       # Returns a string representation of the circle of the form
-      #  lattitude,longitude,radius
-      def to_s  # :nodoc:
-        "#{ self.lattitude },#{ self.longitude } #{ self.radius }"
+      #  lattitude,longitude radius
+      #
+      # @return [String]
+      def to_s  
+        "#{ @lattitude },#{ @longitude } #{ @radius }"
       end
 
-      def inspect # :nodoc:
+      # @return [String]
+      def inspect 
         "(#{ self.to_s })"
       end
 
-      def to_xml_element # :nodoc:
+      # @return [REXML::Element]
+      def to_xml_element 
         xml_element = REXML::Element.new( XML_ELEMENT_NAME )
         xml_element.add_text( self.to_s )
         xml_element
       end
 
-      def to_xml # :nodoc:
+      # @return [String]
+      def to_xml 
         self.to_xml_element.to_s
       end
 
-      def self.parse_circle_string( circle_string ) # :nodoc:
+      # Parses a circle string of the form
+      #   lattitude,longitude radius
+      #
+      # @param [String] circle_string
+      # @return [Array(Float,Float,Float)]
+      def self.parse_circle_string( circle_string ) 
         coordinates, radius = circle_string.split( ' ' )
         lattitude, longitude = coordinates.split( ',' )
         [ lattitude, longitude, radius ].map{ |e| e.to_f }
       end
 
-      def self.from_xml_element( circle_xml_element ) # :nodoc:
+      # @param [REXML::Element] circle_xml_element
+      # @return [Circle]
+      def self.from_xml_element( circle_xml_element ) 
         lattitude, longitude, radius = self.parse_circle_string( circle_xml_element.text )
         circle = self.new( :lattitude => lattitude,
-                          :longitude => longitude,
-                          :radius => radius )
+                           :longitude => longitude,
+                           :radius => radius )
       end
 
       # Two circles are equivalent if their lattitude, longitude and radius are equal.
+      #
+      # @param [Circle] other
+      # @return [true,false]
       def ==( other )
-        [ self.lattitude, self.longitude, self.radius ] == [ other.lattitude, other.longitude, other.radius ]
+        [ @lattitude, @longitude, @radius ] == [ other.lattitude, other.longitude, other.radius ]
       end
 
-      def self.from_yaml_data( circle_yaml_data ) # :nodoc:
+      # @param [Array(Numeric, Numeric, Numeric)] circle_yaml_data lattitude, longitude, radius 
+      # @return [Circle]
+      def self.from_yaml_data( circle_yaml_data ) 
         lattitude, longitude,radius = circle_yaml_data
         self.new( :lattitude => lattitude, :longitude => longitude, :radius => radius )
       end
 
-      RADIUS_KEY    = 'radius' # :nodoc:
-      LATTITUDE_KEY = 'lattitude' # :nodoc:
-      LONGITUDE_KEY = 'longitude' # :nodoc:
-      def to_h # :nodoc:
-        RCAP.attribute_values_to_hash( [ RADIUS_KEY, self.radius ],
-                                       [ LATTITUDE_KEY, self.lattitude ],
-                                       [ LONGITUDE_KEY, self.longitude ])
+      RADIUS_KEY    = 'radius' 
+      LATTITUDE_KEY = 'lattitude' 
+      LONGITUDE_KEY = 'longitude' 
+      
+      # @return [Hash]
+      def to_h 
+        RCAP.attribute_values_to_hash( [ RADIUS_KEY,    @radius ],
+                                       [ LATTITUDE_KEY, @lattitude ],
+                                       [ LONGITUDE_KEY, @longitude ])
       end
 
-      def self.from_h( circle_hash ) # :nodoc:
-        self.new( :radius => circle_hash[ RADIUS_KEY ],
+      # @param [Hash]
+      # @return [Circle]
+      def self.from_h( circle_hash ) 
+        self.new( :radius    => circle_hash[ RADIUS_KEY ],
                   :lattitude => circle_hash[ LATTITUDE_KEY ],
                   :longitude => circle_hash[ LONGITUDE_KEY ])
       end

data/lib/rcap/cap_1_2/event_code.rb

@@ -1,8 +1,9 @@
 module RCAP
   module CAP_1_2
+    # Subclass of {Parameter}
     class EventCode < Parameter
-      XML_ELEMENT_NAME = 'eventCode' # :nodoc:
-      XPATH = "cap:#{ XML_ELEMENT_NAME }" # :nodoc:
+      XML_ELEMENT_NAME = 'eventCode' 
+      XPATH = "cap:#{ XML_ELEMENT_NAME }" 
     end
   end
 end

data/lib/rcap/cap_1_2/geocode.rb

@@ -1,8 +1,9 @@
 module RCAP
   module CAP_1_2
+    # Subclass of {Parameter}
     class Geocode < Parameter
-      XML_ELEMENT_NAME = 'geocode' # :nodoc:
-      XPATH = "cap:#{ XML_ELEMENT_NAME }" # :nodoc:
+      XML_ELEMENT_NAME = 'geocode' 
+      XPATH = "cap:#{ XML_ELEMENT_NAME }" 
     end
   end
 end

data/lib/rcap/cap_1_2/info.rb

@@ -11,104 +11,104 @@ module RCAP
     class Info
       include Validation
 
-      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:
+      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"     
       # 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 ]
 
-      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_ALL_CLEAR = "All Clear" # :nodoc:
-      RESPONSE_TYPE_AVOID     = "Avoid"     # :nodoc:
-      RESPONSE_TYPE_NONE      = "None"      # :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_ALL_CLEAR = "All Clear" 
+      RESPONSE_TYPE_AVOID     = "Avoid"     
+      RESPONSE_TYPE_NONE      = "None"      
       # 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_AVOID, RESPONSE_TYPE_ALL_CLEAR, RESPONSE_TYPE_NONE ]
 
-      URGENCY_IMMEDIATE = "Immediate" # :nodoc:
-      URGENCY_EXPECTED  = "Expected"  # :nodoc:
-      URGENCY_FUTURE    = "Future"    # :nodoc:
-      URGENCY_PAST      = "Past"      # :nodoc:
-      URGENCY_UNKNOWN   = "Unknown"   # :nodoc:
+      URGENCY_IMMEDIATE = "Immediate" 
+      URGENCY_EXPECTED  = "Expected"  
+      URGENCY_FUTURE    = "Future"    
+      URGENCY_PAST      = "Past"      
+      URGENCY_UNKNOWN   = "Unknown"   
       # 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:
+      SEVERITY_EXTREME  = "Extreme"  
+      SEVERITY_SEVERE   = "Severe"   
+      SEVERITY_MODERATE = "Moderate" 
+      SEVERITY_MINOR    = "Minor"    
+      SEVERITY_UNKNOWN  = "Unknown"  
       # 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:
+      CERTAINTY_OBSERVED = "Observed" 
+      CERTAINTY_LIKELY   = "Likely"   
+      CERTAINTY_POSSIBLE = "Possible" 
+      CERTAINTY_UNLIKELY = "Unlikely" 
+      CERTAINTY_UNKNOWN  = "Unknown"  
       # 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:
-      CATEGORY_ELEMENT_NAME      = 'category'     # :nodoc:
-      EVENT_ELEMENT_NAME         = 'event'        # :nodoc:
-      RESPONSE_TYPE_ELEMENT_NAME = 'responseType' # :nodoc:
-      URGENCY_ELEMENT_NAME       = 'urgency'      # :nodoc:
-      SEVERITY_ELEMENT_NAME      = 'severity'     # :nodoc:
-      CERTAINTY_ELEMENT_NAME     = 'certainty'    # :nodoc:
-      AUDIENCE_ELEMENT_NAME      = 'audience'     # :nodoc:
-      EVENT_CODE_ELEMENT_NAME    = 'eventCode'    # :nodoc:
-      EFFECTIVE_ELEMENT_NAME     = 'effective'    # :nodoc:
-      ONSET_ELEMENT_NAME         = 'onset'        # :nodoc:
-      EXPIRES_ELEMENT_NAME       = 'expires'      # :nodoc:
-      SENDER_NAME_ELEMENT_NAME   = 'senderName'   # :nodoc:
-      HEADLINE_ELEMENT_NAME      = 'headline'     # :nodoc:
-      DESCRIPTION_ELEMENT_NAME   = 'description'  # :nodoc:
-      INSTRUCTION_ELEMENT_NAME   = 'instruction'  # :nodoc:
-      WEB_ELEMENT_NAME           = 'web'          # :nodoc:
-      CONTACT_ELEMENT_NAME       = 'contact'      # :nodoc:
+      XML_ELEMENT_NAME           = 'info'         
+      LANGUAGE_ELEMENT_NAME      = 'language'     
+      CATEGORY_ELEMENT_NAME      = 'category'     
+      EVENT_ELEMENT_NAME         = 'event'        
+      RESPONSE_TYPE_ELEMENT_NAME = 'responseType' 
+      URGENCY_ELEMENT_NAME       = 'urgency'      
+      SEVERITY_ELEMENT_NAME      = 'severity'     
+      CERTAINTY_ELEMENT_NAME     = 'certainty'    
+      AUDIENCE_ELEMENT_NAME      = 'audience'     
+      EVENT_CODE_ELEMENT_NAME    = 'eventCode'    
+      EFFECTIVE_ELEMENT_NAME     = 'effective'    
+      ONSET_ELEMENT_NAME         = 'onset'        
+      EXPIRES_ELEMENT_NAME       = 'expires'      
+      SENDER_NAME_ELEMENT_NAME   = 'senderName'   
+      HEADLINE_ELEMENT_NAME      = 'headline'     
+      DESCRIPTION_ELEMENT_NAME   = 'description'  
+      INSTRUCTION_ELEMENT_NAME   = 'instruction'  
+      WEB_ELEMENT_NAME           = 'web'          
+      CONTACT_ELEMENT_NAME       = 'contact'      
 
-      XPATH               = "cap:#{ XML_ELEMENT_NAME }"           # :nodoc:
-      LANGUAGE_XPATH      = "cap:#{ LANGUAGE_ELEMENT_NAME }"      # :nodoc:
-      EVENT_XPATH         = "cap:#{ EVENT_ELEMENT_NAME }"         # :nodoc:
-      URGENCY_XPATH       = "cap:#{ URGENCY_ELEMENT_NAME }"       # :nodoc:
-      RESPONSE_TYPE_XPATH = "cap:#{ RESPONSE_TYPE_ELEMENT_NAME }" # :nodoc:
-      CATEGORY_XPATH      = "cap:#{ CATEGORY_ELEMENT_NAME }"      # :nodoc:
-      SEVERITY_XPATH      = "cap:#{ SEVERITY_ELEMENT_NAME }"      # :nodoc:
-      CERTAINTY_XPATH     = "cap:#{ CERTAINTY_ELEMENT_NAME }"     # :nodoc:
-      AUDIENCE_XPATH      = "cap:#{ AUDIENCE_ELEMENT_NAME }"      # :nodoc:
-      EVENT_CODE_XPATH    = "cap:#{ EVENT_CODE_ELEMENT_NAME }"    # :nodoc:
-      EFFECTIVE_XPATH     = "cap:#{ EFFECTIVE_ELEMENT_NAME }"     # :nodoc:
-      ONSET_XPATH         = "cap:#{ ONSET_ELEMENT_NAME }"         # :nodoc:
-      EXPIRES_XPATH       = "cap:#{ EXPIRES_ELEMENT_NAME }"       # :nodoc:
-      SENDER_NAME_XPATH   = "cap:#{ SENDER_NAME_ELEMENT_NAME }"   # :nodoc:
-      HEADLINE_XPATH      = "cap:#{ HEADLINE_ELEMENT_NAME }"      # :nodoc:
-      DESCRIPTION_XPATH   = "cap:#{ DESCRIPTION_ELEMENT_NAME }"   # :nodoc:
-      INSTRUCTION_XPATH   = "cap:#{ INSTRUCTION_ELEMENT_NAME }"   # :nodoc:
-      WEB_XPATH           = "cap:#{ WEB_ELEMENT_NAME }"           # :nodoc:
-      CONTACT_XPATH       = "cap:#{ CONTACT_ELEMENT_NAME }"       # :nodoc:
+      XPATH               = "cap:#{ XML_ELEMENT_NAME }"           
+      LANGUAGE_XPATH      = "cap:#{ LANGUAGE_ELEMENT_NAME }"      
+      EVENT_XPATH         = "cap:#{ EVENT_ELEMENT_NAME }"         
+      URGENCY_XPATH       = "cap:#{ URGENCY_ELEMENT_NAME }"       
+      RESPONSE_TYPE_XPATH = "cap:#{ RESPONSE_TYPE_ELEMENT_NAME }" 
+      CATEGORY_XPATH      = "cap:#{ CATEGORY_ELEMENT_NAME }"      
+      SEVERITY_XPATH      = "cap:#{ SEVERITY_ELEMENT_NAME }"      
+      CERTAINTY_XPATH     = "cap:#{ CERTAINTY_ELEMENT_NAME }"     
+      AUDIENCE_XPATH      = "cap:#{ AUDIENCE_ELEMENT_NAME }"      
+      EVENT_CODE_XPATH    = "cap:#{ EVENT_CODE_ELEMENT_NAME }"    
+      EFFECTIVE_XPATH     = "cap:#{ EFFECTIVE_ELEMENT_NAME }"     
+      ONSET_XPATH         = "cap:#{ ONSET_ELEMENT_NAME }"         
+      EXPIRES_XPATH       = "cap:#{ EXPIRES_ELEMENT_NAME }"       
+      SENDER_NAME_XPATH   = "cap:#{ SENDER_NAME_ELEMENT_NAME }"   
+      HEADLINE_XPATH      = "cap:#{ HEADLINE_ELEMENT_NAME }"      
+      DESCRIPTION_XPATH   = "cap:#{ DESCRIPTION_ELEMENT_NAME }"   
+      INSTRUCTION_XPATH   = "cap:#{ INSTRUCTION_ELEMENT_NAME }"   
+      WEB_XPATH           = "cap:#{ WEB_ELEMENT_NAME }"           
+      CONTACT_XPATH       = "cap:#{ CONTACT_ELEMENT_NAME }"       
 
       DEFAULT_LANGUAGE = 'en-US'
 
@@ -121,41 +121,72 @@ module RCAP
       validates_inclusion_of_members_of( :categories,     :in  => VALID_CATEGORIES,     :allow_blank => true )
       validates_collection_of( :resources, :areas, :event_codes, :parameters )
 
+      # @return [String]
       attr_accessor( :event )
-      # Value can only be one of VALID_URGENCIES
+      # @return [String] Value can only be one of {VALID_URGENCIES} 
       attr_accessor( :urgency )
-      # Value can only be one of VALID_SEVERITIES
+      # @return [String] Value can only be one of {VALID_SEVERITIES} 
       attr_accessor( :severity )
-      # Value can only be one of VALID_CERTAINTIES
+      # @return [String] Value can only be one of {VALID_CERTAINTIES} 
       attr_accessor( :certainty )
+      # @return [String]
       attr_accessor( :language )
+      # @return [String]
       attr_accessor( :audience )
-      # Effective start time of information
+      # @return [DateTime] Effective start time of information 
       attr_accessor( :effective )
-      # Expected start of event
+      # @return [DateTime] Expected start of event 
       attr_accessor( :onset )
-      # Effective expiry time of information
+      # @return [DateTime] Effective expiry time of information 
       attr_accessor( :expires )
+      # @return [String]
       attr_accessor( :sender_name )
+      # @return [String]
       attr_accessor( :headline )
+      # @return [String]
       attr_accessor( :description )
+      # @return [String]
       attr_accessor( :instruction )
+      # @return [String]
       attr_accessor( :web )
+      # @return [String]
       attr_accessor( :contact )
 
-      # Collection of textual categories; elements can be one of VALID_CATEGORIES
+      # @return [Array<String>] Collection of textual categories; elements can be one of {VALID_CATEGORIES} 
       attr_reader( :categories )
-      #  Collection of textual response types
+      # @return [Array<String>] Collection of textual response types; elements must be from {VALID_RESPONSE_TYPES} 
       attr_reader( :response_types )
-      # Collectoin of EventCode objects
+      # @return [Array<EventCode>] Collection of {EventCode} objects
       attr_reader( :event_codes )
-      # Collection of Parameter objects
+      # @return [Array<Parameter>] Collection of {Parameter} objects
       attr_reader( :parameters )
-      # Collection of Resource objects
+      # @return [Array<Resource> Collection of {Resource} objects
       attr_reader( :resources )
-      # Collection of Area objects
+      # @return [Array<Area>] Collection of {Area} objects
       attr_reader( :areas )
 
+      # @param [Hash] attributes
+      # @option attributes [String] :language Defaults to {DEFAULT_LANGUAGE}
+      # @option attributes [Array<String>] :categories Collection of categories in {VALID_CATEGORIES}
+      # @option attributes [String] :audience
+      # @option attributes [String] :event
+      # @option attributes [Array<String>] :response_types Collection of textual response types from {VALID_RESPONSE_TYPES}
+      # @option attributes [String] :urgency A member of {VALID_URGENCIES}
+      # @option attributes [String] :severity A member of {VALID_SEVERITIES}
+      # @option attributes [String] :certainty A member of {VALID_CERTAINTIES}
+      # @option attributes [DateTime] :effective 
+      # @option attributes [DateTime] :onset
+      # @option attributes [DateTime] :expires
+      # @option attributes [Array<EventCode>] :event_codes Collection of {EventCode} objects
+      # @option attributes [String] :sender_name
+      # @option attributes [String] :headline
+      # @option attributes [String] :description
+      # @option attributes [String] :instruction
+      # @option attributes [String] :web URL
+      # @option attributes [String] :contact
+      # @option attributes [Array<Parameter>] :parameters Collection of {Parameter} objects
+      # @option attributes [Array<Resource>] :resources Collection of {Resource} objects 
+      # @option attributes [Array<Area>] :areas Collection of {Area} objects
       def initialize( attributes = {} )
         @language       = attributes[ :language ] || DEFAULT_LANGUAGE
         @categories     = Array( attributes[ :categories ])
@@ -182,62 +213,83 @@ module RCAP
 
       # Creates a new EventCode object and adds it to the event_codes array. The
       # event_code_attributes are passed as a parameter to EventCode.new.
+      #
+      # @see EventCode#initialize
+      #
+      # @param [Hash] event_code_attributes (see EventCode#initialize)
+      # @return [EventCode]
       def add_event_code( event_code_attributes = {})
         event_code = EventCode.new( event_code_attributes )
-        self.event_codes << event_code
+        @event_codes << event_code
         event_code
       end
 
       # Creates a new Parameter object and adds it to the parameters array. The
       # parameter_attributes are passed as a parameter to Parameter.new.
+      #
+      # @see Parameter#initialize
+      #
+      # @param [Hash] parameter_attributes (see Parameter#initialize)
+      # @return [Parameter]
       def add_parameter( parameter_attributes = {})
         parameter = Parameter.new( parameter_attributes )
-        self.parameters << parameter
+        @parameters << parameter
         parameter
       end
 
       # Creates a new Resource object and adds it to the resources array. The
       # resource_attributes are passed as a parameter to Resource.new.
+      #
+      # @see Resource#initialize
+      #
+      # @param [Hash] resource_attributes (See Resource#initialize)
+      # @return [Resource]
       def add_resource( resource_attributes = {})
         resource = Resource.new( resource_attributes )
-        self.resources << resource
+        @resources << resource
         resource
       end
 
       # Creates a new Area object and adds it to the areas array. The
       # area_attributes are passed as a parameter to Area.new.
+      #
+      # @see Area#initialize
+      #
+      # @param [Hash] area_attributes (see Area#initialize)
+      # @return [Area]
       def add_area( area_attributes = {})
         area = Area.new( area_attributes )
-        self.areas << area
+        @areas << area
         area
       end
 
-      def to_xml_element # :nodoc:
+      # @return [REXML::Element]
+      def to_xml_element 
         xml_element = REXML::Element.new( XML_ELEMENT_NAME )
-        xml_element.add_element( LANGUAGE_ELEMENT_NAME ).add_text( self.language ) if self.language
+        xml_element.add_element( LANGUAGE_ELEMENT_NAME ).add_text( @language ) if @language
         @categories.each do |category|
           xml_element.add_element( CATEGORY_ELEMENT_NAME ).add_text( category )
         end
-        xml_element.add_element( EVENT_ELEMENT_NAME ).add_text( self.event )
+        xml_element.add_element( EVENT_ELEMENT_NAME ).add_text( @event )
         @response_types.each do |response_type|
           xml_element.add_element( RESPONSE_TYPE_ELEMENT_NAME ).add_text( response_type )
         end
-        xml_element.add_element( URGENCY_ELEMENT_NAME ).add_text( self.urgency )
-        xml_element.add_element( SEVERITY_ELEMENT_NAME ).add_text( self.severity )
-        xml_element.add_element( CERTAINTY_ELEMENT_NAME ).add_text( self.certainty )
-        xml_element.add_element( AUDIENCE_ELEMENT_NAME ).add_text( self.audience ) if self.audience
+        xml_element.add_element( URGENCY_ELEMENT_NAME ).add_text( @urgency )
+        xml_element.add_element( SEVERITY_ELEMENT_NAME ).add_text( @severity )
+        xml_element.add_element( CERTAINTY_ELEMENT_NAME ).add_text( @certainty )
+        xml_element.add_element( AUDIENCE_ELEMENT_NAME ).add_text( @audience ) if @audience
         @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_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
+        xml_element.add_element( EFFECTIVE_ELEMENT_NAME ).add_text( @effective.to_s_for_cap ) if @effective
+        xml_element.add_element( ONSET_ELEMENT_NAME ).add_text( @onset.to_s_for_cap )         if @onset
+        xml_element.add_element( EXPIRES_ELEMENT_NAME ).add_text( @expires.to_s_for_cap )     if @expires
+        xml_element.add_element( SENDER_NAME_ELEMENT_NAME ).add_text( @sender_name )          if @sender_name
+        xml_element.add_element( HEADLINE_ELEMENT_NAME ).add_text( @headline )                if @headline
+        xml_element.add_element( DESCRIPTION_ELEMENT_NAME ).add_text( @description )          if @description
+        xml_element.add_element( INSTRUCTION_ELEMENT_NAME ).add_text( @instruction )          if @instruction
+        xml_element.add_element( WEB_ELEMENT_NAME ).add_text( @web )                          if @web
+        xml_element.add_element( CONTACT_ELEMENT_NAME ).add_text( @contact )                  if @contact
         @parameters.each do |parameter|
           xml_element.add_element( parameter.to_xml_element )
         end
@@ -250,46 +302,52 @@ module RCAP
         xml_element
       end
 
-      def to_xml # :nodoc:
+      # @return [String]
+      def to_xml 
         self.to_xml_element.to_s
       end
 
-      def inspect # :nodoc:
-        info_inspect = "Language:       #{ self.language }\n"+
-                       "Categories:     #{ self.categories.to_s_for_cap }\n"+
-                       "Event:          #{ self.event }\n"+
-                       "Response Types: #{ self.response_types.to_s_for_cap }\n"+
-                       "Urgency:        #{ self.urgency }\n"+
-                       "Severity:       #{ self.severity }\n"+
-                       "Certainty:      #{ self.certainty }\n"+
-                       "Audience:       #{ self.audience }\n"+
-                       "Event Codes:    #{ self.event_codes.inspect }\n"+
-                       "Effective:      #{ self.effective }\n"+
-                       "Onset:          #{ self.onset }\n"+
-                       "Expires:        #{ self.expires }\n"+
-                       "Sender Name:    #{ self.sender_name }\n"+
-                       "Headline:       #{ self.headline }\n"+
+      # @return [String]
+      def inspect 
+        info_inspect = "Language:       #{ @language }\n"+
+                       "Categories:     #{ @categories.to_s_for_cap }\n"+
+                       "Event:          #{ @event }\n"+
+                       "Response Types: #{ @response_types.to_s_for_cap }\n"+
+                       "Urgency:        #{ @urgency }\n"+
+                       "Severity:       #{ @severity }\n"+
+                       "Certainty:      #{ @certainty }\n"+
+                       "Audience:       #{ @audience }\n"+
+                       "Event Codes:    #{ @event_codes.inspect }\n"+
+                       "Effective:      #{ @effective }\n"+
+                       "Onset:          #{ @onset }\n"+
+                       "Expires:        #{ @expires }\n"+
+                       "Sender Name:    #{ @sender_name }\n"+
+                       "Headline:       #{ @headline }\n"+
                        "Description:\n"+
-                       self.description.to_s.lines.map{ |line| "  " + line }.join( "\n" )+"\n"+
-                       "Instruction:    #{ self.instruction }\n"+
-                       "Web:            #{ self.web }\n"+
-                       "Contact:        #{ self.contact }\n"+
+                       @description.to_s.lines.map{ |line| "  " + line }.join( "\n")+"\n"+
+                       "Instruction:    #{ @instruction }\n"+
+                       "Web:            #{ @web }\n"+
+                       "Contact:        #{ @contact }\n"+
                        "Parameters:\n"+
-                       self.parameters.map{ |parameter| parameter.inspect }.join( "\n" )+"\n"+
+                       @parameters.map{ |parameter| parameter.inspect }.join( "\n" )+"\n"+
                        "Resources:\n"+
-                       self.resources.map{ |resource| "  " + resource.inspect }.join( "\n" )+"\n"+
+                       @resources.map{ |resource| "  " + resource.inspect }.join( "\n" )+"\n"+
                        "Area:\n"+
-                       self.areas.map{ |area| "  #{ area }" }.join( "\n" )+"\n"
+                       @areas.map{ |area| "  #{ area }" }.join( "\n" )+"\n"
         RCAP.format_lines_for_inspect( 'INFO', info_inspect )
       end
 
       # Returns a string representation of the event of the form
       #  event(urgency/severity/certainty)
+      #
+      # @return [String]
       def to_s
-        "#{ self.event }(#{ self.urgency }/#{ self.severity }/#{ self.certainty })"
+        "#{ @event }(#{ @urgency }/#{ @severity }/#{ @certainty })"
       end
 
-      def self.from_xml_element( info_xml_element ) # :nodoc:
+      # @param [REXML::Element] info_xml_element
+      # @return [Info]
+      def self.from_xml_element( info_xml_element ) 
         self.new(
           :language       => RCAP.xpath_text( info_xml_element, LANGUAGE_XPATH, Alert::XMLNS ) || DEFAULT_LANGUAGE,
           :categories     => RCAP.xpath_match( info_xml_element, CATEGORY_XPATH, Alert::XMLNS ).map{ |element| element.text },
@@ -315,55 +373,59 @@ module RCAP
         )
       end
 
-      LANGUAGE_YAML       = 'Language'       # :nodoc:
-      CATEGORIES_YAML     = 'Categories'     # :nodoc:
-      EVENT_YAML          = 'Event'          # :nodoc:
-      RESPONSE_TYPES_YAML = 'Response Types' # :nodoc:
-      URGENCY_YAML        = 'Urgency'        # :nodoc:
-      SEVERITY_YAML       = 'Severity'       # :nodoc:
-      CERTAINTY_YAML      = 'Certainty'      # :nodoc:
-      AUDIENCE_YAML       = 'Audience'       # :nodoc:
-      EFFECTIVE_YAML      = 'Effective'      # :nodoc:
-      ONSET_YAML          = 'Onset'          # :nodoc:
-      EXPIRES_YAML        = 'Expires'        # :nodoc:
-      SENDER_NAME_YAML    = 'Sender Name'    # :nodoc:
-      HEADLINE_YAML       = 'Headline'       # :nodoc:
-      DESCRIPTION_YAML    = 'Description'    # :nodoc:
-      INSTRUCTION_YAML    = 'Instruction'    # :nodoc:
-      WEB_YAML            = 'Web'            # :nodoc:
-      CONTACT_YAML        = 'Contact'        # :nodoc:
-      EVENT_CODES_YAML    = 'Event Codes'    # :nodoc:
-      PARAMETERS_YAML     = 'Parameters'     # :nodoc:
-      RESOURCES_YAML      = 'Resources'      # :nodoc:
-      AREAS_YAML          = 'Areas'          # :nodoc:
+      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:
+      # @return [String]
+      def to_yaml( options = {} ) 
         parameter_to_hash = lambda{ |hash, parameter| hash.merge( parameter.name => parameter.value )}
 
-        RCAP.attribute_values_to_hash( [ LANGUAGE_YAML,       self.language ],
-                                       [ CATEGORIES_YAML,     self.categories ],
-                                       [ EVENT_YAML,          self.event ],
-                                       [ RESPONSE_TYPES_YAML, self.response_types ],
-                                       [ 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 )
+        RCAP.attribute_values_to_hash(
+          [ 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.inject({}, &parameter_to_hash )],
+          [ PARAMETERS_YAML,     @parameters.inject({}, &parameter_to_hash )],
+          [ RESOURCES_YAML,      @resources ],
+          [ AREAS_YAML,          @areas ]).to_yaml( options )
       end
 
-      def self.from_yaml_data( info_yaml_data ) # :nodoc:
+      # @param [Hash] info_yaml_data
+      # @return [Info]
+      def self.from_yaml_data( info_yaml_data ) 
         self.new(
           :language       => info_yaml_data [ LANGUAGE_YAML ],
           :categories     => info_yaml_data [ CATEGORIES_YAML ],
@@ -389,53 +451,57 @@ module RCAP
         )
       end
 
-      LANGUAGE_KEY       = 'language'       # :nodoc:
-      CATEGORIES_KEY     = 'categories'     # :nodoc:
-      EVENT_KEY          = 'event'          # :nodoc:
-      RESPONSE_TYPES_KEY = 'response_types' # :nodoc:
-      URGENCY_KEY        = 'urgency'        # :nodoc:
-      SEVERITY_KEY       = 'severity'       # :nodoc:
-      CERTAINTY_KEY      = 'certainty'      # :nodoc:
-      AUDIENCE_KEY       = 'audience'       # :nodoc:
-      EFFECTIVE_KEY      = 'effective'      # :nodoc:
-      ONSET_KEY          = 'onset'          # :nodoc:
-      EXPIRES_KEY        = 'expires'        # :nodoc:
-      SENDER_NAME_KEY    = 'sender_name'    # :nodoc:
-      HEADLINE_KEY       = 'headline'       # :nodoc:
-      DESCRIPTION_KEY    = 'description'    # :nodoc:
-      INSTRUCTION_KEY    = 'instruction'    # :nodoc:
-      WEB_KEY            = 'web'            # :nodoc:
-      CONTACT_KEY        = 'contact'        # :nodoc:
-      RESOURCES_KEY      = 'resources'      # :nodoc:
-      EVENT_CODES_KEY    = 'event_codes'    # :nodoc:
-      PARAMETERS_KEY     = 'parameters'     # :nodoc:
-      AREAS_KEY          = 'areas'          # :nodoc:
+      LANGUAGE_KEY       = 'language'       
+      CATEGORIES_KEY     = 'categories'     
+      EVENT_KEY          = 'event'          
+      RESPONSE_TYPES_KEY = 'response_types' 
+      URGENCY_KEY        = 'urgency'        
+      SEVERITY_KEY       = 'severity'       
+      CERTAINTY_KEY      = 'certainty'      
+      AUDIENCE_KEY       = 'audience'       
+      EFFECTIVE_KEY      = 'effective'      
+      ONSET_KEY          = 'onset'          
+      EXPIRES_KEY        = 'expires'        
+      SENDER_NAME_KEY    = 'sender_name'    
+      HEADLINE_KEY       = 'headline'       
+      DESCRIPTION_KEY    = 'description'    
+      INSTRUCTION_KEY    = 'instruction'    
+      WEB_KEY            = 'web'            
+      CONTACT_KEY        = 'contact'        
+      RESOURCES_KEY      = 'resources'      
+      EVENT_CODES_KEY    = 'event_codes'    
+      PARAMETERS_KEY     = 'parameters'     
+      AREAS_KEY          = 'areas'          
 
-      def to_h # :nodoc:
-        RCAP.attribute_values_to_hash( [ LANGUAGE_KEY,       self.language ],
-                                       [ CATEGORIES_KEY,     self.categories ],
-                                       [ EVENT_KEY,          self.event ],
-                                       [ RESPONSE_TYPES_KEY, self.response_types ],
-                                       [ URGENCY_KEY,        self.urgency ],
-                                       [ SEVERITY_KEY,       self.severity ],
-                                       [ CERTAINTY_KEY,      self.certainty ],
-                                       [ AUDIENCE_KEY,       self.audience ],
-                                       [ EFFECTIVE_KEY,      RCAP.to_s_for_cap( self.effective )],
-                                       [ ONSET_KEY,          RCAP.to_s_for_cap( self.onset )],
-                                       [ EXPIRES_KEY,        RCAP.to_s_for_cap( self.expires )],
-                                       [ SENDER_NAME_KEY,    self.sender_name ],
-                                       [ HEADLINE_KEY,       self.headline ],
-                                       [ DESCRIPTION_KEY,    self.description ],
-                                       [ INSTRUCTION_KEY,    self.instruction ],
-                                       [ WEB_KEY,            self.web ],
-                                       [ CONTACT_KEY,        self.contact ],
-                                       [ RESOURCES_KEY,      self.resources.map{ |resource| resource.to_h } ],
-                                       [ EVENT_CODES_KEY,    self.event_codes.map{ |event_code| event_code.to_h } ],
-                                       [ PARAMETERS_KEY,     self.parameters.map{ |parameter| parameter.to_h } ],
-                                       [ AREAS_KEY,          self.areas.map{ |area| area.to_h }])
+      # @return [Hash]
+      def to_h 
+        RCAP.attribute_values_to_hash(
+          [ LANGUAGE_KEY,       @language ],
+          [ CATEGORIES_KEY,     @categories ],
+          [ EVENT_KEY,          @event ],
+          [ RESPONSE_TYPES_KEY, @response_types ],
+          [ URGENCY_KEY,        @urgency ],
+          [ SEVERITY_KEY,       @severity ],
+          [ CERTAINTY_KEY,      @certainty ],
+          [ AUDIENCE_KEY,       @audience ],
+          [ EFFECTIVE_KEY,      RCAP.to_s_for_cap( @effective )],
+          [ ONSET_KEY,          RCAP.to_s_for_cap( @onset )],
+          [ EXPIRES_KEY,        RCAP.to_s_for_cap( @expires )],
+          [ SENDER_NAME_KEY,    @sender_name ],
+          [ HEADLINE_KEY,       @headline ],
+          [ DESCRIPTION_KEY,    @description ],
+          [ INSTRUCTION_KEY,    @instruction ],
+          [ WEB_KEY,            @web ],
+          [ CONTACT_KEY,        @contact ],
+          [ RESOURCES_KEY,      @resources.map{ |resource| resource.to_h } ],
+          [ EVENT_CODES_KEY,    @event_codes.map{ |event_code| event_code.to_h } ],
+          [ PARAMETERS_KEY,     @parameters.map{ |parameter| parameter.to_h } ],
+          [ AREAS_KEY,          @areas.map{ |area| area.to_h }])
       end
 
-      def self.from_h( info_hash ) # :nodoc:
+      # @param [Hash] info_hash
+      # @return [Info]
+      def self.from_h( info_hash ) 
         self.new( :language       => info_hash[ LANGUAGE_KEY ],
                   :categories     => info_hash[ CATEGORIES_KEY ],
                   :event          => info_hash[ EVENT_KEY ],