rcap 1.3.1 → 2.0.0

data/lib/rcap/base/parameter.rb

@@ -0,0 +1,88 @@
+module RCAP
+  module Base
+    class Parameter
+      include Validation
+
+      validates_presence_of( :name, :value )
+
+      # @return [String]
+      attr_accessor( :name )
+      # @return [String]
+      attr_accessor( :value )
+
+      XML_ELEMENT_NAME   = "parameter"
+      NAME_ELEMENT_NAME  = "valueName"
+      VALUE_ELEMENT_NAME = "value"
+
+      XPATH       = "cap:#{ XML_ELEMENT_NAME }"
+      NAME_XPATH  = "cap:#{ NAME_ELEMENT_NAME }"
+      VALUE_XPATH = "cap:#{ VALUE_ELEMENT_NAME }"
+
+      # @param [Hash] attributes
+      # @option attributes [Symbol] :name Parameter name
+      # @option attributes [Symbol] :value Parameter value
+      def initialize
+        yield( self ) if block_given?
+      end
+
+      # @return [REXML::Element]
+      def to_xml_element
+        xml_element = REXML::Element.new( self.class::XML_ELEMENT_NAME )
+        xml_element.add_element( self.class::NAME_ELEMENT_NAME ).add_text( @name )
+        xml_element.add_element( self.class::VALUE_ELEMENT_NAME ).add_text( @value )
+        xml_element
+      end
+
+      # @return [String]
+      def to_xml
+        self.to_xml_element.to_s
+      end
+
+      # @return [String]
+      def inspect
+        "#{ @name }: #{ @value }"
+      end
+
+      # Returns a string representation of the parameter of the form
+      #  name: value
+      #
+      # @return [String]
+      def to_s
+        self.inspect
+      end
+
+      # Two parameters are equivalent if they have the same name and value.
+      #
+      # @param [Parameter] other
+      # @return [true, false]
+      def ==( other )
+        [ @name, @value ] == [ other.name, other.value ]
+      end
+
+      # @param [REXML::Element] parameter_xml_element
+      # @return [Parameter]
+      def self.from_xml_element( parameter_xml_element )
+        self.new do |parameter|
+           parameter.name  = RCAP.xpath_text( parameter_xml_element, self::NAME_XPATH, parameter.xmlns )
+           parameter.value = RCAP.xpath_text( parameter_xml_element, self::VALUE_XPATH, parameter.xmlns )
+        end
+      end
+
+      # @return [Hash]
+      def to_h
+        RCAP.attribute_values_to_hash( [ @name, @value ])
+      end
+
+      # @param [Hash] hash
+      # @return [Parameter]
+      def self.from_h( hash )
+        key = hash.keys.first
+        self.new do |parameter|
+          parameter.name = key
+          parameter.value = hash[ key ]
+        end
+      end
+    end
+  end
+end
+

data/lib/rcap/base/point.rb

