rcap 0.1

data/lib/rcap/event_code.rb

@@ -0,0 +1,20 @@
+module RCAP
+  class EventCode < Parameter
+
+    XML_ELEMENT_NAME = 'eventCode' # :nodoc:
+
+		XPATH = "cap:#{ XML_ELEMENT_NAME }" # :nodoc:
+
+    def to_xml_element # :nodoc:
+      xml_element = REXML::Element.new( XML_ELEMENT_NAME )
+      xml_element.add_element( NAME_ELEMENT_NAME ).add_text( self.name )
+      xml_element.add_element( VALUE_ELEMENT_NAME ).add_text( self.value )
+      xml_element
+    end
+
+		def self.from_xml_element( event_code_xml_element ) # :nodoc:
+			EventCode.new( :name  => RCAP.xpath_text( event_code_xml_element, NAME_XPATH ),
+										 :value => RCAP.xpath_text( event_code_xml_element, VALUE_XPATH ))
+		end
+  end
+end

data/lib/rcap/geocode.rb

@@ -0,0 +1,20 @@
+module RCAP
+  class Geocode < Parameter
+
+    XML_ELEMENT_NAME = 'geocode' # :nodoc:
+
+    XPATH = "cap:#{ XML_ELEMENT_NAME }" # :nodoc:
+    
+    def to_xml_element # :nodoc:
+      xml_element = REXML::Element.new( XML_ELEMENT_NAME )
+      xml_element.add_element( NAME_ELEMENT_NAME ).add_text( @name )
+      xml_element.add_element( VALUE_ELEMENT_NAME ).add_text( @value )
+      xml_element
+    end
+
+    def self.from_xml_element( geocode_xml_element ) # :nodoc:
+      self.new( :name => RCAP.xpath_text( geocode_xml_element, NAME_XPATH ),
+               :value => RCAP.xpath_text( geocode_xml_element, VALUE_XPATH ))
+    end
+  end
+end

data/lib/rcap/info.rb

