contentful-management 0.9.0 → 1.0.0

data/lib/contentful/management/locale.rb

@@ -15,87 +15,18 @@ module Contentful
       property :publish, :boolean
       property :default, :boolean
 
-      # Gets a collection of locales.
-      #
-      # @param [String] space_id
-      # @param [Hash] _parameters Search Parameters
-      # @option _parameters [String] :name
-      # @option _parameters [String] :code
-      #
-      # @return [Contentful::Management::Array<Contentful::Management::Locale>]
-      def self.all(space_id = nil, _parameters = {})
-        request = Request.new("/#{space_id}/locales")
-        response = request.get
-        result = ResourceBuilder.new(response, { 'Locale' => Locale }, {})
-        result.run
-      end
-
-      # Gets a specific locale.
-      #
-      # @param [String] space_id
-      # @param [String] locale_id
-      #
-      # @return [Contentful::Management::Locale]
-      def self.find(space_id, locale_id)
-        request = Request.new("/#{space_id}/locales/#{locale_id}")
-        response = request.get
-        result = ResourceBuilder.new(response, { 'Locale' => Locale }, {})
-        result.run
-      end
-
-      # Creates a locale.
-      #
-      # @param [String] space_id
-      # @param [Hash] attributes
-      # @option attributes [String] :name
-      # @option attributes [String] :code
-      #
-      # @return [Contentful::Management::Locale]
-      def self.create(space_id, attributes)
-        request = Request.new(
-          "/#{space_id}/locales",
+      # @private
+      def self.create_attributes(_client, attributes)
+        {
           'name' => attributes.fetch(:name),
           'code' => attributes.fetch(:code)
-        )
-        response = request.post
-        result = ResourceBuilder.new(response, { 'Locale' => Locale }, {})
-        result.run
+        }
       end
 
-      # Updates a locale.
-      #
-      # @param [Hash] attributes
-      # @option attributes [String] :name
-      # @option attributes [String] :code
-      #
-      # @return [Contentful::Management::Locale]
-      def update(attributes)
-        parameters = {}
-        attributes.each { |k, v| parameters[k.to_s] = v }
-
-        request = Request.new(
-          "/#{space.id}/locales/#{id}",
-          parameters,
-          nil,
-          version: sys[:version]
-        )
-        response = request.put
-        result = ResourceBuilder.new(response, { 'Locale' => Locale }, {})
-        refresh_data(result.run)
-      end
+      protected
 
-      # Deletes a locale.
-      #
-      # @return [true, Contentful::Management::Error] success
-      def destroy
-        request = Request.new("/#{space.id}/locales/#{id}")
-        response = request.delete
-        if response.status == :no_content
-          return true
-        else
-          result = ResourceBuilder.new(response, {}, {})
-          result.run
-        end
+      def query_attributes(attributes)
+        attributes.each_with_object({}) { |(k, v), result| result[k.to_sym] = v }
       end
     end
   end

data/lib/contentful/management/request.rb

@@ -6,10 +6,10 @@ module Contentful
     class Request
       attr_reader :client, :type, :query, :id, :endpoint
 
-      def initialize(endpoint, query = {}, id = nil, header = {})
+      def initialize(client, endpoint, query = {}, id = nil, header = {})
         @header = header
         @initial_id = id
-        @client = Contentful::Management::Client.shared_instance
+        @client = client
         @client.version = header[:version]
         @client.organization_id = header[:organization_id]
         @client.content_type_id = header[:content_type_id]
@@ -60,7 +60,7 @@ module Contentful
 
       # Returns a new Request object with the same data
       def copy
-        self.class.new(@endpoint, @query, @initial_id, @header)
+        self.class.new(@client, @endpoint, @query, @initial_id, @header)
       end
 
       private

data/lib/contentful/management/resource.rb

@@ -27,7 +27,8 @@ module Contentful
       }
       # rubocop:enable Style/DoubleNegation
 
