frodo 0.10.0

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

@@ -0,0 +1,40 @@
+module Frodo
+  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/frodo/query/criteria.rb

@@ -0,0 +1,92 @@
+require 'frodo/query/criteria/comparison_operators'
+require 'frodo/query/criteria/string_functions'
+require 'frodo/query/criteria/date_functions'
+require 'frodo/query/criteria/geography_functions'
+require 'frodo/query/criteria/lambda_operators'
+
+module Frodo
+  class Query
+    # Represents a discreet criteria within an Frodo::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/frodo/query/in_batches.rb

@@ -0,0 +1,58 @@
+module Frodo
+  class Query
+    module InBatches
+      DEFAULT_BATCH_SIZE = 10
+
+      # Process results in batches.
+      #
+      # When a block is given, yields `Frodo::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? Frodo::Query::Result # true
+      #   end
+      #
+      # Returns an Enumerator to process results individually.
+      #
+      #   service['Products'].query.in_batches.each do |entity|
+      #     entity.is_a? Frodo::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/frodo/query.rb

@@ -0,0 +1,221 @@
+require 'frodo/query/criteria'
+require 'frodo/query/in_batches'
+
+module Frodo
+  # Frodo::Query provides the query interface for requesting Entities matching
+  # specific criteria from an Frodo::EntitySet. This class should not be
+  # instantiated directly, but can be. Normally you will access a Query by
+  # first asking for one from the Frodo::EntitySet you want to query.
+  class Query
+    attr_reader :options
+
+    # Create a new Query for the provided EntitySet
+    # @param entity_set [Frodo::EntitySet]
+    # @param options [Hash] Query options
+    def initialize(entity_set, options = {})
+      @entity_set = entity_set
+      @options    = options
+      setup_empty_criteria_set
+    end
+
+    # Instantiates an Frodo::Query::Criteria for the named property.
+    # @param property [to_s]
+    def [](property)
+      property_instance = @entity_set.new_entity.get_property(property)
+      property_instance = property if property_instance.nil?
+      Frodo::Query::Criteria.new(property: property_instance)
+    end
+
+    # Build a query to find an entity with the supplied key value.
+    # @param key [to_s] primary key to lookup
+    # @return the path and querystring [String]
+    def find(key)
+      entity = @entity_set.new_entity
+      key_property = entity.get_property(entity.primary_key)
+      key_property.value = key
+
+      pathname = "#{entity_set.name}(#{key_property.url_value})"
+
+      select_criteria = if list_criteria(:select)
+                          list_criteria(:select).map { |k, v| "#{k}=#{v}" }.join('&')
+                        end
+      [pathname, select_criteria].compact.join('?')
+    end
+
+    # Adds a filter criteria to the query.
+    # For filter syntax see https://msdn.microsoft.com/en-us/library/gg309461.aspx
+    # Syntax:
+    #   Property Operator Value
+    #
+    # For example:
+    #   Name eq 'Customer Service'
+    #
+    # Operators:
+    # eq, ne, gt, ge, lt, le, and, or, not
+    #
+    # Value
+    #  can be 'null', can use single quotes
+    # @param criteria
+    def where(criteria)
+      criteria_set[:filter] << criteria
+      self
+    end
+
+    # Adds a fulltext search term to the query
+    # NOTE: May not be implemented by the service
+    # @param term [String]
+    def search(term)
+      criteria_set[:search] << term
+      self
+    end
+
+    # Adds a filter criteria to the query with 'and' logical operator.
+    # @param criteria
+    #def and(criteria)
+    #
+    #end
+
+    # Adds a filter criteria to the query with 'or' logical operator.
+    # @param criteria
+    #def or(criteria)
+    #
+    #end
+
+    # Specify properties to order the result by.
+    # Can use 'desc' like 'Name desc'
+    # @param properties [Array<Symbol>]
+    # @return [self]
+    def order_by(*properties)
+      criteria_set[:orderby] += properties
+      self
+    end
+
+    # Specify associations to expand in the result.
+    # @param associations [Array<Symbol>]
+    # @return [self]
+    def expand(*associations)
+      criteria_set[:expand] += associations
+      self
+    end
+
+    # Specify properties to select within the result.
+    # @param properties [Array<Symbol>]
+    # @return [self]
+    def select(*properties)
+      criteria_set[:select] += properties
+      self
+    end
+
+    # Add skip criteria to query.
+    # @param value [to_i]
+    # @return [self]
+    def skip(value)
+      criteria_set[:skip] = value.to_i
+      self
+    end
+
+    # Add limit criteria to query.
+    # @param value [to_i]
+    # @return [self]
+    def limit(value)
+      criteria_set[:top] = value.to_i
+      self
+    end
+
+    # Add inline count criteria to query.
+    # Not Supported in CRM2011
+    # @return [self]
+    def include_count
+      criteria_set[:inline_count] = true
+      self
+    end
+
+    # Convert Query to string.
+    # @return [String]
+    def to_s
+      criteria = params.map { |k, v| "#{k}=#{v}" }.join('&')
+      [entity_set.name, params.any? ? criteria : nil].compact.join('?')
+    end
+
+    # Build a query to count of an entity set
+    # @return [Integer]
+    def count
+      "#{entity_set.name}/$count"
+    end
+
+    # The EntitySet for this query.
+    # @return [Frodo::EntitySet]
+    # @api private
+    def entity_set
+      @entity_set
+    end
+
+    # The parameter hash for this query.
+    # @return [Hash] Params hash
+    def params
+      assemble_criteria || {}
+    end
+
+    # The service for this query
+    # @return [Frodo::Service]
+    # @api private
+    def service
+      @service ||= entity_set.service
+    end
+
+    private
+
+    attr_reader :criteria_set
+
+    def setup_empty_criteria_set
+      @criteria_set = {
+        filter:       [],
+        search:       [],
+        select:       [],
+        expand:       [],
+        orderby:      [],
+        skip:         0,
+        top:          0,
+        inline_count: false
+      }
+    end
+
+    def assemble_criteria
+      [
+        filter_criteria,
+        search_criteria,
+        list_criteria(:orderby),
+        list_criteria(:expand),
+        list_criteria(:select),
+        inline_count_criteria,
+        paging_criteria(:skip),
+        paging_criteria(:top)
+      ].compact.reduce(&:merge)
+    end
+
+    def filter_criteria
+      return nil if criteria_set[:filter].empty?
+      filters = criteria_set[:filter].collect(&:to_s)
+      { '$filter' => filters.join(' and ') }
+    end
+
+    def search_criteria
+      return nil if criteria_set[:search].empty?
+      filters = criteria_set[:search].collect(&:to_s)
+      { '$search' => filters.join(' AND ') }
+    end
+
+    def list_criteria(name)
+      return nil if criteria_set[name].empty?
+      { "$#{name}" => criteria_set[name].join(',') }
+    end
+
+    def inline_count_criteria
+      criteria_set[:inline_count] ? { '$count' => 'true' } : nil
+    end
+
+    def paging_criteria(name)
+      criteria_set[name] == 0 ? nil : { "$#{name}" => criteria_set[name] }
+    end
+  end
+end

