contentful-management 0.0.1.pre

data/lib/contentful/management/error.rb

@@ -0,0 +1,62 @@
+# -*- encoding: utf-8 -*-
+module Contentful
+  module Management
+    # All errors raised by the contentful gem are either instances of Contentful::Error
+    # or inherit from Contentful::Error
+    class Error < StandardError
+      attr_reader :response
+
+      def initialize(response)
+        @response = response
+        super @response.error_message
+      end
+
+      # Shortcut for creating specialized error classes
+      # USAGE rescue Contentful::Error[404]
+      def self.[](error_status_code)
+        case error_status_code
+          when 404
+            NotFound
+          when 400
+            BadRequest
+          when 403
+            AccessDenied
+          when 401
+            Unauthorized
+          when 500
+            ServerError
+          else
+            Error
+        end
+      end
+    end
+
+    # 404
+    class NotFound < Error;
+    end
+
+    # 400
+    class BadRequest < Error;
+    end
+
+    # 403
+    class AccessDenied < Error;
+    end
+
+    # 401
+    class Unauthorized < Error;
+    end
+
+    # 500
+    class ServerError < Error;
+    end
+
+    # Raised when response is no valid json
+    class UnparsableJson < Error;
+    end
+
+    # Raised when response is not parsable as a Contentful::Resource
+    class UnparsableResource < Error;
+    end
+  end
+end

data/lib/contentful/management/field.rb

@@ -0,0 +1,34 @@
+# -*- encoding: utf-8 -*-
+require_relative 'resource'
+
+module Contentful
+  module Management
+    class Field
+      include Contentful::Management::Resource
+
+      property :id, :string
+      property :name, :string
+      property :type, :string
+      property :linkType, :string
+      property :items, Field
+      property :required, :boolean
+      property :localized, :boolean
+
+      def deep_merge!(field)
+        properties.merge!(field.properties.select { |name, _type| name != :items })
+        items.properties.merge!(field.items.properties) if (items.respond_to?(:properties) && field.items.respond_to?(:properties))
+      end
+
+      def properties_to_hash
+        properties.each_with_object({}) do |(key, value), results|
+          if key == :items
+            results[key] = value.properties_to_hash if type == 'Array' && value.is_a?(Field)
+          else
+            results[key] = value if !value.nil? && (value.respond_to?(:empty?) && !value.empty? || !value.respond_to?(:empty?) && value)
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/contentful/management/file.rb

@@ -0,0 +1,15 @@
+# -*- encoding: utf-8 -*-
+require_relative 'resource'
+
+module Contentful
+  module Management
+    class File
+      include Contentful::Management::Resource
+
+      property :fileName, :string
+      property :contentType, :string
+      property :details
+      property :url, :string
+    end
+  end
+end

data/lib/contentful/management/http_client.rb

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+module Contentful
+  module Management
+    module HTTPClient
+      def get_http(url, query, headers = {})
+        HTTP[headers].get(url, params: query)
+      end
+
+      def post_http(url, params, headers = {})
+        HTTP[headers].post(url, json: params)
+      end
+
+      def delete_http(url, params, headers = {})
+        HTTP[headers].delete(url, params: params)
+      end
+
+      def put_http(url, params, headers = {})
+        HTTP[headers].put(url, json: params)
+      end
+    end
+  end
+end

data/lib/contentful/management/link.rb

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

data/lib/contentful/management/locale.rb

