odata4 0.8.0 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e28c4147df950462c72f8824c2868601941872c5
-  data.tar.gz: 8044f114aaa10c09719c3d3e5743f5f5c96de9d7
+  metadata.gz: 9adfc90966866d69ec4082404f10a60cd8404563
+  data.tar.gz: 293c604e274b209c738496e41318f2441d41e159
 SHA512:
-  metadata.gz: c10b8c4859b7f2acdbf33d5258f12e43970d24061f558afac558be6212a955e4c5b5118720de78e74ae22231f7bf5479a137591082a0568aee13f5a325350788
-  data.tar.gz: 8d73fc1f5877df150a21a28ca10871582e58657f0419726fadb1d2c514c62d09517ff1f7eb2d1559bd49d6aea8fb50435e7280bedd60ed174a9528c26d926f05
+  metadata.gz: 52bad8a865f20e227aa331f09e680d857caaaa3da8e70df5be873d78477d96b7e4451506e1a70efec9239034c4e98693c0f7b5600f78e5f383fcb56249e6085c
+  data.tar.gz: c1868354a432bed72b9b6db7b0e76d6194fd221e05827d3077cdaf9d258687e46bd489a444132154eb95a4835f959ca18e7f64c22dbaf49a41a1299f6d3be382

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # CHANGELOG
 
+## 0.8.1
+
+* [New Feature] Basic support for `Collection` property type
+* [Refactor] Moved all HTTP-related code into `Service::Request`,
+             renamed `Query::Result` to `Service::Response`
+* [Bugfix] Fixed incorrect `OData-Version` header being sent
+* [Bugfix] Fixed duplicate namespace in Atom serialization
+
 ## 0.8.0
 
 * [New Feature] Support for multiple schemas

data/README.md