@@ -0,0 +1,239 @@
+module RCAP
+	# In Info object is valid if
+	# * it has an event
+	# * it has an urgency with a valid value
+	# * it has a severity with a valid value
+	# * it has a certainty with a valid value
+	# * all categories are valid and categories has at minimum 1 entry
+	# * all Resource objects in the resources collection are valid
+	# * all Area objects in the areas collection are valid
+	#
+  class Info
+    include Validation
+
+    CATEGORY_GEO       = "Geo"
+    CATEGORY_MET       = "Met"
+    CATEGORY_SAFETY    = "Safety"
+    CATEGORY_SECURITY  = "Security"
+    CATEGORY_RESCUE    = "Rescue"
+    CATEGORY_FIRE      = "Fire"
+    CATEGORY_HEALTH    = "Health"
+    CATEGORY_ENV       = "Env"
+    CATEGORY_TRANSPORT = "Transport"
+    CATEGORY_INFRA     = "Infra"
+    CATEGORY_CBRNE     = "CBRNE"
+    CATEGORY_OTHER     = "Other"
+    ALL_CATEGORIES = [ CATEGORY_GEO, CATEGORY_MET, CATEGORY_SAFETY,  
+      CATEGORY_SECURITY, CATEGORY_RESCUE,   CATEGORY_FIRE, CATEGORY_HEALTH,
+      CATEGORY_ENV, CATEGORY_TRANSPORT, CATEGORY_INFRA, CATEGORY_CBRNE,
+      CATEGORY_OTHER ] # :nodoc:
+
+    RESPONSE_TYPE_SHELTER  = "Shelter"
+    RESPONSE_TYPE_EVACUATE = "Evacuate"
+    RESPONSE_TYPE_PREPARE  = "Prepare"
+    RESPONSE_TYPE_EXECUTE  = "Execute"
+    RESPONSE_TYPE_MONITOR  = "Monitor"
+    RESPONSE_TYPE_ASSESS   = "Assess"
+    RESPONSE_TYPE_NONE     = "None"
+    ALL_RESPONSE_TYPES = [ RESPONSE_TYPE_SHELTER, RESPONSE_TYPE_EVACUATE, 
+      RESPONSE_TYPE_PREPARE, RESPONSE_TYPE_EXECUTE, RESPONSE_TYPE_MONITOR, 
+      RESPONSE_TYPE_ASSESS, RESPONSE_TYPE_NONE ] # :nodoc:
+
+    URGENCY_IMMEDIATE = "Immediate"
+    URGENCY_EXPECTED  = "Expected"
+    URGENCY_FUTURE    = "Future"
+    URGENCY_PAST      = "Past"
+    URGENCY_UNKNOWN   = "Unknown"
+    ALL_URGENCIES = [ URGENCY_IMMEDIATE, URGENCY_EXPECTED, URGENCY_FUTURE,   
+      URGENCY_PAST, URGENCY_UNKNOWN ] # :nodoc:
+
+    SEVERITY_EXTREME  = "Extreme"
+    SEVERITY_SEVERE   = "Severe"
+    SEVERITY_MODERATE = "Moderate"
+    SEVERITY_MINOR    = "Minor"
+    SEVERITY_UNKNOWN  = "Unknown"
+    ALL_SEVERITIES = [ SEVERITY_EXTREME, SEVERITY_SEVERE, SEVERITY_MODERATE,
+      SEVERITY_MINOR, SEVERITY_UNKNOWN ] # :nodoc: 
+
+    CERTAINTY_OBSERVED = "Observed"
+    CERTAINTY_LIKELY   = "Likely"
+    CERTAINTY_POSSIBLE = "Possible"
+    CERTAINTY_UNLIKELY = "Unlikely"
+    CERTAINTY_UNKNOWN  = "Unknown"
+    ALL_CERTAINTIES = [ CERTAINTY_OBSERVED, CERTAINTY_LIKELY,
+      CERTAINTY_POSSIBLE, CERTAINTY_UNLIKELY, CERTAINTY_UNKNOWN ] # :nodoc:
+
+    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   = 'sernderName'  # :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:
+
+    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: 
+
+    DEFAULT_LANGUAGE = 'en-US'
+
+    validates_presence_of( :event, :urgency, :severity, :certainty )
+    validates_length_of( :categories, :minimum => 1 )
+    validates_inclusion_of( :certainty, :allow_nil => true, :in => ALL_CERTAINTIES, :message => "can only be assigned the following values: #{ ALL_CERTAINTIES.join(', ') }")
+    validates_inclusion_of( :severity, :allow_nil  => true, :in => ALL_SEVERITIES, :message  => "can only be assigned the following values: #{ ALL_SEVERITIES.join(', ') }" )
+    validates_inclusion_of( :urgency, :allow_nil   => true, :in => ALL_URGENCIES, :message   => "can only be assigned the following values: #{ ALL_URGENCIES.join(', ') }" )
+    validates_inclusion_of_members_of( :response_types, :in => ALL_RESPONSE_TYPES, :allow_blank => true )
+		validates_inclusion_of_members_of( :categories, :in => ALL_CATEGORIES, :allow_blank => true )
+    validates_collection_of( :resources, :areas )
+
+    attr_accessor( :event )
+		attr_accessor( :urgency )
+		attr_accessor( :severity )
+		attr_accessor( :certainty )
+		attr_accessor( :language )
+		attr_accessor( :audience )
+		# Effective start time of information
+		attr_accessor( :effective )
+		# Expected start of event
+		attr_accessor( :onset )
+		# Effected expiry time of information
+		attr_accessor( :expires )
+		attr_accessor( :sender_name )
+		attr_accessor( :headline )
+		attr_accessor( :description )
+		attr_accessor( :instruction )
+		attr_accessor( :web )
+		attr_accessor( :contact )
+
+		# Collection of textual categories
+    attr_reader( :categories )
+		#  Collection of textual response types
+		attr_reader( :response_types )
+		# Collectoin of EventCode objects
+		attr_reader( :event_codes )
+		# Collection of Parameter objects
+		attr_reader( :parameters )
+		# Collection of Resource objects
+		attr_reader( :resources )
+		# Collection of Area objects
+		attr_reader( :areas )
+
+    def initialize( attributes = {} )
+      @language       = attributes[ :language ] || DEFAULT_LANGUAGE
+      @categories     = Array( attributes[ :categories ])
+      @event          = attributes [ :event ]
+      @response_types = Array( attributes[ :response_types ])
+      @urgency        = attributes[ :urgency ]
+      @severity       = attributes[ :severity ]
+      @certainty      = attributes[ :certainty ]
+      @effective      = attributes[ :effective ]
+      @onset          = attributes[ :onset ]
+      @expires        = attributes[ :expires ]
+      @event_codes    = Array( attributes[ :event_codes ])
+      @sender_name    = attributes[ :sender_name ]
+      @headline       = attributes[ :headline ]
+      @description    = attributes[ :description ]
+      @instruction    = attributes[ :instruction ]
+      @web            = attributes[ :web ]
+      @contact        = attributes[ :contact ]
+      @parameters     = Array( attributes[ :parameters ])
+      @resources      = Array( attributes[ :resources ])
+      @areas          = Array( attributes[ :areas ])
+    end
+
+    def to_xml_element # :nodoc:
+      xml_element = REXML::Element.new( XML_ELEMENT_NAME )
+      xml_element.add_element( LANGUAGE_ELEMENT_NAME ).add_text( self.language ) if self.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 )
+      @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
+      @event_codes.each do |event_code|
+        xml_element.add_element( event_code.to_xml_element )
+      end
+      xml_element.add_element( EFFECTIVE_ELEMENT_NAME ).add_text( self.effective.to_s ) if self.effective
+      xml_element.add_element( ONSET_ELEMENT_NAME ).add_text( self.onset.to_s )         if self.onset
+      xml_element.add_element( EXPIRES_ELEMENT_NAME ).add_text( self.expires.to_s )     if self.expires
+      xml_element.add_element( SENDER_NAME_ELEMENT_NAME ).add_text( self.sender_name )  if self.sender_name
+      xml_element.add_element( HEADLINE_ELEMENT_NAME ).add_text( self.headline )        if self.headline
+      xml_element.add_element( DESCRIPTION_ELEMENT_NAME ).add_text( self.description )  if self.description
+      xml_element.add_element( INSTRUCTION_ELEMENT_NAME ).add_text( self.instruction )  if self.instruction
+      xml_element.add_element( WEB_ELEMENT_NAME ).add_text( self.web )                  if self.web
+      xml_element.add_element( CONTACT_ELEMENT_NAME ).add_text( self.contact )          if self.contact
+      @parameters.each do |parameter|
+        xml_element.add_element( parameter.to_xml_element )
+      end
+      @resources.each do |resource|
+        xml_element.add_element( resource.to_xml_element )
+      end
+      @areas.each do |area|
+        xml_element.add_element( area.to_xml_element )
+      end
+      xml_element
+    end
+
+    def to_xml # :nodoc:
+      self.to_xml_element.to_s
+    end
+
+    def self.from_xml_element( info_xml_element ) # :nodoc:
+      self.new(
+        :language       => RCAP.xpath_text( info_xml_element, LANGUAGE_XPATH ) || DEFAULT_LANGUAGE,
+        :categories     => RCAP.xpath_match( info_xml_element, CATEGORY_XPATH ).map{ |element| element.text },
+        :event          => RCAP.xpath_text( info_xml_element, EVENT_XPATH ),
+        :response_types => RCAP.xpath_match( info_xml_element, RESPONSE_TYPE_XPATH ).map{ |element| element.text },
+        :urgency        => RCAP.xpath_text( info_xml_element, URGENCY_XPATH ),
+        :severity       => RCAP.xpath_text( info_xml_element, SEVERITY_XPATH ),
+        :certainty      => RCAP.xpath_text( info_xml_element, CERTAINTY_XPATH ),
+        :audience       => RCAP.xpath_text( info_xml_element, AUDIENCE_XPATH ),
+        :effective      => (( effective = RCAP.xpath_first( info_xml_element, EFFECTIVE_XPATH )) ? DateTime.parse( effective.text ) : nil ),
+        :onset          => (( onset = RCAP.xpath_first( info_xml_element, ONSET_XPATH )) ? DateTime.parse( onset.text ) : nil ),
+        :expires        => (( expires = RCAP.xpath_first( info_xml_element, EXPIRES_XPATH )) ? DateTime.parse( expires.text ) : nil ),
+        :sender_name    => RCAP.xpath_text( info_xml_element, SENDER_NAME_XPATH ),
+        :headline       => RCAP.xpath_text( info_xml_element, HEADLINE_XPATH ),
+        :description    => RCAP.xpath_text( info_xml_element, DESCRIPTION_XPATH ),
+        :instruction    => RCAP.xpath_text( info_xml_element, INSTRUCTION_XPATH ),
+        :web            => RCAP.xpath_text( info_xml_element, WEB_XPATH ),
+        :contact        => RCAP.xpath_text( info_xml_element, CONTACT_XPATH ),
+				:event_codes    => RCAP.xpath_match( info_xml_element, RCAP::EventCode::XPATH ).map{ |element| RCAP::EventCode.from_xml_element( element )},
+				:parameters => RCAP.xpath_match( info_xml_element, RCAP::Parameter::XPATH ).map{ |element| RCAP::Parameter.from_xml_element( element )},
+				:areas => RCAP.xpath_match( info_xml_element, RCAP::Area::XPATH ).map{ |element| RCAP::Area.from_xml_element( element )}
+      )
+    end
+  end
+end

