rcap 2.4.1 → 2.5.0

data/lib/rcap/base/area.rb

@@ -4,21 +4,21 @@ module RCAP
       include Validation
 
       # @return [String] Textual description of area.
-      attr_accessor( :area_desc )
+      attr_accessor(:area_desc)
       # @return [Numeric] Expressed in feet above sea level
-      attr_accessor( :altitude )
+      attr_accessor(:altitude)
       # @return [Numeric] Expressed in feet above sea level.
-      attr_accessor( :ceiling )
+      attr_accessor(:ceiling)
       # @return [Array<Circle>]
-      attr_reader( :circles )
+      attr_reader(:circles)
       # @return [Array<Geocode>]
-      attr_reader( :geocodes )
+      attr_reader(:geocodes)
       # @return [Array<Polygon>]
-      attr_reader( :polygons )
+      attr_reader(:polygons)
 
-      validates_presence_of( :area_desc )
-      validates_collection_of( :circles, :geocodes, :polygons, allow_empty: true )
-      validates_dependency_of( :ceiling, on: :altitude )
+      validates_presence_of(:area_desc)
+      validates_collection_of(:circles, :geocodes, :polygons, allow_empty: true)
+      validates_dependency_of(:ceiling, on: :altitude)
 
       XML_ELEMENT_NAME       = 'area'
       AREA_DESC_ELEMENT_NAME = 'areaDesc'
@@ -42,15 +42,15 @@ module RCAP
         @circles  = []
         @geocodes = []
         @polygons = []
-        yield( self ) if block_given?
+        yield(self) if block_given?
       end
 
       # Creates a new {Polygon} object and adds it to the {#polygons} array.
       #
       # @return [Polygon]
       def add_polygon
-        self.polygon_class.new.tap do |polygon|
-          yield( polygon ) if block_given?
+        polygon_class.new.tap do |polygon|
+          yield(polygon) if block_given?
           @polygons << polygon
         end
       end
@@ -59,8 +59,8 @@ module RCAP
       #
       # @return [Circle]
       def add_circle
-        self.circle_class.new.tap do |circle|
-          yield( circle ) if block_given?
+        circle_class.new.tap do |circle|
+          yield(circle) if block_given?
           @circles << circle
         end
       end
@@ -69,70 +69,69 @@ module RCAP
       #
       # @return [Geocode]
       def add_geocode
-        self.geocode_class.new do |geocode|
-          yield( geocode ) if block_given?
+        geocode_class.new do |geocode|
+          yield(geocode) if block_given?
           @geocodes << geocode
         end
       end
 
-      def self.from_xml_element( area_xml_element )
-        self.new do |area|
-          area.area_desc = RCAP.xpath_text( area_xml_element, AREA_DESC_XPATH, area.xmlns )
-          area.altitude  = RCAP.to_f_if_given( RCAP.xpath_text( area_xml_element, ALTITUDE_XPATH, area.xmlns ))
-          area.ceiling   = RCAP.to_f_if_given( RCAP.xpath_text( area_xml_element, CEILING_XPATH, area.xmlns ))
+      def self.from_xml_element(area_xml_element)
+        new do |area|
+          area.area_desc = RCAP.xpath_text(area_xml_element, AREA_DESC_XPATH, area.xmlns)
+          area.altitude  = RCAP.to_f_if_given(RCAP.xpath_text(area_xml_element, ALTITUDE_XPATH, area.xmlns))
+          area.ceiling   = RCAP.to_f_if_given(RCAP.xpath_text(area_xml_element, CEILING_XPATH, area.xmlns))
 
-          RCAP.xpath_match( area_xml_element, area.circle_class::XPATH, area.xmlns ).each do |circle_element|
-            area.circles << area.circle_class.from_xml_element( circle_element )
+          RCAP.xpath_match(area_xml_element, area.circle_class::XPATH, area.xmlns).each do |circle_element|
+            area.circles << area.circle_class.from_xml_element(circle_element)
           end
 
-          RCAP.xpath_match( area_xml_element, area.geocode_class::XPATH, area.xmlns ).each do |geocode_element|
-            area.geocodes  << area.geocode_class.from_xml_element( geocode_element )
+          RCAP.xpath_match(area_xml_element, area.geocode_class::XPATH, area.xmlns).each do |geocode_element|
+            area.geocodes  << area.geocode_class.from_xml_element(geocode_element)
           end
 
-          RCAP.xpath_match( area_xml_element, area.polygon_class::XPATH, area.xmlns ).each do |polygon_element|
-            area.polygons  << area.polygon_class.from_xml_element( polygon_element )
+          RCAP.xpath_match(area_xml_element, area.polygon_class::XPATH, area.xmlns).each do |polygon_element|
+            area.polygons  << area.polygon_class.from_xml_element(polygon_element)
           end
         end
       end
 
       # @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|
-          element.add_element( object.to_xml_element )
-          element
+        REXML::Element.new(XML_ELEMENT_NAME).tap do |xml_element|
+          xml_element.add_element(AREA_DESC_ELEMENT_NAME).add_text(@area_desc.to_s)
+          add_to_xml_element = lambda do |element, object|
+            element.add_element(object.to_xml_element)
+            element
+          end
+          @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 @altitude.blank?
+          xml_element.add_element(CEILING_ELEMENT_NAME).add_text(@ceiling.to_s)   unless @altitude.blank?
         end
