contentful 1.2.2 → 2.0.0

data/lib/contentful/error.rb

@@ -58,5 +58,5 @@ module Contentful
   class UnparsableJson < Error; end
 
   # Raised when response is not parsable as a Contentful::Resource
-  class UnparsableResource < Error; end
+  class UnparsableResource < StandardError; end
 end

data/lib/contentful/field.rb

@@ -1,17 +1,45 @@
-require_relative 'resource'
+require_relative 'location'
+require_relative 'coercions'
 
 module Contentful
   # A ContentType's field schema
   # See https://www.contentful.com/developers/documentation/content-management-api/#resources-content-types-fields
   class Field
-    include Contentful::Resource
+    # Coercions from Contentful Types to Ruby native types
+    KNOWN_TYPES = {
+      'String'   => StringCoercion,
+      'Text'     => TextCoercion,
+      'Symbol'   => SymbolCoercion,
+      'Integer'  => IntegerCoercion,
+      'Float'    => FloatCoercion,
+      'Boolean'  => BooleanCoercion,
+      'Date'     => DateCoercion,
+      'Location' => LocationCoercion,
+      'Object'   => ObjectCoercion,
+      'Array'    => ArrayCoercion,
+      'Link'     => LinkCoercion
+    }
 
-    property :id, :string
-    property :name, :string
-    property :type, :string
-    property :linkType, :string
-    property :items, Field
-    property :required, :boolean
-    property :localized, :boolean
+    attr_reader :raw, :id, :name, :type, :link_type, :items, :required, :localized
+
+    def initialize(json)
+      @raw = json
+      @id = json.fetch('id', nil)
+      @name = json.fetch('name', nil)
+      @type = json.fetch('type', nil)
+      @link_type = json.fetch('linkType', nil)
+      @items = json.key?('items') ? Field.new(json.fetch('items', {})) : nil
+      @required = json.fetch('required', false)
+      @localized = json.fetch('localized', false)
+    end
+
+    # Coerces value to proper type
+    def coerce(value)
+      return value if type.nil?
+
+      options = {}
+      options[:coercion_class] = KNOWN_TYPES[items.type] unless items.nil?
+      KNOWN_TYPES[type].new(value, options).coerce
+    end
   end
 end

data/lib/contentful/fields_resource.rb

@@ -0,0 +1,115 @@
+require_relative 'support'
+require_relative 'base_resource'
+
+module Contentful
+  # Base definition of a Contentful Resource containing Field properties
+  class FieldsResource < BaseResource
+    def initialize(item, _configuration, localized = false, includes = [], *)
+      super
+
+      @fields = hydrate_fields(localized, includes)
+
+      define_fields_methods!
+    end
+
+    # Returns all fields of the asset
+    #
+    # @return [Hash] fields for Resource on selected locale
+    def fields(wanted_locale = nil)
+      wanted_locale = internal_resource_locale if wanted_locale.nil?
+      @fields.fetch(wanted_locale.to_s, {})
+    end
+
+    # Returns all fields of the asset with locales nested by field
+    #
+    # @return [Hash] fields for Resource grouped by field name
+    def fields_with_locales
+      remapped_fields = {}
+      locales.each do |locale|
+        fields(locale).each do |name, value|
+          remapped_fields[name] ||= {}
+          remapped_fields[name][locale.to_sym] = value
+        end
+      end
+
+      remapped_fields
+    end
+
+    # Provides a list of the available locales for a Resource
+    def locales
+      @fields.keys
+    end
+
+    # @private
+    def marshal_dump
+      raw_with_links
+    end
+
+    # @private
+    def marshal_load(raw_object)
+      super(raw_object)
+      localized = raw_object.fetch('fields', {}).all? { |_, v| v.is_a?(Hash) }
+      @fields = hydrate_fields(localized, [])
+      define_fields_methods!
+    end
+
+    # @private
+    def raw_with_links
+      links = fields.keys.select { |property| known_link?(property) }
+      processed_raw = raw.clone
+      raw['fields'].each do |k, v|
+        processed_raw['fields'][k] = links.include?(Support.snakify(k).to_sym) ? send(Support.snakify(k)) : v
+      end
+
+      processed_raw
+    end
+
+    private
+
+    def define_fields_methods!
+      fields.each do |k, v|
+        define_singleton_method k do
+          v
+        end
+      end
+    end
+
+    def hydrate_fields(localized, includes)
+      return {} unless raw.key?('fields')
+
+      locale = internal_resource_locale
+      result = { locale => {} }
+
+      if localized
+        raw['fields'].each do |name, locales|
+          locales.each do |loc, value|
+            result[loc] ||= {}
+            result[loc][Support.snakify(name).to_sym] = coerce(
+              Support.snakify(name),
+              value,
+              localized,
+              includes
+            )
+          end
+        end
+      else
+        raw['fields'].each do |name, value|
+          result[locale][Support.snakify(name).to_sym] = coerce(
+            Support.snakify(name),
+            value,
+            localized,
+            includes
+          )
+        end
+      end
+
+      result
+    end
+
+    protected
+
+    def coerce(_field_id, value, _localized, _includes)
+      value
+    end
+  end
+end

