frodo 0.10.0

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

@@ -0,0 +1,38 @@
+module Frodo
+  module Properties
+    module Geography
+      class Polygon < Base
+        def type
+          'Edm.GeographyPolygon'
+        end
+
+        def coords_to_s
+          '(' + value.map { |pos| pos.join(' ') }.join(',') + ')'
+        end
+
+        def coords_from_s(str)
+          str.gsub(/[()]/, '')
+             .split(',').map { |pos| pos.split(' ').map(&:to_f) }
+        end
+
+        def xml_value
+          {
+            exterior: {
+              LinearRing: 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.rb

@@ -0,0 +1,13 @@
+require 'frodo/properties/geography/base'
+require 'frodo/properties/geography/point'
+require 'frodo/properties/geography/line_string'
+require 'frodo/properties/geography/polygon'
+
+Frodo::Properties::Geography.constants.each do |property_name|
+  next if property_name =~ /Base$/
+  klass = Frodo::Properties::Geography.const_get(property_name)
+  if klass.is_a?(Class)
+    property = klass.new('test', nil)
+    Frodo::PropertyRegistry.add(property.type, property.class)
+  end
+end

data/lib/frodo/properties/guid.rb

@@ -0,0 +1,17 @@
+module Frodo
+  module Properties
+    # Defines the GUID Frodo type.
+    class Guid < Frodo::Property
+      # The Frodo type name
+      def type
+        'Edm.Guid'
+      end
+
+      # Value to be used in URLs.
+      # @return [String]
+      def url_value
+        "#{value}"
+      end
+    end
+  end
+end

data/lib/frodo/properties/integer.rb

@@ -0,0 +1,107 @@
+module Frodo
+  module Properties
+    # Defines the Integer Frodo type.
+    class Integer < Frodo::Property
+      include Frodo::Properties::Number
+
+      # Returns the property value, properly typecast
+      # @return [Integer,nil]
+      def value
+        if (@value.nil? || @value.empty?) && allows_nil?
+          nil
+        else
+          @value.to_i
+        end
+      end
+
+      # Sets the property value
+      # @params new_value [to_i]
+      def value=(new_value)
+        validate(new_value.to_i)
+        @value = new_value.to_i.to_s
+      end
+
+      # The Frodo type name
+      def type
+        'Edm.Int64'
+      end
+
+      private
+
+      def exponent_size
+        63
+      end
+
+      def min_value
+        @min ||= -(2**exponent_size)
+      end
+
+      def max_value
+        @max ||= (2**exponent_size)-1
+      end
+    end
+
+    # Defines the Integer (16 bit) Frodo type.
+    class Int16 < Integer
+      # The Frodo type name
+      def type
+        'Edm.Int16'
+      end
+
+      private
+
+      def exponent_size
+        15
+      end
+    end
+
+    # Defines the Integer (32 bit) Frodo type.
+    class Int32 < Integer
+      # The Frodo type name
+      def type
+        'Edm.Int32'
+      end
+
+      private
+
+      def exponent_size
+        31
+      end
+    end
+
+    # Defines the Integer (64 bit) Frodo type.
+    class Int64 < Integer; end
+
+    # Defines the Byte Frodo type.
+    class Byte < Integer
+      # The Frodo type name
+      def type
+        'Edm.Byte'
+      end
+
+      private
+
+      def exponent_size
+        8
+      end
+
+      def min_value
+        0
+      end
+    end
+
+    # Defines the Signed Byte Frodo type.
+    class SByte < Integer
+      # The Frodo type name
+      def type
+        'Edm.SByte'
+      end
+
+      private
+
+      def exponent_size
+        7
+      end
+    end
+  end
+end

data/lib/frodo/properties/number.rb

@@ -0,0 +1,14 @@
+module Frodo
+  module Properties
+    # Defines common behavior for Frodo numeric types.
+    module Number
+      private
+
+      def validate(value)
+        if value > max_value || value < min_value
+          validation_error "Value is outside accepted range: #{min_value} to #{max_value}"
+        end
+      end
+    end
+  end
+end

data/lib/frodo/properties/string.rb

@@ -0,0 +1,72 @@
+module Frodo
+  module Properties
+    # Defines the String Frodo type.
+    class String < Frodo::Property
+      # Returns the property value, properly typecast
+      # @return [String,nil]
+      def value
+        if (@value.nil? || @value.empty?) && allows_nil?
+          nil
+        else
+          encode_value(@value)
+        end
+      end
+
+      # Sets the property value
+      # @params new_value [to_s,nil]
+      def value=(new_value)
+        validate(new_value)
+        @value = new_value.nil? ? nil : encode_value(new_value.to_s)
+      end
+
+      # Value to be used in URLs.
+      # @return [String]
+      def url_value
+        "'#{value}'"
+      end
+
+      # The Frodo type name
+      def type
+        'Edm.String'
+      end
+
+      # Is the property value Unicode encoded
+      def is_unicode?
+        options[:unicode]
+      end
+
+      # Does the property have a default value
+      def has_default_value?
+        not(options[:default_value].nil?)
+      end
+
+      # The default value for the property
+      def default_value
+        options[:default_value]
+      end
+
+      private
+
+      def default_options
+        super.merge({
+          unicode: true,
+          default_value: nil
+        })
+      end
+
+      def validate(new_value)
+        if new_value.nil? && !allows_nil?
+          validation_error 'This property does not allow for nil values to be set'
+        end
+      end
+
+      def encode_value(new_value)
+        if options[:unicode]
+          new_value.encode(Encoding::UTF_8)
+        else
+          new_value.encode(Encoding::ASCII)
+        end
+      end
+    end
+  end
+end

data/lib/frodo/properties/time.rb

@@ -0,0 +1,40 @@
+module Frodo
+  module Properties
+    # Defines the Time Frodo type.
+    class Time < Frodo::Property
+      # Returns the property value, properly typecast
+      # @return [Time,nil]
+      def value
+        if (@value.nil? || @value.empty?) && allows_nil?
+          nil
+        else
+          ::Time.strptime(@value, '%H:%M:%S%:z')
+        end
+      end
+
+      # Sets the property value
+      # @params new_value [Time]
+      def value=(new_value)
+        validate(new_value)
+        @value = parse_value(new_value)
+      end
+
+      # The Frodo type name
+      def type
+        'Edm.Time'
+      end
+
+      private
+
+      def validate(value)
+        unless value.is_a?(::Time)
+          validation_error 'Value is not a time object'
+        end
+      end
+
+      def parse_value(value)
+        value.strftime('%H:%M:%S%:z')
+      end
+    end
+  end
+end

data/lib/frodo/properties/time_of_day.rb

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

data/lib/frodo/properties.rb

@@ -0,0 +1,32 @@
+# Modules
+require 'frodo/properties/number'
+
+# Implementations
+require 'frodo/properties/binary'
+require 'frodo/properties/boolean'
+require 'frodo/properties/collection'
+require 'frodo/properties/complex'
+require 'frodo/properties/date'
+require 'frodo/properties/date_time'
+require 'frodo/properties/date_time_offset'
+require 'frodo/properties/decimal'
+require 'frodo/properties/enum'
+require 'frodo/properties/float'
+require 'frodo/properties/geography'
+require 'frodo/properties/guid'
+require 'frodo/properties/integer'
+require 'frodo/properties/string'
+require 'frodo/properties/time'
+require 'frodo/properties/time_of_day'
+
+Frodo::Properties.constants.each do |property_name|
+  klass = Frodo::Properties.const_get(property_name)
+  if klass.is_a?(Class)
+    begin
+      property = klass.new('test', nil)
+      Frodo::PropertyRegistry.add(property.type, property.class)
+    rescue NotImplementedError
+      # Abstract type classes cannot be instantiated, ignore
+    end
+  end
+end

data/lib/frodo/property.rb

@@ -0,0 +1,139 @@
+module Frodo
+  # Frodo::Property represents an abstract property, defining the basic
+  # interface and required methods, with some default implementations. All
+  # supported property types should be implemented under the Frodo::Properties
+  # namespace.
+  class Property
+    # The property's name
+    attr_reader :name
+    # The property's value
+    attr_accessor :value
+    # The property's options
+    attr_reader :options
+
+    # Default intialization for a property with a name, value and options.
+    # @param name [to_s]
+    # @param value [to_s,nil]
+    # @param options [Hash]
+    def initialize(name, value, options = {})
+      @name = name.to_s
+      @value = value.nil? ? nil : value.to_s
+      @options = default_options.merge(options)
+    end
+
+    # Abstract implementation, should return property type, based on
+    # Frodo::Service metadata in proper implementation.
+    # @raise NotImplementedError
+    def type
+      raise NotImplementedError
+    end
+
+    # Provides for value-based equality checking.
+    # @param other [value] object for comparison
+    # @return [Boolean]
+    def ==(other)
+      self.value == other.value
+    end
+
+    # Whether the property permits a nil value.
+    # (Default=true)
+    # @return [Boolean]
+    def allows_nil?
+      options[:allows_nil]
+    end
+
+    # Whether the property uses strict validation.
+    # (Default=false)
+    # @return [Boolean]
+    def strict?
+      if options.key? :strict
+        options[:strict]
+      elsif service
+        service.options[:strict]
+      else
+        true
+      end
+    end
+
+    # The configured concurrency mode for the property.
+    # @return [String]
+    def concurrency_mode
+      @concurrency_mode ||= options[:concurrency_mode]
+    end
+
+    # Value to be used in XML.
+    # @return [String]
+    def xml_value
+      @value
+    end
+
+    # Value to be used in JSON.
+    # @return [*]
+    def json_value
+      value
+    end
+
+    # Value to be used in URLs.
+    # @return [String]
+    def url_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,
+      }
+
+      if value.nil?
+        attributes['metadata:null'] = 'true'
+        xml_builder['data'].send(name.to_sym, attributes)
+      else
+        xml_builder['data'].send(name.to_sym, attributes, xml_value)
+      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 = {})
+      if property_xml.attributes['null'].andand.value == 'true'
+        content = nil
+      else
+        content = property_xml.content
+      end
+
+      new(property_xml.name, content, options)
+    end
+
+    protected
+
+    def default_options
+      {
+        allows_nil:       true,
+        concurrency_mode: :none
+      }
+    end
+
+    def service
+      options[:service]
+    end
+
+    def logger
+      # Use a dummy logger if service is not available (-> unit tests)
+      @logger ||= service.andand.logger || Logger.new('/dev/null')
+    end
+
+    def validation_error(message)
+      if strict?
+        raise ArgumentError, "#{name}: #{message}"
+      else
+        logger.warn "#{name}: #{message}"
+        nil
+      end
+    end
+  end
+end