-        @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 @altitude.blank?
-        xml_element.add_element( CEILING_ELEMENT_NAME ).add_text( @ceiling.to_s )   unless @altitude.blank?
-        xml_element
       end
 
       # @return [String] XML representation of the Area
       def to_xml
-        self.to_xml_element.to_s
+        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 )
+      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
 
       # @return [String]
       def inspect
-        area_inspect = "Area Description: #{ @area_desc }\n"+
-                       "Polygons:\n"+
-                       @polygons.map{ |polygon| "  " + polygon.inspect }.join("\n" )+"\n"+
-                       "Circles:          #{ @circles.inspect }\n"+
+        area_inspect = "Area Description: #{ @area_desc }\n"\
+                       "Polygons:\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 )
+        RCAP.format_lines_for_inspect('AREA', area_inspect)
       end
 
       # Returns the area description
@@ -142,7 +141,6 @@ module RCAP
         @area_desc
       end
 
-
       AREA_DESC_YAML = 'Area Description'
       ALTITUDE_YAML  = 'Altitude'
       CEILING_YAML   = 'Ceiling'
@@ -150,42 +148,42 @@ module RCAP
       GEOCODES_YAML  = 'Geocodes'
       POLYGONS_YAML  = 'Polygons'
 
-      # @return [Hash] 
+      # @return [Hash]
       def to_yaml_data
-        RCAP.attribute_values_to_hash( [ AREA_DESC_YAML, @area_desc ],
-                                       [ ALTITUDE_YAML,  @altitude ],
-                                       [ CEILING_YAML,   @ceiling ],
-                                       [ CIRCLES_YAML,   @circles.map{ |circle| circle.to_a }],
-                                       [ GEOCODES_YAML,  @geocodes.inject({}){|h,geocode| h.merge( geocode.name => geocode.value )}],
-                                       [ POLYGONS_YAML,  @polygons.map( &:to_yaml_data )])
+        RCAP.attribute_values_to_hash([AREA_DESC_YAML, @area_desc],
+                                      [ALTITUDE_YAML,  @altitude],
+                                      [CEILING_YAML,   @ceiling],
+                                      [CIRCLES_YAML,   @circles.map { |circle| circle.to_a }],
+                                      [GEOCODES_YAML,  @geocodes.reduce({}) { |h, geocode| h.merge(geocode.name => geocode.value) }],
+                                      [POLYGONS_YAML,  @polygons.map(&:to_yaml_data)])
       end
 
       # @return [String] YAML representation of object
-      def to_yaml( options = {} )
-        self.to_yaml_data.to_yaml( options )
+      def to_yaml(options = {})
+        to_yaml_data.to_yaml(options)
       end
 
       # @param [Hash] area_yaml_data
       # @return [Area]
-      def self.from_yaml_data( area_yaml_data )
-        self.new do |area|
-          area.area_desc = area_yaml_data[ AREA_DESC_YAML ]
-          area.altitude  = area_yaml_data[ ALTITUDE_YAML ]
-          area.ceiling   = area_yaml_data[ CEILING_YAML ]
-
-          Array( area_yaml_data[ CIRCLES_YAML ]).each do |circle_yaml_data|
-            area.circles << area.circle_class.from_yaml_data( circle_yaml_data )
+      def self.from_yaml_data(area_yaml_data)
+        new do |area|
+          area.area_desc = area_yaml_data[AREA_DESC_YAML]
+          area.altitude  = area_yaml_data[ALTITUDE_YAML]
+          area.ceiling   = area_yaml_data[CEILING_YAML]
+
+          Array(area_yaml_data[CIRCLES_YAML]).each do |circle_yaml_data|
+            area.circles << area.circle_class.from_yaml_data(circle_yaml_data)
           end
 
-          Array( area_yaml_data[ GEOCODES_YAML ]).each do |name, value|
+          Array(area_yaml_data[GEOCODES_YAML]).each do |name, value|
             area.add_geocode do |geocode|
               geocode.name = name
               geocode.value = value
             end
           end
 
-          Array( area_yaml_data[ POLYGONS_YAML ]).each do |polyon_yaml_data|
-            area.polygons << area.polygon_class.from_yaml_data( polyon_yaml_data )
+          Array(area_yaml_data[POLYGONS_YAML]).each do |polyon_yaml_data|
+            area.polygons << area.polygon_class.from_yaml_data(polyon_yaml_data)
           end
         end
       end
@@ -199,34 +197,34 @@ module RCAP
 
       # @param [Hash] area_hash
       # @return [Area]
-      def self.from_h( area_hash )
-        self.new do |area|
-          area.area_desc = area_hash[ AREA_DESC_KEY ]
-          area.altitude  = area_hash[ ALTITUDE_KEY ]
-          area.ceiling   = area_hash[ CEILING_KEY ]
-
-          Array( area_hash[ CIRCLES_KEY ]).each do |circle_array|
-            area.circles << area.circle_class.from_a( circle_array )
+      def self.from_h(area_hash)
+        new do |area|
+          area.area_desc = area_hash[AREA_DESC_KEY]
+          area.altitude  = area_hash[ALTITUDE_KEY]
+          area.ceiling   = area_hash[CEILING_KEY]
+
+          Array(area_hash[CIRCLES_KEY]).each do |circle_array|
+            area.circles << area.circle_class.from_a(circle_array)
           end
 