data/lib/rcap/parameter.rb

@@ -0,0 +1,54 @@
+module RCAP
+	# A Parameter object is valid if
+	# * it has a name
+	# * it has a value
+	class Parameter
+		include Validation
+
+		validates_presence_of( :name, :value )
+
+		attr_accessor( :name, :value )
+
+		XML_ELEMENT_NAME   = "parameter" # :nodoc:
+		NAME_ELEMENT_NAME  = "valueName" # :nodoc:
+		VALUE_ELEMENT_NAME = "value"     # :nodoc:
+
+		XPATH       = "cap:#{ XML_ELEMENT_NAME }"     # :nodoc:
+		NAME_XPATH  = "cap:#{ NAME_ELEMENT_NAME }"    # :nodoc:
+		VALUE_XPATH = "cap:#{ VALUE_ELEMENT_NAME }"   # :nodoc:
+
+		def initialize( attributes = {} )
+			@name = attributes[ :name ]
+			@value = attributes[ :value ] 
+		end
+
+		def to_xml_element # :nodoc:
+			xml_element = REXML::Element.new( XML_ELEMENT_NAME )
+			xml_element.add_element( NAME_ELEMENT_NAME ).add_text( self.name )
+			xml_element.add_element( VALUE_ELEMENT_NAME ).add_text( self.value )
+			xml_element
+		end
+
+		def to_xml # :nodoc:
+			self.to_xml_element.to_s
+		end
+
+    def inspect # :nodoc:
+      "#{ self.name }: #{ self.value }"
+    end
+
+    def to_s # :nodoc:
+      self.inspect
+		end
+
+		def self.from_xml_element( parameter_xml_element ) # :nodoc:
+			Parameter.new( :name  => RCAP.xpath_text( parameter_xml_element, NAME_XPATH ),
+										 :value => RCAP.xpath_text( parameter_xml_element, VALUE_XPATH ))
+		end
+
+		# Two parameters are equivalent if they have the same name and value.
+		def ==( other )
+			[ self.name, self.value ] == [ other.name, other.value ]
+		end
+	end
+end

