contentful-management 0.0.1.pre

data/lib/contentful/management/resource/array_like.rb

@@ -0,0 +1,37 @@
+# -*- encoding: utf-8 -*-
+module Contentful
+  module Management
+    module Resource
+      # Useful methods for array-like resources that can be included if an
+      # :items property exists
+      module ArrayLike
+        include Enumerable
+
+        # Returns true for array-like resources
+        def array?
+          true
+        end
+
+        # Delegates to items#each
+        def each_item(&block)
+          items.each(&block)
+        end
+
+        alias each each_item
+
+        # Delegates to items#empty?
+        def empty?
+          items.empty?
+        end
+
+        # Delegetes to items#size
+        def size
+          items.size
+        end
+
+        alias length size
+
+      end
+    end
+  end
+end

data/lib/contentful/management/resource/fields.rb

@@ -0,0 +1,69 @@
+# -*- encoding: utf-8 -*-
+require_relative '../file'
+
+module Contentful
+  module Management
+    module Resource
+      module Fields
+
+        def fields(wanted_locale = default_locale)
+          requested_locale = locale || wanted_locale
+          @fields[requested_locale] = {} unless @fields[requested_locale]
+          @fields[requested_locale]
+        end
+
+        def initialize(object = nil, *)
+          super
+          @fields = {}
+          extract_fields_from_object! object if object
+        end
+
+        def inspect(info = nil)
+          if fields.empty?
+            super(info)
+          else
+            super("#{ info } @fields=#{ fields.inspect }")
+          end
+        end
+
+        def self.included(base)
+          base.fields_coercions.keys.each { |name|
+            accessor_name = Contentful::Management::Support.snakify(name)
+            base.send :define_method, accessor_name do
+              fields[name.to_sym]
+            end
+            base.send :define_method, "#{ accessor_name }_with_locales" do
+              fields_for_query[name.to_sym]
+            end
+            base.send :define_method, "#{ accessor_name }=" do |value|
+              fields[name.to_sym] = value
+            end
+            base.send :define_method, "#{ accessor_name }_with_locales=" do |values|
+              values.each do |locale, value|
+                @fields[locale] = {} if @fields[locale].nil?
+                @fields[locale][name.to_sym] = value
+              end
+            end
+          }
+        end
+
+        private
+
+        def extract_fields_from_object!(object)
+          if nested_locale_fields? && !object['fields'].nil?
+            object['fields'].each do |field_name, nested_child_object|
+              nested_child_object.each do |object_locale, real_child_object|
+                @fields[object_locale] ||= {}
+                @fields[object_locale].merge! extract_from_object(
+                                                  { field_name => real_child_object }, :fields
+                                              )
+              end
+            end
+          else
+            @fields[locale || default_locale] = extract_from_object object['fields'], :fields
+          end
+        end
+      end
+    end
+  end
+end

data/lib/contentful/management/resource/refresher.rb

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+module Contentful
+  module Management
+    module Resource
+      # Adds the feature to have properties and system data reload for Resource.
+      module Refresher
+
+        def refresh_data(resource)
+          if resource.is_a? Error
+            resource
+          else
+            @properties = resource.instance_variable_get(:@properties)
+            @fields = resource.instance_variable_get(:@fields) if self.is_a?(Contentful::Management::Entry)
+            @sys = resource.instance_variable_get(:@sys)
+            self
+          end
+        end
+      end
+    end
+  end
+end

data/lib/contentful/management/resource/system_properties.rb

@@ -0,0 +1,56 @@
+# -*- encoding: utf-8 -*-
+module Contentful
+  module Management
+    module Resource
+      # Adds the feature to have system properties to a Resource.
+      module SystemProperties
+        SYS_COERCIONS = {
+            type: :string,
+            id: :string,
+            space: nil,
+            contentType: nil,
+            linkType: :string,
+            revision: :integer,
+            createdAt: :date,
+            updatedAt: :date,
+            locale: :string
+        }
+        attr_reader :sys
+
+        def initialize(object = { 'sys' => nil }, *)
+          super
+          object ||= { 'sys' => nil }
+          @sys = extract_from_object object['sys'], :sys
+        end
+
+        def inspect(info = nil)
+          if sys.empty?
+            super(info)
+          else
+            super("#{ info } @sys=#{ sys.inspect }")
+          end
+        end
+
+        module ClassMethods
+          def sys_coercions
+            SYS_COERCIONS
+          end
+        end
+
+        def self.included(base)
+          base.extend(ClassMethods)
+
+          base.sys_coercions.keys.each { |name|
+            accessor_name = Contentful::Management::Support.snakify(name)
+            base.send :define_method, accessor_name do
+              sys[name.to_sym]
+            end
+            base.send :define_method, "#{ accessor_name }=" do |value|
+              sys[name.to_sym] = value
+            end
+          }
+        end
+      end
+    end
+  end
+end