-      attr_reader :properties, :request, :client, :default_locale, :raw_object
+      attr_reader :properties, :request, :default_locale, :raw_object
+      attr_accessor :client
 
       # @private
       def initialize(object = nil,
@@ -45,6 +46,33 @@ module Contentful
         @raw_object = object
       end
 
+      # @private
+      def after_create(_attributes)
+      end
+
+      # Updates a resource.
+      #
+      # @param [Hash] attributes
+      #
+      # @see _ README for more information on how to create each resource
+      #
+      # @return [Contentful::Management::Resource]
+      def update(attributes)
+        ResourceRequester.new(client, self.class).update(
+          self,
+          { space_id: space.id, resource_id: id },
+          query_attributes(attributes),
+          version: sys[:version]
+        )
+      end
+
+      # Destroys a resource.
+      #
+      # @return [true, Contentful::Management::Error] success
+      def destroy
+        ResourceRequester.new(client, self.class).destroy(space_id: space.id, resource_id: id)
+      end
+
       # @private
       def inspect(info = nil)
         properties_info = properties.empty? ? '' : " @properties=#{properties.inspect}"
@@ -78,6 +106,17 @@ module Contentful
         Contentful::Management::Client.shared_instance
       end
 
+      # @return [true]
+      def resource?
+        true
+      end
+
+      protected
+
+      def query_attributes(attributes)
+        attributes
+      end
+
       private
 
       def extract_from_object(object, namespace, keys = nil)
@@ -114,22 +153,80 @@ module Contentful
       end
 
       # Register the resources properties on class level by using the #property method
-      # @private
       module ClassMethods
+        # @private
+        def endpoint
+          "#{Support.snakify(name.split('::')[-1])}s"
+        end
+
+        # @private
+        def build_endpoint(endpoint_options)
+          return "/#{endpoint_options[:space_id]}/public/#{endpoint}" if endpoint_options.key?(:public)
+          base = "/#{endpoint_options[:space_id]}/#{endpoint}"
+          return "#{base}/#{endpoint_options[:resource_id]}#{endpoint_options[:suffix]}" if endpoint_options.key?(:resource_id)
+          base
+        end
+
+        # Gets a collection of resources.
+        #
+        # @param [Contentful::Management::Client] client
+        # @param [String] space_id
+        # @param [Hash] parameters Search Options
+        # @see _ For complete option list: http://docs.contentfulcda.apiary.io/#reference/search-parameters
+        #
+        # @return [Contentful::Management::Array<Contentful::Management::Resource>]
+        def all(client, space_id, parameters = {})
+          ResourceRequester.new(client, self).all({ space_id: space_id }, parameters)
+        end
+
+        # Gets a specific resource.
+        #
+        # @param [Contentful::Management::Client] client
+        # @param [String] space_id
+        # @param [String] resource_id
+        #
+        # @return [Contentful::Management::Resource]
+        def find(client, space_id, resource_id)
+          ResourceRequester.new(client, self).find(space_id: space_id, resource_id: resource_id)
+        end
+
+        # Creates a resource.
+        #
+        # @param [Contentful::Management::Client] client
+        # @param [String] space_id
+        # @param [Hash] attributes
+        # @see _ README for full attribute list for each resource.
+        #
+        # @return [Contentful::Management::Resource]
+        def create(client, space_id, attributes)
+          endpoint_options = { space_id: space_id }
+          endpoint_options[:resource_id] = attributes[:id] if attributes.key?(:id)
+          ResourceRequester.new(client, self).create(
+            endpoint_options,
+            attributes
+          )
+        end
+
+        # @private
+        def create_attributes(_client, _attributes)
+          {}
+        end
+
+        # @private
+        def create_headers(_client, _attributes)
+          {}
+        end
+
         # By default, fields come flattened in the current locale. This is different for sync
         def nested_locale_fields?
           false
         end
 
+        # Default property coercions
         def property_coercions
           @property_coercions ||= {}
         end
 
-        # Shared instance of the API client
-        def client
-          Contentful::Management::Client.shared_instance
-        end
-
         # Defines which properties of a resource your class expects
         # Define them in :camelCase, they will be available as #snake_cased methods
         #
@@ -172,6 +269,7 @@ module Contentful
         end
       end
 
+      # @private
       def self.included(base)
         base.extend(ClassMethods)
       end

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

@@ -0,0 +1,24 @@
+module Contentful
+  module Management
+    module Resource
+      # Wrapper Class for Resources with '/public' API calls
+      module AllPublished
+        # Gets a collection of published resources.
+        #
+        # @param [Contentful::Management::Client] client
+        # @param [String] space_id
+        # @param [Hash] parameters
+        # @see _ For complete option list: http://docs.contentfulcda.apiary.io/#reference/search-parameters
+        # @option parameters [String] 'sys.id' Entry ID
+        # @option parameters [String] :content_type
+        # @option parameters [Integer] :limit
+        # @option parameters [Integer] :skip
+        #
+        # @return [Contentful::Management::Array<Contentful::Management::Resource>]
+        def all_published(client, space_id, parameters = {})
+          client_association_class.new(client).all_published(space_id, parameters)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+module Contentful
+  module Management
+    module Resource
+      # Wrapper for Resources with /archived API
+      module Archiver
+        # Archives a resource.
+        #
+        # @return [Contentful::Management::Resource]
+        def archive
+          ResourceRequester.new(client, self.class).archive(
+            self,
+            { space_id: space.id, resource_id: id, suffix: '/archived' },
+            version: sys[:version]
+          )
+        end
+
+        # Unarchives a resource.
+        #
+        # @return [Contentful::Management::Resource]
+        def unarchive
+          ResourceRequester.new(client, self.class).unarchive(
+            self,
+            { space_id: space.id, resource_id: id, suffix: '/archived' },
+            version: sys[:version]
+          )
+        end
+
+        # Checks if a resource is archived.
+        #
+        # @return [Boolean]
+        def archived?
+          sys[:archivedAt] ? true : false
+        end
+      end
+    end
+  end
+end

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

@@ -6,40 +6,55 @@ module Contentful
         # Creates fields for entry based on it's ContentType
         #
         # @param [Entry] entry the expected entry to modify
-        def self.create_fields_for_content_type(entry)
-          entry.instance_eval do
-            content_type.fields.each do |field|
-              localized_or_default_locale = Contentful::Management::Resource::FieldAware.localized_or_default_locale(
-                field,
-                default_locale,
-                locale
-              )
-
-              accessor_name = Support.snakify(field.id)
-              define_singleton_method accessor_name do
-                fields[field.id.to_sym]
-              end
-              define_singleton_method "#{accessor_name}_with_locales" do
-                fields_for_query[field.id.to_sym]
-              end
-              define_singleton_method "#{accessor_name}=" do |value|
-                if localized_or_default_locale
-                  @fields[locale] ||= {}
-                  @fields[locale][field.id.to_sym] = value
-                end
-              end
-              define_singleton_method "#{accessor_name}_with_locales=" do |values|
-                values.each do |locale, value|
-                  if localized_or_default_locale
-                    @fields[locale] ||= {}
-                    @fields[locale][field.id.to_sym] = value
-                  end
-                end
+        def self.create_fields_for_content_type(entry, method = :instance)
+          entry.content_type.fields.each do |field|
+            accessor_name = Support.snakify(field.id)
+
+            FieldAware.create_getter(entry, accessor_name, field, method)
+            FieldAware.create_setter(entry, accessor_name, field, method)
+          end
+        end
+
+        # Creates getters for field
+        # @private
+        def self.create_getter(entry, accessor_name, field, method)
+          entry.send("#{method}_eval") do
+            send(FieldAware.define(method), accessor_name) do
+              fields[field.id.to_sym]
+            end
+
+            send(FieldAware.define(method), "#{accessor_name}_with_locales") do
+              fields_for_query[field.id.to_sym]
+            end
+          end
+        end
+
+        # Creates setters for field
+        # @private
+        def self.create_setter(entry, accessor_name, field, method)
+          entry.send("#{method}_eval") do
+            send(FieldAware.define(method), "#{accessor_name}=") do |value|
+              FieldAware.create_setter_field(self, field, value, locale, default_locale)
+            end
+
+            send(FieldAware.define(method), "#{accessor_name}_with_locales=") do |values|
+              values.each do |locale, value|
+                FieldAware.create_setter_field(self, field, value, locale, default_locale)
               end
             end
           end
         end
 
+        # Sets fields with value for locale
+        # @private
+        def self.create_setter_field(entry, field, value, locale, default_locale)
+          fields = entry.instance_variable_get(:@fields)
+          if localized_or_default_locale(field, default_locale, locale)
+            fields[locale] ||= {}
+            fields[locale][field.id.to_sym] = value
+          end
+        end
+
         # Verifies if field is localized or default locale matches current locale
         #
         # @param [Field] field an entry field
@@ -50,6 +65,11 @@ module Contentful
         def self.localized_or_default_locale(field, default_locale, locale)
           field.localized || default_locale == locale
         end
+
+        # @private
+        def self.define(class_or_instance)
+          "define_#{class_or_instance == :instance ? 'singleton_' : ''}method"
+        end
       end
     end
   end

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

@@ -0,0 +1,37 @@
+module Contentful
+  module Management
+    module Resource
+      # Wrapper for Resources with /published API
+      module Publisher
+        # Publishes a resource.
+        #
+        # @return [Contentful::Management::Resource]
+        def publish
+          ResourceRequester.new(client, self.class).publish(
+            self,
+            { space_id: space.id, resource_id: id, suffix: '/published' },
+            version: sys[:version]
+          )
+        end
+
+        # Unpublishes a resource.
+        #
+        # @return [Contentful::Management::Resource]
+        def unpublish
+          ResourceRequester.new(client, self.class).unpublish(
+            self,
+            { space_id: space.id, resource_id: id, suffix: '/published' },
+            version: sys[:version]
+          )
+        end
+
+        # Checks if a resource is published.
+        #
+        # @return [Boolean]
+        def published?
+          sys[:publishedAt] ? true : false
+        end
+      end
+    end
+  end
+end