@@ -0,0 +1,48 @@
+# -*- encoding: utf-8 -*-
+require_relative 'resource'
+
+module Contentful
+
+  module Management
+
+    class Locale
+      include Contentful::Management::Resource
+      include Contentful::Management::Resource::SystemProperties
+      include Contentful::Management::Resource::Refresher
+
+      property :code, :string
+      property :name, :string
+      property :contentManagementApi, :boolean
+      property :contentDeliveryApi, :boolean
+      property :publish, :boolean
+
+      def self.all(space_id = nil)
+        request = Request.new("/#{ space_id }/locales")
+        response = request.get
+        result = ResourceBuilder.new(self, response, { 'Locale' => Locale }, {})
+        result.run
+      end
+
+      def self.create(space_id, attributes)
+        request = Request.new("/#{ space_id }/locales", { 'name' => attributes.fetch(:name), 'code' => attributes.fetch(:code) })
+        response = request.post
+        result = ResourceBuilder.new(self, response, { 'Locale' => Locale }, {})
+        result.run
+      end
+
+      def self.find(space_id, locale_id)
+        request = Request.new("/#{ space_id }/locales/#{ locale_id }")
+        response = request.get
+        result = ResourceBuilder.new(self, response, { 'Locale' => Locale }, {})
+        result.run
+      end
+
+      def update(attributes)
+        request = Request.new("/#{ space.id }/locales/#{ id }", { 'name' => attributes.fetch(:name) }, id = nil, version: sys[:version])
+        response = request.put
+        result = ResourceBuilder.new(self, response, { 'Locale' => Locale }, {})
+        refresh_data(result.run)
+      end
+    end
+  end
+end

data/lib/contentful/management/location.rb

@@ -0,0 +1,15 @@
+# -*- encoding: utf-8 -*-
+require_relative 'resource'
+
+module Contentful
+  module Management
+    # 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::Management::Resource
+
+      property :lat, :float
+      property :lon, :float
+    end
+  end
+end

data/lib/contentful/management/request.rb

@@ -0,0 +1,82 @@
+# -*- encoding: utf-8 -*-
+module Contentful
+  module Management
+    # This object represents a request that is to be made. It gets initialized by the client
+    # with domain specific logic. The client later uses the Request's #url and #query methods
+    # to execute the HTTP request.
+    class Request
+      attr_reader :client, :type, :query, :id
+
+      def initialize(endpoint, query = {}, id = nil, header = {})
+        @client = Contentful::Management::Client.shared_instance
+        @client.version = header[:version] if  header[:version]
+        @client.organization_id = header[:organization_id] if  header[:organization_id]
+        @client.content_type_id = header[:content_type_id] if  header[:content_type_id]
+        @client.zero_length = query.empty?
+        @endpoint = endpoint
+        @absolute = true if @endpoint.start_with?('http')
+
+        @query = if query && !query.empty?
+                   normalize_query(query)
+                 end
+
+        if id
+          @type = :single
+          @id = URI.escape(id)
+        else
+          @type = :multi
+          @id = nil
+        end
+      end
+
+      # Returns the final URL, relative to a contentful space
+      def url
+        "#{@endpoint }#{ @type == :single ? "/#{ id }" : '' }"
+      end
+
+      # Delegates the actual HTTP work to the client
+      def get
+        client.get(self)
+      end
+
+      # Delegates the actual HTTP POST request to the client
+      def post
+        client.post(self)
+      end
+
+      # Delegates the actual HTTP PUT request to the client
+      def put
+        client.put(self)
+      end
+
+      def delete
+        client.delete(self)
+      end
+
+      # Returns true if endpoint is an absolute url
+      def absolute?
+        !!@absolute
+      end
+
+      # Returns a new Request object with the same data
+      def copy
+        Marshal.load(Marshal.dump(self))
+      end
+
+
+      private
+
+      def normalize_query(query)
+        Hash[
+            query.map do |key, value|
+              [
+                  key.to_sym,
+                  value
+              # TODO why there was this line? value.is_a?(::Array) ? value.join(',') : value
+              ]
+            end
+        ]
+      end
+    end
+  end
+end

data/lib/contentful/management/resource.rb