data/lib/rcap/point.rb

@@ -0,0 +1,39 @@
+module RCAP
+	# A Point object is valid if
+	# * it has a lattitude within the minimum and maximum lattitude values
+	# * it has a longitude within the minimum and maximum longitude values
+  class Point
+    include Validation
+
+    MAX_LONGITUDE = 180
+    MIN_LONGITUDE = -180
+    MAX_LATTITUDE = 90
+    MIN_LATTITUDE= -90
+
+    attr_accessor( :lattitude )
+		attr_accessor( :longitude )
+
+    validates_numericality_of( :lattitude, :longitude )
+    validates_inclusion_of( :lattitude, :in => MIN_LATTITUDE..MAX_LATTITUDE )
+    validates_inclusion_of( :longitude, :in => MIN_LONGITUDE..MAX_LONGITUDE)
+
+    def initialize( attributes = {} )
+      @lattitude = attributes[ :lattitude ]
+      @longitude = attributes[ :longitude ]
+    end
+
+    def to_s # :nodoc:
+      "#{ self.lattitude },#{ self.longitude }"
+    end
+
+    def inspect # :nodoc:
+      '('+self.to_s+')'
+    end
+
+		# Two points are equivalent if they have the same lattitude and longitude
+		def ==( other )
+			self.lattitude == other.lattitude &&
+				self.longitude == other.longitude
+		end
+  end
+end

