frodo 0.10.0

data/lib/frodo/properties/collection.rb

@@ -0,0 +1,50 @@
+module Frodo
+  module Properties
+    # Defines the Collection Frodo type.
+    class Collection < Frodo::Property
+      # Overriding default constructor to avoid converting
+      # value to string.
+      # TODO: Make this the default for all property types?
+      def initialize(name, value, options = {})
+        super(name, value, options)
+        self.value = value
+      end
+
+      def value
+        if @value.nil?
+          nil
+        else
+          @value.map(&:value)
+        end
+      end
+
+      def value=(value)
+        if value.nil? && allows_nil?
+          @value = nil
+        elsif value.respond_to?(:map)
+          @value = value.map.with_index do |element, index|
+            type_class.new("#{name}[#{index}]", element)
+          end
+        else
+          validation_error 'Value must be an array'
+        end
+      end
+
+      def url_value
+        '[' + @value.map(&:url_value).join(',') + ']'
+      end
+
+      def type
+        "Collection(#{value_type})"
+      end
+
+      def value_type
+        options[:value_type] || 'Edm.String'
+      end
+
+      def type_class
+        Frodo::PropertyRegistry[value_type]
+      end
+    end
+  end
+end

data/lib/frodo/properties/complex.rb

@@ -0,0 +1,114 @@
+module Frodo
+  module Properties
+    # Abstract base class for Frodo ComplexTypes
+    # @see [Frodo::Schema::ComplexType]
+    class Complex < Frodo::Property
+      def initialize(name, value, options = {})
+        super(name, value, options)
+        init_properties
+      end
+
+      # Returns the property value, properly typecast
+      # @return [Hash, nil]
+      def value
+        if allows_nil? && properties.values.all?(&:nil?)
+          nil
+        else
+          Hash[properties.map { |key, value| [key, value.value] }]
+        end
+      end
+
+      # Sets the property value
+      # @params new_value [Hash]
+      def value=(new_value)
+        validate(new_value)
+        if new_value.nil?
+          property_names.each { |name| self[name] = nil }
+        else
+          property_names.each { |name| self[name] = new_value[name] }
+        end
+      end
+
+      # Returns a list of this ComplexType's property names.
+      # @return [Array<String>]
+      def property_names
+        @property_names ||= properties.keys
+      end
+
+      # Returns the value of the requested property.
+      # @param property_name [to_s]
+      # @return [*]
+      def [](property_name)
+        properties[property_name.to_s].value
+      end
+
+      # Sets the value of the named property.
+      # @param property_name [to_s]
+      # @param value [*]
+      # @return [*]
+      def []=(property_name, value)
+        properties[property_name.to_s].value = value
+      end
+
+      # Returns the XML representation of the property to the supplied XML
+      # builder.
+      # @param xml_builder [Nokogiri::XML::Builder]
+      def to_xml(xml_builder)
+        attributes = {
+            'metadata:type' => type,
+        }
+
+        xml_builder['data'].send(name.to_sym, attributes) do
+          properties.each do |name, property|
+            property.to_xml(xml_builder)
+          end
+        end
+      end
+
+      # Creates a new property instance from an XML element
+      # @param property_xml [Nokogiri::XML::Element]
+      # @param options [Hash]
+      # @return [Frodo::Property]
+      def self.from_xml(property_xml, options = {})
+        nodes = property_xml.element_children
+        props = Hash[nodes.map { |el| [el.name, el.content] }]
+        new(property_xml.name, props.to_json, options)
+      end
+
+      private
+
+      def complex_type
+        raise NotImplementedError, 'Subclass must override'
+      end
+
+      def properties
+        @properties
+      end
+
+      def init_properties
+        @properties = complex_type.send(:collect_properties)
+        set_properties(JSON.parse(@value)) unless @value.nil?
+      end
+
+      def set_properties(new_properties)
+        property_names.each do |prop_name|
+          self[prop_name] = new_properties[prop_name]
+        end
+      end
+
+      def validate(value)
+        return if value.nil? && allows_nil?
+        raise ArgumentError, 'Value must be a Hash' unless value.is_a?(Hash)
+        value.keys.each do |name|
+          unless property_names.include?(name) || name =~ /@odata/
+            raise ArgumentError, "Invalid property #{name}"
+          end
+        end
+      end
+
+      def validate_options(options)
+        raise ArgumentError, 'Type is required' unless options[:type]
+      end
+    end
+  end
+end

data/lib/frodo/properties/date.rb