-          Array( area_hash[ GEOCODES_KEY ]).each do |geocode_hash|
-            area.geocodes << area.geocode_class.from_h( geocode_hash )
+          Array(area_hash[GEOCODES_KEY]).each do |geocode_hash|
+            area.geocodes << area.geocode_class.from_h(geocode_hash)
           end
 
-          Array( area_hash[ POLYGONS_KEY ]).each do |polygon_hash|
-            area.polygons << area.polygon_class.from_h( polygon_hash )
+          Array(area_hash[POLYGONS_KEY]).each do |polygon_hash|
+            area.polygons << area.polygon_class.from_h(polygon_hash)
           end
         end
       end
 
       # @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_a }],
-                                       [ GEOCODES_KEY,  @geocodes.map{ |geocode| geocode.to_h }],
-                                       [ POLYGONS_KEY,  @polygons.map{ |polygon| polygon.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_a }],
+                                      [GEOCODES_KEY,  @geocodes.map { |geocode| geocode.to_h }],
+                                      [POLYGONS_KEY,  @polygons.map { |polygon| polygon.to_h }])
       end
     end
   end

data/lib/rcap/base/circle.rb

@@ -4,10 +4,10 @@ module RCAP
       include Validation
 
       # @return [Numeric] Expresed in kilometers
-      attr_accessor( :radius )
+      attr_accessor(:radius)
 
-      validates_presence_of( :radius )
-      validates_numericality_of( :radius , greater_than_or_equal: 0 )
+      validates_presence_of(:radius)
+      validates_numericality_of(:radius, greater_than_or_equal: 0)
 
       XML_ELEMENT_NAME = 'circle'
 
@@ -18,7 +18,7 @@ module RCAP
       # @option attributes [Numeric] :longitude
       # @option attributes [Numeric] :radius
       def initialize
-        yield( self ) if block_given?
+        yield(self) if block_given?
       end
 
       # Returns a string representation of the circle of the form
@@ -31,19 +31,19 @@ module RCAP
 
       # @return [String]
       def inspect
-        "(#{ self.to_s })"
+        "(#{ self })"
       end
 
       # @return [REXML::Element]
       def to_xml_element
-        xml_element = REXML::Element.new( XML_ELEMENT_NAME )
-        xml_element.add_text( self.to_s )
+        xml_element = REXML::Element.new(XML_ELEMENT_NAME)
+        xml_element.add_text(to_s)
         xml_element
       end
 
       # @return [String]
       def to_xml
-        self.to_xml_element.to_s
+        to_xml_element.to_s
       end
 
       # Parses a circle string of the form
@@ -51,31 +51,31 @@ module RCAP
       #
       # @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 }
+      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
 
       # @param [REXML::Element] circle_xml_element
       # @return [Circle]
-      def self.from_xml_element( circle_xml_element )
-        self.from_a( self.parse_circle_string( circle_xml_element.text ))
+      def self.from_xml_element(circle_xml_element)
+        from_a(parse_circle_string(circle_xml_element.text))
       end
 
       # Two circles are equivalent if their lattitude, longitude and radius are equal.
       #
       # @param [Circle] other
       # @return [true,false]
-      def ==( other )
-        self.to_a == other.to_a
+      def ==(other)
+        to_a == other.to_a
       end
 
       # @param [Array(Numeric, Numeric, Numeric)] circle_yaml_data lattitude, longitude, radius
       # @return [Circle]
-      def self.from_yaml_data( circle_yaml_data )
+      def self.from_yaml_data(circle_yaml_data)
         lattitude, longitude, radius = circle_yaml_data
-        self.new do |circle|
+        new do |circle|
           circle.lattitude = lattitude.to_f
           circle.longitude = longitude.to_f
           circle.radius    = radius.to_f
@@ -85,35 +85,35 @@ module RCAP
       RADIUS_KEY    = 'radius'
       # @return [Hash]
       def to_h
-        RCAP.attribute_values_to_hash( [ RADIUS_KEY,    @radius ],
-                                       [ LATTITUDE_KEY, @lattitude ],
-                                       [ LONGITUDE_KEY, @longitude ])
+        RCAP.attribute_values_to_hash([RADIUS_KEY,    @radius],
+                                      [LATTITUDE_KEY, @lattitude],
+                                      [LONGITUDE_KEY, @longitude])
       end
 
       # @param [Hash] circle_hash
       # @return [Circle]
-      def self.from_h( circle_hash )
-        self.new do |circle|
-          circle.radius    = circle_hash[ RADIUS_KEY ].to_f
-          circle.lattitude = circle_hash[ LATTITUDE_KEY ].to_f
-          circle.longitude = circle_hash[ LONGITUDE_KEY ].to_f
+      def self.from_h(circle_hash)
+        new do |circle|
+          circle.radius    = circle_hash[RADIUS_KEY].to_f
+          circle.lattitude = circle_hash[LATTITUDE_KEY].to_f
+          circle.longitude = circle_hash[LONGITUDE_KEY].to_f
         end
       end
 
       # @return [Array(Numeric,Numeric,Numeric)]
       def to_a
-        [ @lattitude, @longitude, @radius ]
+        [@lattitude, @longitude, @radius]
       end
 
       RADIUS_INDEX = 2
 
       # @param [Array] circle_array
       # @return [Circle]
