rcap 0.4 → 1.0.0.rc.1

data/lib/rcap/cap_1_2/parameter.rb

@@ -0,0 +1,68 @@
+module RCAP
+  module CAP_1_2
+    # 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
+
+      # Returns a string representation of the parameter of the form
+      #  name: value
+      def to_s
+        self.inspect
+      end
+
+      def self.from_xml_element( parameter_xml_element ) # :nodoc:
+        Parameter.new( :name  => RCAP.xpath_text( parameter_xml_element, NAME_XPATH, Alert::XMLNS ),
+                      :value => RCAP.xpath_text( parameter_xml_element, VALUE_XPATH, Alert::XMLNS ))
+      end
+
+      # Two parameters are equivalent if they have the same name and value.
+      def ==( other )
+        [ self.name, self.value ] == [ other.name, other.value ]
+      end
+
+      def to_h # :nodoc:
+        RCAP.attribute_values_to_hash(
+          [ @name, @value ])
+      end
+
+      def self.from_h( hash ) # :nodoc:
+        key = hash.keys.first
+        self.new( :name => key, :value => hash[ key ])
+      end
+    end
+  end
+end

data/lib/rcap/cap_1_2/point.rb

@@ -0,0 +1,55 @@
+module RCAP
+  module CAP_1_2
+    # 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
+
+      # Returns a string representation of the point of the form
+      #  lattitude,longitude
+      def to_s
+        "#{ 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, self.longitude ] == [ other.lattitude, other.longitude ]
+      end
+
+      LATTITUDE_KEY = 'lattitude_hash'  # :nodoc:
+      LONGITUDE_KEY = 'longitude_hash'  # :nodoc:
+
+      def to_h # :nodoc:
+        RCAP.attribute_values_to_hash(
+          [ LATTITUDE_KEY, self.lattitude ],
+          [ LONGITUDE_KEY, self.longitude ])
+      end
+
+      def self.from_h( point_hash ) # :nodoc:
+        self.new( :lattitude => point_hash[ LATTITUDE_KEY ], :longitude => point_hash[ LONGITUDE_KEY ])
+      end
+    end
+  end
+end

data/lib/rcap/cap_1_2/polygon.rb

@@ -0,0 +1,90 @@
+module RCAP
+  module CAP_1_2
+    # 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_collection_of( :points )
+      validates_length_of( :points, :minimum => 4 )
+      validates_equality_of_first_and_last( :points )
+
+      XML_ELEMENT_NAME = 'polygon'                   # :nodoc:
+      XPATH            = "cap:#{ XML_ELEMENT_NAME }" # :nodoc:
+
+      def initialize( attributes = {})
+        @points = Array( attributes[ :points ])
+      end
+
+      # Creates a new Point object and adds it to the points array. The
+      # poitn_attributes are passed as a parameter to Point.new.
+      def add_point( point_attributes = {})
+        point = Point.new( point_attributes )
+        self.points << point
+        point
+      end
+
+      # Returns a string representation of the polygon of the form
+      #  points[0] points[1] points[2] ... points[n-1] points[0]
+      # where each point is formatted with Point#to_s
+      def to_s
+        @points.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:
+        if !polygon_xml_element.text.nil?
+          coordinates = self.parse_polygon_string( polygon_xml_element.text )
+          points = coordinates.map{ |lattitude, longitude| Point.new( :lattitude => lattitude, :longitude => longitude )}
+          polygon = self.new( :points => points )
+        else
+          self.new
+        end
+      end
+
+
+      def to_yaml( options = {} ) # :nodoc:
+        yaml_points = self.points.map{ |point| [ point.lattitude, point.longitude ]}
+        def yaml_points.to_yaml_style; :inline; end
+
+        yaml_points.to_yaml( options )
+      end
+
+      def self.from_yaml_data( polygon_yaml_data ) # :nodoc:
+        self.new( :points => Array( polygon_yaml_data ).map{ |lattitude, longitude| Point.new( :lattitude => lattitude, :longitude => longitude )})
+      end
+
+      POINTS_KEY  = 'points' # :nodoc:
+
+      def to_h # :nodoc:
+        { POINTS_KEY => self.points.map{ |point| point.to_h }}
+      end
+
+      def self.from_h( polygon_hash ) # :nodoc:
+        self.new( :points => polygon_hash[ POINTS_KEY ].map{ |point_hash| Point.from_h( point_hash )})
+      end
+    end
+  end
+end

data/lib/rcap/cap_1_2/resource.rb