@@ -0,0 +1,27 @@
+require 'frodo/properties/date_time'
+
+module Frodo
+  module Properties
+    # Defines the Date Frodo type.
+    class Date < Frodo::Properties::DateTime
+      # The Frodo type name
+      def type
+        'Edm.Date'
+      end
+
+      def url_value
+        @value
+      end
+
+      protected
+
+      def date_class
+        ::Date
+      end
+
+      def strptime_format
+        '%Y-%m-%d'
+      end
+    end
+  end
+end

data/lib/frodo/properties/date_time.rb

@@ -0,0 +1,83 @@
+module Frodo
+  module Properties
+    # Defines the DateTime Frodo type.
+    class DateTime < Frodo::Property
+      # Returns the property value, properly typecast
+      # @return [DateTime, nil]
+      def value
+        if (@value.nil? || @value.empty?) && allows_nil?
+          nil
+        else
+          begin
+            date_class.strptime(@value, strptime_format)
+          rescue ArgumentError
+            date_class.parse(@value)
+          end
+        end
+      end
+
+      # Sets the property value
+      # @params new_value [DateTime]
+      def value=(new_value)
+        validate(new_value)
+        @value = parse_value(new_value)
+      end
+
+      # The Frodo type name
+      def type
+        'Edm.DateTime'
+      end
+
+      # Value to be used in JSON.
+      # @return [String]
+      def xml_value
+        @value.andand.sub(/[\+\-]00:00$/, 'Z')
+      end
+
+      # Value to be used in JSON.
+      # @return [String]
+      def json_value
+        xml_value
+      end
+
+      # Value to be used in URLs.
+      # @return [String]
+      def url_value
+        xml_value
+      end
+
+      protected
+
+      # Specifies date/time implementation to use
+      def date_class
+        ::DateTime
+      end
+
+      # Specifies the date/time format string used for `strptime`
+      def strptime_format
+        #'%Y-%m-%dT%H:%M:%S.%L'
+        "%Y-%m-%dT%H:%M:%SZ"
+      end
+
+      def validate(value)
+        begin
+          return if value.nil? && allows_nil?
+          return if value.is_a?(date_class)
+          date_class.parse(value)
+        rescue
+          validation_error "Value '#{value}' is not a date time format that can be parsed"
+        end
+      end
+
+      def parse_value(value)
+        return value if value.nil? && allows_nil?
+        if value.is_a?(date_class)
+          parsed_value = value
+        else
+          parsed_value = date_class.parse(value)
+        end
+        parsed_value.strftime(strptime_format)
+      end
+    end
+  end
+end

data/lib/frodo/properties/date_time_offset.rb

@@ -0,0 +1,17 @@
+module Frodo
+  module Properties
+    # Defines the DateTimeOffset Frodo type.
+    class DateTimeOffset < Frodo::Properties::DateTime
+      # The Frodo type name
+      def type
+        'Edm.DateTimeOffset'
+      end
+
+      protected
+
+      def strptime_format
+        '%Y-%m-%dT%H:%M:%S%:z'
+      end
+    end
+  end
+end

data/lib/frodo/properties/decimal.rb

@@ -0,0 +1,54 @@
+module Frodo
+  module Properties
+    # Defines the Decimal Frodo type.
+    class Decimal < Frodo::Property
+      # Returns the property value, properly typecast
+      # @return [BigDecimal,nil]
+      def value
+        if (@value.nil? || @value.empty?) && (!strict? && allows_nil?)
+          nil
+        else
+          BigDecimal(@value)
+        end
+      end
+
+      # Sets the property value
+      # @params new_value something BigDecimal() can parse
+      def value=(new_value)
+        @value = if (new_value.nil? && !strict? && allows_nil?)
+                    nil
+                  else
+                    validate(BigDecimal(new_value.to_s))
+                    new_value.to_s
+                  end
+      end
+
+      # The Frodo type name
+      def type
+        'Edm.Decimal'
+      end
+
+      # Value to be used in URLs.
+      # @return [String]
+      def url_value
+        "#{value.to_f}"
+      end
+
+      private
+
+      def validate(value)
+        if value > max_value || value < min_value || value.precs.first > 29
+          validation_error "Value is outside accepted range: #{min_value} to #{max_value}, or has more than 29 significant digits"
+        end
+      end
+
+      def min_value
+        @min ||= BigDecimal(-7.9 * (10**28), 2)
+      end
+
+      def max_value
+        @max ||= BigDecimal(7.9 * (10**28), 2)
+      end
+    end
+  end
+end

data/lib/frodo/properties/enum.rb