data/lib/frodo/property_registry.rb

@@ -0,0 +1,41 @@
+require 'singleton'
+
+module Frodo
+  # Provides a registry for keeping track of various property types used by
+  # Frodo.
+  class PropertyRegistry
+    include Singleton
+
+    # Add a property type to the registry
+    #
+    # @param type_name [String] property type name to register
+    # @param klass [Class] Ruby class to use for the specified type
+    def add(type_name, klass)
+      properties[type_name] = klass
+    end
+
+    # Lookup a property by name and get the Ruby class to use for its instances
+    #
+    # @param type_name [String] the type name to lookup
+    # @return [Class, nil] the proper class or nil
+    def [](type_name)
+      properties[type_name]
+    end
+
+    # (see #add)
+    def self.add(type_name, klass)
+      Frodo::PropertyRegistry.instance.add(type_name, klass)
+    end
+
+    # (see #[])
+    def self.[](type_name)
+      Frodo::PropertyRegistry.instance[type_name]
+    end
+
+    private
+
+    def properties
+      @properties ||= {}
+    end
+  end
+end

data/lib/frodo/query/criteria/comparison_operators.rb

@@ -0,0 +1,49 @@
+module Frodo
+  class Query
+    class Criteria
+      module ComparisonOperators
+        # Sets up equality operator.
+        # @param value [to_s]
+        # @return [self]
+        def eq(value)
+          set_operator_and_value(:eq, value)
+        end
+
+        # Sets up non-equality operator.
+        # @param value [to_s]
+        # @return [self]
+        def ne(value)
+          set_operator_and_value(:ne, value)
+        end
+
+        # Sets up greater-than operator.
+        # @param value [to_s]
+        # @return [self]
+        def gt(value)
+          set_operator_and_value(:gt, value)
+        end
+
+        # Sets up greater-than-or-equal operator.
+        # @param value [to_s]
+        # @return [self]
+        def ge(value)
+          set_operator_and_value(:ge, value)
+        end
+
+        # Sets up less-than operator.
+        # @param value [to_s]
+        # @return [self]
+        def lt(value)
+          set_operator_and_value(:lt, value)
+        end
+
+        # Sets up less-than-or-equal operator.
+        # @param value [to_s]
+        # @return [self]
+        def le(value)
+          set_operator_and_value(:le, value)
+        end
+      end
+    end
+  end
+end

