rcap-rails-generators 1.3

data/lib/generators/rcap/models/templates/models/parameter.rb

@@ -0,0 +1,64 @@
+# A Parameter object is valid if
+# * it has a name
+# * it has a value
+class Parameter < ActiveRecord::Base
+	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 ),
+									 :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
+
+  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

data/lib/generators/rcap/models/templates/models/point.rb

@@ -0,0 +1,51 @@
+# A Point object is valid if
+# * it has a latitude within the minimum and maximum latitude values
+# * it has a longitude within the minimum and maximum longitude values
+class Point < ActiveRecord::Base
+  include Validation
+
+  MAX_LONGITUDE = 180
+  MIN_LONGITUDE = -180
+  MAX_LATITUDE = 90
+  MIN_LATITUDE= -90
+
+  attr_accessor( :latitude )
+	attr_accessor( :longitude )
+
+  validates_numericality_of( :latitude, :longitude )
+  validates_inclusion_of( :latitude, :in => MIN_LATITUDE..MAX_LATITUDE )
+  validates_inclusion_of( :longitude, :in => MIN_LONGITUDE..MAX_LONGITUDE)
+
+  def initialize( attributes = {} )
+    @latitude = attributes[ :latitude ]
+    @longitude = attributes[ :longitude ]
+  end
+
+	# Returns a string representation of the point of the form
+	#  latitude,longitude
+  def to_s
+    "#{ self.latitude },#{ self.longitude }"
+  end
+
+  def inspect # :nodoc:
+    '('+self.to_s+')'
+  end
+
+	# Two points are equivalent if they have the same latitude and longitude
+	def ==( other )
+		[ self.latitude, self.longitude ] == [ other.latitude, other.longitude ]
+	end
+
+  LATITUDE_KEY = 'latitude_hash'  # :nodoc:
+  LONGITUDE_KEY = 'longitude_hash'  # :nodoc:
+
+  def to_h # :nodoc:
+    RCAP.attribute_values_to_hash(
+      [ LATITUDE_KEY, self.latitude ],
+      [ LONGITUDE_KEY, self.longitude ])
+  end
+
+  def self.from_h( point_hash ) # :nodoc:
+    self.new( :latitude => point_hash[ LATITUDE_KEY ], :longitude => point_hash[ LONGITUDE_KEY ])
+  end
+end

data/lib/generators/rcap/models/templates/models/polygon.rb

@@ -0,0 +1,75 @@
+# A Polygon object is valid if
+# * it has a minimum of three points
+# * each Point object in the points collection is valid
+class Polygon < ActiveRecord::Base
+  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
+
+	# Returns a string representation of the polygon of the form
+	#  points[0] points[1] points[2] ... points[n-1] points[0]
+  # where each point is formatted with RCAP::Point#to_s
+  def to_s
+    (@points + [ @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
+
+
+  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

data/lib/generators/rcap/models/templates/models/resource.rb

@@ -0,0 +1,143 @@
+# A Resourse object is valid if
+# * it has a resource description
+class Resource < ActiveRecord::Base
+  include Validation
+
+  belongs_to :item
+
+	# 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
+
+	# Returns a string representation of the resource of the form
+	#  resource_desc
+  def to_s
+    self.resource_desc
+  end
+
+  def self.from_xml_element( resource_xml_element ) # :nodoc:
+    resource = self.new( :resource_desc => RCAP.xpath_text( resource_xml_element, RESOURCE_DESC_XPATH ),
+                        :uri           => RCAP.xpath_text( resource_xml_element, URI_XPATH ),
+                        :mime_type     => RCAP.xpath_text( resource_xml_element, MIME_TYPE_XPATH ),
+                        :deref_uri     => RCAP.xpath_text( resource_xml_element, DEREF_URI_XPATH ),
+                        :size          => RCAP.xpath_text( resource_xml_element, SIZE_XPATH ),
+                        :digest        => RCAP.xpath_text( resource_xml_element, DIGEST_XPATH ))
+  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

data/lib/generators/rcap/models/templates/modules/rcap.rb

@@ -0,0 +1,5 @@
+module RCAP
+	XMLNS = "urn:oasis:names:tc:emergency:cap:1.1"
+  CAP_VERSION = "1.1"
+	VERSION = "0.4"
+end

data/lib/generators/rcap/models/templates/modules/validations.rb

@@ -0,0 +1,116 @@
+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' 
+      }.merge!( attributes.extract_options! )
+
+      validates_each( *attributes ) do |object, attribute, value|
+        next if ( value.nil? && options[ :allow_nil ]) || ( value.blank? && options[ :allow_blank ])
+        unless options[ :in ].include?( value )
+          object.errors[ attribute ] << options[ :message ]
+        end
+      end
+    end
+
+    def validates_inclusion_of_members_of( *attributes )
+      options = {
+        :message => 'contains members that are not valid'
+      }.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.all?{ |member| options[ :in ].include?( member )}
+          object.errors[ attribute ] << options[ :message ]
+        end
+      end
+    end
+
+    def validates_length_of_members_of( *attributes )
+      options = {
+        :message => 'contains members with incorrect length'
+      }.merge!( attributes.extract_options! )
+
+      validates_each( *attributes ) do |object, attribute, collection|
+        next if ( collection.nil? && options[ :allow_nil ]) || (collection.blank? && options[ :allow_blank ])
+        unless options[ :minimum ] && collection.length >= options[ :minimum ]
+          object.errors[ attribute ] << options[ :message ]
+        end
+      end
+    end
+
+    def validates_validity_of( *attributes )
+      options = {
+        :message => 'is not valid'
+      }.merge!( attributes.extract_options! )
+
+      validates_each( *attributes ) do |object, attribute, value|
+        next if ( value.nil? && options[ :allow_nil ]) || ( value.blank? && options[ :allow_blank ])
+        unless value && value.valid?
+          object.errors[ attribute ] << options[ :message ]
+        end
+      end
+    end
+
+    def validates_collection_of( *attributes )
+      options = {
+        :message => 'contains an invalid element'
+      }.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.all?{ |element| element.valid? }
+          object.errors[ attribute ] << options[ :message ]
+        end
+      end
+    end
+
+    def validates_dependency_of( *attributes )
+      options = {
+        :message => 'is dependent on :attribute being defined'
+      }.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 ])
+          object.errors[ attribute ] << options[ :message ].gsub( /:attribute/, options[ :on ].to_s )
+        end
+      end
+    end
+
+    def validates_numericality_of( *attributes )
+      options = {
+        :message => 'is not a number',
+      }.merge!(attributes.extract_options!)
+
+      re = options[:only_integer] ? CAP_INTEGER_REGEX : CAP_NUMBER_REGEX
+
+      validates_each( *attributes ) do |object, attribute, value|
+        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 ] 
+        end
+      end
+    end
+
+
+    def validates_responsiveness_of( *attributes )
+      options = {
+        :message => 'does not respond to the given method'
+      }.merge!( attributes.extract_options! )
+
+      validates_each( *attributes ) do |object, attribute, value|
+        next if ( collection.nil? && options[ :allow_nil ]) || ( collection.blank? && options[ :allow_blank ])
+        unless options[ :to ].all?{ |method_name| object.respond_to?( method_name )}
+          object.errors[ attribute ] << options [ :message ]
+        end
+      end
+    end
+  end
+end