frodata 0.9.1

data/lib/frodata/query/criteria.rb

@@ -0,0 +1,92 @@
+require 'frodata/query/criteria/comparison_operators'
+require 'frodata/query/criteria/string_functions'
+require 'frodata/query/criteria/date_functions'
+require 'frodata/query/criteria/geography_functions'
+require 'frodata/query/criteria/lambda_operators'
+
+module FrOData
+  class Query
+    # Represents a discreet criteria within an FrOData::Query. Should not,
+    # normally, be instantiated directly.
+    class Criteria
+      # The property name that is the target of the criteria.
+      attr_reader :property
+      # The operator of the criteria.
+      attr_reader :operator
+      # The value of the criteria.
+      attr_reader :value
+      # A function to apply to the property.
+      attr_reader :function
+      # An optional argument to the function.
+      attr_reader :argument
+
+      # Initializes a new criteria with provided options.
+      # @param options [Hash]
+      def initialize(options = {})
+        @property = options[:property]
+        @operator = options[:operator]
+        @function = options[:function]
+        @argument = options[:argument]
+        @value    = options[:value]
+      end
+
+      include ComparisonOperators
+      include StringFunctions
+      include DateFunctions
+      include GeographyFunctions
+      include LambdaOperators
+
+      # Returns criteria as query-ready string.
+      def to_s
+        query = function ? function_expression : property_name
+
+        if operator && !lambda_operator?
+          "#{query} #{operator} #{url_value(value)}"
+        else
+          query
+        end
+      end
+
+      private
+
+      def property_name
+        property.name
+      rescue NoMethodError
+        property.to_s
+      end
+
+      def function_expression
+        return lambda_expression if lambda_operator?
+
+        if argument
+          "#{function}(#{property_name},#{url_value(argument)})"
+        else
+          "#{function}(#{property_name})"
+        end
+      end
+
+      def lambda_expression
+        "#{property_name}/#{function}(d:d/#{argument} #{operator} #{url_value(value)})"
+      end
+
+      def url_value(value)
+        property.value = value
+        property.url_value
+      rescue
+        value
+      end
+
+      def set_operator_and_value(operator, value)
+        @operator = operator
+        @value = value
+        self
+      end
+
+      def set_function_and_argument(function, argument)
+        @function = function
+        @argument = argument
+        self
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+module FrOData
+  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/frodata/query/criteria/date_functions.rb

@@ -0,0 +1,61 @@
+module FrOData
+  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/frodata/query/criteria/geography_functions.rb

@@ -0,0 +1,21 @@
+module FrOData
+  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/frodata/query/criteria/lambda_operators.rb

@@ -0,0 +1,27 @@
+module FrOData
+  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

data/lib/frodata/query/criteria/string_functions.rb

@@ -0,0 +1,40 @@
+module FrOData
+  class Query
+    class Criteria
+      module StringFunctions
+        # Sets up a `contains` function criterium.
+        # @param str [to_s]
+        # @return [self]
+        def contains(str)
+          set_function_and_argument(:contains, str)
+        end
+
+        # Sets up a `startswith` function criterium.
+        # @param str [to_s]
+        # @return [self]
+        def startswith(str)
+          set_function_and_argument(:startswith, str)
+        end
+
+        # Sets up a `endswith` function criterium.
+        # @param str [to_s]
+        # @return [self]
+        def endswith(str)
+          set_function_and_argument(:endswith, str)
+        end
+
+        # Applies the `tolower` function to the property.
+        # @return [self]
+        def tolower
+          set_function_and_argument(:tolower, nil)
+        end
+
+        # Applies the `toupper` function to the property.
+        # @return [self]
+        def toupper
+          set_function_and_argument(:toupper, nil)
+        end
+      end
+    end
+  end
+end

data/lib/frodata/query/in_batches.rb

@@ -0,0 +1,58 @@
+module FrOData
+  class Query
+    module InBatches
+      DEFAULT_BATCH_SIZE = 10
+
+      # Process results in batches.
+      #
+      # When a block is given, yields `FrOData::Query::Result`
+      # objects of specified batch size to the block.
+      #
+      #   service['Products'].query.in_batches(of: 10) do |batch|
+      #     batch.count # batch size (10 except for last batch)
+      #     batch.is_a? FrOData::Query::Result # true
+      #   end
+      #
+      # Returns an Enumerator to process results individually.
+      #
+      #   service['Products'].query.in_batches.each do |entity|
+      #     entity.is_a? FrOData::Entity # true
+      #   end
+      #
+      # @param of: [int] batch size
+      # @return [Enumerator]
+      def in_batches(of: DEFAULT_BATCH_SIZE, &block)
+        per_page = of
+
+        if block_given?
+          each_batch(of, &block)
+        else
+          Enumerator.new do |result|
+            each_batch(of) do |batch|
+              batch.each { |entity| result << entity }
+            end
+          end
+        end
+      end
+
+      private
+
+      def each_batch(per_page, &block)
+        page = 0
+
+        loop do
+          batch = get_paginated_entities(per_page, page)
+          break if batch.empty?
+
+          yield batch
+
+          page += 1
+        end
+      end
+
+      def get_paginated_entities(per_page, page)
+        skip(per_page * page).limit(per_page).execute
+      end
+    end
+  end
+end

data/lib/frodata/railtie.rb