@@ -0,0 +1,166 @@
+# -*- encoding: utf-8 -*-
+require_relative 'resource/system_properties'
+require_relative 'resource/refresher'
+require 'date'
+
+module Contentful
+  module Management
+    # Include this module to declare a class to be a contentful resource.
+    # This is done by the default in the existing resource classes
+    #
+    # You can define your own classes that behave like contentful resources:
+    # See examples/custom_classes.rb to see how.
+    #
+    # Take a look at examples/resource_mapping.rb on how to register them to be returned
+    # by the client by default
+    module Resource
+      COERCIONS = {
+          string: ->(v) { v.to_s },
+          integer: ->(v) { v.to_i },
+          float: ->(v) { v.to_f },
+          boolean: ->(v) { !!v },
+          date: ->(v) { !v.nil? ? DateTime.parse(v) : nil }
+      }
+
+      attr_reader :properties, :request, :client, :default_locale
+
+      def initialize(object = nil, request = nil, client = nil, nested_locale_fields = false, default_locale = Contentful::Management::Client::DEFAULT_CONFIGURATION[:default_locale])
+        self.class.update_coercions!
+        @nested_locale_fields = nested_locale_fields
+        @default_locale = default_locale
+
+        @properties = extract_from_object object, :property, self.class.property_coercions.keys
+        @request = request
+        @client = client
+      end
+
+      def inspect(info = nil)
+        properties_info = properties.empty? ? '' : " @properties=#{ properties.inspect }"
+        "#<#{ self.class }:#{ properties_info }#{ info }>"
+      end
+
+      # Returns true for resources that behave like an array
+      def array?
+        false
+      end
+
+      # By default, fields come flattened in the current locale. This is different for syncs
+      def nested_locale_fields?
+        !!@nested_locale_fields
+      end
+
+      # Resources that don't include SystemProperties return nil for #sys
+      def sys
+        nil
+      end
+
+      # Resources that don't include Fields or AssetFields return nil for #fields
+      def fields
+        nil
+      end
+
+      # Issues the request that was made to fetch this response again.
+      # Only works for top-level resources
+      def reload
+        if request
+          request.get
+        else
+          false
+        end
+      end
+
+      private
+
+      def extract_from_object(object, namespace, keys = nil)
+        if object
+          keys ||= object.keys
+          keys.each.with_object({}) do |name, res|
+            res[name.to_sym] = coerce_value_or_array(
+                object.is_a?(::Array) ? object : object[name.to_s],
+                self.class.public_send(:"#{ namespace }_coercions")[name.to_sym]
+            )
+          end
+        else
+          {}
+        end
+      end
+
+      def coerce_value_or_array(value, what = nil)
+        if value.is_a? ::Array
+          value.map { |v| coerce_or_create_class(v, what) }
+        else
+          coerce_or_create_class(value, what)
+        end
+      end
+
+      def coerce_or_create_class(value, what)
+        case what
+          when Symbol
+            COERCIONS[what] ? COERCIONS[what][value] : value
+          when Class
+            what.new(value, client)
+          else
+            value
+        end
+      end
+
+      # Register the resources properties on class level by using the #property method
+      module ClassMethods
+        # By default, fields come flattened in the current locale. This is different for sync
+        def nested_locale_fields?
+          false
+        end
+
+        def property_coercions
+          @property_coercions ||= {}
+        end
+
+        # Defines which properties of a resource your class expects
+        # Define them in :camelCase, they will be available as #snake_cased methods
+        #
+        # You can pass in a second "type" argument:
+        # - If it is a class, it will be initialized for the property
+        # - Symbols are looked up in the COERCION constant for a lambda that
+        #   defines a type conversion to apply
+        #
+        # Note: This second argument is not meant for contentful sub-resources,
+        # but for structured objects (like locales in a space)
+        # Sub-resources are handled by the resource builder
+        def property(name, property_class = nil)
+          property_coercions[name.to_sym] = property_class
+          accessor_name = Contentful::Management::Support.snakify(name)
+          define_method accessor_name do
+            properties[name.to_sym]
+          end
+          define_method "#{ accessor_name }=" do |value|
+            properties[name.to_sym] = value
+          end
+        end
+
+        # Ensure inherited classes pick up coercions
+        def update_coercions!
+          return if @coercions_updated
+
+          if superclass.respond_to? :property_coercions
+            @property_coercions = superclass.property_coercions.dup.merge(@property_coercions || {})
+          end
+
+          if superclass.respond_to? :sys_coercions
+            @sys_coercions = superclass.sys_coercions.dup.merge(@sys_coercions || {})
+          end
+
+          if superclass.respond_to? :fields_coercions
+            @fields_coercions = superclass.fields_coercions.dup.merge(@fields_coercions || {})
+          end
+
+          @coercions_updated = true
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+    end
+  end
+end