data/lib/rcap/polygon.rb

@@ -0,0 +1,50 @@
+module RCAP
+	# A Polygon object is valid if
+	# * it has a minimum of three points
+	# * each Point object in the points collection is valid
+	class Polygon
+    include Validation
+
+		# Collection of Point objects.
+    attr_reader( :points )
+
+    validates_length_of( :points, :minimum => 3 )
+    validates_collection_of( :points )
+
+    XML_ELEMENT_NAME = 'polygon'                   # :nodoc: 
+    XPATH            = "cap:#{ XML_ELEMENT_NAME }" # :nodoc: 
+
+    def initialize( attributes = {})
+      @points = Array( attributes[ :points ])
+    end
+
+    def to_s # :nodoc:
+      (@points.map{ |point| point.to_s } + [ @points.first ]).join( ' ' )
+    end
+
+    def inspect # :nodoc:
+      "(#{ @points.map{|point| point.inspect}.join(', ')})"
+    end
+
+    def to_xml_element # :nodoc:
+      xml_element = REXML::Element.new( XML_ELEMENT_NAME )
+      xml_element.add_text( self.to_s )
+      xml_element
+    end
+
+		# Two polygons are equivalent if their collection of points is equivalent.
+    def ==( other )
+      self.points == other.points
+    end
+
+    def self.parse_polygon_string( polygon_string ) # :nodoc:
+      polygon_string.split( ' ' ).map{ |coordinate_string| coordinate_string.split( ',' ).map{|coordinate| coordinate.to_f }}
+    end
+
+    def self.from_xml_element( polygon_xml_element ) # :nodoc:
+      coordinates = self.parse_polygon_string( polygon_xml_element.text )
+      points = coordinates.map{ |lattitude, longitude| RCAP::Point.new( :lattitude => lattitude, :longitude => longitude )}[0..-2]
+      polygon = self.new( :points => points )
+    end
+  end
+end

data/lib/rcap/resource.rb