@@ -0,0 +1,62 @@
+module Frodo
+  module Properties
+    # Abstract base class for Frodo EnumTypes
+    # @see [Frodo::Schema::EnumType]
+    class Enum < Frodo::Property
+      # Returns the property value, properly typecast
+      # @return [String, nil]
+      def value
+        if @value.nil? && allows_nil?
+          nil
+        else
+          @value
+        end
+      end
+
+      # Sets the property value
+      # @params new_value [String]
+      def value=(new_value)
+        parsed_value = validate(new_value)
+        @value = is_flags? ? parsed_value : parsed_value.first
+      end
+
+      # Value to be used in URLs.
+      # @return [String]
+      def url_value
+        "#{type}'#{@value}'"
+      end
+
+      private
+
+      def members
+        raise NotImplementedError, 'Subclass must override'
+      end
+
+      def validate(value)
+        return [] if value.nil? && allows_nil?
+        values = parse_value(value)
+
+        if values.length > 1 && !is_flags?
+          raise ArgumentError, 'Multiple values are not allowed for this property'
+        end
+
+        values.map do |value|
+          if members.keys.include?(value)
+            members[value]
+          elsif members.values.include?(value)
+            value
+          else
+            validation_error "Value must be one of #{members.to_a}, but was: '#{value}'"
+          end
+        end.compact
+      end
+
+      def parse_value(value)
+        return nil if value.nil?
+        value.to_s.split(',').map(&:strip).map do |val|
+          val =~ /^[0-9]+$/ ? val.to_i : val
+        end
+      end
+    end
+  end
+end

data/lib/frodo/properties/float.rb

@@ -0,0 +1,67 @@
+module Frodo
+  module Properties
+    # Defines the Float Frodo type.
+    class Float < Frodo::Property
+      include Frodo::Properties::Number
+
+      # Returns the property value, properly typecast
+      # @return [Float,nil]
+      def value
+        if (@value.nil? || @value.empty?) && allows_nil?
+          nil
+        else
+          @value.to_f
+        end
+      end
+
+      # Sets the property value
+      # @params new_value [to_f]
+      def value=(new_value)
+        validate(new_value.to_f)
+        @value = new_value.to_f.to_s
+      end
+
+      # The Frodo type name
+      def type
+        'Edm.Double'
+      end
+
+      private
+
+      def min_value
+        @min ||= -(1.7 * (10**308))
+      end
+
+      def max_value
+        @max ||= (1.7 * (10**308))
+      end
+    end
+
+    # Defines the Double (Float) Frodo type.
+    class Double < Frodo::Properties::Float; end
+
+    # Defines the Single (Float) Frodo type.
+    class Single < Frodo::Properties::Float
+      # The Frodo type name
+      def type
+        'Edm.Single'
+      end
+
+      # Value to be used in URLs.
+      # @return [String]
+      def url_value
+        "#{value}F"
+      end
+
+      private
+
+      def min_value
+        @min ||= -(3.4 * (10**38))
+      end
+
+      def max_value
+        @max ||= (3.4 * (10**38))
+      end
+    end
+  end
+end

data/lib/frodo/properties/geography/base.rb

