contentful_model 0.2.0 → 1.0.0

data/lib/contentful_model/client.rb

@@ -1,14 +1,25 @@
+require_relative 'asset'
+
 module ContentfulModel
+  # Wrapper for the CDA Client
   class Client < Contentful::Client
-
-    PREVIEW_API_URL = "preview.contentful.com"
+    PREVIEW_API_URL = 'preview.contentful.com'.freeze
 
     def initialize(configuration)
+      configuration[:resource_mapping] = configuration.fetch(:resource_mapping, {}).merge(
+        'Asset' => ContentfulModel::Asset
+      )
+
       if ContentfulModel.use_preview_api
         configuration[:api_url] = PREVIEW_API_URL
         configuration[:access_token] = configuration[:preview_access_token]
       end
-      super({ raise_errors: true, dynamic_entries: :auto }.merge(configuration))
+      super({
+        raise_errors: true,
+        dynamic_entries: :auto,
+        integration_name: 'contentful_model',
+        integration_version: ::ContentfulModel::VERSION
+      }.merge(configuration))
     end
   end
 end

data/lib/contentful_model/errors.rb

@@ -1,5 +1,4 @@
 module ContentfulModel
   class AssociationError < StandardError; end
   class VersionMismatchError < StandardError; end
-  class AttributeNotFoundError < NoMethodError; end
 end

data/lib/contentful_model/manageable.rb

@@ -1,9 +1,18 @@
+require_relative 'errors'
+require_relative 'management'
+
 module ContentfulModel
+  # Adds CMA functionality to Base
   module Manageable
     attr_reader :dirty
 
-    def initialize(*args)
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    def initialize(_item, _configuration = {}, localized = false, *)
       super
+      @localized = localized
       @dirty = false
       @changed_fields = []
       define_setters
@@ -27,7 +36,9 @@ module ContentfulModel
       @management_entry = fetch_management_entry
     end
 
-    def save
+    def save(skip_validations = false)
+      return false if !skip_validations && invalid?(true)
+
       begin
         to_management.save
       rescue Contentful::Management::Conflict
@@ -40,7 +51,14 @@ module ContentfulModel
 
       self
     rescue Contentful::Management::Conflict
-      fail ContentfulModel::VersionMismatchError, "Version Mismatch persisting after refetch attempt, use :refetch_management_entry and try again later."
+      raise(
+        ContentfulModel::VersionMismatchError,
+        'Version Mismatch persisting after refetch attempt, use :refetch_management_entry and try again later.'
+      )
+    end
+
+    def save!
+      save(true)
     end
 
     def publish
@@ -52,17 +70,25 @@ module ContentfulModel
 
       self
     rescue Contentful::Management::Conflict
-      fail ContentfulModel::VersionMismatchError, "Version Mismatch persisting after refetch attempt, use :refetch_management_entry and try again later."
+      raise(
+        ContentfulModel::VersionMismatchError,
+        'Version Mismatch persisting after refetch attempt, use :refetch_management_entry and try again later.'
+      )
     end
 
     private
 
-    def management_space
-      @management_space ||= self.class.management(default_locale: locale).spaces.find(space.id)
+    def management_proxy
+      @management_proxy ||= self.class.management(
+        default_locale: locale
+      ).entries(
+        space.id,
+        ContentfulModel.configuration.environment
+      )
     end
 
     def fetch_management_entry
-      management_space.entries.find(id)
+      management_proxy.find(id)
     end
 
     def management_entry
@@ -72,7 +98,7 @@ module ContentfulModel
 
     def define_setters
       fields.each do |k, v|
-        if Contentful::Constants::KNOWN_LOCALES.include?(k.to_s)
+        if @localized
           v.keys.each do |name|
             define_setter(name)
           end
@@ -86,7 +112,7 @@ module ContentfulModel
       define_singleton_method "#{name.to_s.underscore}=" do |value|
         @dirty = true
         @changed_fields << name
-        fields(default_locale)[name] = value
+        fields[name] = value
       end
     end
 
@@ -97,39 +123,41 @@ module ContentfulModel
       when Contentful::Asset
         Contentful::Management::Entry.hash_with_link_object('Asset', entry_value)
       when Contentful::Link
-        Contentful::Management::Entry.hash_with_link_object(entry_value.sys[:contentType], entry_value)
+        Contentful::Management::Entry.hash_with_link_object(entry_value.sys[:link_type], entry_value)
       else
         entry_value
       end
     end
 
