contentful 1.2.2 → 2.0.0

data/lib/contentful/client.rb

@@ -2,6 +2,7 @@ require_relative 'request'
 require_relative 'response'
 require_relative 'resource_builder'
 require_relative 'sync'
+require_relative 'content_type_cache'
 
 require 'http'
 require 'logger'
@@ -32,12 +33,13 @@ module Contentful
       proxy_password: nil,
       proxy_port: nil,
       max_rate_limit_retries: 1,
-      max_rate_limit_wait: 60
+      max_rate_limit_wait: 60,
+      max_include_resolution_depth: 20
     }
     # Rate Limit Reset Header Key
     RATE_LIMIT_RESET_HEADER_KEY = 'x-contentful-ratelimit-reset'
 
-    attr_reader :configuration, :dynamic_entry_cache, :logger, :proxy
+    attr_reader :configuration, :logger, :proxy
 
     # Wraps the actual HTTP request via proxy
     # @private
@@ -62,6 +64,7 @@ module Contentful
     # @option given_configuration [Number] :proxy_port
     # @option given_configuration [Number] :max_rate_limit_retries
     # @option given_configuration [Number] :max_rate_limit_wait
+    # @option given_configuration [Number] :max_include_resolution_depth
     # @option given_configuration [Boolean] :gzip_encoded
     # @option given_configuration [Boolean] :raw_mode
     # @option given_configuration [false, ::Logger] :logger
@@ -76,11 +79,7 @@ module Contentful
       validate_configuration!
       setup_logger
 
-      if configuration[:dynamic_entries] == :auto
-        update_dynamic_entry_cache!
-      else
-        @dynamic_entry_cache = {}
-      end
+      update_dynamic_entry_cache! if configuration[:dynamic_entries] == :auto
     end
 
     # @private
@@ -140,7 +139,13 @@ module Contentful
     #
     # @return [Contentful::Entry]
     def entry(id, query = {})
-      Request.new(self, '/entries', query, id).get
+      normalize_select!(query)
+      query['sys.id'] = id
+      entries = Request.new(self, '/entries', query).get
+
+      return entries if configuration[:raw_mode]
+
+      entries.first
     end
 
     # Gets a collection of entries
@@ -205,22 +210,23 @@ module Contentful
     # @private
     def get(request, build_resource = true)
       retries_left = configuration[:max_rate_limit_retries]
+      result = nil
       begin
         response = run_request(request)
 
         return response if !build_resource || configuration[:raw_mode]
 
-        result = do_build_resource(response)
+        return fail_response(response) if response.status != :ok
 
-        fail result if result.is_a?(Error) && configuration[:raise_errors]
+        result = do_build_resource(response)
+      rescue UnparsableResource => error
+        raise error if configuration[:raise_errors]
+        return error
       rescue Contentful::RateLimitExceeded => rate_limit_error
         reset_time = rate_limit_error.response.raw[RATE_LIMIT_RESET_HEADER_KEY].to_i
         if should_retry(retries_left, reset_time, configuration[:max_rate_limit_wait])
           retries_left -= 1
-          retry_message = 'Contentful API Rate Limit Hit! '
-          retry_message += "Retrying - Retries left: #{retries_left}"
-          retry_message += "- Time until reset (seconds): #{reset_time}"
-          logger.info(retry_message) if logger
+          logger.info(retry_message(retries_left, reset_time)) if logger
           sleep(reset_time * Random.new.rand(1.0..1.2))
           retry
         end
@@ -231,6 +237,20 @@ module Contentful
       result
     end
 
+    # @private
+    def retry_message(retries_left, reset_time)
+      message = 'Contentful API Rate Limit Hit! '
+      message += "Retrying - Retries left: #{retries_left}"
+      message += "- Time until reset (seconds): #{reset_time}"
+      message
+    end
+
+    # @private
+    def fail_response(response)
+      fail response.object if configuration[:raise_errors]
+      response.object
+    end
+
     # @private
     def should_retry(retries_left, reset_time, max_wait)
       retries_left > 0 && max_wait > reset_time
@@ -256,11 +276,11 @@ module Contentful
     def do_build_resource(response)
       logger.debug(response: response) if logger
       configuration[:resource_builder].new(
-        self,
-        response,
-        configuration[:resource_mapping],
-        configuration[:entry_mapping],
-        configuration[:default_locale]
+        response.object,
+        configuration,
+        (response.request.query || {}).fetch(:locale, nil) == '*',
+        0,
+        response.request.endpoint
       ).run
     end
 
@@ -268,21 +288,16 @@ module Contentful
     # See README for details.
     # @private
     def update_dynamic_entry_cache!
-      @dynamic_entry_cache = Hash[
-        content_types(limit: 1000).map do |ct|
-          [
-            ct.id.to_sym,
-            DynamicEntry.create(ct)
-          ]
-        end
-      ]
+      content_types(limit: 1000).map do |ct|
+        ContentTypeCache.cache_set(configuration[:space], ct.id, ct)
+      end
     end
 
     # Use this method to manually register a dynamic entry
     # See examples/dynamic_entries.rb
     # @private
     def register_dynamic_entry(key, klass)
