rcap 0.4 → 1.0.0.rc.1

data/lib/rcap/parameter.rb

@@ -1,66 +0,0 @@
-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
-
-		# 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
-end

data/lib/rcap/point.rb

@@ -1,53 +0,0 @@
-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
-
-		# 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

data/lib/rcap/polygon.rb

@@ -1,77 +0,0 @@
-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
-
-		# 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
-end

data/lib/rcap/resource.rb

@@ -1,143 +0,0 @@
-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
-
-		# 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
-end

data/spec/area_spec.rb

@@ -1,179 +0,0 @@
-require 'spec_helper'
-
-describe( RCAP::Area ) do
-	context( 'on initialisation' ) do
-		before( :each ) do
-			@area = RCAP::Area.new
-		end
-
-		# Atomic
-		it( 'should not have a area_desc' ){ @area.area_desc.should( be_nil )}
-		it( 'should not have a altitude' ){ @area.altitude.should( be_nil )}
-		it( 'should not have a ceiling' ){ @area.ceiling.should( be_nil )}
-		
-		# Group
-		it( 'should have an empty polygons' ){ @area.polygons.should( be_empty )}
-		it( 'should have an empty circles' ){ @area.circles.should( be_empty )}
-		it( 'should have an empty geocodes' ){ @area.geocodes.should( be_empty )}
-
-    shared_examples_for( "it can parse into an Area object" ) do
-			it( 'should parse the area_desc correctly' ) do
-				@area.area_desc.should == @original_area.area_desc
-			end
-
-			it( 'should parse the altitude correctly' ) do
-				@area.altitude.should == @original_area.altitude
-			end
-
-			it( 'should parse the ceiling correctly' ) do
-				@area.ceiling.should == @original_area.ceiling
-			end
-			
-			it( 'should parse the circles correctly' ) do
-				@area.circles.should == @original_area.circles
-			end
-
-			it( 'should parse the geocodes correctly' ) do
-				@area.geocodes.should == @original_area.geocodes
-			end
-
-			it( 'should parse the polygons correctly' ) do
-				@area.polygons.should == @original_area.polygons
-			end
-    end
-
-		context( 'from XML' ) do
-			before( :each ) do
-				@original_area = RCAP::Area.new( :area_desc => 'Area Description',
-																			 :altitude => 100,
-																			 :ceiling => 200,
-																			 :circles => RCAP::Circle.new( :lattitude => 0, :longitude => 0 , :radius => 100 ),
-																			 :geocodes => RCAP::Geocode.new( :name => 'name', :value => 'value' ),
-																			 :polygons => RCAP::Polygon.new( :points => RCAP::Point.new( :lattitude =>1, :longitude => 1 ))) 
-
-				@alert = RCAP::Alert.new( :infos => RCAP::Info.new( :areas => @original_area ))
-				@xml_string = @alert.to_xml
-				@xml_document = REXML::Document.new( @xml_string )
-				@info_xml_element = RCAP.xpath_first( @xml_document.root, RCAP::Info::XPATH )
-				@area_xml_element = RCAP.xpath_first( @info_xml_element, RCAP::Area::XPATH )
-				@area = RCAP::Area.from_xml_element( @area_xml_element )
-			end
-
-      it_should_behave_like( "it can parse into an Area object" )
-		end
-
-    context( 'from a hash' ) do
-			before( :each ) do
-				@original_area = RCAP::Area.new( :area_desc => 'Area Description',
-																			 :altitude => 100,
-																			 :ceiling => 200,
-																			 :circles => RCAP::Circle.new( :lattitude => 0, :longitude => 0 , :radius => 100 ),
-																			 :geocodes => RCAP::Geocode.new( :name => 'name', :value => 'value' ),
-																			 :polygons => RCAP::Polygon.new( :points => RCAP::Point.new( :lattitude =>1, :longitude => 1 ))) 
-
-				@area = RCAP::Area.from_h( @original_area.to_h )
-			end
-
-      it_should_behave_like( "it can parse into an Area object" )
-    end
-	end
-
-  context( 'when exported' ) do
-    before( :each ) do
-      @area = RCAP::Area.new( :area_desc => 'Area Description',
-                             :altitude => 100,
-                             :ceiling => 200,
-                             :circles => RCAP::Circle.new(  :lattitude => 0, :longitude => 0 , :radius => 100 ),
-                             :geocodes => RCAP::Geocode.new( :name => 'name', :value => 'value' ),
-                             :polygons => RCAP::Polygon.new( :points => RCAP::Point.new( :lattitude =>1, :longitude => 1 ))) 
-    end
-    context( 'to a hash' ) do
-      before( :each ) do
-        @area_hash = @area.to_h
-      end
-
-      it( 'should export the area description correctly' ) do
-        @area_hash[ RCAP::Area::AREA_DESC_KEY ].should == @area.area_desc 
-      end
-
-      it( 'should export the altitude correctly' ) do
-        @area_hash[ RCAP::Area::ALTITUDE_KEY ].should == @area.altitude 
-      end
-
-      it( 'should set the ceiling correctly' ) do
-        @area_hash[ RCAP::Area::CEILING_KEY ].should == @area.ceiling
-      end
-
-      it( 'should export the circles correctly' ) do
-        @area_hash[ RCAP::Area::CIRCLES_KEY ].should == @area.circles.map{ |circle| circle.to_h }
-      end
-
-      it( 'should export the geocodes correctly' ) do
-        @area_hash[ RCAP::Area::GEOCODES_KEY ].should == @area.geocodes.map{ |geocode| geocode.to_h }
-      end
-
-      it( 'should export the polygons correctly' ) do
-        @area_hash[ RCAP::Area::POLYGONS_KEY ].should == @area.polygons.map{ |polygon| polygon.to_h }
-      end
-    end
-  end
-
-  context( 'is not valid if' ) do
-    before( :each ) do
-      @area = RCAP::Area.new( :area_desc => "Cape Town Metropole" )
-      @area.should( be_valid )
-    end
-
-    it( 'does not have an area descrtiption (area_desc)') do
-      @area.area_desc = nil
-      @area.should_not( be_valid )
-    end
-
-    it( 'has a ceiling defined but no altitude' ) do
-      @area.ceiling = 1
-      @area.altitude = nil
-      @area.should_not( be_valid )
-    end
-
-    context( 'it contains circles and it' ) do
-      before( :each ) do
-        @area.circles << RCAP::Circle.new( :lattitude => 0, :longitude => 0, :radius => 1)
-        @area.should( be_valid )
-      end
-
-      it( 'has an invalid circle' ) do
-        @area.circles.first.lattitude = nil
-        @area.should_not( be_valid )
-      end
-    end
-
-    context( 'it contains polygons and it' ) do
-      before( :each ) do
-        @polygon = RCAP::Polygon.new
-        @polygon.points.push( RCAP::Point.new( :lattitude => 0, :longitude => 0 ),
-                             RCAP::Point.new( :lattitude => 0, :longitude => 1 ),
-                             RCAP::Point.new( :lattitude => 1, :longitude => 0 ))
-        @area.polygons << @polygon
-        @area.should( be_valid )
-      end
-
-      it( 'has an invalid polygon' ) do
-        @polygon.points.first.lattitude = nil
-        @area.should_not( be_valid )
-      end
-    end
-
-    context( 'it contains geocodes and it' ) do
-      before( :each ) do
-        @geocode = RCAP::Geocode.new( :name => 'foo', :value => 'bar' )
-        @area.geocodes << @geocode
-        @area.should( be_valid )
-      end
-
-      it( 'has an invalid geocode' ) do
-        @geocode.value = nil
-        @area.should_not( be_valid )
-      end
-    end
-  end
-end