@@ -0,0 +1,19 @@
+module FrOData
+  class Railtie < Rails::Railtie
+    config.before_initialize do
+      ::FrOData::Railtie.load_configuration!
+      ::FrOData::Railtie.setup_service_registry!
+    end
+
+    # Looks for config/odata.yml and loads the configuration.
+    def self.load_configuration!
+      # TODO Implement Rails configuration loading
+    end
+
+    # Examines the loaded configuration and populates the
+    # FrOData::ServiceRegistry accordingly.
+    def self.setup_service_registry!
+      # TODO Populate FrOData::ServiceRegistry based on configuration
+    end
+  end
+end

data/lib/frodata/schema.rb

@@ -0,0 +1,155 @@
+require 'frodata/schema/complex_type'
+require 'frodata/schema/enum_type'
+
+module FrOData
+  class Schema
+    # The schema's parent service
+    attr_reader :service
+    # The schema's metadata (i.e its XML definition)
+    attr_reader :metadata
+
+    # Creates a new schema.
+    #
+    # @param schema_definition [Nokogiri::XML] The schema's XML definition
+    # @param service [FrOData::Service] The schema's parent service
+    def initialize(schema_definition, service)
+      @metadata = schema_definition
+      @service = service
+    end
+
+    # Returns the schema's `Namespace` attribute (mandatory).
+    # @return [String]
+    def namespace
+      @namespace ||= metadata.attributes['Namespace'].value
+    end
+
+    # Returns a list of actions defined by the schema.
+    # @return [Array<String>]
+    def actions
+      @actions ||= metadata.xpath('//Action').map do |action|
+        action.attributes['Name'].value
+      end
+    end
+
+    # Returns a list of entities defined by the schema.
+    # @return [Array<String>]
+    def entity_types
+      @entity_types ||= metadata.xpath('//EntityType').map do |entity|
+        entity.attributes['Name'].value
+      end
+    end
+
+    # Returns a list of `ComplexType`s defined by the schema.
+    # @return [Hash<String, FrOData::Schema::ComplexType>]
+    def complex_types
+      @complex_types ||= metadata.xpath('//ComplexType').map do |entity|
+        [
+          entity.attributes['Name'].value,
+          ComplexType.new(entity, self)
+        ]
+      end.to_h
+    end
+
+    # Returns a list of EnumTypes defined by the schema.
+    # @return [Hash<String, FrOData::Schema::EnumType>]
+    def enum_types
+      @enum_types ||= metadata.xpath('//EnumType').map do |entity|
+        [
+          entity.attributes['Name'].value,
+          EnumType.new(entity, self)
+        ]
+      end.to_h
+    end
+
+    # Returns a list of functions defined by the schema.
+    # @return [Array<String>]
+    def functions
+      @functions ||= metadata.xpath('//Function').map do |function|
+        function.attributes['Name'].value
+      end
+    end
+
+    # Returns a list of type definitions defined by the schema.
+    # @return [Array<String>]
+    def type_definitions
+      @typedefs ||= metadata.xpath('//TypeDefinition').map do |typedef|
+        typedef.attributes['Name'].value
+      end
+    end
+
+    # Returns a hash for finding an association through an entity type's defined
+    # NavigationProperty elements.
+    # @return [Hash<Hash<FrOData::NavigationProperty>>]
+    def navigation_properties
+      @navigation_properties ||= metadata.xpath('//EntityType').map do |entity_type_def|
+        [
+          entity_type_def.attributes['Name'].value,
+          entity_type_def.xpath('./NavigationProperty').map do |nav_property_def|
+            [
+              nav_property_def.attributes['Name'].value,
+              ::FrOData::NavigationProperty.build(nav_property_def)
+            ]
+          end.to_h
+        ]
+      end.to_h
+    end
+
+    # Get the property type for an entity from metadata.
+    #
+    # @param entity_name [to_s] the name of the relevant entity
+    # @param property_name [to_s] the property name needed
+    # @return [String] the name of the property's type
+    def get_property_type(entity_name, property_name)
+      metadata.xpath("//EntityType[@Name='#{entity_name}']/Property[@Name='#{property_name}']").first.attributes['Type'].value
+    end
+
+    # Get the primary key for the supplied Entity.
+    #
+    # @param entity_name [to_s]
+    # @return [String]
+    def primary_key_for(entity_name)
+      metadata.xpath("//EntityType[@Name='#{entity_name}']/Key/PropertyRef").first.attributes['Name'].value
+    end
+
+    # Get the list of properties and their various options for the supplied
+    # Entity name.
+    # @param entity_name [to_s]
+    # @return [Hash]
+    # @api private
+    def properties_for_entity(entity_name)
+      type_definition = metadata.xpath("//EntityType[@Name='#{entity_name}']").first
+      raise ArgumentError, "Unknown EntityType: #{entity_name}" if type_definition.nil?
+      properties_to_return = {}
+      type_definition.xpath('./Property').each do |property_xml|
+        property_name, property = process_property_from_xml(property_xml)
+        properties_to_return[property_name] = property
+      end
+      properties_to_return
+    end
+
+    private
+
+    def process_property_from_xml(property_xml)
+      property_name = property_xml.attributes['Name'].value
+      property_type = property_xml.attributes['Type'].value
+      property_options = { service: service }
+
+      property_type, value_type = property_type.split(/\(|\)/)
+      if property_type == 'Collection'
+        klass = ::FrOData::Properties::Collection
+        property_options.merge(value_type: value_type)
+      else
+        klass = ::FrOData::PropertyRegistry[property_type]
+      end
+
+      if klass.nil?
+        raise RuntimeError, "Unknown property type: #{value_type}"
+      else
+        property_options[:allows_nil] = false if property_xml.attributes['Nullable'] == 'false'
+        property = klass.new(property_name, nil, property_options)
+      end
+
+      return [property_name, property]
+    end
+  end
+end