-      @dynamic_entry_cache[key.to_sym] = klass
+      ContentTypeCache.cache_set(configuration[:space], key, klass)
     end
 
     # Create a new synchronisation object
@@ -317,19 +332,13 @@ module Contentful
 
     def validate_configuration!
       fail ArgumentError, 'You will need to initialize a client with a :space' if configuration[:space].empty?
-
       fail ArgumentError, 'You will need to initialize a client with an :access_token' if configuration[:access_token].empty?
-
       fail ArgumentError, 'The client configuration needs to contain an :api_url' if configuration[:api_url].empty?
-
       fail ArgumentError, 'The client configuration needs to contain a :default_locale' if configuration[:default_locale].empty?
-
       fail ArgumentError, 'The :api_version must be a positive number or nil' unless configuration[:api_version].to_i >= 0
-
       fail ArgumentError, 'The authentication mechanism must be :header or :query_string' unless [:header, :query_string].include?(
         configuration[:authentication_mechanism]
       )
-
       fail ArgumentError, 'The :dynamic_entries mode must be :auto or :manual' unless [:auto, :manual].include?(
         configuration[:dynamic_entries]
       )

data/lib/contentful/coercions.rb

@@ -0,0 +1,116 @@
+require_relative 'location'
+
+module Contentful
+  # Basic Coercion
+  class BaseCoercion
+    attr_reader :value, :options
+    def initialize(value, options = {})
+      @value = value
+      @options = options
+    end
+
+    # Coerces value
+    def coerce
+      value
+    end
+  end
+
+  # Coercion for String Types
+  class StringCoercion < BaseCoercion
+    # Coerces value to String
+    def coerce
+      value.to_s
+    end
+  end
+
+  # Coercion for Text Types
+  class TextCoercion < StringCoercion; end
+
+  # Coercion for Symbol Types
+  class SymbolCoercion < StringCoercion; end
+
+  # Coercion for Integer Types
+  class IntegerCoercion < BaseCoercion
+    # Coerces value to Integer
+    def coerce
+      value.to_i
+    end
+  end
+
+  # Coercion for Float Types
+  class FloatCoercion < BaseCoercion
+    # Coerces value to Float
+    def coerce
+      value.to_f
+    end
+  end
+
+  # Coercion for Boolean Types
+  class BooleanCoercion < BaseCoercion
+    # Coerces value to Boolean
+    def coerce
+      # rubocop:disable Style/DoubleNegation
+      !!value
+      # rubocop:enable Style/DoubleNegation
+    end
+  end
+
+  # Coercion for Date Types
+  class DateCoercion < BaseCoercion
+    # Coerces value to DateTime
+    def coerce
+      DateTime.parse(value)
+    end
+  end
+
+  # Coercion for Location Types
+  class LocationCoercion < BaseCoercion
+    # Coerces value to Location
+    def coerce
+      Location.new(value)
+    end
+  end
+
+  # Coercion for Object Types
+  class ObjectCoercion < BaseCoercion
+    # Coerces value to hash, symbolizing each key
+    def coerce
+      symbolize_recursive(value)
+    end
+
+    private
+
+    def symbolize_recursive(hash)
+      {}.tap do |h|
+        hash.each { |key, value| h[key.to_sym] = map_value(value) }
+      end
+    end
+
+    def map_value(thing)
+      case thing
+      when Hash
+        symbolize_recursive(thing)
+      when Array
+        thing.map { |v| map_value(v) }
+      else
+        thing
+      end
+    end
+  end
+
+  # Coercion for Link Types
+  # Nothing should be done here as include resolution is handled within
+  # entries due to depth handling (explained within Entry).
+  # Only present as a placeholder for proper resolution within ContentType.
+  class LinkCoercion < BaseCoercion; end
+
+  # Coercion for Array Types
+  class ArrayCoercion < BaseCoercion
+    # Coerces value for each element
+    def coerce
+      value.map do |e|
+        options[:coercion_class].new(e).coerce
+      end
+    end
+  end
+end

data/lib/contentful/content_type.rb

@@ -1,16 +1,31 @@
-require_relative 'resource'
+require_relative 'base_resource'
 require_relative 'field'
+require_relative 'support'
 
 module Contentful
   # Resource Class for Content Types
   # https://www.contentful.com/developers/documentation/content-delivery-api/#content-types
-  class ContentType
-    include Contentful::Resource
-    include Contentful::Resource::SystemProperties
+  class ContentType < BaseResource
+    attr_reader :name, :description, :fields, :display_field
 
-    property :name, :string
-    property :description, :string
-    property :fields, Field
-    property :displayField, :string
+    def initialize(item, *)
+      super
+
+      @name = item.fetch('name', nil)
+      @description = item.fetch('description', nil)
+      @fields = item.fetch('fields', []).map { |field| Field.new(field) }
+      @display_field = item.fetch('displayField', nil)
+    end
+
+    # Field definition for field
+    def field_for(field_id)
+      fields.detect { |f| Support.snakify(f.id) == Support.snakify(field_id) }
+    end
+
+    protected
+
+    def repr_name
+      "#{super}[#{name}]"
+    end
   end
 end