+    # Management Class methods
     module ClassMethods
       def management(options = {})
         @management ||= ContentfulModel::Management.new(
-          options.merge(default_locale: ContentfulModel.configuration.default_locale)
+          options.merge(
+            default_locale: ContentfulModel.configuration.default_locale,
+            raise_errors: true,
+            integration_name: 'contentful_model',
+            integration_version: ::ContentfulModel::VERSION
+          )
         )
       end
 
       def create(values = {}, publish = false)
-        entry = management.entries.create(
-          management.content_types.find(
-            ContentfulModel.configuration.space,
-            content_type_id
-          ),
+        space = ContentfulModel.configuration.space
+        environment = ContentfulModel.configuration.environment
+
+        entry = management.entries(space, environment).create(
+          management.content_types(space, environment).find(content_type_id),
           values
         )
 
         if publish
           entry.publish
-          entry = self.find(entry.id)
+          entry = find(entry.id)
         end
 
         entry
       end
     end
-
-    def self.included(base)
-      base.extend(ClassMethods)
-    end
   end
 end

data/lib/contentful_model/management.rb

@@ -1,4 +1,5 @@
 module ContentfulModel
+  # Wrapper for the CMA Client
   class Management < Contentful::Management::Client
     def initialize(options = {})
       super(ContentfulModel.configuration.management_token, options)

data/lib/contentful_model/migrations/content_type.rb

@@ -1,6 +1,11 @@
+require_relative 'errors'
+
 module ContentfulModel
   module Migrations
+    # Class for defining Content Type transformations
     class ContentType
+      attr_accessor :id, :name
+
       def initialize(name = nil, management_content_type = nil)
         @name = name
         @management_content_type = management_content_type
@@ -8,8 +13,11 @@ module ContentfulModel
 
       def save
         if new?
-          @management_content_type = management.content_types.create(
+          @management_content_type = management.content_types(
             ContentfulModel.configuration.space,
+            ContentfulModel.configuration.environment
+          ).create(
+            id: id || camel_case(@name),
             name: @name,
             fields: fields
           )
@@ -54,53 +62,46 @@ module ContentfulModel
       end
 
       def fields
-        if new?
-          return @fields ||= []
-        else
-          return @fields ||= fields_from_management_type
-        end
+        @fields ||= new? ? [] : fields_from_management_type
       end
 
       private
 
+      def camel_case(a_string)
+        a_string.split(/\s|_|-/).inject([]) { |a, e| a.push(a.empty? ? e.downcase : e.capitalize) }.join
+      end
+
       def fields_from_management_type
         @management_content_type.fields
       end
 
       def management_type(type)
-        if [
-          :text, :symbol,
-          :integer, :number,
-          :date, :boolean,
-          :location, :object
-        ].include?(type.to_sym)
-          return type.capitalize
+        if %i[text symbol integer number date boolean location object].include?(type.to_sym)
+          type.capitalize
         elsif type == 'string'
-          return 'Symbol'
+          'Symbol'
         elsif link?(type)
-          return 'Link'
+          'Link'
         elsif array?(type)
-          return 'Array'
+          'Array'
         else
           raise_field_type_error(type)
         end
       end
 
       def management_link_type(type)
-        if [:entry_link, :asset_link].include?(type.to_sym)
-          return type.split('_').first.capitalize
-        else
-          raise_field_type_error(type)
-        end
+        raise_field_type_error(type) unless %i[entry_link asset_link].include?(type.to_sym)
+
+        type.split('_').first.capitalize
       end
 
       def management_items(type)
-        if [:entry_array, :asset_array].include?(type.to_sym)
+        if %i[entry_array asset_array].include?(type.to_sym)
           items = Contentful::Management::Field.new
           items.type = 'Link'
           items.link_type = type.split('_').first.capitalize
 
-          return items
+          items
         else
           raise_field_type_error(type)
         end
@@ -124,4 +125,3 @@ module ContentfulModel
     end
   end
 end
-

data/lib/contentful_model/migrations/content_type_factory.rb

@@ -1,13 +1,16 @@
+require_relative 'content_type'
+
 module ContentfulModel
   module Migrations
+    # Content Type Factory class
     module ContentTypeFactory
-      def self.create(name, fields = {}, &block)
+      def self.create(name, fields = {}, &_block)
         content_type = ContentfulModel::Migrations::ContentType.new(name)
 
         yield(content_type) if block_given?
 
-        fields.each do |name, type|
-          content_type.field(name, type)
+        fields.each do |field_name, type|
+          content_type.field(field_name, type)
         end
 
         content_type.save
@@ -16,10 +19,10 @@ module ContentfulModel
       def self.find(content_type_id)
         ContentfulModel::Migrations::ContentType.new(
           nil,
-          ContentfulModel::Management.new.content_types.find(
+          ContentfulModel::Management.new.content_types(
             ContentfulModel.configuration.space,
-            content_type_id
-          )
+            ContentfulModel.configuration.environment
+          ).find(content_type_id)
         )
       end
     end

data/lib/contentful_model/migrations/migration.rb

@@ -1,16 +1,21 @@
+require_relative 'content_type_factory'
+
 module ContentfulModel
+  # Migrations module
   module Migrations
+    # Content Type Migration methods
     module Migration
       def create_content_type(name, fields = {}, &block)
         ContentfulModel::Migrations::ContentTypeFactory.create(name, fields, &block)
       end
 
-      def add_content_type_field(content_type_id, name, type)
+      def add_content_type_field(content_type_id, name, type, &_block)
         content_type = ContentfulModel::Migrations::ContentTypeFactory.find(content_type_id)
+        field = content_type.field(name, type)
 
-        content_type.field(name, type)
+        yield(field) if block_given?
 
-        content_type.save
+        content_type.save.publish
       end
 
       def remove_content_type_field(content_type_id, field_id)
@@ -18,7 +23,7 @@ module ContentfulModel
 
         content_type.remove_field(field_id)
 
-        content_type.save
+        content_type.save.publish
       end
     end
   end

data/lib/contentful_model/queries.rb

@@ -1,27 +1,78 @@
+require_relative 'query'
+
 module ContentfulModel
+  # Module to extend Base with querying capabilities
   module Queries
     def self.included(base)
       base.extend ClassMethods
     end
 
+    # Class methods for Queries
     module ClassMethods
-      def inherited(subclass)
-        instantiate_query(subclass)
+      def query
+        ContentfulModel::Query.new(self)
       end
 
-      def instantiate_query(klass)
-        klass.instance_variable_set(:"@query", ContentfulModel::Query.new(klass))
+      def all
+        fail ArgumentError, 'You need to set self.content_type in your model class' if @content_type_id.nil?
+        query
       end
 
       def load
-        old_query = @query.dup
-        @query.reset
-        return old_query.execute
+        all.load
+      end
+
+      def first
+        query.first
+      end
+
+      def params(options)
+        query.params(options)
+      end
+
+      def offset(n)
+        query.offset(n)
+      end
+      alias skip offset
+
+      def limit(n)
+        query.limit(n)
+      end
+
+      def locale(locale_code)
+        query.locale(locale_code)
+      end
+
+      def paginate(page = 1, per_page = 100, order_field = 'sys.updatedAt', additional_options = {})
+        query.paginate(page, per_page, order_field, additional_options)
+      end
+
+      def each_page(per_page = 100, order_field = 'sys.updatedAt', additional_options = {}, &block)
+        query.each_page(per_page, order_field, additional_options, &block)
+      end
+
+      def each_entry(per_page = 100, order_field = 'sys.updatedAt', additional_options = {}, &block)
+        query.each_entry(per_page, order_field, additional_options, &block)
+      end
+
+      def load_children(n)
+        query.load_children(n)
+      end
+
+      def order(args)
+        query.order(args)
       end
 
       def find(id)
-        @query << {'sys.id' => id}
-        load.first
+        query.find(id)
+      end
+
+      def find_by(find_query = {})
+        query.find_by(find_query)
+      end
+
+      def search(parameters)
+        query.search(parameters)
       end
     end
   end

data/lib/contentful_model/query.rb

@@ -1,7 +1,10 @@
 module ContentfulModel
+  # Class to wrap query parameters
   class Query
+    SYS_PROPERTIES = %w[type id space contentType linkType revision createdAt updatedAt locale]
+
     attr_accessor :parameters
-    def initialize(referenced_class, parameters=nil)
+    def initialize(referenced_class, parameters = nil)
       @parameters = parameters || {}
       @referenced_class = referenced_class
     end
@@ -10,22 +13,162 @@ module ContentfulModel
       @parameters.merge!(parameters)
     end
 
+    def params(options)
+      self << options
+      self
+    end
+
+    def first
+      self << { 'limit' => 1 }
+      load.first
+    end
+
+    def offset(n)
+      self << { 'skip' => n }
+      self
+    end
+    alias skip offset
+
+    def limit(n)
+      self << { 'limit' => n }
+      self
+    end
+
+    def locale(locale_code)
+      self << { 'locale' => locale_code }
+      self
+    end
+
+    def paginate(page = 1, per_page = 100, order_field = 'sys.updatedAt', additional_options = {})
+      page = 1 if page.nil? || !page.is_a?(Numeric) || page <= 0
+      per_page = 100 if per_page.nil? || !per_page.is_a?(Numeric) || per_page <= 0
+
+      skip_records_count = (page - 1) * per_page
+      self << { 'limit' => per_page, 'skip' => skip_records_count, 'order' => order_field }
+      self << additional_options
+      self
+    end
+
+    def each_page(per_page = 100, order_field = 'sys.updatedAt', additional_options = {}, &block)
+      total = self.class.new(@referenced_class).limit(1).load_children(0).params(additional_options).execute.total
+
+      ((total / per_page) + 1).times do |i|
+        page = self.class.new(@referenced_class).paginate(i, per_page, order_field, additional_options).execute
+        block[page]
+      end
+    end
+
+    def each_entry(per_page = 100, order_field = 'sys.updatedAt', additional_options = {}, &block)
+      each_page(per_page, order_field, additional_options) do |page|
+        page.each do |entry|
+          block[entry]
+        end
+      end
+    end
+
+    def load_children(n)
+      self << { 'include' => n }
+      self
+    end
+
+    def order(args)
+      prefix = ''
+      if args.is_a?(Hash)
+        column = args.first.first.to_s
+        prefix = '-' if args.first.last == :desc
+      elsif args.is_a?(Symbol)
+        column = args.to_s
+        prefix = ''
+      else
+        column = args.to_s
+      end
+      property_name = column.camelize(:lower).to_sym
+      property_type = SYS_PROPERTIES.include?(property_name.to_s) ? 'sys' : 'fields'
+
+      self << { 'order' => "#{prefix}#{property_type}.#{property_name}" }
+      self
+    end
+
+    def find(id)
+      self << { 'sys.id' => id }
+      load.first
+    end
+
+    def find_by(find_query = {})
+      find_query.each do |field, value|
+        key = if field.to_s.include?('sys.') || field.to_s.include?('fields.')
+                field
+              elsif SYS_PROPERTIES.include?(field.to_s)
+                "sys.#{field}"
+              else
+                "fields.#{field}"
+              end
+
+        case value
+        when Array # we need to do an 'in' query
+          self << { "#{key}[in]" => value.join(',') }
+        when String, Numeric, true, false
+          self << { key.to_s => value }
+        when Hash
+          # if the search is a hash, use the key to specify the search field operator
+          # For example
+          # Model.search(start_date: {gte: DateTime.now}) => "fields.start_date[gte]" => DateTime.now
+          value.each do |search_predicate, search_value|
+            self << { "#{key}[#{search_predicate}]" => search_value }
+          end
+        end
+      end
+
+      self
+    end
+    alias where find_by
+
+    def search(parameters)
+      if parameters.is_a?(Hash)
+        parameters.each do |field, search|
+          # if the search is a hash, use the key to specify the search field operator
+          # For example
+          # Model.search(start_date: {gte: DateTime.now}) => "fields.start_date[gte]" => DateTime.now
+          if search.is_a?(Hash)
+            search_key, search_value = *search.flatten
+            self << { "fields.#{field.to_s.camelize(:lower)}[#{search_key}]" => search_value }
+          else
+            self << { "fields.#{field.to_s.camelize(:lower)}[match]" => search }
+          end
+        end
+      elsif parameters.is_a?(String)
+        self << { 'query' => parameters }
+      end
+
+      self
+    end
+
     def default_parameters
-      { 'content_type' => @referenced_class.send(:content_type_id) }
+      { 'content_type' => @referenced_class.content_type_id }
     end
 
     def execute
       query = @parameters.merge(default_parameters)
-      result = client.send(:entries,query)
-      return result.to_a.reject {|entity| entity.is_a?(Contentful::Link) || entity.invalid?}
+
+      discovered_includes = discover_includes
+      query['include'] = discovered_includes unless query.key?('include') || discovered_includes == 1
+
+      result = client.entries(query)
+      result.items.reject!(&:invalid?)
+      result
     end
+    alias load execute
 
     def client
-      @client ||= @referenced_class.send(:client)
+      @client ||= @referenced_class.client
     end
 
     def reset
       @parameters = default_parameters
     end
+
+    def discover_includes
+      @referenced_class.discovered_include_level
+    end
   end
 end