-      def self.from_a( circle_array )
-        self.new do |circle|
-          circle.longitude = circle_array[ LONGITUDE_INDEX ].to_f
-          circle.lattitude = circle_array[ LATTITUDE_INDEX ].to_f
-          circle.radius    = circle_array[ RADIUS_INDEX ].to_f
+      def self.from_a(circle_array)
+        new do |circle|
+          circle.longitude = circle_array[LONGITUDE_INDEX].to_f
+          circle.lattitude = circle_array[LATTITUDE_INDEX].to_f
+          circle.radius    = circle_array[RADIUS_INDEX].to_f
         end
       end
     end

data/lib/rcap/base/info.rb

@@ -3,50 +3,50 @@ 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"
+      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 ]
-
-      URGENCY_IMMEDIATE = "Immediate"
-      URGENCY_EXPECTED  = "Expected"
-      URGENCY_FUTURE    = "Future"
-      URGENCY_PAST      = "Past"
-      URGENCY_UNKNOWN   = "Unknown"
+      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]
+
+      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"
-      SEVERITY_SEVERE   = "Severe"
-      SEVERITY_MODERATE = "Moderate"
-      SEVERITY_MINOR    = "Minor"
-      SEVERITY_UNKNOWN  = "Unknown"
+      VALID_URGENCIES = [URGENCY_IMMEDIATE, URGENCY_EXPECTED, URGENCY_FUTURE,
+                         URGENCY_PAST, URGENCY_UNKNOWN]
+
+      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_VERY_LIKELY = "Very Likely"
-      CERTAINTY_LIKELY      = "Likely"
-      CERTAINTY_POSSIBLE    = "Possible"
-      CERTAINTY_UNLIKELY    = "Unlikely"
-      CERTAINTY_UNKNOWN     = "Unknown"
+      VALID_SEVERITIES = [SEVERITY_EXTREME, SEVERITY_SEVERE, SEVERITY_MODERATE,
+                          SEVERITY_MINOR, SEVERITY_UNKNOWN]
+
+      CERTAINTY_VERY_LIKELY = 'Very Likely'
+      CERTAINTY_LIKELY      = 'Likely'
+      CERTAINTY_POSSIBLE    = 'Possible'
+      CERTAINTY_UNLIKELY    = 'Unlikely'
+      CERTAINTY_UNKNOWN     = 'Unknown'
       # Valid valies for certainty
-      VALID_CERTAINTIES = [ CERTAINTY_VERY_LIKELY, CERTAINTY_LIKELY,
-        CERTAINTY_POSSIBLE, CERTAINTY_UNLIKELY, CERTAINTY_UNKNOWN ]
+      VALID_CERTAINTIES = [CERTAINTY_VERY_LIKELY, CERTAINTY_LIKELY,
+                           CERTAINTY_POSSIBLE, CERTAINTY_UNLIKELY, CERTAINTY_UNKNOWN]
 
       XML_ELEMENT_NAME           = 'info'
       LANGUAGE_ELEMENT_NAME      = 'language'
@@ -88,57 +88,56 @@ module RCAP
 
       DEFAULT_LANGUAGE = 'en-US'
 
-      validates_presence_of( :event )
-      validates_presence_of( :urgency )
-      validates_presence_of( :severity )
-      validates_presence_of( :certainty )
-      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( :categories, :in  => VALID_CATEGORIES, :allow_blank => true )
-      validates_collection_of( :resources, :areas, :event_codes, :parameters )
+      validates_presence_of(:event)
+      validates_presence_of(:urgency)
+      validates_presence_of(:severity)
+      validates_presence_of(:certainty)
+      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(:categories, in: VALID_CATEGORIES, allow_blank: true)
+      validates_collection_of(:resources, :areas, :event_codes, :parameters)
 
       # @return [String]
-      attr_accessor( :event )
+      attr_accessor(:event)
       # @return [String] Value can only be one of {VALID_URGENCIES}
-      attr_accessor( :urgency )
+      attr_accessor(:urgency)
       # @return [String] Value can only be one of {VALID_SEVERITIES}
-      attr_accessor( :severity )
+      attr_accessor(:severity)
       # @return [String] Value can only be one of {VALID_CERTAINTIES}
-      attr_accessor( :certainty )
+      attr_accessor(:certainty)
       # @return [String]
-      attr_accessor( :language )
+      attr_accessor(:language)
       # @return [String]
-      attr_accessor( :audience )
+      attr_accessor(:audience)
       # @return [DateTime] Effective start time of information
-      attr_accessor( :effective )
+      attr_accessor(:effective)
       # @return [DateTime] Expected start of event
-      attr_accessor( :onset )
+      attr_accessor(:onset)
       # @return [DateTime] Effective expiry time of information
-      attr_accessor( :expires )
+      attr_accessor(:expires)
       # @return [String]
-      attr_accessor( :sender_name )
+      attr_accessor(:sender_name)
       # @return [String]
-      attr_accessor( :headline )
+      attr_accessor(:headline)
       # @return [String]
-      attr_accessor( :description )
+      attr_accessor(:description)
       # @return [String]
-      attr_accessor( :instruction )
+      attr_accessor(:instruction)
       # @return [String]
-      attr_accessor( :web )
+      attr_accessor(:web)
       # @return [String]
-      attr_accessor( :contact )
+      attr_accessor(:contact)
 
       # @return [Array<String>] Collection of textual categories; elements can be one of {VALID_CATEGORIES}
-      attr_reader( :categories )
+      attr_reader(:categories)
       # @return [Array<EventCode>] Collection of {EventCode} objects
-      attr_reader( :event_codes )
+      attr_reader(:event_codes)
       # @return [Array<Parameter>] Collection of {Parameter} objects