@@ -0,0 +1,81 @@
+module RCAP
+	# A Resourse object is valid if
+	# * it has a resource description
+  class Resource
+    include Validation
+
+		# Resource Description
+    attr_accessor( :resource_desc )
+		attr_accessor( :mime_type )
+		# Expressed in bytes
+		attr_accessor( :size )
+		# Resource location
+		attr_accessor( :uri )
+		# Dereferenced URI - contents of URI Base64 encoded
+		attr_accessor( :deref_uri )
+			# SHA-1 hash of contents of resource
+		attr_accessor( :digest )
+
+    validates_presence_of( :resource_desc )
+    
+    XML_ELEMENT_NAME           = 'resource'     # :nodoc: 
+    MIME_TYPE_ELEMENT_NAME     = 'mimeType'     # :nodoc: 
+    SIZE_ELEMENT_NAME          = 'size'         # :nodoc: 
+    URI_ELEMENT_NAME           = 'uri'          # :nodoc: 
+    DEREF_URI_ELEMENT_NAME     = 'derefUri'     # :nodoc: 
+    DIGEST_ELEMENT_NAME        = 'digest'       # :nodoc: 
+    RESOURCE_DESC_ELEMENT_NAME = 'resourceDesc' # :nodoc: 
+
+    XPATH               = "cap:#{ XML_ELEMENT_NAME }"           # :nodoc: 
+    MIME_TYPE_XPATH     = "cap:#{ MIME_TYPE_ELEMENT_NAME }"     # :nodoc: 
+    SIZE_XPATH          = "cap:#{ SIZE_ELEMENT_NAME }"          # :nodoc: 
+    URI_XPATH           = "cap:#{ URI_ELEMENT_NAME }"           # :nodoc: 
+    DEREF_URI_XPATH     = "cap:#{ DEREF_URI_ELEMENT_NAME }"     # :nodoc: 
+    DIGEST_XPATH        = "cap:#{ DIGEST_ELEMENT_NAME }"        # :nodoc: 
+    RESOURCE_DESC_XPATH = "cap:#{ RESOURCE_DESC_ELEMENT_NAME }" # :nodoc: 
+
+    def initialize( attributes = {} )
+      @mime_type     = attributes[ :mime_type ]
+      @size          = attributes[ :size ]
+      @uri           = attributes[ :uri ]
+      @deref_uri     = attributes[ :deref_uri ]
+      @digest        = attributes[ :digest ]
+      @resource_desc = attributes[ :resource_desc ]
+    end
+
+    def to_xml_element # :nodoc:
+      xml_element = REXML::Element.new( XML_ELEMENT_NAME )
+      xml_element.add_element( RESOURCE_DESC_ELEMENT_NAME ).add_text( self.resource_desc )
+      xml_element.add_element( MIME_TYPE_ELEMENT_NAME ).add_text( self.mime_type ) if self.mime_type
+      xml_element.add_element( SIZE_ELEMENT_NAME ).add_text( self.size ) if self.size
+      xml_element.add_element( URI_ELEMENT_NAME ).add_text( self.uri ) if self.uri
+      xml_element.add_element( DEREF_URI_ELEMENT_NAME ).add_text( self.deref_uri ) if self.deref_uri
+      xml_element.add_element( DIGEST_ELEMENT_NAME ).add_text( self.digest ) if self.digest
+      xml_element
+    end
+
+		# If size is defined returns the size in kilobytes
+    def size_in_kb
+      if self.size
+        self.size.to_f/1024
+      end
+    end
+
+    def to_xml # :nodoc:
+      self.to_xml_element.to_s
+    end
+
+    def inspect # :nodoc:
+      [ self.resource_desc, self.uri, self.mime_type, self.size ? format( "%.1fKB", self.size_in_kb ) : nil ].compact.join(' - ')
+    end
+
+    def self.from_xml_element( resource_xml_element ) # :nodoc:
+      resource = self.new( :resource_desc => RCAP.xpath_text( resource_xml_element, RESOURCE_DESC_XPATH ),
+                           :uri           => RCAP.xpath_text( resource_xml_element, URI_XPATH ),
+                           :mime_type     => RCAP.xpath_text( resource_xml_element, MIME_TYPE_XPATH ),
+                           :deref_uri     => RCAP.xpath_text( resource_xml_element, DEREF_URI_XPATH ),
+                           :size          => RCAP.xpath_text( resource_xml_element, SIZE_XPATH ),
+                           :digest        => RCAP.xpath_text( resource_xml_element, DIGEST_XPATH ))
+    end
+  end
+end