data/lib/frodo/railtie.rb

@@ -0,0 +1,19 @@
+module Frodo
+  class Railtie < Rails::Railtie
+    config.before_initialize do
+      ::Frodo::Railtie.load_configuration!
+      ::Frodo::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
+    # Frodo::ServiceRegistry accordingly.
+    def self.setup_service_registry!
+      # TODO Populate Frodo::ServiceRegistry based on configuration
+    end
+  end
+end

data/lib/frodo/schema/complex_type.rb

@@ -0,0 +1,79 @@
+module Frodo
+  class Schema
+    # ComplexTypes are used in Frodo to either encapsulate richer data types for
+    # use as Entity properties. ComplexTypes are composed of properties the same
+    # way that Entities are and, so, the interface for working with the various
+    # properties of a ComplexType mimics that of Entities.
+    class ComplexType
+      # Creates a new ComplexType based on the supplied options.
+      # @param type_xml [Nokogiri::XML::Element]
+      # @param service [Frodo::Service]
+      def initialize(type_definition, schema)
+        @type_definition = type_definition
+        @schema          = schema
+      end
+
+      # The name of the ComplexType
+      # @return [String]
+      def name
+        @name ||= type_definition.attributes['Name'].value
+      end
+
+      # Returns the namespaced type for the ComplexType.
+      # @return [String]
+      def type
+        "#{namespace}.#{name}"
+      end
+
+      # Returns the namespace this ComplexType belongs to.
+      # @return [String]
+      def namespace
+        @namespace ||= service.namespace
+      end
+
+      # Returns this ComplexType's properties.
+      # @return [Hash<String, Frodo::Property>]
+      def properties
+        @properties ||= collect_properties
+      end
+
+      # Returns a list of this ComplexType's property names.
+      # @return [Array<String>]
+      def property_names
+        @property_names ||= properties.keys
+      end
+
+      # Returns the property class that implements this `ComplexType`.
+      # @return [Class < Frodo::Properties::Complex]
+      def property_class
+        @property_class ||= lambda { |type, complex_type|
+          klass = Class.new ::Frodo::Properties::Complex
+          klass.send(:define_method, :type) { type }
+          klass.send(:define_method, :complex_type) { complex_type }
+          klass
+        }.call(type, self)
+      end
+
+      private
+
+      def schema
+        @schema
+      end
+
+      def service
+        @schema.service
+      end
+
+      def type_definition
+        @type_definition
+      end
+
+      def collect_properties
+        Hash[type_definition.xpath('./Property').map do |property_xml|
+          property_name, property = schema.send(:process_property_from_xml, property_xml)
+          [property_name, property]
+        end]
+      end
+    end
+  end
+end