-      attr_reader( :parameters )
+      attr_reader(:parameters)
       # @return [Array<Resource> Collection of {Resource} objects
-      attr_reader( :resources )
+      attr_reader(:resources)
       # @return [Array<Area>] Collection of {Area} objects
-      attr_reader( :areas )
-
+      attr_reader(:areas)
 
       # Initialises a new Info object which will be yielded to an attached block if given
       #
@@ -150,15 +149,15 @@ module RCAP
         @parameters     = []
         @resources      = []
         @areas          = []
-        yield( self ) if block_given?
+        yield(self) if block_given?
       end
 
       # Creates a new EventCode object and adds it to the event_codes array.
       #
       # @return [EventCode]
       def add_event_code
-        event_code = self.event_code_class.new
-        yield( event_code ) if block_given?
+        event_code = event_code_class.new
+        yield(event_code) if block_given?
         @event_codes << event_code
         event_code
       end
@@ -167,8 +166,8 @@ module RCAP
       #
       # @return [Parameter]
       def add_parameter
-        parameter = self.parameter_class.new
-        yield( parameter ) if block_given?
+        parameter = parameter_class.new
+        yield(parameter) if block_given?
         @parameters << parameter
         parameter
       end
@@ -177,8 +176,8 @@ module RCAP
       #
       # @return [Resource]
       def add_resource
-        resource = self.resource_class.new
-        yield( resource ) if block_given?
+        resource = resource_class.new
+        yield(resource) if block_given?
         @resources << resource
         resource
       end
@@ -187,123 +186,119 @@ module RCAP
       #
       # @return [Area]
       def add_area
-        area = self.area_class.new
-        yield( area ) if block_given?
+        area = area_class.new
+        yield(area) if block_given?
         @areas << area
         area
       end
 
       # @return [REXML::Element]
       def to_xml_element
-        xml_element = REXML::Element.new( XML_ELEMENT_NAME )
-        xml_element.add_element( LANGUAGE_ELEMENT_NAME ).add_text( @language ) if @language
+        xml_element = REXML::Element.new(XML_ELEMENT_NAME)
+        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 )
+          xml_element.add_element(CATEGORY_ELEMENT_NAME).add_text(category)
         end
-        xml_element.add_element( EVENT_ELEMENT_NAME ).add_text( @event )
-        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
+        xml_element.add_element(EVENT_ELEMENT_NAME).add_text(@event)
+        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 )
+          xml_element.add_element(event_code.to_xml_element)
         end
-        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
+        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 )
+          xml_element.add_element(parameter.to_xml_element)
         end
         @resources.each do |resource|
-          xml_element.add_element( resource.to_xml_element )
+          xml_element.add_element(resource.to_xml_element)
         end
         @areas.each do |area|
-          xml_element.add_element( area.to_xml_element )
+          xml_element.add_element(area.to_xml_element)
         end
         xml_element
       end
 
       # @return [String]
       def to_xml
-        self.to_xml_element.to_s
+        to_xml_element.to_s
       end
 
       # @param [REXML::Element] info_xml_element
       # @return [Info]
-      def self.from_xml_element( info_xml_element )
-        self.new do |info|
-          info.language       = RCAP.xpath_text( info_xml_element, LANGUAGE_XPATH, info.xmlns ) || DEFAULT_LANGUAGE
+      def self.from_xml_element(info_xml_element)
+        new do |info|
+          info.language       = RCAP.xpath_text(info_xml_element, LANGUAGE_XPATH, info.xmlns) || DEFAULT_LANGUAGE
 
-          RCAP.xpath_match( info_xml_element, CATEGORY_XPATH, info.xmlns ).each do |element|
+          RCAP.xpath_match(info_xml_element, CATEGORY_XPATH, info.xmlns).each do |element|
             info.categories << element.text
           end
 