data/lib/contentful/file.rb

@@ -1,13 +1,12 @@
-require_relative 'resource'
-
 module Contentful
   # An Assets's file info
   class File
-    include Contentful::Resource
-
-    property :fileName, :string
-    property :contentType, :string
-    property :details
-    property :url, :string
+    attr_reader :file_name, :content_type, :details, :url
+    def initialize(json)
+      @file_name = json.fetch('fileName', nil)
+      @content_type = json.fetch('contentType', nil)
+      @details = json.fetch('details', nil)
+      @url = json.fetch('url', nil)
+    end
   end
 end

data/lib/contentful/link.rb

@@ -1,15 +1,12 @@
-require_relative 'resource'
+require_relative 'base_resource'
 
 module Contentful
   # Resource Class for Links
   # https://www.contentful.com/developers/documentation/content-delivery-api/#links
-  class Link
-    include Contentful::Resource
-    include Contentful::Resource::SystemProperties
-
+  class Link < BaseResource
     # Queries contentful for the Resource the Link is refering to
     # Takes an optional query hash
-    def resolve(query = {})
+    def resolve(client, query = {})
       id_and_query = [(id unless link_type == 'Space')].compact + [query]
       client.public_send(
         Contentful::Support.snakify(link_type).to_sym,

data/lib/contentful/locale.rb

@@ -1,13 +1,13 @@
-require_relative 'resource'
-
 module Contentful
   # A Locale definition as included in Space
   # Read more about Localization at https://www.contentful.com/developers/documentation/content-delivery-api/#i18n
   class Locale
-    include Contentful::Resource
+    attr_reader :code, :name, :default
 
-    property :code, :string
-    property :name, :string
-    property :default, :boolean
+    def initialize(json)
+      @code = json.fetch('code', nil)
+      @name = json.fetch('name', nil)
+      @default = json.fetch('default', false)
+    end
   end
 end

data/lib/contentful/location.rb

@@ -1,12 +1,14 @@
-require_relative 'resource'
-
 module Contentful
   # Location Field Type
   # You can directly query for them: https://www.contentful.com/developers/documentation/content-delivery-api/#search-filter-geo
   class Location
-    include Contentful::Resource
+    attr_reader :lat, :lon
+    alias latitude lat
+    alias longitude lon
 
-    property :lat, :float
-    property :lon, :float
+    def initialize(json)
+      @lat = json.fetch('lat', nil)
+      @lon = json.fetch('lon', nil)
+    end
   end
 end

data/lib/contentful/resource_builder.rb

@@ -1,9 +1,7 @@
 require_relative 'error'
-require_relative 'resource'
 require_relative 'space'
 require_relative 'content_type'
 require_relative 'entry'
-require_relative 'dynamic_entry'
 require_relative 'asset'
 require_relative 'array'
 require_relative 'link'
@@ -19,9 +17,9 @@ module Contentful
     DEFAULT_RESOURCE_MAPPING = {
       'Space' => Space,
       'ContentType' => ContentType,
-      'Entry' => :find_entry_class,
+      'Entry' => Entry,
       'Asset' => Asset,
-      'Array' => :array_or_sync_page,
+      'Array' => Array,
       'Link' => Link,
       'DeletedEntry' => DeletedEntry,
       'DeletedAsset' => DeletedAsset
@@ -30,271 +28,119 @@ module Contentful
     # @see _ README for more information on Entry Mapping
     DEFAULT_ENTRY_MAPPING = {}
 
-    attr_reader :client, :response, :resource_mapping, :entry_mapping, :resource
+    attr_reader :json, :default_locale, :endpoint, :depth, :localized, :resource_mapping, :entry_mapping, :resource
 
-    def initialize(client,
-                   response,
-                   resource_mapping = {},
-                   entry_mapping = {},
-                   default_locale = Contentful::Client::DEFAULT_CONFIGURATION[:default_locale])
-      @response = response
-      @client = client
-      @included_resources = {}
-      @known_resources = Hash.new { |h, k| h[k] = {} }
-      @default_locale = default_locale
-      @resource_mapping = default_resource_mapping.merge(resource_mapping)
-      @entry_mapping = default_entry_mapping.merge(entry_mapping)
+    def initialize(json, configuration = {}, localized = false, depth = 0, endpoint = nil)
+      @json = json
+      @default_locale = configuration.fetch(:default_locale, ::Contentful::Client::DEFAULT_CONFIGURATION[:default_locale])
+      @resource_mapping = default_resource_mapping.merge(configuration.fetch(:resource_mapping, {}))
+      @entry_mapping = default_entry_mapping.merge(configuration.fetch(:entry_mapping, {}))
+      @includes_for_single = configuration.fetch(:includes_for_single, [])
+      @localized = localized
+      @depth = depth
+      @endpoint = endpoint
+      @configuration = configuration
     end
 
     # Starts the parsing process.
+    #
     # @return [Contentful::Resource, Contentful::Error]
     def run
-      if response.status == :ok
-        create_all_resources!
-      else
-        response.object
-      end
-    end
-
-    # PARSING MECHANISM
-    # - raise error if response not valid
-    # - look for included objects and parse them to resources
-    # - parse main object to resource
-    # - replace links in included resources with known resources
-    # - replace links in main resource with known resources
-    # - return main resource
-    def create_all_resources!
-      create_included_resources! response.object['includes']
-      @resource = create_resource(response.object)
-
-      unless @included_resources.empty?
-        replace_links_in_included_resources_with_known_resources
-      end
-
-      replace_links_with_known_resources @resource
-
-      @resource
+      return build_array if array?
+      build_single
     rescue UnparsableResource => error
       error
     end
 
-    # Creates a single resource from the response object
-    def create_resource(object)
-      res_class = detect_resource_class(object)
-      res = res_class.new(object, response.request, client, @default_locale)
-
-      add_to_known_resources res
-      replace_children res, object
-      replace_child_array res.items if res.array?
-
-      res
-    end
-
-    # Checks in a custom class for an entry was defined in entry_mapping
-    def find_entry_class(object)
-      entry_mapping[content_type_id_for_entry(object)] || try_dynamic_entry(object)
-    end
-
-    # Automatically converts Entry to DynamicEntry if in cache
-    def try_dynamic_entry(object)
-      get_dynamic_entry(object) || Entry
-    end
-
-    # Finds the proper DynamicEntry class for an entry
-    def get_dynamic_entry(object)
-      content_id = content_type_id_for_entry(object)
-      client.dynamic_entry_cache[content_id.to_sym] if content_id
-    end
-
-    # Returns the id of the related ContentType, if there is one
-    def content_type_id_for_entry(object)
-      object['sys'] &&
-        object['sys']['contentType'] &&
-        object['sys']['contentType']['sys'] &&
-        object['sys']['contentType']['sys']['id']
-    end
-
-    # Detects if a resource is an Contentful::Array or a SyncPage
-    def array_or_sync_page(object)
-      if object['nextPageUrl'] || object['nextSyncUrl']
-        SyncPage
-      else
-        Array
-      end
-    end
-
-    # Uses the resource mapping to find the proper Resource class to initialize
-    # for this Response object type
-    #
-    # The mapping value can be a
-    # - Class
-    # - Proc: Will be called, expected to return the proper Class
-    # - Symbol: Will be called as method of the ResourceBuilder itself
-    def detect_resource_class(object)
-      type = object['sys'] && object['sys']['type']
-
-      case res_class = resource_mapping[type]
-      when Symbol
-        public_send(res_class, object)
-      when Proc
-        res_class[object]
-      when nil
-        fail UnparsableResource, response
-      else
-        res_class
-      end
-    end
-
-    # The default mapping for #detect_resource_class
-    def default_resource_mapping
-      DEFAULT_RESOURCE_MAPPING.dup
-    end
-
-    # The default entry mapping
-    def default_entry_mapping
-      DEFAULT_ENTRY_MAPPING.dup
-    end
-
     private
 
-    def detect_child_objects(object)
-      if object.is_a? Hash
-        object.select { |_, v| v.is_a?(Hash) && v.key?('sys') }
-      else
-        {}
+    def build_array
+      includes = fetch_includes
+      result = json['items'].map do |item|
+        build_item(item, includes)
       end
+      array_class = fetch_array_class
+      array_class.new(json.dup.merge('items' => result), default_locale, endpoint)
     end
 
-    def detect_child_arrays(object)
-      if object.is_a? Hash
-        object.select do |_, v|
-          v.is_a?(::Array) &&
-            v.first &&
-            v.first.is_a?(Hash) &&
-            v.first.key?('sys')
-        end
-      else
-        {}
-      end
+    def build_single
+      includes = @includes_for_single
+      build_item(json, includes)
     end
 
-    def add_to_known_resources(res)
-      @known_resources[res.type][res.id] = res if res.sys && res.id && res.type != 'Link'
-    end
+    def build_item(item, includes = [])
+      buildables = %w(Entry Asset ContentType Space DeletedEntry DeletedAsset)
+      item_type = buildables.detect { |b| b.to_s == item['sys']['type'] }
+      fail UnparsableResource, 'Item type is not known, could not parse' if item_type.nil?
+      item_class = resource_class(item)
 
-    def localized_entry?(object, property_name, potential_objects)
-      object['sys']['type'] == 'Entry' &&
-        property_name == 'fields' &&
-        potential_objects.is_a?(::Hash) &&
-        potential_objects.any? { |_, p| Support.localized?(p) }
+      item_class.new(item, @configuration, localized?, includes, depth)
     end
 
-    def replace_children(res, object)
-      object.each do |name, potential_objects|
-        replace_localized_children(res, object, name, potential_objects)
-
-        detect_child_objects(potential_objects).each do |child_name, child_object|
-          res.public_send(name)[child_name.to_sym] = create_resource(child_object)
-        end
-        next if name == 'includes'
-        detect_child_arrays(potential_objects).each do |child_name, _child_array|
-          replace_child_array res.public_send(name)[child_name.to_sym]
+    def fetch_includes
+      includes = json['items'].dup
+      %w(Entry Asset).each do |type|
+        if json.fetch('includes', {}).key?(type)
+          includes.concat(json['includes'].fetch(type, []))
         end
       end
+      includes
     end
 
-    def replace_localized_children(result, object, property_name, potential_objects)
-      return unless localized_entry?(object, property_name, potential_objects)
-
-      localized_objects = potential_objects.select { |_, p| Support.localized?(p) }
-      localized_objects.each do |field_name, localized_object|
-        detect_child_objects(localized_object).each do |locale, child_object|
-          result.public_send(property_name, locale)[field_name.to_sym] = create_resource(child_object)
-        end
-        detect_child_arrays(localized_object).each do |locale, _child_array|
-          replace_child_array result.public_send(property_name, locale)[field_name.to_sym]
-        end
-      end
+    def resource_class(item)
+      return fetch_custom_resource_class(item) if %w(Entry Asset).include?(item['sys']['type'])
+      resource_mapping[item['sys']['type']]
     end
 
-    def replace_child_array(child_array)
-      child_array.map! { |resource_object| create_resource(resource_object) }
-    end
+    def fetch_custom_resource_class(item)
+      case item['sys']['type']
+      when 'Entry'
+        resource_class = entry_mapping[item['sys']['contentType']['sys']['id']]
+        return resource_class unless resource_class.nil?
 
-    def create_included_resources!(included_objects)
-      if included_objects
-        included_objects.each do |type, objects|
-          @included_resources[type] = Hash[
-            objects.map do |object|
-              res = create_resource(object)
-              [res.id, res]
-            end
-          ]
-        end
+        return fetch_custom_resource_mapping(item, 'Entry', Entry)
+      when 'Asset'
+        return fetch_custom_resource_mapping(item, 'Asset', Asset)
       end
     end
 
-    def replace_links_with_known_resources(res, seen_resource_ids = [])
-      seen_resource_ids << res.id
-
-      property_containers = [:properties, :sys].map do |property_container_name|
-        res.public_send(property_container_name)
-      end
-
-      if res.is_a?(Entry)
-        res.locales.each do |locale|
-          property_containers << res.fields(locale)
-        end
-      else
-        property_containers << res.fields
-      end
+    def fetch_custom_resource_mapping(item, type, default_class)
+      resources = resource_mapping[type]
+      return default_class if resources.nil?
 
-      property_containers.compact!
+      return resources if resources.is_a?(Class)
+      return resources[item] if resources.respond_to?(:call)
 
-      property_containers.each do |property_container|
-        replace_links_in_properties(property_container, seen_resource_ids)
-      end
+      default_class
+    end
 
-      replace_links_in_array res.items, seen_resource_ids if res.array?
+    def fetch_array_class
+      return SyncPage if sync?
+      ::Contentful::Array
     end
 
-    def replace_links_in_properties(property_container, seen_resource_ids)
-      property_container.each do |property_name, property_value|
-        if property_value.is_a? ::Array
-          replace_links_in_array property_value, seen_resource_ids
-        else
-          replace_link_or_check_recursively property_value, property_container, property_name, seen_resource_ids
-        end
-      end
+    def localized?
+      return true if @localized
+      return true if array? && sync?
+      false
     end
 
-    def replace_links_in_array(property_container, seen_resource_ids)
-      property_container.each.with_index do |child_property, property_index|
-        replace_link_or_check_recursively child_property, property_container, property_index, seen_resource_ids
-      end
+    def array?
+      json.fetch('sys', {}).fetch('type', '') == 'Array'
     end
 
-    def replace_link_or_check_recursively(property_value, property_container, property_name, seen_resource_ids)
-      if property_value.is_a? Link
-        maybe_replace_link(property_value, property_container, property_name)
-      elsif property_value.is_a?(Resource) && property_value.sys && !seen_resource_ids.include?(property_value.id)
-        replace_links_with_known_resources(property_value, seen_resource_ids)
-      end
+    def sync?
+      json.fetch('nextSyncUrl', nil) || json.fetch('nextPageUrl', nil)
     end
 
-    def maybe_replace_link(link, parent, key)
-      if @known_resources[link.link_type] &&
-         @known_resources[link.link_type].key?(link.id)
-        parent[key] = @known_resources[link.link_type][link.id]
-      end
+    # The default mapping for #detect_resource_class
+    def default_resource_mapping
+      DEFAULT_RESOURCE_MAPPING.dup
     end
 
-    def replace_links_in_included_resources_with_known_resources
-      @included_resources.each do |_, for_type|
-        for_type.each do |_, res|
-          replace_links_with_known_resources(res)
-        end
-      end
+    # The default entry mapping
+    def default_entry_mapping
+      DEFAULT_ENTRY_MAPPING.dup
     end
   end
 end