odata4 0.7.0 → 0.8.0

data/lib/odata4/enum_type/property.rb

@@ -46,7 +46,7 @@ module OData4
           elsif members.values.include?(value)
             value
           else
-            raise ArgumentError, "Property '#{name}': Value must be one of #{members.to_a}, but was: '#{value}'" if strict?
+            validation_error "Value must be one of #{members.to_a}, but was: '#{value}'"
           end
         end.compact
       end

data/lib/odata4/navigation_property/proxy.rb

@@ -34,6 +34,10 @@ module OData4
         @namespace ||= service.namespace
       end
 
+      def schema
+        @schema ||= service.schemas[namespace]
+      end
+
       def entity_type
         @entity_type ||= entity.name
       end
@@ -43,7 +47,7 @@ module OData4
       end
 
       def nav_property
-        service.navigation_properties[entity_type][nav_name]
+        schema.navigation_properties[entity_type][nav_name]
       end
 
       def fetch_result

data/lib/odata4/properties/binary.rb

@@ -42,9 +42,9 @@ module OData4
 
       def validate(value)
         unless [0,1,'0','1',true,false].include?(value)
-          raise ArgumentError, 'Value is outside accepted range: 0 or 1'
+          validation_error 'Value is outside accepted range: 0 or 1'
         end
       end
     end
   end
-end
+end

data/lib/odata4/properties/boolean.rb

@@ -29,7 +29,7 @@ module OData4
       def validate(value)
         return if value.nil? && allows_nil?
         unless [0,1,'0','1','true','false',true,false].include?(value)
-          raise ArgumentError, 'Value is outside accepted range: true or false'
+          validation_error 'Value is outside accepted range: true or false'
         end
       end
     end

data/lib/odata4/properties/date_time.rb

@@ -65,7 +65,7 @@ module OData4
           return if value.is_a?(date_class)
           date_class.parse(value)
         rescue
-          raise ArgumentError, "Value '#{value}' is not a date time format that can be parsed"
+          validation_error "Value '#{value}' is not a date time format that can be parsed"
         end
       end
 

data/lib/odata4/properties/decimal.rb

@@ -27,14 +27,14 @@ module OData4
       # Value to be used in URLs.
       # @return [String]
       def url_value
-        "#{value.to_f}M"
+        "#{value.to_f}"
       end
 
       private
 
       def validate(value)
         if value > max_value || value < min_value || value.precs.first > 29
-          raise ArgumentError, "Value is outside accepted range: #{min_value} to #{max_value}, or has more than 29 significant digits"
+          validation_error "Value is outside accepted range: #{min_value} to #{max_value}, or has more than 29 significant digits"
         end
       end
 

data/lib/odata4/properties/number.rb

@@ -6,9 +6,9 @@ module OData4
 
       def validate(value)
         if value > max_value || value < min_value
-          raise ::ArgumentError, "Value is outside accepted range: #{min_value} to #{max_value}"
+          validation_error "Value is outside accepted range: #{min_value} to #{max_value}"
         end
       end
     end
   end
-end
+end

data/lib/odata4/properties/string.rb

@@ -56,7 +56,7 @@ module OData4
 
       def validate(new_value)
         if new_value.nil? && !allows_nil?
-          raise ArgumentError, 'This property does not allow for nil values to be set'
+          validation_error 'This property does not allow for nil values to be set'
         end
       end
 
@@ -69,4 +69,4 @@ module OData4
       end
     end
   end
-end
+end

data/lib/odata4/properties/time.rb

@@ -28,7 +28,7 @@ module OData4
 
       def validate(value)
         unless value.is_a?(::Time)
-          raise ArgumentError, 'Value is not a time object'
+          validation_error 'Value is not a time object'
         end
       end
 

data/lib/odata4/property.rb

@@ -8,6 +8,8 @@ module OData4
     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]
@@ -44,13 +46,19 @@ module OData4
     # (Default=false)
     # @return [Boolean]
     def strict?
