frodo 0.10.0

data/lib/frodo/schema.rb

@@ -0,0 +1,164 @@
+require 'frodo/schema/complex_type'
+require 'frodo/schema/enum_type'
+
+module Frodo
+  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 [Frodo::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, Frodo::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, Frodo::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<Frodo::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,
+              ::Frodo::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 = {}
+
+      parent_properties = if base_type = type_definition.attributes['BaseType']
+                            parent_type = base_type.value.split('.').last
+                            properties_for_entity(parent_type)
+                          else
+                            {}
+                          end
+
+      type_definition.xpath('./Property').each do |property_xml|
+        property_name, property = process_property_from_xml(property_xml)
+        properties_to_return[property_name] = property
+      end
+      parent_properties.merge!(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 = ::Frodo::Properties::Collection
+        property_options.merge(value_type: value_type)
+      else
+        klass = ::Frodo::PropertyRegistry[property_type]
+      end
+
+      if klass.nil?
+        raise RuntimeError, "Unknown property type: #{property_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

data/lib/frodo/service.rb

@@ -0,0 +1,199 @@
+
+module Frodo
+  # Encapsulates the basic details and functionality needed to interact with an
+  # Frodo service.
+  class Service
+    # The Frodo Service's URL
+    attr_reader :service_url
+    # Service options
+    attr_reader :options
+
+
+    # Opens the service based on the requested URL and adds the service to
+    # {Frodo::Registry}
+    #
+    # @param service_url [String]
+    #   The URL to the Frodo service
+    # @param options [Hash] options to pass to the service
+    # @return [Frodo::Service] an instance of the service
+    def initialize(service_url, options = {}, &block)
+      @options = default_options.merge(options)
+      @service_url = service_url
+
+      Frodo::ServiceRegistry.add(self)
+      register_custom_types
+    end
+
+    # Returns user supplied name for service, or its URL
+    # @return [String]
+    def name
+      @name ||= options[:name] || service_url
+    end
+
+    # Returns the service's metadata URL.
+    # @return [String]
+    def metadata_url
+      "#{service_url}/$metadata"
+    end
+
+    # Returns the service's metadata definition.
+    # @return [Nokogiri::XML]
+    def metadata
+      @metadata ||= lambda { read_metadata }.call
+    end
+
+    # Returns all of the service's schemas.
+    # @return Hash<String, Frodo::Schema>
+    def schemas
+      @schemas ||= metadata.xpath('//Schema').map do |schema_xml|
+        [
+          schema_xml.attributes['Namespace'].value,
+          Schema.new(schema_xml, self)
+        ]
+      end.to_h
+    end
+
+    # Returns the service's EntityContainer (singleton)
+    # @return Frodo::EntityContainer
+    def entity_container
+      @entity_container ||= EntityContainer.new(self)
+    end
+
+    # Returns a hash of EntitySet names and their respective EntityType names
+    # @return Hash<String, String>
+    def entity_sets
+      entity_container.entity_sets
+    end
+
+    # Retrieves the EntitySet associated with a specific EntityType by name
+    #
+    # @param entity_set_name [to_s] the name of the EntitySet desired
+    # @return [Frodo::EntitySet] an Frodo::EntitySet to query
+    def [](entity_set_name)
+      entity_container[entity_set_name]
+    end
+
+    # Returns the default namespace, that is, the namespace of the schema
+    # that contains the service's EntityContainer.
+    # @return [String]
+    def namespace
+      entity_container.namespace
+    end
+
+    # Returns a list of `EntityType`s exposed by the service
+    # @return Array<String>
+    def entity_types
+      @entity_types ||= schemas.map do |namespace, schema|
+        schema.entity_types.map do |entity_type|
+          "#{namespace}.#{entity_type}"
+        end
+      end.flatten
+    end
+
+    # Returns a list of `ComplexType`s used by the service.
+    # @return [Hash<String, Frodo::Schema::ComplexType>]
+    def complex_types
+      @complex_types ||= schemas.map do |namespace, schema|
+        schema.complex_types.map do |name, complex_type|
+          [ "#{namespace}.#{name}", complex_type ]
+        end.to_h
+      end.reduce({}, :merge)
+    end
+
+    # Returns a list of `EnumType`s used by the service
+    # @return [Hash<String, Frodo::Schema::EnumType>]
+    def enum_types
+      @enum_types ||= schemas.map do |namespace, schema|
+        schema.enum_types.map do |name, enum_type|
+          [ "#{namespace}.#{name}", enum_type ]
+        end.to_h
+      end.reduce({}, :merge)
+    end
+
+    # Returns a more compact inspection of the service object
+    def inspect
+      "#<#{self.class.name}:#{self.object_id} name='#{name}' service_url='#{self.service_url}'>"
+    end
+
+    # Get the property type for an entity from metadata.
+    #
+    # @param entity_name [to_s] the fully qualified entity name
+    # @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)
+      namespace, _, entity_name = entity_name.rpartition('.')
+      raise ArgumentError, 'Namespace missing' if namespace.nil? || namespace.empty?
+      schemas[namespace].get_property_type(entity_name, property_name)
+    end
+
+    # Get the primary key for the supplied Entity.
+    #
+    # @param entity_name [to_s] The fully qualified entity name
+    # @return [String]
+    def primary_key_for(entity_name)
+      namespace, _, entity_name = entity_name.rpartition('.')
+      raise ArgumentError, 'Namespace missing' if namespace.nil? || namespace.empty?
+      schemas[namespace].primary_key_for(entity_name)
+    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)
+      namespace, _, entity_name = entity_name.rpartition('.')
+      raise ArgumentError, 'Namespace missing' if namespace.nil? || namespace.empty?
+      schemas[namespace].properties_for_entity(entity_name)
+    end
+
+    # Returns the logger instance used by the service.
+    # When Ruby on Rails has been detected, the service will
+    # use `Rails.logger`. The log level will NOT be changed.
+    #
+    # When no Rails has been detected, a default logger will
+    # be used that logs to STDOUT with the log level supplied
+    # via options, or the default log level if none was given.
+    # @return [Logger]
+    def logger
+      @logger ||= options[:logger] || if defined?(Rails)
+        Rails.logger
+      else
+        default_logger
+      end
+    end
+
+    private
+
+    def default_options
+      {
+        strict: true # strict property validation
+      }
+    end
+
+    def default_logger
+        Frodo.configuration.logger if Frodo.log?
+    end
+
+    def read_metadata
+      # From file, good for debugging
+      if options[:metadata_file]
+        data = File.read(options[:metadata_file])
+        ::Nokogiri::XML(data).remove_namespaces!
+      elsif options[:metadata_document]
+        data = options[:metadata_document]
+        ::Nokogiri::XML(data).remove_namespaces!
+      end
+    end
+
+    def register_custom_types
+      complex_types.each do |name, type|
+        ::Frodo::PropertyRegistry.add(name, type.property_class)
+      end
+
+      enum_types.each do |name, type|
+        ::Frodo::PropertyRegistry.add(name, type.property_class)
+      end
+    end
+  end
+end

data/lib/frodo/service_registry.rb

@@ -0,0 +1,52 @@
+require 'singleton'
+
+module Frodo
+  # Provides a registry for keeping track of multiple Frodo::Service instances
+  class ServiceRegistry
+    include Singleton
+
+    # Add a service to the Registry
+    #
+    # @param service [Frodo::Service] service to add to the registry
+    def add(service)
+      initialize_instance_variables
+      @services << service if service.is_a?(Frodo::Service) && !@services.include?(service)
+      @services_by_name[service.name] = @services.find_index(service)
+      @services_by_url[service.service_url] = @services.find_index(service)
+    end
+
+    # Lookup a service by URL or name
+    #
+    # @param lookup_key [String] the URL or name to lookup
+    # @return [Frodo::Service, nil] the Frodo::Service or nil
+    def [](lookup_key)
+      initialize_instance_variables
+      index = @services_by_name[lookup_key] || @services_by_url[lookup_key]
+      index.nil? ? nil : @services[index]
+    end
+
+    # (see #add)
+    def self.add(service)
+      Frodo::ServiceRegistry.instance.add(service)
+    end
+
+    # (see #[])
+    def self.[](lookup_key)
+      Frodo::ServiceRegistry.instance[lookup_key]
+    end
+
+    private
+
+    def initialize_instance_variables
+      @services ||= []
+      @services_by_name ||= {}
+      @services_by_url ||= {}
+    end
+
+    def flush
+      @services = []
+      @services_by_name = {}
+      @services_by_url = {}
+    end
+  end
+end

data/lib/frodo/version.rb

@@ -0,0 +1,3 @@
+module Frodo
+  VERSION = '0.10.0'
+end

data/lib/frodo.rb

@@ -0,0 +1,67 @@
+require 'uri'
+require 'date'
+require 'time'
+require 'bigdecimal'
+require 'nokogiri'
+require 'faraday'
+require 'logger'
+require 'andand'
+require 'json'
+require 'faraday_middleware'
+
+require 'frodo/concerns/api'
+require 'frodo/concerns/authentication'
+require 'frodo/concerns/base'
+require 'frodo/concerns/caching'
+require 'frodo/concerns/connection'
+require 'frodo/concerns/verbs'
+
+
+require 'frodo/middleware'
+require 'frodo/middleware/authentication'
+require 'frodo/middleware/authentication/token'
+require 'frodo/middleware/authorization'
+require 'frodo/middleware/caching'
+require 'frodo/middleware/custom_headers'
+require 'frodo/middleware/gzip'
+require 'frodo/middleware/instance_url'
+require 'frodo/middleware/logger'
+require 'frodo/middleware/odata_headers'
+require 'frodo/middleware/raise_error'
+require 'frodo/middleware/multipart'
+require 'frodo/abstract_client'
+require 'frodo/client'
+require 'frodo/config'
+
+require 'frodo/version'
+require 'frodo/errors'
+require 'frodo/property_registry'
+require 'frodo/property'
+require 'frodo/properties'
+require 'frodo/navigation_property'
+require 'frodo/entity'
+require 'frodo/entity_container'
+require 'frodo/entity_set'
+require 'frodo/query'
+require 'frodo/schema'
+require 'frodo/service'
+require 'frodo/service_registry'
+
+require 'frodo/railtie' if defined?(::Rails)
+
+# The Frodo gem provides a convenient way to interact with OData V4 services from
+# Ruby. Please look to the {file:README.md README} for how to get started using
+# the Frodo gem.
+module Frodo
+  Error               = Class.new(StandardError)
+  ServerError         = Class.new(Error)
+  AuthenticationError = Class.new(Error)
+  UnauthorizedError   = Class.new(Error)
+  APIVersionError     = Class.new(Error)
+
+  class << self
+    def new(*args, &block)
+      Frodo::Client.new(*args, &block)
+    end
+  end
+end

data/spec/fixtures/auth_success_response.json

@@ -0,0 +1,11 @@
+{
+  "token_type": "Bearer",
+  "scope": "user_impersonation",
+  "expires_in": "3599",
+  "ext_expires_in": "3599",
+  "expires_on": "1552430212",
+  "not_before": "1552426312",
+  "resource": "https://emmanueltest.crm.dynamics.com",
+  "access_token": "gfEzf4azkWZMTjlay7usiSWhc0eOLNkKMw",
+  "refresh_token": "QswqIkdHSdbyvbDFuLwHNAoU1QgAA"
+}

data/spec/fixtures/error.json

@@ -0,0 +1,11 @@
+{
+  "error": {
+    "code": "0x8006088a",
+    "message": "Resource not found for the segment 'leadsss'.",
+    "innererror": {
+      "message": "Resource not found for the segment 'leadsss'.",
+      "type": "Microsoft.OData.UriParser.ODataUnrecognizedPathException",
+      "stacktrace": "   at Microsoft.OData.UriParser.ODataPathParser.CreateDynamicPathSegment(ODataPathSegment previous, String identifier, String parenthesisExpression)rn   at Microsoft.OData.UriParser.ODataPathParser.CreateFirstSegment(String segmentText)rn   at Microsoft.OData.UriParser.ODataPathParser.ParsePath(ICollection`1 segments)rn   at Microsoft.OData.UriParser.ODataPathFactory.BindPath(ICollection`1 segments, ODataUriParserConfiguration configuration)rn   at Microsoft.OData.UriParser.ODataUriParser.Initialize()rn   at System.Web.OData.Routing.DefaultODataPathHandler.Parse(String serviceRoot, String odataPath, IServiceProvider requestContainer, Boolean template)rn   at System.Web.OData.Routing.DefaultODataPathHandler.Parse(String serviceRoot, String odataPath, IServiceProvider requestContainer)rn   at Microsoft.Crm.Extensibility.ODataV4.Routing.CrmODataPathHandler.Parse(String serviceRoot, String odataPath, IServiceProvider requestContainer)"
+    }
+  }
+}

data/spec/fixtures/files/entity_to_xml.xml

@@ -0,0 +1,18 @@
+<?xml version="1.0"?>
+<entry xmlns="http://www.w3.org/2005/Atom" xmlns:data="http://docs.oasis-open.org/odata/ns/data" xmlns:metadata="http://docs.oasis-open.org/odata/ns/metadata" xmlns:georss="http://www.georss.org/georss" xmlns:gml="http://www.opengis.net/gml" xml:base="http://services.odata.org/V4/OData/OData.svc">
+  <category term="ODataDemo.Product" scheme="http://docs.oasis-open.org/odata/ns/scheme"/>
+  <author>
+    <name/>
+  </author>
+  <content type="application/xml">
+    <metadata:properties>
+      <data:Name metadata:type="Edm.String">Bread</data:Name>
+      <data:Description metadata:type="Edm.String">Whole grain bread</data:Description>
+      <data:ReleaseDate metadata:type="Edm.DateTimeOffset">1992-01-01T00:00:00Z</data:ReleaseDate>
+      <data:DiscontinuedDate metadata:type="Edm.DateTimeOffset" metadata:null="true"/>
+      <data:Rating metadata:type="Edm.Int16">4</data:Rating>
+      <data:Price metadata:type="Edm.Double">2.5</data:Price>
+      <data:ProductStatus metadata:type="ODataDemo.ProductStatus" metadata:null="true"/>
+    </metadata:properties>
+  </content>
+</entry>

data/spec/fixtures/files/error.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<m:error xmlns:m="http://docs.oasis-open.org/odata/ns/metadata">
+    <m:code />
+    <m:message>Resource not found for the segment 'Products'.</m:message>
+</m:error>