-          info.event          = RCAP.xpath_text( info_xml_element, EVENT_XPATH, info.xmlns )
-          info.urgency        = RCAP.xpath_text( info_xml_element, URGENCY_XPATH, info.xmlns )
-          info.severity       = RCAP.xpath_text( info_xml_element, SEVERITY_XPATH, info.xmlns )
-          info.certainty      = RCAP.xpath_text( info_xml_element, CERTAINTY_XPATH, info.xmlns )
-          info.audience       = RCAP.xpath_text( info_xml_element, AUDIENCE_XPATH, info.xmlns )
-          info.effective      = RCAP.parse_datetime( RCAP.xpath_text( info_xml_element, EFFECTIVE_XPATH, info.xmlns ))
-          info.onset          = RCAP.parse_datetime( RCAP.xpath_text( info_xml_element, ONSET_XPATH, info.xmlns ))
-          info.expires        = RCAP.parse_datetime( RCAP.xpath_text( info_xml_element, EXPIRES_XPATH, info.xmlns ))
-          info.sender_name    = RCAP.xpath_text( info_xml_element, SENDER_NAME_XPATH, info.xmlns )
-          info.headline       = RCAP.xpath_text( info_xml_element, HEADLINE_XPATH, info.xmlns )
-          info.description    = RCAP.xpath_text( info_xml_element, DESCRIPTION_XPATH, info.xmlns )
-          info.instruction    = RCAP.xpath_text( info_xml_element, INSTRUCTION_XPATH, info.xmlns )
-          info.web            = RCAP.xpath_text( info_xml_element, WEB_XPATH, info.xmlns )
-          info.contact        = RCAP.xpath_text( info_xml_element, CONTACT_XPATH, info.xmlns )
-
-          RCAP.xpath_match( info_xml_element, info.event_code_class::XPATH, info.xmlns ).each do |element|
-            info.event_codes << info.event_code_class.from_xml_element( element )
+          info.event          = RCAP.xpath_text(info_xml_element, EVENT_XPATH, info.xmlns)
+          info.urgency        = RCAP.xpath_text(info_xml_element, URGENCY_XPATH, info.xmlns)
+          info.severity       = RCAP.xpath_text(info_xml_element, SEVERITY_XPATH, info.xmlns)
+          info.certainty      = RCAP.xpath_text(info_xml_element, CERTAINTY_XPATH, info.xmlns)
+          info.audience       = RCAP.xpath_text(info_xml_element, AUDIENCE_XPATH, info.xmlns)
+          info.effective      = RCAP.parse_datetime(RCAP.xpath_text(info_xml_element, EFFECTIVE_XPATH, info.xmlns))
+          info.onset          = RCAP.parse_datetime(RCAP.xpath_text(info_xml_element, ONSET_XPATH, info.xmlns))
+          info.expires        = RCAP.parse_datetime(RCAP.xpath_text(info_xml_element, EXPIRES_XPATH, info.xmlns))
+          info.sender_name    = RCAP.xpath_text(info_xml_element, SENDER_NAME_XPATH, info.xmlns)
+          info.headline       = RCAP.xpath_text(info_xml_element, HEADLINE_XPATH, info.xmlns)
+          info.description    = RCAP.xpath_text(info_xml_element, DESCRIPTION_XPATH, info.xmlns)
+          info.instruction    = RCAP.xpath_text(info_xml_element, INSTRUCTION_XPATH, info.xmlns)
+          info.web            = RCAP.xpath_text(info_xml_element, WEB_XPATH, info.xmlns)
+          info.contact        = RCAP.xpath_text(info_xml_element, CONTACT_XPATH, info.xmlns)
+
+          RCAP.xpath_match(info_xml_element, info.event_code_class::XPATH, info.xmlns).each do |element|
+            info.event_codes << info.event_code_class.from_xml_element(element)
           end
 
-          RCAP.xpath_match( info_xml_element, info.parameter_class::XPATH, info.xmlns ).each do |element|
-            info.parameters <<  info.parameter_class.from_xml_element( element )
+          RCAP.xpath_match(info_xml_element, info.parameter_class::XPATH, info.xmlns).each do |element|
+            info.parameters <<  info.parameter_class.from_xml_element(element)
           end
 
-          RCAP.xpath_match( info_xml_element, info.resource_class::XPATH, info.xmlns ).each do  |element|
-           info.resources <<  info.resource_class.from_xml_element( element )
+          RCAP.xpath_match(info_xml_element, info.resource_class::XPATH, info.xmlns).each do  |element|
+            info.resources <<  info.resource_class.from_xml_element(element)
           end
 
-          RCAP.xpath_match( info_xml_element, info.area_class::XPATH, info.xmlns ).each do |element|
-            info.areas << info.area_class.from_xml_element( element )
+          RCAP.xpath_match(info_xml_element, info.area_class::XPATH, info.xmlns).each do |element|
+            info.areas << info.area_class.from_xml_element(element)
           end
         end
       end
 
       # @return [String]
       def inspect
-        info_inspect = "Language:       #{ @language }\n"+
-        "Categories:     #{ @categories.to_s_for_cap }\n"+
-        "Event:          #{ @event }\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"+
-          @description.to_s.lines.map{ |line| "  " + line }.join( "\n")+"\n"+
-          "Instruction:    #{ @instruction }\n"+
-        "Web:            #{ @web }\n"+
-        "Contact:        #{ @contact }\n"+
-        "Parameters:\n"+
-          @parameters.map{ |parameter| "  " + parameter.inspect }.join( "\n" )+"\n"+
-          "Resources:\n"+
-          @resources.map{ |resource| "  " + resource.inspect }.join( "\n" )+"\n"+
-          "Area:\n"+
-          @areas.map{ |area| "  #{ area }" }.join( "\n" )+"\n"
-        RCAP.format_lines_for_inspect( 'INFO', info_inspect )
+        info_inspect = "Language:       #{ @language }\n"\
+        "Categories:     #{ @categories.to_s_for_cap }\n"\
+        "Event:          #{ @event }\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" +           @description.to_s.lines.map { |line| '  ' + line }.join("\n") + "\n"\
+          "Instruction:    #{ @instruction }\n"\
+        "Web:            #{ @web }\n"\
+        "Contact:        #{ @contact }\n"\
+        "Parameters:\n" +           @parameters.map { |parameter| '  ' + parameter.inspect }.join("\n") + "\n"\
+          "Resources:\n" +           @resources.map { |resource| '  ' + resource.inspect }.join("\n") + "\n"\
+          "Area:\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
@@ -337,78 +332,78 @@ module RCAP
 
       # @return [Hash]
       def to_yaml_data