data/lib/contentful/management/resource_builder.rb

@@ -0,0 +1,269 @@
+# -*- encoding: utf-8 -*-
+require_relative 'error'
+require_relative 'resource'
+require_relative 'entry'
+require_relative 'dynamic_entry'
+require_relative 'array'
+require_relative 'link'
+require_relative 'space'
+require_relative 'content_type'
+require_relative 'asset'
+
+module Contentful
+  module Management
+    # Transforms a Contentful::Response into a Contentful::Resource or a Contentful::Error
+    # See example/resource_mapping.rb for avanced usage
+    class ResourceBuilder
+      DEFAULT_RESOURCE_MAPPING = {
+          'Space' => Contentful::Management::Space,
+          'ContentType' => Contentful::Management::ContentType,
+          'Entry' => :find_entry_class,
+          'Asset' => Contentful::Management::Asset,
+          'Array' => :array_or_sync_page,
+          'Link' => Contentful::Management::Link
+      }
+      DEFAULT_ENTRY_MAPPING = {}
+
+      attr_reader :client, :response, :resource_mapping, :entry_mapping, :resource
+
+
+      def initialize(client, response, resource_mapping = {}, entry_mapping = {})
+        @response = response
+        @client = client
+        @included_resources = {}
+        @known_resources = Hash.new { |h, k| h[k] = {} }
+        @nested_locales = true
+        @default_locale = (Contentful::Management::Client.shared_instance.configuration || Contentful::Client::DEFAULT_CONFIGURATION)[:default_locale]
+        @resource_mapping = default_resource_mapping.merge(resource_mapping)
+        @entry_mapping = default_entry_mapping.merge(entry_mapping)
+      end
+
+      # Starts the parsing process.
+      # Either returns an Error, or the parsed Resource
+      def run
+        case response.status
+          when :contentful_error
+            Error[response.raw.status].new(response)
+          when :unparsable_json
+            UnparsableJson.new(response)
+          when :not_contentful
+            Error.new(response)
+          else
+            begin
+              create_all_resources!
+            rescue UnparsableResource => error
+              error
+            end
+        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
+          replace_links_with_known_resources @resource
+        end
+
+        @resource
+      end
+
+      # Creates a single resource from the response object
+      def create_resource(object)
+        res_class = detect_resource_class(object)
+        @nested_locales ||= res_class.nested_locale_fields?
+        res = res_class.new(object, response.request, client, @nested_locales, @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) || Contentful::Management::Entry
+      end
+
+      # Finds the proper DynamicEntry class for an entry
+      def get_dynamic_entry(object)
+        if content_id = content_type_id_for_entry(object)
+          client.dynamic_entry_cache[content_id.to_sym]
+        end
+      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
+            raise UnparsableResource.new(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
+          {}
+        end
+      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
+      end
+
+      def add_to_known_resources(res)
+        @known_resources[res.type][res.id] = res if res.sys && res.id && res.type != 'Link'
+      end
+
+      def replace_children(res, object)
+        object.each do |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]
+          end
+        end
+      end
+
+      def replace_child_array(child_array)
+        child_array.map! { |resource_object| create_resource(resource_object) }
+      end
+
+      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
+        end
+      end
+
+      def replace_links_with_known_resources(res, seen_resource_ids = [])
+        seen_resource_ids << res.id
+
+        [:properties, :sys, :fields].map do |property_container_name|
+          res.public_send(property_container_name)
+        end.compact.each do |property_container|
+          replace_links_in_properties(property_container, seen_resource_ids)
+        end
+
+        if res.array?
+          replace_links_in_array res.items, seen_resource_ids
+        end
+      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
+      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
+      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
+      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
+      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
+      end
+    end
+  end
+end