@@ -0,0 +1,162 @@
+module Frodo
+  module Properties
+    module Geography
+      class Base < Frodo::Property
+        # The SRID (Spatial Reference ID) of this property.
+        attr_accessor :srid
+
+        # The default SRID (same as used by GPS)
+        DEFAULT_SRID = 4326
+
+        # Initializes a geography property.
+        #
+        # Special options available for geographic types:
+        #
+        # +srid+: the SRID (spatial reference ID) of the
+        #         coordinate system being used.
+        #         Defaults to 4326 (same as GPS).
+        #
+        # @param name [to_s]
+        # @param value [Hash|Array|to_s|nil]
+        # @param options [Hash]
+        def initialize(name, value, options = {})
+          super(name, value, options)
+          self.value = value
+          self.srid  = srid || options[:srid] || DEFAULT_SRID
+        end
+
+        # Sets the value of the property.
+        # @param value [Hash|Array|to_s|nil]
+        def value=(value)
+          if value.nil? && allows_nil?
+            @value = nil
+          elsif value.is_a?(Hash)
+            @value = value['coordinates']
+          elsif value.is_a?(Array)
+            @value = value
+          else
+            @value = parse_wkt(value.to_s)
+          end
+        end
+
+        # Value to be used in URLs.
+        # @return [String]
+        def url_value
+          "geography'SRID=#{srid};#{type_name}(#{coords_to_s})'"
+        end
+
+        # Value to be used in JSON.
+        # @return [Hash]
+        def json_value
+          {
+            type: type_name,
+            coordinates: value,
+            crs: crs
+          }
+        end
+
+        # The name of the SRS (Spatial Reference System) used.
+        # Basically, the SRID in URI/URL form.
+        # @return [String]
+        def srs_name
+          if srid == DEFAULT_SRID
+            "http://www.opengis.net/def/crs/EPSG/0/#{srid}"
+          else
+            raise NotImplementedError, "Unsupported SRID #{srid}"
+          end
+        end
+
+        # The name of the CRS (Coordinate Reference System) used.
+        # Used in GeoJSON representation
+        # @return [String]
+        def crs_name
+          if srid == DEFAULT_SRID
+            "EPSG:#{srid}"
+          else
+            raise NotImplementedError, "Unsupported SRID #{srid}"
+          end
+        end
+
+        # The full CRS representation as used by GeoJSON
+        # @return [Hash]
+        def crs
+          {
+            type: 'name',
+            properties: { name: crs_name }
+          }
+        end
+
+        # Returns the XML representation of the property to the supplied XML
+        # builder.
+        # @param xml_builder [Nokogiri::XML::Builder]
+        def to_xml(xml_builder)
+          attributes = { 'metadata:type' => type }
+          type_attrs = { 'gml:srsName' => srs_name }
+
+          xml_builder['data'].send(name.to_sym, attributes) do
+            xml_builder['gml'].send(type_name, type_attrs) do
+              value_to_xml(xml_value, xml_builder)
+            end
+          end
+        end
+
+        # Creates a new property instance from an XML element
+        # @param property_xml [Nokogiri::XML::Element]
+        # @param options [Hash]
+        # @return [Frodo::Properties::Geography]
+        def self.from_xml(property_xml, options = {})
+          if property_xml.attributes['null'].andand.value == 'true'
+            content = nil
+          else
+            content = parse_xml(property_xml)
+            options.merge!(srid: srid_from_xml(property_xml))
+          end
+
+          new(property_xml.name, content, options)
+        end
+
+        protected
+
+        def type_name
+          self.class.name.split('::').last
+        end
+
+        def parse_wkt(value)
+          if value =~ /^geography'(SRID=(\d+);)+(\w+)\((.+)\)'$/
+            $3 == type_name or raise ArgumentError, "Invalid geography type '#{$3}'"
+            self.srid = $1 ? $2.to_i : DEFAULT_SRID
+            coords_from_s($4)
+          else
+            raise ArgumentError, "Invalid geography value '#{value}'"
+          end
+        end
+
+        # Recursively turn a JSON-like data structure into XML
+        def value_to_xml(value, xml_builder)
+          if value.is_a?(Hash)
+            value.each do |key, val|
+              xml_builder['gml'].send(key) do
+                value_to_xml(val, xml_builder)
+              end
+            end
+          elsif value.is_a?(Array)
+            value.each do |val|
+              value_to_xml(val, xml_builder)
+            end
+          else
+            xml_builder.text(value)
+          end
+        end
+
+        # Extract the SRID from a GML element's `srsName` attribute
+        def self.srid_from_xml(property_xml)
+          gml_elem = property_xml.element_children.first
+          srs_attr = gml_elem.attributes['srsName']
+          if srs_attr
+            srs_attr.value.split(/[\/:]/).last.to_i
+          end
+        end
+      end
+    end
+  end
+end

data/lib/frodo/properties/geography/line_string.rb

@@ -0,0 +1,33 @@
+module Frodo
+  module Properties
+    module Geography
+      class LineString < Base
+        def type
+          'Edm.GeographyLineString'
+        end
+
+        def coords_to_s
+          value.map { |pos| pos.join(' ') }.join(',')
+        end
+
+        def coords_from_s(str)
+          str.split(',').map { |pos| pos.split(' ').map(&:to_f) }
+        end
+
+        def xml_value
+          value.map do |coords|
+            { pos: coords.join(' ') }
+          end
+        end
+
+        private
+
+        def self.parse_xml(property_xml)
+          property_xml.xpath('//pos').map do |el|
+            el.content.split(' ').map(&:to_f)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/frodo/properties/geography/point.rb

@@ -0,0 +1,31 @@
+module Frodo
+  module Properties
+    module Geography
+      class Point < Base
+        def type
+          'Edm.GeographyPoint'
+        end
+
+        def coords_to_s
+          value.join(' ')
+        end
+
+        def coords_from_s(str)
+          str.split(' ').map(&:to_f)
+        end
+
+        def xml_value
+          { pos: coords_to_s }
+        end
+
+        private
+
+        def self.parse_xml(property_xml)
+          property_xml.xpath('//pos').map do |el|
+            el.content.split(' ').map(&:to_f)
+          end.flatten
+        end
+      end
+    end
+  end
+end