-        parameter_to_hash = lambda{ |hash, parameter| hash.merge( parameter.name => parameter.value )}
-
-        RCAP.attribute_values_to_hash( [ LANGUAGE_YAML,       @language ],
-                                       [ CATEGORIES_YAML,     @categories ],
-                                       [ EVENT_YAML,          @event ],
-                                       [ 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.map( &:to_yaml_data )],
-                                       [ AREAS_YAML,          @areas.map(&:to_yaml_data )])
+        parameter_to_hash = lambda { |hash, parameter| hash.merge(parameter.name => parameter.value) }
+
+        RCAP.attribute_values_to_hash([LANGUAGE_YAML,       @language],
+                                      [CATEGORIES_YAML,     @categories],
+                                      [EVENT_YAML,          @event],
+                                      [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.map(&:to_yaml_data)],
+                                      [AREAS_YAML,          @areas.map(&:to_yaml_data)])
       end
 
       # @return [String]
-      def to_yaml( options = {} )
-        self.to_yaml_data.to_yaml( options )
+      def to_yaml(options = {})
+        to_yaml_data.to_yaml(options)
       end
 
       # @param [Hash] info_yaml_data
       # @return [Info]
-      def self.from_yaml_data( info_yaml_data )
-        self.new do |info|
-          info.language    = info_yaml_data [ LANGUAGE_YAML ]
-          Array( info_yaml_data [ CATEGORIES_YAML ]).each do |category|
+      def self.from_yaml_data(info_yaml_data)
+        new do |info|
+          info.language    = info_yaml_data [LANGUAGE_YAML]
+          Array(info_yaml_data [CATEGORIES_YAML]).each do |category|
             info.categories << category
           end
-          info.event       = RCAP.strip_if_given( info_yaml_data [ EVENT_YAML ])
-          info.urgency     = RCAP.strip_if_given( info_yaml_data [ URGENCY_YAML ])
-          info.severity    = RCAP.strip_if_given( info_yaml_data [ SEVERITY_YAML ])
-          info.certainty   = RCAP.strip_if_given( info_yaml_data [ CERTAINTY_YAML ])
-          info.audience    = RCAP.strip_if_given( info_yaml_data [ AUDIENCE_YAML ])
-          info.effective   = RCAP.parse_datetime( info_yaml_data[ EFFECTIVE_YAML ])
-          info.onset       = RCAP.parse_datetime( info_yaml_data[ ONSET_YAML ])
-          info.expires     = RCAP.parse_datetime( info_yaml_data[ EXPIRES_YAML ])
-          info.sender_name = RCAP.strip_if_given( info_yaml_data [ SENDER_NAME_YAML ])
-          info.headline    = RCAP.strip_if_given( info_yaml_data [ HEADLINE_YAML ])
-          info.description = RCAP.strip_if_given( info_yaml_data [ DESCRIPTION_YAML ])
-          info.instruction = RCAP.strip_if_given( info_yaml_data [ INSTRUCTION_YAML ])
-          info.web         = RCAP.strip_if_given( info_yaml_data [ WEB_YAML ])
-          info.contact     = RCAP.strip_if_given( info_yaml_data [ CONTACT_YAML ])
-
-          Array( info_yaml_data [ EVENT_CODES_YAML ]).each do  |name,value|
+          info.event       = RCAP.strip_if_given(info_yaml_data [EVENT_YAML])
+          info.urgency     = RCAP.strip_if_given(info_yaml_data [URGENCY_YAML])
+          info.severity    = RCAP.strip_if_given(info_yaml_data [SEVERITY_YAML])
+          info.certainty   = RCAP.strip_if_given(info_yaml_data [CERTAINTY_YAML])
+          info.audience    = RCAP.strip_if_given(info_yaml_data [AUDIENCE_YAML])
+          info.effective   = RCAP.parse_datetime(info_yaml_data[EFFECTIVE_YAML])
+          info.onset       = RCAP.parse_datetime(info_yaml_data[ONSET_YAML])
+          info.expires     = RCAP.parse_datetime(info_yaml_data[EXPIRES_YAML])
+          info.sender_name = RCAP.strip_if_given(info_yaml_data [SENDER_NAME_YAML])
+          info.headline    = RCAP.strip_if_given(info_yaml_data [HEADLINE_YAML])
+          info.description = RCAP.strip_if_given(info_yaml_data [DESCRIPTION_YAML])
+          info.instruction = RCAP.strip_if_given(info_yaml_data [INSTRUCTION_YAML])
+          info.web         = RCAP.strip_if_given(info_yaml_data [WEB_YAML])
+          info.contact     = RCAP.strip_if_given(info_yaml_data [CONTACT_YAML])
+
+          Array(info_yaml_data [EVENT_CODES_YAML]).each do  |name, value|
             info.add_event_code do |event_code|
-              event_code.name  = RCAP.strip_if_given( name )
-              event_code.value = RCAP.strip_if_given( value )
+              event_code.name  = RCAP.strip_if_given(name)
+              event_code.value = RCAP.strip_if_given(value)
             end
           end
 
-          Array( info_yaml_data [ PARAMETERS_YAML ]).each do |name,value|
+          Array(info_yaml_data [PARAMETERS_YAML]).each do |name, value|
             info.add_parameter do |parameter|
-              parameter.name  = RCAP.strip_if_given( name )
-              parameter.value = RCAP.strip_if_given( value )
+              parameter.name  = RCAP.strip_if_given(name)
+              parameter.value = RCAP.strip_if_given(value)
             end
           end
 
-          Array( info_yaml_data [ RESOURCES_YAML ]).each do |resource_yaml_data|
-            info.resources << info.resource_class.from_yaml_data( resource_yaml_data )
+          Array(info_yaml_data [RESOURCES_YAML]).each do |resource_yaml_data|
+            info.resources << info.resource_class.from_yaml_data(resource_yaml_data)
           end
 