data/lib/frodo/query/criteria/date_functions.rb

@@ -0,0 +1,61 @@
+module Frodo
+  class Query
+    class Criteria
+      module DateFunctions
+        # Applies the `year` function.
+        # @return [self]
+        def year
+          set_function_and_argument(:year, nil)
+        end
+
+        # Applies the `month` function.
+        # @return [self]
+        def month
+          set_function_and_argument(:month, nil)
+        end
+
+        # Applies the `day` function.
+        # @return [self]
+        def day
+          set_function_and_argument(:day, nil)
+        end
+
+        # Applies the `hour` function.
+        # @return [self]
+        def hour
+          set_function_and_argument(:hour, nil)
+        end
+
+        # Applies the `minute` function.
+        # @return [self]
+        def minute
+          set_function_and_argument(:minute, nil)
+        end
+
+        # Applies the `second` function.
+        # @return [self]
+        def second
+          set_function_and_argument(:second, nil)
+        end
+
+        # Applies the `fractionalseconds` function.
+        # @return [self]
+        def fractionalseconds
+          set_function_and_argument(:fractionalseconds, nil)
+        end
+
+        # Applies the `date` function.
+        # @return [self]
+        def date
+          set_function_and_argument(:date, nil)
+        end
+
+        # Applies the `time` function.
+        # @return [self]
+        def time
+          set_function_and_argument(:time, nil)
+        end
+      end
+    end
+  end
+end

data/lib/frodo/query/criteria/geography_functions.rb

@@ -0,0 +1,21 @@
+module Frodo
+  class Query
+    class Criteria
+      module GeographyFunctions
+        # Applies the `geo.distance` function.
+        # @param to [to_s]
+        # @return [self]
+        def distance(to)
+          set_function_and_argument(:'geo.distance', to)
+        end
+
+        # Applies the `geo.intersects` function.
+        # @param what [to_s]
+        # @return [self]
+        def intersects(what)
+          set_function_and_argument(:'geo.intersects', what)
+        end
+      end
+    end
+  end
+end

data/lib/frodo/query/criteria/lambda_operators.rb

@@ -0,0 +1,27 @@
+module Frodo
+  class Query
+    class Criteria
+      module LambdaOperators
+        # Applies the `any` lambda operator to the given property
+        # @param property [to_s]
+        # @return [self]
+        def any(property)
+          set_function_and_argument(:any, property)
+        end
+
+        # Applies the `any` lambda operator to the given property
+        # @param property [to_s]
+        # @return [self]
+        def all(property)
+          set_function_and_argument(:all, property)
+        end
+
+        private
+
+        def lambda_operator?
+          [:any, :all].include?(function)
+        end
+      end
+    end
+  end
+end