@@ -0,0 +1,87 @@
+module RCAP
+  module Base
+    class Point
+      include Validation
+
+      MAX_LONGITUDE = 180
+      MIN_LONGITUDE = -180
+      MAX_LATTITUDE = 90
+      MIN_LATTITUDE= -90
+
+      # @return [Numeric]
+      attr_accessor( :lattitude )
+      # @return [Numeric]
+      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)
+
+      # @param [Hash] attributes
+      # @option attributes [Numeric] :lattitude
+      # @option attributes [Numeric] :longitude
+      def initialize
+        yield( self ) if block_given?
+      end
+
+      # Returns a string representation of the point of the form
+      #  lattitude,longitude
+      #
+      # @return [String]
+      def to_s
+        "#{ self.lattitude },#{ self.longitude }"
+      end
+
+      # @return [String]
+      def inspect
+        '('+self.to_s+')'
+      end
+
+      # Two points are equivalent if they have the same lattitude and longitude
+      #
+      # @param [Point] other
+      # @return [true, false]
+      def ==( other )
+        [ self.lattitude, self.longitude ] == [ other.lattitude, other.longitude ]
+      end
+
+      LATTITUDE_KEY = 'lattitude'
+      LONGITUDE_KEY = 'longitude'
+
+      # @return [Hash]
+      def to_h
+        RCAP.attribute_values_to_hash( [ LATTITUDE_KEY, self.lattitude ],
+                                       [ LONGITUDE_KEY, self.longitude ])
+      end
+
+      # @param [Hash] point_hash
+      # @return [Point]
+      def self.from_h( point_hash )
+        self.new do |point|
+          point.lattitude = point_hash[ LATTITUDE_KEY ]
+          point.longitude = point_hash[ LONGITUDE_KEY ]
+        end
+      end
+
+      LATTITUDE_INDEX = 0
+      LONGITUDE_INDEX = 1
+
+      # @return [Array(Numeric, Numeric)]
+      def to_a
+        Array.new.tap do |array|
+          array[ LATTITUDE_INDEX ] = self.lattitude
+          array[ LONGITUDE_INDEX ] = self.longitude
+        end
+      end
+
+      # @param [Array(Numeric, Numeric)] point_array
+      # @return [Point]
+      def self.from_a( point_array )
+        self.new do |point|
+          point.lattitude = point_array[ LATTITUDE_INDEX ]
+          point.longitude = point_array[ LONGITUDE_INDEX ]
+        end
+      end
+    end
+  end
+end

data/lib/rcap/base/polygon.rb

@@ -0,0 +1,120 @@
+module RCAP
+  module Base
+    class Polygon
+      include Validation
+
+      # @return [Array<Point>] Collection of {Point} objects
+      attr_reader( :points )
+
+      validates_collection_of( :points )
+      validates_length_of( :points, :minimum => 3 )
+      validates_equality_of_first_and_last( :points )
+
+      XML_ELEMENT_NAME = 'polygon'
+      XPATH            = "cap:#{ XML_ELEMENT_NAME }"
+
+      # @param [Hash] attributes
+      # @option attributes [Array<Point>] :points Collection of {Point} objects
+      def initialize
+        @points =  []
+        yield( self ) if block_given?
+      end
+
+      def add_point
+        point = self.point_class.new
+        yield( point ) if block_given?
+        self.points << point
+        point
+      end
+
+      # Returns a string representation of the polygon of the form
+      #  points[0] points[1] points[2] ...
+      # where each point is formatted with Point#to_s
+      def to_s
+        @points.join( ' ' )
+      end
+
+      # @return [String]
+      def inspect
+        "(#{ @points.map{|point| point.inspect}.join(', ')})"
+      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
+      end
+
+      # @return [Polygon]
+      def self.from_xml_element( polygon_xml_element )
+        if !polygon_xml_element.text.nil? && !polygon_xml_element.text.empty?
+          coordinates = self.parse_polygon_string( polygon_xml_element.text )
+          self.new do |polygon|
+            coordinates.each do |lattitude, longitude|
+              polygon.add_point do |point|
+                point.lattitude = lattitude
+                point.longitude = longitude
+              end
+            end
+          end
+        else
+          self.new
+        end
+      end
+
+      # @return [String]
+      def to_xml
+        self.to_xml_element.to_s
+      end
+
+      # Two polygons are equivalent if their collection of points is equivalent.
+      #
+      # @return [true,false]
+      def ==( other )
+        @points == other.points
+      end
+
+      # @return [Array<Array(Numeric,Numeric)>]
+      def self.parse_polygon_string( polygon_string )
+        polygon_string.split( ' ' ).map{ |coordinate_string| coordinate_string.split( ',' ).map{|coordinate| coordinate.to_f }}
+      end
+
+      # @return [Polygon]
+      def self.from_yaml_data( polygon_yaml_data )
+        self.new do |polygon|
+          Array( polygon_yaml_data ).each do |lattitude, longitude|
+            polygon.add_point do |point|
+              point.lattitude = lattitude
+              point.longitude = longitude
+            end
+          end
+        end
+      end
+
+      # @return [String]
+      def to_yaml( options = {} )
+        @points.map{ |point| [ point.lattitude, point.longitude ]}.to_yaml( options )
+      end
+
+      POINTS_KEY  = 'points'
+
+      # @return [Polygon]
+      def self.from_h( polygon_hash )
+        self.new do |polygon|
+          Array( polygon_hash[ POINTS_KEY ]).each do |point_array|
+            polygon.add_point do |point|
+              point.lattitude = point_array[ Point::LATTITUDE_INDEX ]
+              point.longitude = point_array[ Point::LONGITUDE_INDEX ]
+            end
+          end
+        end
+      end
+
+      # @return [Hash]
+      def to_h
+        { POINTS_KEY => @points.map{ |point| point.to_a }}
+      end
+    end
+  end
+end