-      options[: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
-      @concurrecy_mode ||= options[:concurrency_mode]
+      @concurrency_mode ||= options[:concurrency_mode]
     end
 
     # Value to be used in XML.
@@ -76,7 +84,7 @@ module OData4
     # @param xml_builder [Nokogiri::XML::Builder]
     def to_xml(xml_builder)
       attributes = {
-          'metadata:type' => type,
+        'metadata:type' => type,
       }
 
       if value.nil?
@@ -101,18 +109,31 @@ module OData4
       new(property_xml.name, content, options)
     end
 
-    private
+    protected
 
     def default_options
       {
         allows_nil:       true,
-        concurrency_mode: :none,
-        strict:           false
+        concurrency_mode: :none
       }
     end
 
-    def options
-      @options
+    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/odata4/schema.rb

@@ -0,0 +1,146 @@
+module OData4
+  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 [OData4::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, OData4::ComplexType>]
+    def complex_types
+      @complex_types ||= metadata.xpath('//ComplexType').map do |entity|
+        [
+          entity.attributes['Name'].value,
+          ::OData4::ComplexType.new(entity, self)
+        ]
+      end.to_h
+    end
+
+    # Returns a list of EnumTypes defined by the schema.
+    # @return [Hash<String, OData4::EnumType>]
+    def enum_types
+      @enum_types ||= metadata.xpath('//EnumType').map do |entity|
+        [
+          entity.attributes['Name'].value,
+          ::OData4::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<OData4::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,
+              ::OData4::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
+      value_type = property_xml.attributes['Type'].value
+      property_options = { service: service }
+
+      klass = ::OData4::PropertyRegistry[value_type]
+
+      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

data/lib/odata4/service.rb

@@ -52,64 +52,78 @@ module OData4
       "#{service_url}/$metadata"
     end
 
-    # Returns a list of entities exposed by the service
-    def entity_types
-      @entity_types ||= metadata.xpath('//EntityType').collect {|entity| entity.attributes['Name'].value}
+    # Returns the service's metadata definition.
+    # @return [Nokogiri::XML]
+    def metadata
+      @metadata ||= lambda { read_metadata }.call
     end
 
-    # Returns a hash of EntitySet names keyed to their respective EntityType name
-    def entity_sets
-      @entity_sets ||= metadata.xpath('//EntityContainer/EntitySet').collect {|entity|
+    # Returns all of the service's schemas.
+    # @return Hash<String, OData4::Schema>
+    def schemas
+      @schemas ||= metadata.xpath('//Schema').map do |schema_xml|
         [
-          entity.attributes['EntityType'].value.gsub("#{namespace}.", ''),
-          entity.attributes['Name'].value
+          schema_xml.attributes['Namespace'].value,
+          Schema.new(schema_xml, self)
         ]
-      }.to_h
+      end.to_h
     end
 
-    # Returns a list of ComplexTypes used by the service
-    # @return [Hash<String, OData4::ComplexType>]
-    def complex_types
-      @complex_types ||= metadata.xpath('//ComplexType').map do |entity|
-        [
-          entity.attributes['Name'].value,
-          ::OData4::ComplexType.new(entity, self)
-        ]
-      end.to_h
+    # Returns the service's EntityContainer (singleton)
+    # @return OData4::EntityContainer
+    def entity_container
+      @entity_container ||= EntityContainer.new(self)
     end
 
-    # Returns a list of EnumTypes used by the service
-    # @return [Hash<String, OData4::EnumType>]
-    def enum_types
-      @enum_types ||= metadata.xpath('//EnumType').map do |entity|
-        [
-          entity.attributes['Name'].value,
-          ::OData4::EnumType.new(entity, self)
-        ]
-      end.to_h
+    # Returns a hash of EntitySet names and their respective EntityType names
+    # @return Hash<String, String>
+    def entity_sets
+      entity_container.entity_sets
     end
 
-    # Returns a hash for finding an association through an entity type's defined
-    # NavigationProperty elements.
-    # @return [Hash<Hash<OData4::Association>>]
-    def navigation_properties
-      @navigation_properties ||= metadata.xpath('//EntityType').collect do |entity_type_def|
-        entity_type_name = entity_type_def.attributes['Name'].value
-        [
-            entity_type_name,
-            entity_type_def.xpath('./NavigationProperty').collect do |nav_property_def|
-              [
-                  nav_property_def.attributes['Name'].value,
-                  ::OData4::NavigationProperty.build(nav_property_def)
-              ]
-            end.to_h
-        ]
-      end.to_h
+    # Retrieves the EntitySet associated with a specific EntityType by name
+    #
+    # @param entity_set_name [to_s] the name of the EntitySet desired
+    # @return [OData4::EntitySet] an OData4::EntitySet to query
+    def [](entity_set_name)
+      entity_container[entity_set_name]
     end
 
-    # Returns the namespace defined on the service's schema
+    # Returns the default namespace, that is, the namespace of the schema
+    # that contains the service's EntityContainer.
+    # @return [String]
     def namespace
-      @namespace ||= metadata.xpath('//Schema').first.attributes['Namespace'].value
+      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, OData4::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, OData4::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
@@ -117,23 +131,6 @@ module OData4
       "#<#{self.class.name}:#{self.object_id} name='#{name}' service_url='#{self.service_url}'>"
     end
 
-    # Retrieves the EntitySet associated with a specific EntityType by name
-    #
-    # @param entity_set_name [to_s] the name of the EntitySet desired
-    # @return [OData4::EntitySet] an OData4::EntitySet to query
-    def [](entity_set_name)
-      xpath_query = "//EntityContainer/EntitySet[@Name='#{entity_set_name}']"
-      entity_set_node = metadata.xpath(xpath_query).first
-      raise ArgumentError, "Unknown Entity Set: #{entity_set_name}" if entity_set_node.nil?
-      container_name = entity_set_node.parent.attributes['Name'].value
-      entity_type_name = entity_set_node.attributes['EntityType'].value.gsub(/#{namespace}\./, '')
-      OData4::EntitySet.new(name: entity_set_name,
-                           namespace: namespace,
-                           type: entity_type_name.to_s,
-                           service_name: name,
-                           container: container_name)
-    end
-
     # Execute a request against the service
     #
     # @param url_chunk [to_s] string to append to service url
@@ -189,19 +186,23 @@ module OData4
 
     # Get the property type for an entity from metadata.
     #
-    # @param entity_name [to_s] the name of the relevant entity
+    # @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)
-      metadata.xpath("//EntityType[@Name='#{entity_name}']/Property[@Name='#{property_name}']").first.attributes['Type'].value
+      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]
+    # @param entity_name [to_s] The fully qualified entity name
     # @return [String]
     def primary_key_for(entity_name)
-      metadata.xpath("//EntityType[@Name='#{entity_name}']/Key/PropertyRef").first.attributes['Name'].value
+      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
@@ -210,14 +211,9 @@ module OData4
     # @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
+      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 log level set via initial options, or the
@@ -262,7 +258,8 @@ module OData4
         typhoeus: {
           headers: { 'OData4-Version' => '4.0' },
           timeout: HTTP_TIMEOUT
-        }
+        },
+        strict: true # strict property validation
       }
     end
 
@@ -276,10 +273,6 @@ module OData4
       end
     end
 
-    def metadata
-      @metadata ||= lambda { read_metadata }.call
-    end
-
     def read_metadata
       response = nil
       # From file, good for debugging
@@ -314,30 +307,13 @@ module OData4
       OData4::Query::Result.new(nil, response).error_message
     end
 
-    def process_property_from_xml(property_xml)
-      property_name = property_xml.attributes['Name'].value
-      value_type = property_xml.attributes['Type'].value
-      property_options = {}
-
-      klass = ::OData4::PropertyRegistry[value_type]
-
-      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
-
     def register_custom_types
       complex_types.each do |name, type|
-        ::OData4::PropertyRegistry.add(type.type, type.property_class)
+        ::OData4::PropertyRegistry.add(name, type.property_class)
       end
 
       enum_types.each do |name, type|
-        ::OData4::PropertyRegistry.add(type.type, type.property_class)
+        ::OData4::PropertyRegistry.add(name, type.property_class)
       end
     end
   end