-          Array( info_yaml_data [ AREAS_YAML ]).each do |area_yaml_data|
-            info.areas << info.area_class.from_yaml_data( area_yaml_data )
+          Array(info_yaml_data [AREAS_YAML]).each do |area_yaml_data|
+            info.areas << info.area_class.from_yaml_data(area_yaml_data)
           end
         end
       end
@@ -436,65 +431,65 @@ module RCAP
 
       # @return [Hash]
       def to_h
-        RCAP.attribute_values_to_hash( [ LANGUAGE_KEY,      @language ],
-                                       [ CATEGORIES_KEY,     @categories ],
-                                       [ EVENT_KEY,          @event ],
-                                       [ 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 }])
+        RCAP.attribute_values_to_hash([LANGUAGE_KEY,      @language],
+                                      [CATEGORIES_KEY,     @categories],
+                                      [EVENT_KEY,          @event],
+                                      [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
 
       # @param [Hash] info_hash
       # @return [Info]
-      def self.from_h( info_hash )
-        self.new do |info|
-          info.language       = info_hash[ LANGUAGE_KEY ]
-          Array( info_hash[ CATEGORIES_KEY ]).each do |category|
-            info.categories << RCAP.strip_if_given( category )
+      def self.from_h(info_hash)
+        new do |info|
+          info.language       = info_hash[LANGUAGE_KEY]
+          Array(info_hash[CATEGORIES_KEY]).each do |category|
+            info.categories << RCAP.strip_if_given(category)
           end
-          info.event          = RCAP.strip_if_given( info_hash[ EVENT_KEY ])
-          info.urgency        = RCAP.strip_if_given( info_hash[ URGENCY_KEY ])
-          info.severity       = RCAP.strip_if_given( info_hash[ SEVERITY_KEY ])
-          info.certainty      = RCAP.strip_if_given( info_hash[ CERTAINTY_KEY ])
-          info.audience       = RCAP.strip_if_given( info_hash[ AUDIENCE_KEY ])
-          info.effective      = RCAP.parse_datetime( info_hash[ EFFECTIVE_KEY ])
-          info.onset          = RCAP.parse_datetime( info_hash[ ONSET_KEY ])
-          info.expires        = RCAP.parse_datetime( info_hash[ EXPIRES_KEY ])
-          info.sender_name    = RCAP.strip_if_given( info_hash[ SENDER_NAME_KEY ])
-          info.headline       = RCAP.strip_if_given( info_hash[ HEADLINE_KEY ])
-          info.description    = RCAP.strip_if_given( info_hash[ DESCRIPTION_KEY ])
-          info.instruction    = RCAP.strip_if_given( info_hash[ INSTRUCTION_KEY ])
-          info.web            = RCAP.strip_if_given( info_hash[ WEB_KEY ])
-          info.contact        = RCAP.strip_if_given( info_hash[ CONTACT_KEY ])
-
-          Array( info_hash[ RESOURCES_KEY ]).each do |resource_hash|
-            info.resources << info.resource_class.from_h( resource_hash )
+          info.event          = RCAP.strip_if_given(info_hash[EVENT_KEY])
+          info.urgency        = RCAP.strip_if_given(info_hash[URGENCY_KEY])
+          info.severity       = RCAP.strip_if_given(info_hash[SEVERITY_KEY])
+          info.certainty      = RCAP.strip_if_given(info_hash[CERTAINTY_KEY])
+          info.audience       = RCAP.strip_if_given(info_hash[AUDIENCE_KEY])
+          info.effective      = RCAP.parse_datetime(info_hash[EFFECTIVE_KEY])
+          info.onset          = RCAP.parse_datetime(info_hash[ONSET_KEY])
+          info.expires        = RCAP.parse_datetime(info_hash[EXPIRES_KEY])
+          info.sender_name    = RCAP.strip_if_given(info_hash[SENDER_NAME_KEY])
+          info.headline       = RCAP.strip_if_given(info_hash[HEADLINE_KEY])
+          info.description    = RCAP.strip_if_given(info_hash[DESCRIPTION_KEY])
+          info.instruction    = RCAP.strip_if_given(info_hash[INSTRUCTION_KEY])
+          info.web            = RCAP.strip_if_given(info_hash[WEB_KEY])
+          info.contact        = RCAP.strip_if_given(info_hash[CONTACT_KEY])
+
+          Array(info_hash[RESOURCES_KEY]).each do |resource_hash|
+            info.resources << info.resource_class.from_h(resource_hash)
           end
 
-          Array( info_hash[ EVENT_CODES_KEY ]).each do |event_code_hash|
-            info.event_codes << info.event_code_class.from_h( event_code_hash )
+          Array(info_hash[EVENT_CODES_KEY]).each do |event_code_hash|
+            info.event_codes << info.event_code_class.from_h(event_code_hash)
           end
 
-          Array( info_hash[ PARAMETERS_KEY ]).each do |parameter_hash|
-            info.parameters << info.parameter_class.from_h( parameter_hash )
+          Array(info_hash[PARAMETERS_KEY]).each do |parameter_hash|
+            info.parameters << info.parameter_class.from_h(parameter_hash)
           end
 
-          Array( info_hash[ AREAS_KEY ]).each do |area_hash|
-           info.areas <<  info.area_class.from_h( area_hash )
+          Array(info_hash[AREAS_KEY]).each do |area_hash|
+            info.areas <<  info.area_class.from_h(area_hash)
           end
         end
       end