data/lib/frodo/schema/enum_type.rb

@@ -0,0 +1,95 @@
+module Frodo
+  class Schema
+    # Enumeration types are nominal types that represent a series of related values.
+    # Enumeration types expose these related values as members of the enumeration.
+    class EnumType
+      # Creates a new EnumType based on the supplied options.
+      # @param type_xml [Nokogiri::XML::Element]
+      # @param service [Frodo::Service]
+      # @return [self]
+      def initialize(type_definition, schema)
+        @type_definition = type_definition
+        @schema          = schema
+      end
+
+      # The name of the EnumType
+      # @return [String]
+      def name
+        options['Name']
+      end
+
+      # Returns the namespaced type for the EnumType.
+      # @return [String]
+      def type
+        "#{namespace}.#{name}"
+      end
+
+      # Whether this EnumType supports setting multiple values.
+      # @return [Boolean]
+      def is_flags?
+        options['IsFlags'] == 'true'
+      end
+
+      # The underlying type of this EnumType.
+      # @return [String]
+      def underlying_type
+        options['UnderlyingType'] || 'Edm.Int32'
+      end
+
+      # Returns the namespace this EnumType belongs to.
+      # @return [String]
+      def namespace
+        @namespace ||= service.namespace
+      end
+
+      # Returns the members of this EnumType and their values.
+      # @return [Hash]
+      def members
+        @members ||= collect_members
+      end
+
+      # Returns the property class that implements this `EnumType`.
+      # @return [Class < Frodo::Properties::Enum]
+      def property_class
+        @property_class ||= lambda { |type, members, is_flags|
+          klass = Class.new ::Frodo::Properties::Enum
+          klass.send(:define_method, :type) { type }
+          klass.send(:define_method, :members) { members }
+          klass.send(:define_method, :is_flags?) { is_flags }
+          klass
+        }.call(type, members, is_flags?)
+      end
+
+      # Returns the value of the requested member.
+      # @param member_name [to_s]
+      # @return [*]
+      def [](member_name)
+        members.invert[member_name.to_s]
+      end
+
+      private
+
+      def service
+        @schema.service
+      end
+
+      def type_definition
+        @type_definition
+      end
+
+      def options
+        @options = type_definition.attributes.map do |name, attr|
+          [name, attr.value]
+        end.to_h
+      end
+
+      def collect_members
+        Hash[type_definition.xpath('./Member').map.with_index do |member_xml, index|
+          member_name  = member_xml.attributes['Name'].value
+          member_value = member_xml.attributes['Value'].andand.value.andand.to_i
+          [member_value || index, member_name]
+        end]
+      end
+    end
+  end
+end