data/lib/contentful/content_type_cache.rb

@@ -0,0 +1,26 @@
+module Contentful
+  # Cache for Content Types
+  class ContentTypeCache
+    @cache = {}
+
+    class << self
+      attr_reader :cache
+    end
+
+    # Clears the Content Type Cache
+    def self.clear!
+      @cache = {}
+    end
+
+    # Gets a Content Type from the Cache
+    def self.cache_get(space_id, content_type_id)
+      @cache.fetch(space_id, {}).fetch(content_type_id.to_sym, nil)
+    end
+
+    # Sets a Content Type in the Cache
+    def self.cache_set(space_id, content_type_id, klass)
+      @cache[space_id] ||= {}
+      @cache[space_id][content_type_id.to_sym] = klass
+    end
+  end
+end

data/lib/contentful/deleted_asset.rb

@@ -1,10 +1,7 @@
-require_relative 'resource'
+require_relative 'base_resource'
 
 module Contentful
   # Resource class for deleted entries
   # https://www.contentful.com/developers/documentation/content-delivery-api/http/#sync-item-types
-  class DeletedAsset
-    include Contentful::Resource
-    include Contentful::Resource::SystemProperties
-  end
+  class DeletedAsset < BaseResource; end
 end

data/lib/contentful/deleted_entry.rb

@@ -1,10 +1,7 @@
-require_relative 'resource'
+require_relative 'base_resource'
 
 module Contentful
   # Resource class for deleted entries
   # https://www.contentful.com/developers/documentation/content-delivery-api/http/#sync-item-types
-  class DeletedEntry
-    include Contentful::Resource
-    include Contentful::Resource::SystemProperties
-  end
+  class DeletedEntry < BaseResource; end
 end

data/lib/contentful/entry.rb

@@ -1,38 +1,10 @@
-require_relative 'resource'
-require_relative 'resource/fields'
+require_relative 'fields_resource'
+require_relative 'content_type_cache'
 
 module Contentful
   # Resource class for Entry.
   # @see _ https://www.contentful.com/developers/documentation/content-delivery-api/#entries
-  class Entry
-    include Contentful::Resource
-    include Contentful::Resource::SystemProperties
-    include Contentful::Resource::Fields
-
-    # @private
-    def marshal_dump
-      raw_with_links
-    end
-
-    # @private
-    def marshal_load(raw_object)
-      @properties = extract_from_object(raw_object, :property, self.class.property_coercions.keys)
-      @sys = raw_object.key?('sys') ? extract_from_object(raw_object['sys'], :sys) : {}
-      extract_fields_from_object!(raw_object)
-      @raw = raw_object
-    end
-
-    # @private
-    def raw_with_links
-      links = properties.keys.select { |property| known_link?(property) }
-      processed_raw = raw.clone
-      raw['fields'].each do |k, v|
-        processed_raw['fields'][k] = links.include?(k.to_sym) ? send(snakify(k)) : v
-      end
-
-      processed_raw
-    end
-
+  class Entry < FieldsResource
     # Returns true for resources that are entries
     def entry?
       true
@@ -40,6 +12,54 @@ module Contentful
 
     private
 
+    def coerce(field_id, value, localized, includes)
+      return build_nested_resource(value, localized, includes) if Support.link?(value)
+      return coerce_link_array(value, localized, includes) if Support.link_array?(value)
+
+      content_type = ContentTypeCache.cache_get(sys[:space].id, sys[:content_type].id)
+
+      unless content_type.nil?
+        content_type_field = content_type.field_for(field_id)
+        return content_type_field.coerce(value) unless content_type_field.nil?
+      end
+
+      super(field_id, value, localized, includes)
+    end
+
+    def coerce_link_array(value, localized, includes)
+      items = []
+      value.each do |link|
+        items << build_nested_resource(link, localized, includes)
+      end
+
+      items
+    end
+
+    # Maximum include depth is 10 in the API, but we raise it to 20 (by default),
+    # in case one of the included items has a reference in an upper level,
+    # so we can keep the include chain for that object as well
+    # Any included object after the maximum include resolution depth will be just a Link
+    def build_nested_resource(value, localized, includes)
+      if @depth < @configuration.fetch(:max_include_resolution_depth, 20)
+        resource = Support.resource_for_link(value, includes)
+        return resolve_include(resource, localized, includes) unless resource.nil?
+      end
+
+      build_link(value)
+    end
+
+    def resolve_include(resource, localized, includes)
+      require_relative 'resource_builder'
+
+      ResourceBuilder.new(
+        resource,
+        @configuration.merge(includes_for_single: includes),
+        localized,
+        @depth + 1,
+        includes
+      ).run
+    end
+
     def known_link?(name)
       field_name = name.to_sym
       return true if known_contentful_object?(fields[field_name])
@@ -50,8 +70,10 @@ module Contentful
       (object.is_a?(Contentful::Entry) || object.is_a?(Contentful::Asset))
     end
 
-    def snakify(name)
-      Contentful::Support.snakify(name).to_sym
+    protected
+
+    def repr_name
+      "#{super}[#{sys[:content_type].id}]"
     end
   end
 end