data/lib/rcap/base/resource.rb

@@ -0,0 +1,168 @@
+module RCAP
+  module Base
+    class Resource
+      include Validation
+
+      # @return [String] Resource Description
+      attr_accessor( :resource_desc )
+      # @return [String]
+      attr_accessor( :mime_type )
+      # @return [Integer] Expressed in bytes
+      attr_accessor( :size )
+      # @return [String] Resource location
+      attr_accessor( :uri )
+      # @return [String] SHA-1 hash of contents of resource
+      attr_accessor( :digest )
+
+      validates_presence_of( :resource_desc )
+
+      XML_ELEMENT_NAME           = 'resource'
+      MIME_TYPE_ELEMENT_NAME     = 'mimeType'
+      SIZE_ELEMENT_NAME          = 'size'
+      URI_ELEMENT_NAME           = 'uri'
+      DIGEST_ELEMENT_NAME        = 'digest'
+      RESOURCE_DESC_ELEMENT_NAME = 'resourceDesc'
+
+      XPATH               = "cap:#{ XML_ELEMENT_NAME }"
+      MIME_TYPE_XPATH     = "cap:#{ MIME_TYPE_ELEMENT_NAME }"
+      SIZE_XPATH          = "cap:#{ SIZE_ELEMENT_NAME }"
+      URI_XPATH           = "cap:#{ URI_ELEMENT_NAME }"
+      DIGEST_XPATH        = "cap:#{ DIGEST_ELEMENT_NAME }"
+      RESOURCE_DESC_XPATH = "cap:#{ RESOURCE_DESC_ELEMENT_NAME }"
+
+      # @param [Hash{Symbol => Object}] attributes
+      # @option attributes [String] :mime_type
+      # @option attributes [Numeric] :size Size in bytes
+      # @option attributes [String] :uri
+      # @option attributes [String] :digest
+      # @option attributes [String] :resource_desc
+      def initialize
+        yield( self ) if block_given?
+      end
+
+      # @return [REXML::Element]
+      def to_xml_element
+        xml_element = REXML::Element.new( XML_ELEMENT_NAME )
+        xml_element.add_element( RESOURCE_DESC_ELEMENT_NAME ).add_text( @resource_desc )
+        xml_element.add_element( MIME_TYPE_ELEMENT_NAME ).add_text( @mime_type ) if @mime_type
+        xml_element.add_element( SIZE_ELEMENT_NAME ).add_text( @size.to_s )      if @size
+        xml_element.add_element( URI_ELEMENT_NAME ).add_text( @uri )             if @uri
+        xml_element.add_element( DIGEST_ELEMENT_NAME ).add_text( @digest )       if @digest
+        xml_element
+      end
+
+      # @param [REXML::Element] resource_xml_element
+      # @return [Resource]
+      def self.from_xml_element( resource_xml_element )
+        resource = self.new do |resource|
+          resource.resource_desc = RCAP.xpath_text( resource_xml_element, RESOURCE_DESC_XPATH, resource.xmlns )
+          resource.uri           = RCAP.xpath_text( resource_xml_element, URI_XPATH, resource.xmlns )
+          resource.mime_type     = RCAP.xpath_text( resource_xml_element, MIME_TYPE_XPATH, resource.xmlns )
+          resource.size          = RCAP.xpath_text( resource_xml_element, SIZE_XPATH, resource.xmlns ).to_i
+          resource.digest        = RCAP.xpath_text( resource_xml_element, DIGEST_XPATH, resource.xmlns )
+        end
+      end
+
+      # Calculates the SHA-1 hash and size of the contents of {#deref_uri}.
+      # Returns an array containing the size (in bytes) and SHA-1 hash if
+      # {#deref_uri} is present otherwise returns nil.
+      #
+      # @return [nil,Array(Integer,String)]
+      def calculate_hash_and_size
+        if @deref_uri
+          @digest = Digest::SHA1.hexdigest( @deref_uri )
+          @size = @deref_uri.bytesize
+          [ @size, @digest ]
+        end
+      end
+
+      # The decoded contents of {#deref_uri} if present otherwise nil.
+      #
+      # @return [nil,String]
+      def decoded_deref_uri
+        Base64.decode64( @deref_uri ) if @deref_uri
+      end
+
+      # If size is defined returns the size in kilobytes
+      # @return [Float]
+      def size_in_kb
+        if @size
+          @size.to_f/1024
+        end
+      end
+
+      # @return [String]
+      def to_xml
+        self.to_xml_element.to_s
+      end
+
+      # @return [String]
+      def inspect
+        [ @resource_desc, @uri, @mime_type, @size ? format( "%.1fKB", @size_in_kb ) : nil ].compact.join(' - ')
+      end
+
+      # Returns a string representation of the resource of the form
+      #  resource_desc
+      #
+      # @return [String]
+      def to_s
+        @resource_desc
+      end
+
+      RESOURCE_DESC_YAML = "Resource Description"
+      URI_YAML           = "URI"
+      MIME_TYPE_YAML     = "Mime Type"
+      SIZE_YAML          = "Size"
+      DIGEST_YAML        = "Digest"
+
+      # @param [Hash] options
+      # @return [String]
+      def to_yaml( options = {} )
+        RCAP.attribute_values_to_hash( [ RESOURCE_DESC_YAML, @resource_desc ],
+                                       [ URI_YAML,           @uri ],
+                                       [ MIME_TYPE_YAML,     @mime_type ],
+                                       [ SIZE_YAML,          @size ],
+                                       [ DIGEST_YAML,        @digest ]).to_yaml( options )
+      end
+
+      # @param [Hash] resource_yaml_data
+      # @return [Resource]
+      def self.from_yaml_data( resource_yaml_data )
+        self.new do |resource|
+          resource.resource_desc = resource_yaml_data[ RESOURCE_DESC_YAML ]
+          resource.uri           = resource_yaml_data[ URI_YAML ]
+          resource.mime_type     = resource_yaml_data[ MIME_TYPE_YAML ]
+          resource.size          = resource_yaml_data[ SIZE_YAML ]
+          resource.digest        = resource_yaml_data[ DIGEST_YAML ]
+        end
+      end
+
+      RESOURCE_DESC_KEY = 'resource_desc'
+      URI_KEY           = 'uri'
+      MIME_TYPE_KEY     = 'mime_type'
+      SIZE_KEY          = 'size'
+      DIGEST_KEY        = 'digest'
+
+      # @return [Hash]
+      def to_h
+        RCAP.attribute_values_to_hash( [ RESOURCE_DESC_KEY, @resource_desc ],
+                                       [ URI_KEY,           @uri],
+                                       [ MIME_TYPE_KEY,     @mime_type],
+                                       [ SIZE_KEY,          @size ],
+                                       [ DIGEST_KEY,        @digest ])
+      end
+
+      # @param [Hash] resource_hash
+      # @return [Resource]
+      def self.from_h( resource_hash )
+        self.new do |resource|
+          resource.resource_desc = resource_hash[ RESOURCE_DESC_KEY ]
+          resource.uri           = resource_hash[ URI_KEY ]
+          resource.mime_type     = resource_hash[ MIME_TYPE_KEY ]
+          resource.size          = resource_hash[ SIZE_KEY ]
+          resource.digest        = resource_hash[ DIGEST_KEY ]
+        end
+      end
+    end
+  end
+end