@@ -13,6 +13,7 @@ If you need a gem to integration with OData Version 3, you can use James Thompso
 [![Test Coverage](https://api.codeclimate.com/v1/badges/f151944dc05b2c7268e5/test_coverage)](https://codeclimate.com/github/wrstudios/odata4/test_coverage)
 [![Dependency Status](https://gemnasium.com/badges/github.com/wrstudios/odata4.svg)](https://gemnasium.com/github.com/wrstudios/odata4)
 [![Documentation](http://inch-ci.org/github/wrstudios/odata4.png?branch=master)](http://www.rubydoc.info/github/wrstudios/odata4/master)
+[![Gem Version](https://badge.fury.io/rb/odata4.svg)](https://badge.fury.io/rb/odata4)
 
 ## Installation
 

data/lib/odata4/entity.rb

@@ -169,7 +169,7 @@ module OData4
       namespaces = XML_NAMESPACES.merge('xml:base' => service.service_url)
       builder = Nokogiri::XML::Builder.new do |xml|
         xml.entry(namespaces) do
-          xml.category(term: "#{namespace}.#{type}",
+          xml.category(term: type,
                        scheme: 'http://docs.oasis-open.org/odata/ns/scheme')
           xml.author { xml.name }
 
@@ -236,13 +236,21 @@ module OData4
     private
 
     def instantiate_property(property_name, value_xml)
-      value_type = schema.get_property_type(name, property_name)
-      klass = ::OData4::PropertyRegistry[value_type]
+      prop_type = schema.get_property_type(name, property_name)
+      prop_type, value_type = prop_type.split(/\(|\)/)
+
+      if prop_type == 'Collection'
+        klass = ::OData4::Properties::Collection
+        options = { value_type: value_type }
+      else
+        klass = ::OData4::PropertyRegistry[prop_type]
+        options = {}
+      end
 
       if klass.nil?
-        raise RuntimeError, "Unknown property type: #{value_type}"
+        raise RuntimeError, "Unknown property type: #{prop_type}"
       else
-        klass.from_xml(value_xml, service: service)
+        klass.from_xml(value_xml, options.merge(service: service))
       end
     end
 

data/lib/odata4/properties/collection.rb

@@ -0,0 +1,50 @@
+module OData4
+  module Properties
+    # Defines the Collection OData4 type.
+    class Collection < OData4::Property
+      # Overriding default constructor to avoid converting
+      # value to string.
+      # TODO: Make this the default for all property types?
+      def initialize(name, value, options = {})
+        super(name, value, options)
+        self.value = value
+      end
+
+      def value
+        if @value.nil?
+          nil
+        else
+          @value.map(&:value)
+        end
+      end
+
+      def value=(value)
+        if value.nil? && allows_nil?
+          @value = nil
+        elsif value.respond_to?(:map)
+          @value = value.map.with_index do |element, index|
+            type_class.new("#{name}[#{index}]", element)
+          end
+        else
+          validation_error 'Value must be an array'
+        end
+      end
+
+      def url_value
+        '[' + @value.map(&:url_value).join(',') + ']'
+      end
+
+      def type
+        "Collection(#{value_type})"
+      end
+
+      def value_type
+        options[:value_type] || 'Edm.String'
+      end
+
+      def type_class
+        OData4::PropertyRegistry[value_type]
+      end
+    end
+  end
+end

data/lib/odata4/properties.rb

@@ -4,6 +4,7 @@ require 'odata4/properties/number'
 # Implementations
 require 'odata4/properties/binary'
 require 'odata4/properties/boolean'
+require 'odata4/properties/collection'
 require 'odata4/properties/date'
 require 'odata4/properties/date_time'
 require 'odata4/properties/date_time_offset'

data/lib/odata4/query.rb

@@ -1,3 +1,6 @@
+require 'odata4/query/criteria'
+require 'odata4/query/in_batches'
+
 module OData4
   # OData4::Query provides the query interface for requesting Entities matching
   # specific criteria from an OData4::EntitySet. This class should not be
@@ -133,17 +136,16 @@ module OData4
     end
 
     # Execute the query.
-    # @return [OData4::Query::Result]
-    def execute(query = self.to_s)
-      response = service.execute(query, options)
-      OData4::Query::Result.new(self, response)
+    # @return [OData4::Service::Response]
+    def execute(url_chunk = self.to_s)
+      service.execute(url_chunk, options.merge(query: self))
     end
 
     # Executes the query to get a count of entities.
     # @return [Integer]
     def count
       url_chunk = ["#{entity_set.name}/$count", assemble_criteria].compact.join('?')
-      response = service.execute(url_chunk)
+      response = self.execute(url_chunk)
       # Some servers (*cough* Microsoft *cough*) seem to
       # return extraneous characters in the response.
       response.body.scan(/\d+/).first.to_i

data/lib/odata4/schema.rb

@@ -128,10 +128,16 @@ module OData4
 
     def process_property_from_xml(property_xml)
       property_name = property_xml.attributes['Name'].value
-      value_type = property_xml.attributes['Type'].value
+      property_type = property_xml.attributes['Type'].value
       property_options = { service: service }
 
-      klass = ::OData4::PropertyRegistry[value_type]
+      property_type, value_type = property_type.split(/\(|\)/)
+      if property_type == 'Collection'
+        klass = ::OData4::Properties::Collection
+        property_options.merge(value_type: value_type)
+      else
+        klass = ::OData4::PropertyRegistry[property_type]
+      end
 
       if klass.nil?
         raise RuntimeError, "Unknown property type: #{value_type}"

data/lib/odata4/service/request.rb

@@ -0,0 +1,81 @@
+module OData4
+  class Service
+    # Encapsulates a single request to an OData service.
+    class Request
+      # The OData service against which the request is performed
+      attr_reader :service
+      # The OData4::Query that generated this request (optional)
+      attr_reader :query
+      # The HTTP method for this request
+      attr_accessor :method
+      # The request format (`:atom`, `:json`, or `:auto`)
+      attr_accessor :format
+
+      # Create a new request
+      # @param service [OData4::Service] Where the request will be sent
+      # @param url_chunk [String] Request path, relative to the service URL, including query params
+      # @param options [Hash] Additional request options
+      def initialize(service, url_chunk, options = {})
+        @service = service
+        @url_chunk = url_chunk
+        @method = options[:method] || :get
+        @format = options[:format] || :auto
+        @query  = options[:query]
+      end
+
+      # Return the full request URL (including service base)
+      # @return [String]
+      def url
+        ::URI.join("#{service.service_url}/", ::URI.escape(url_chunk)).to_s
+      end
+
+      # The content type for this request. Depends on format.
+      # @return [String]
+      def content_type
+        if format == :auto
+          MIME_TYPES.values.join(',')
+        elsif MIME_TYPES.has_key? format
+          MIME_TYPES[format]
+        else
+          raise ArgumentError, "Unknown format '#{format}'"
+        end
+      end
+
+      # Execute the request
+      #
+      # @param additional_options [Hash] options to pass to Typhoeus
+      # @return [OData4::Service::Response]
+      def execute(additional_options = {})
+        options = request_options(additional_options)
+        request = ::Typhoeus::Request.new(url, options)
+        logger.info "Requesting #{method.to_s.upcase} #{url}..."
+        request.run
+
+        Response.new(service, request.response, query)
+      end
+
+      private
+
+      attr_reader :url_chunk
+
+      def logger
+        service.logger
+      end
+
+      def request_options(additional_options = {})
+        options = service.options[:typhoeus]
+          .merge({ method: method })
+          .merge(additional_options)
+
+        # Don't overwrite Accept header if already present
+        unless options[:headers]['Accept']
+          options[:headers] = options[:headers].merge({
+            'Accept' => content_type
+          })
+        end
+
+        options
+      end
+    end
+  end
+end

data/lib/odata4/{query/result → service/response}/atom.rb

@@ -1,14 +1,9 @@
 module OData4
-  class Query
-    class Result
-      # Represents the results of executing a OData4::Query.
-      # @api private
+  class Service
+    class Response
       module Atom
-        def process_results(&block)
-          find_entities.each do |entity_xml|
-            entity = OData4::Entity.from_xml(entity_xml, entity_options)
-            block_given? ? block.call(entity) : yield(entity)
-          end
+        def parse_entity(entity_xml, entity_options)
+          OData4::Entity.from_xml(entity_xml, entity_options)
         end
 
         def next_page
@@ -23,10 +18,14 @@ module OData4
           result_xml.xpath('//error/message').first.andand.text
         end
 
+        def parsed_body
+          result_xml
+        end
+
         private
 
         def result_xml
-          @result_xml ||= ::Nokogiri::XML(result.body).remove_namespaces!
+          @result_xml ||= ::Nokogiri::XML(response.body).remove_namespaces!
         end
 
         # Find entity entries in a result set

data/lib/odata4/{query/result → service/response}/json.rb

@@ -1,14 +1,9 @@
 module OData4
-  class Query
-    class Result
-      # Represents the results of executing a OData4::Query.
-      # @api private
+  class Service
+    class Response
       module JSON
-        def process_results(&block)
-          find_entities.each do |entity_json|
-            entity = OData4::Entity.from_json(entity_json, entity_options)
-            block_given? ? block.call(entity) : yield(entity)
-          end
+        def parse_entity(entity_json, entity_options)
+          OData4::Entity.from_json(entity_json, entity_options)
         end
 
         def next_page
@@ -23,10 +18,14 @@ module OData4
           result_json['error'].andand['message']
         end
 
+        def parsed_body
+          result_json
+        end
+
         private
 
         def result_json
-          @result_json ||= ::JSON.parse(result.body)
+          @result_json ||= ::JSON.parse(response.body)
         end
 
         def single_entity?

data/lib/odata4/service/response/plain.rb

@@ -0,0 +1,36 @@
+module OData4
+  class Service
+    class Response
+      module Plain
+        def parse_entity(entity_data, entity_options)
+          raise NotImplementedError, 'Not Available'
+        end
+
+        def next_page
+          raise NotImplementedError, 'Not available'
+        end
+
+        def next_page_url
+          raise NotImplementedError, 'Not available'
+        end
+
+        def error_message
+          response.body
+        end
+
+        def parsed_body
+          response.body
+        end
+
+        private
+
+        # Find entity entries in a response set
+        #
+        # @return [Array]
+        def find_entities
+          []
+        end
+      end
+    end
+  end
+end

data/lib/odata4/service/response/xml.rb

@@ -0,0 +1,40 @@
+module OData4
+  class Service
+    class Response
+      module XML
+        def parse_entity(entity_data, entity_options)
+          raise NotImplementedError, 'Not Available'
+        end
+
+        def next_page
+          raise NotImplementedError, 'Not Available'
+        end
+
+        def next_page_url
+          raise NotImplementedError, 'Not Available'
+        end
+
+        def error_message
+          response_xml.xpath('//error/message').first.andand.text
+        end
+
+        def parsed_body
+          response_xml
+        end
+
+        private
+
+        def response_xml
+          @response_xml ||= ::Nokogiri::XML(response.body).remove_namespaces!
+        end
+
+        # Find entity entries in a response set
+        #
+        # @return [Array]
+        def find_entities
+          []
+        end
+      end
+    end
+  end
+end

data/lib/odata4/service/response.rb

@@ -0,0 +1,160 @@
+require 'odata4/service/response/atom'
+require 'odata4/service/response/json'
+require 'odata4/service/response/plain'
+require 'odata4/service/response/xml'
+
+module OData4
+  class Service
+    # The result of executing a OData4::Service::Request.
+    class Response
+      include Enumerable
+
+      # The service that generated this response
+      attr_reader :service
+      # The underlying (raw) response
+      attr_reader :response
+      # The query that generated the response (optional)
+      attr_reader :query
+
+      # Create a new response given a service and a raw response.
+      # @param service [OData4::Service]
+      # @param response [Typhoeus::Result]
+      def initialize(service, response, query = nil)
+        @service  = service
+        @response = response
+        @query    = query
+        check_content_type
+        validate!
+      end
+
+      # Returns the HTTP status code.
+      def status
+        response.code
+      end
+
+      # Whether the request was successful.
+      def success?
+        200 <= status && status < 300
+      end
+
+      # Returns the content type of the resonse.
+      def content_type
+        response.headers['Content-Type'] || ''
+      end
+
+      def is_atom?
+        content_type =~ /#{Regexp.escape OData4::Service::MIME_TYPES[:atom]}/
+      end
+
+      def is_json?
+        content_type =~ /#{Regexp.escape OData4::Service::MIME_TYPES[:json]}/
+      end
+
+      def is_plain?
+        content_type =~ /#{Regexp.escape OData4::Service::MIME_TYPES[:plain]}/
+      end
+
+      def is_xml?
+        content_type =~ /#{Regexp.escape OData4::Service::MIME_TYPES[:xml]}/
+      end
+
+      # Whether the response contained any entities.
+      # @return [Boolean]
+      def empty?
+        @empty ||= find_entities.empty?
+      end
+
+      # Whether the response failed due to a timeout
+      def timed_out?
+        response.timed_out?
+      end
+
+      # Iterates over all entities in the response, using
+      # automatic paging if necessary.
+      # Provided for Enumerable functionality.
+      # @param block [block] a block to evaluate
+      # @return [OData4::Entity] each entity in turn for the query result
+      def each(&block)
+        unless empty?
+          process_results(&block)
+          unless next_page.nil?
+            # ensure request gets executed with the same options
+            query.execute(URI.decode next_page_url).each(&block)
+          end
+        end
+      end
+
+      # Returns the response body.
+      def body
+        response.body
+      end
+
+      # Validates the response. Throws an exception with
+      # an appropriate message if a 4xx or 5xx status code
+      # occured.
+      #
+      # @return [self]
+      def validate!
+        raise "Bad Request. #{error_message(response)}" if response.code == 400
+        raise "Access Denied" if response.code == 401
+        raise "Forbidden" if response.code == 403
+        raise "Not Found" if [0,404].include?(response.code)
+        raise "Method Not Allowed" if response.code == 405
+        raise "Not Acceptable" if response.code == 406
+        raise "Request Entity Too Large" if response.code == 413
+        raise "Internal Server Error" if response.code == 500
+        raise "Service Unavailable" if response.code == 503
+        self
+      end
+
+      private
+
+      def logger
+        service.logger
+      end
+
+      def check_content_type
+        logger.debug <<-EOS
+          [OData4: #{service.name}] Received response:
+            Headers: #{response.headers}
+            Body: #{response.body}
+        EOS
+        # Dynamically extend instance with methods for
+        # processing the current result type
+        if is_atom?
+          extend OData4::Service::Response::Atom
+        elsif is_json?
+          extend OData4::Service::Response::JSON
+        elsif is_xml?
+          extend OData4::Service::Response::XML
+        elsif is_plain?
+          extend OData4::Service::Response::Plain
+        elsif response.body.empty?
+          # Some services (*cough* Microsoft *cough*) return
+          # an empty response with no `Content-Type` header set.
+          # We catch that here and bypass content type detection.
+          @empty = true
+        else
+          raise ArgumentError, "Invalid response type '#{content_type}'"
+        end
+      end
+
+      def entity_options
+        if query
+          query.entity_set.entity_options
+        else
+          {
+            service_name: service.name,
+          }
+        end
+      end
+
+      def process_results(&block)
+        find_entities.each do |entity_data|
+          entity = parse_entity(entity_data, entity_options)
+          block_given? ? block.call(entity) : yield(entity)
+        end
+      end
+    end
+  end
+end