@@ -0,0 +1,147 @@
+module RCAP
+  module CAP_1_2
+    # A Resourse object is valid if
+    # * it has a resource description
+    class Resource
+      include Validation
+
+      # Resource Description
+      attr_accessor( :resource_desc )
+      # MIME type as described in RFC 2046
+      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 )
+      validates_presence_of( :mime_type )
+
+      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
+
+      # Returns a string representation of the resource of the form
+      #  resource_desc
+      def to_s
+        self.resource_desc
+      end
+
+      def self.from_xml_element( resource_xml_element ) # :nodoc:
+        resource = self.new( :resource_desc => RCAP.xpath_text( resource_xml_element, RESOURCE_DESC_XPATH, Alert::XMLNS ),
+                            :uri           => RCAP.xpath_text( resource_xml_element, URI_XPATH, Alert::XMLNS ),
+                            :mime_type     => RCAP.xpath_text( resource_xml_element, MIME_TYPE_XPATH, Alert::XMLNS ),
+                            :deref_uri     => RCAP.xpath_text( resource_xml_element, DEREF_URI_XPATH, Alert::XMLNS ),
+                            :size          => RCAP.xpath_text( resource_xml_element, SIZE_XPATH, Alert::XMLNS ),
+                            :digest        => RCAP.xpath_text( resource_xml_element, DIGEST_XPATH, Alert::XMLNS ))
+      end
+
+      RESOURCE_DESC_YAML = "Resource Description" # :nodoc:
+      URI_YAML           = "URI"                  # :nodoc:
+      MIME_TYPE_YAML     = "Mime Type"            # :nodoc:
+      DEREF_URI_YAML     = "Derefrenced URI Data" # :nodoc:
+      SIZE_YAML          = "Size"                 # :nodoc:
+      DIGEST_YAML        = "Digest"               # :nodoc:
+
+      def to_yaml( options ) # :nodoc:
+        RCAP.attribute_values_to_hash(
+          [ RESOURCE_DESC_YAML, self.resource_desc ],
+          [ URI_YAML,           self.uri ],
+          [ MIME_TYPE_YAML,     self.mime_type ],
+          [ DEREF_URI_YAML,     self.deref_uri ],
+          [ SIZE_YAML,          self.size ],
+          [ DIGEST_YAML,        self.digest ]
+        ).to_yaml( options )
+      end
+
+      def self.from_yaml_data( resource_yaml_data ) # :nodoc:
+        self.new(
+          :resource_desc => reource_yaml_data[ RESOURCE_DESC_YAML ],
+          :uri           => reource_yaml_data[ URI_YAML ],
+          :mime_type     => reource_yaml_data[ MIME_TYPE_YAML ],
+          :deref_uri     => reource_yaml_data[ DEREF_URI_YAML ],
+          :size          => reource_yaml_data[ SIZE_YAML ],
+          :digest        => reource_yaml_data[ DIGEST_YAML ]
+        )
+      end
+
+      RESOURCE_DESC_KEY = 'resource_desc' # :nodoc:
+      URI_KEY           = 'uri'           # :nodoc:
+      MIME_TYPE_KEY     = 'mime_type'     # :nodoc:
+      DEREF_URI_KEY     = 'deref_uri'     # :nodoc:
+      SIZE_KEY          = 'size'          # :nodoc:
+      DIGEST_KEY        = 'digest'        # :nodoc:
+
+      def to_h # :nodoc:
+        RCAP.attribute_values_to_hash(
+          [ RESOURCE_DESC_KEY, self.resource_desc ],
+          [ URI_KEY,           self.uri],
+          [ MIME_TYPE_KEY,     self.mime_type],
+          [ DEREF_URI_KEY,     self.deref_uri],
+          [ SIZE_KEY,          self.size ],
+          [ DIGEST_KEY,        self.digest ])
+      end
+
+      def self.from_h( resource_hash ) # :nodoc:
+        self.new(
+          :resource_desc => resource_hash[ RESOURCE_DESC_KEY ],
+          :uri => resource_hash[ URI_KEY ],
+          :mime_type => resource_hash[ MIME_TYPE_KEY ],
+          :deref_uri => resource_hash[ DEREF_URI_KEY ],
+          :size => resource_hash[ SIZE_KEY ],
+          :digest => resource_hash[ DIGEST_KEY ])
+      end
+    end
+  end
+end

data/lib/rcap/utilities.rb

@@ -19,7 +19,7 @@ class String # :nodoc:
   end
 
   def unpack_cap_list
-    self.split( CAP_LIST_REGEX ).reject{ |match| match == "" || match =~ WHITESPACE_REGEX }  
+    self.split( CAP_LIST_REGEX ).reject{ |match| match == "" || match =~ WHITESPACE_REGEX }
   end
 end
 
@@ -33,7 +33,8 @@ class Time # :nodoc:
   RCAP_ZONE_FORMAT = "%+03i:00"
 
   def to_s_for_cap
-    self.strftime( RCAP_TIME_FORMAT ) + format( RCAP_ZONE_FORMAT , self.utc_hours_offset ) 
+    t = self.strftime( RCAP_TIME_FORMAT ) + format( RCAP_ZONE_FORMAT , self.utc_hours_offset )
+    t.sub(/\+(00:\d\d)$/, '-\1')
   end
 
   def utc_hours_offset
@@ -42,17 +43,21 @@ class Time # :nodoc:
 end
 
 module RCAP # :nodoc:
-  def self.xpath_text( xml_element, xpath ) 
-    element = self.xpath_first( xml_element, xpath )
+  def self.generate_identifier
+    UUIDTools::UUID.random_create.to_s
+  end
+
+  def self.xpath_text( xml_element, xpath, namespace )
+    element = self.xpath_first( xml_element, xpath, namespace )
     element.text if element
   end
 
-  def self.xpath_first( xml_element, xpath )
-    REXML::XPath.first( xml_element, xpath, { 'cap' => RCAP::XMLNS })
+  def self.xpath_first( xml_element, xpath, namespace )
+    REXML::XPath.first( xml_element, xpath, { 'cap' => namespace })
   end
 
-  def self.xpath_match( xml_element, xpath )
-    REXML::XPath.match( xml_element, xpath, { 'cap' => RCAP::XMLNS })
+  def self.xpath_match( xml_element, xpath, namespace )
+    REXML::XPath.match( xml_element, xpath, { 'cap' => namespace })
   end
 
   def self.format_lines_for_inspect( header, inspect_string )
@@ -65,7 +70,7 @@ module RCAP # :nodoc:
   end
 
   def self.attribute_values_to_hash( *attribute_values )
-    Hash[ *attribute_values.reject{ |key, value| value.blank? }.flatten( 1 )] 
+    Hash[ *attribute_values.reject{ |key, value| value.blank? }.flatten( 1 )]
   end
 
   def self.to_s_for_cap( object )

data/lib/rcap/validations.rb

@@ -1,12 +1,12 @@
-module Validation  # :nodoc: 
+module Validation  # :nodoc:
   module ClassMethods # :nodoc:
 
     CAP_NUMBER_REGEX  = Regexp.new( '^-{0,1}\d*\.{0,1}\d+$' )
     CAP_INTEGER_REGEX = Regexp.new( '\-{0,1}A[+-]?\d+\Z' )
 
     def validates_inclusion_of( *attributes )
-      options = { 
-        :message => 'is not in the required range' 
+      options = {
+        :message => 'is not in the required range'
       }.merge!( attributes.extract_options! )
 
       validates_each( *attributes ) do |object, attribute, value|
@@ -75,14 +75,33 @@ module Validation  # :nodoc:
       }.merge!( attributes.extract_options! )
 
       validates_each( *attributes ) do |object, attribute, value|
-        contingent_on_value = object.send( options[ :on ])
-        next if ( value.nil? && options[ :allow_nil ]) || ( value.blank? && options[ :allow_blank ])
-        unless value.blank? || !value.blank? && !contingent_on_value.blank? && ( options[ :with_value ].nil? || contingent_on_value == options[ :with_value ])
+        next if value.blank?
+        contingent_on_attribute = object.send( options[ :on ])
+        contingent_on_attribute_value = options[ :with_value ]
+
+        if contingent_on_attribute.nil? || !contingent_on_attribute_value.nil? && contingent_on_attribute_value != contingent_on_attribute
           object.errors[ attribute ] << options[ :message ].gsub( /:attribute/, options[ :on ].to_s )
         end
       end
     end
 
+    def validates_conditional_presence_of( *attributes )
+      options = {
+        :message => 'is not defined but is required by :contingent_attribute'
+      }.merge!( attributes.extract_options! )
+
+      validates_each( *attributes ) do |object, attribute, value|
+        contingent_attribute_value = object.send( options[ :when ] )
+        required_contingent_attribute_value = options[ :is ]
+
+        next if contingent_attribute_value.nil? || contingent_attribute_value != required_contingent_attribute_value && !options[ :is ].blank?
+        if value.blank?
+          object.errors[ attribute ] << options[ :message ].gsub( /:contingent_attribute/, options[ :whenn ].to_s )
+        end
+      end
+    end
+
+
     def validates_numericality_of( *attributes )
       options = {
         :message => 'is not a number',
@@ -94,7 +113,7 @@ module Validation  # :nodoc:
         next if (value.nil? && options[ :allow_nil ]) || (value.blank? && options[ :allow_blank ])
         unless ( value.to_s =~ re ) &&
           ( options[ :greater_than ].nil? || value && value > options[ :greater_than ])
-          object.errors[ attribute ] << options[ :message ] 
+          object.errors[ attribute ] << options[ :message ]
         end
       end
     end
@@ -112,5 +131,18 @@ module Validation  # :nodoc:
         end
       end
     end
+
+    def validates_equality_of_first_and_last( *attributes )
+      options = {
+        :message => 'does not have equal first and last elements'
+      }.merge!( attributes.extract_options! )
+
+      validates_each( *attributes ) do |object, attribute, collection|
+        next if ( collection.nil? && options[ :allow_nil ]) || ( collection.blank? && options[ :allow_blank ])
+        unless collection.first == collection.last
+          object.errors[ attribute ] << options[ :message ]
+        end
+      end
+    end
   end
 end