contentful_model 0.2.0 → 1.0.0

data/lib/contentful_model/associations/has_many_nested.rb

@@ -1,10 +1,12 @@
 module ContentfulModel
   module Associations
+    # Module for Has Many Nested association
     module HasManyNested
       def self.included(base)
         base.extend ClassMethods
       end
 
+      # Class method
       module ClassMethods
         # has_many_nested allows you to set up a tree relationship
         # it calls has_many and belongs_to_many on the class, and sets up
@@ -13,7 +15,7 @@ module ContentfulModel
         # To set this up in contentful, add a multi-entry field validated to the same model
         # as the parent, and give it a name. For example, Page might have a field called childPages:
         #
-        # has_many_nested :child_pages, root: -> { Page.find("some_id")}
+        # has_many_nested :child_pages, root: -> { Page.find("some_id") }
         #
         # would setup up an instance attribute called parent_pages which lists all the direct
         # parents of this page. It would also create methods to find a page based on an array
@@ -21,26 +23,26 @@ module ContentfulModel
         # ancestors which called the object; because 'many' associations in Contentful are actually
         # 'belongs_to_many' from the child end, we might have several ancestors to a page. You will need
         # to write your own recursion for this, because it's probably an implementation-specific problem.
+        # rubocop:disable Style/PredicateName
         def has_many_nested(association_name, options = {})
-          has_many association_name, inverse_of: :"parent_#{self.to_s.underscore}"
-          belongs_to_many :"parent_#{self.to_s.underscore.pluralize}", class_name: self.to_s, inverse_of: association_name
-          if options[:root].is_a?(Proc)
-            @root_method = options[:root]
-          end
+          has_many association_name, class_name: to_s, inverse_of: :"parent_#{to_s.underscore}"
+          belongs_to_many :"parent_#{to_s.underscore.pluralize}", class_name: to_s
+          root_method = options[:root] if options[:root].is_a?(Proc)
 
           # If there's a root method defined, set up a class method called root_[class name]. In our example this would be
           # Page.root_page.
           # @return [Object] the root entity returned from the proc defined in has_many_nested
-          if defined?(@root_method) && @root_method.is_a?(Proc)
+          if defined?(root_method) && root_method.is_a?(Proc)
             # @return [Object] the root entity
-            define_singleton_method :"root_#{self.to_s.underscore}" do
-              @root_method.call
+            define_method :"root_#{to_s.underscore}" do
+              root_method.call
             end
           end
 
           # A utility method which returns the parent object; saves passing around interpolated strings
           define_method :parent do
-            self.send(:"parent_#{self.class.to_s.underscore}")
+            parents = send(:"parent_#{self.class.to_s.underscore.pluralize}")
+            parents.first unless parents.nil?
           end
 
           # Determine if the object has any parents. If it doesn't, it's considered a root.
@@ -55,43 +57,44 @@ module ContentfulModel
           define_method :find_ancestors do |&block|
             return enum_for(:find_ancestors) unless block
             if parent.nil?
-              #this *is* the parent
+              # this *is* the parent
               return self
             end
-            block.call(parent)
-            unless parent && parent.root?
-              parent.find_ancestors {|a| block.call(a)}
-            end
+            block[parent]
+
+            parent.find_ancestors { |a| block[a] } if parent && !parent.root?
           end
 
           # A utility method to return the results of `find_ancestors` as an array
           # @return [Array] of ancestors in reverse order (root last)
           define_method :ancestors do
-            self.find_ancestors.to_a
+            find_ancestors.to_a
           end
 
-          # Return the last member of the enumerable, which is the root
+          # If this entry is the root, return self.
+          # Otherwise, return the last member of the ancestors, which is the root
           # @return the root instance of this object
           define_method :root do
+            return self if root?
+
             find_ancestors.to_a.last
           end
 
           # @return [Boolean] whether or not this instance has children
-          define_method :has_children? do
-            !self.send(association_name).empty?
+          define_method :children? do
+            !send(association_name).empty?
           end
 
           # @return [Array] a collection of child objects, based on the association name
           define_method :children do
-            self.send(association_name)
+            send(association_name)
           end
 
           # @return [Hash] a hash of nested child objects
           define_method :nested_children do
-            self.children.inject({}) do |h,c|
-              children = c.has_children? ? c.nested_children : nil
-              h[c] = children
-              h
+            children.each_with_object({}) do |e, a|
+              children = e.children? ? e.nested_children : nil
+              a[e] = children
             end
           end
 
@@ -99,38 +102,37 @@ module ContentfulModel
           # @param field [Symbol] the field you want to return, nested for each child
           # @return [Hash] of nested children, by that field
           define_method :nested_children_by do |field|
-            self.children.inject({}) do |h,c|
-              children = c.has_children? ? c.nested_children_by(field) : nil
-              h[c.send(field)] = children
-              h
+            children.each_with_object({}) do |e, a|
+              children = e.children? ? e.nested_children_by(field) : nil
+              a[e.send(field)] = children
             end
           end
 
           # Return a flattened hash of children by the specified field
           define_method :all_child_paths_by do |field, opts = {}|
-            options = {prefix: nil}.merge!(opts)
+            options = { prefix: nil }.merge!(opts)
             flatten_hash(nested_children_by(field)).keys.collect do |path|
               options[:prefix] ? path.unshift(options[:prefix]) : path
             end
           end
 
           # Search for a child by a certain field. This is called on the parent(s).
-          # e.g. Page.root.find_child_path_by(:slug, "some-slug"). Accepts a prefix if you want to
+          # e.g. Page.root.find_child_path_by(:slug, "some-slug"). Accepts a prefix if you want to
           # prefix the children with the parent
           define_method :find_child_path_by do |field, value, opts = {}|
-            all_child_paths_by(field,opts).select {|child| child.include?(value)}
+            all_child_paths_by(field, opts).select { |child| child.include?(value) }
           end
 
           # Private method to flatten a hash. Courtesy Cary Swoveland http://stackoverflow.com/a/23861946
-          define_method :flatten_hash do |h,f=[],g={}|
-            return g.update({ f=>h }) unless h.is_a? Hash
-            h.each { |k,r| flatten_hash(r,f+[k],g) }
+          define_method :flatten_hash do |h, f = [], g = {}|
+            return g.update(f => h) unless h.is_a? Hash
+            h.each { |k, r| flatten_hash(r, f + [k], g) }
             g
           end
-          self.send(:private, :flatten_hash)
-
+          send(:private, :flatten_hash)
         end
+        # rubocop:enable Style/PredicateName
       end
     end
   end
-end
+end

data/lib/contentful_model/associations/has_one.rb

@@ -1,45 +1,53 @@
 module ContentfulModel
   module Associations
+    # Module for Has One association
     module HasOne
       def self.included(base)
         base.extend ClassMethods
       end
 
+      # Class method
       module ClassMethods
-        #has_one defines a method on the parent which wraps around the superclass's implementation. In most cases this
-        #will end up at ContentfulModel::Base#method_missing and look at the fields on a content object.
-        #We wrap around it like this so we can specify a class_name option to call a different method from the association
-        #name.
+        # has_one defines a method on the parent which wraps around the superclass's implementation. In most cases this
+        # will end up at ContentfulModel::Base#method_missing and look at the fields on a content object.
+        # We wrap around it like this so we can specify a class_name option to call a different method from the association
+        # name.
+        #
         # class Foo
         #   has_one :special_bar, class_name: "Bar"
         # end
+        #
         # @param association_name [Symbol] the name of the association. In this case Foo.special_bar.
         # @param options [Hash] a hash, the only key of which is important is class_name.
+        # rubocop:disable Style/PredicateName
         def has_one(association_name, options = {})
           default_options = {
             class_name: association_name.to_s.classify,
-            inverse_of: self.to_s.underscore.to_sym
+            inverse_of: to_s.underscore.to_sym
           }
           options = default_options.merge(options)
+
+          include_discovered(options[:class_name])
+
           # Define a method which matches the association name
           define_method association_name do
             begin
               # Start by calling the association name as a method on the superclass.
               # this will end up in ContentfulModel::Base#method_missing and return the value from Contentful.
               # We set the singular of the association name on this object to allow easy recursing.
-              super().send(:"#{options[:inverse_of]}=",self)
-            rescue ContentfulModel::AttributeNotFoundError
-              # If method_missing returns an error, the field doesn't exist. If a class is specified, try that.
-              if options[:class_name].underscore.to_sym != association_name
-                self.send(options[:class_name].underscore.to_sym)
-              else
-                #otherwise give up and return nil
-                nil
+              super().tap do |child|
+                child.send(:"#{options[:inverse_of]}=", self) if child.respond_to?(:"#{options[:inverse_of]}=")
               end
+            rescue NoMethodError
+              # If method_missing returns an error, the field doesn't exist. If a class is specified, try that.
+              possible_field_name = options[:class_name].underscore.to_sym
+              return send(possible_field_name) if possible_field_name != association_name && respond_to?(possible_field_name)
+              nil
             end
           end
         end
+        # rubocop:enable Style/PredicateName
       end
     end
   end
-end
+end

data/lib/contentful_model/base.rb

@@ -1,109 +1,133 @@
+require_relative 'associations/associations'
+require_relative 'validations/validations'
+require_relative 'manageable'
+require_relative 'queries'
+require_relative 'errors'
+require_relative 'client'
+
 module ContentfulModel
-  class Base < Contentful::DynamicEntry
-    include ContentfulModel::ChainableQueries
+  # Wrapper for Contentful::Entry which provides ActiveModel-like syntax
+  class Base < Contentful::Entry
     include ContentfulModel::Associations
     include ContentfulModel::Validations
     include ContentfulModel::Manageable
+    include ContentfulModel::Queries
 
-    def initialize(*args)
+    def initialize(*)
       super
-      define_getters
-      self.class.coercions ||= {}
+      override_getters
+    end
+
+    def cache_key(*timestamp_names)
+      fail ArgumentError, "ContentfulModel::Base models don't support named timestamps." if timestamp_names.present?
+
+      "#{self.class.to_s.underscore}/#{id}-#{updated_at.utc.to_s(:usec)}"
+    end
+
+    def hash
+      "#{sys[:content_type].id}-#{sys[:id]}".hash
+    end
+
+    def eql?(other)
+      super || other.instance_of?(self.class) && sys[:id].present? && other.sys[:id] == sys[:id]
     end
 
     private
 
-    def define_getters
-      fields.each do |k, v|
-        if Contentful::Constants::KNOWN_LOCALES.include?(k.to_s)
-          v.keys.each do |name|
-            define_getter(name)
-          end
-        else
-          define_getter(k)
+    def define_sys_methods
+      sys.keys.each do |name|
+        define_singleton_method name do
+          self.class.coerce_value(name, sys[name])
         end
       end
     end
 
-    def define_getter(name)
-      define_singleton_method "#{name.to_s.underscore}" do
-        fields(default_locale)[name]
-      end
+    def filter_invalids(value)
+      return value.reject { |v| v.is_a?(Contentful::Link) || (v.respond_to?(:invalid?) && v.invalid?) } if value.is_a?(Array)
+      return nil if value.is_a?(Contentful::Link) || value.respond_to?(:fields) && value.fields.empty?
+
+      value
     end
 
-    #use method_missing to call fields on the model
-    def method_missing(method, *args, &block)
-      result = fields[:"#{method.to_s.camelize(:lower)}"]
-      # we need to pull out any Contentful::Link references, and also things which don't have any fields at all
-      # because they're newly created
-      if result.is_a?(Array)
-        result.reject! {|r| r.is_a?(Contentful::Link) || (r.respond_to?(:invalid) && r.invalid?)}
-      elsif result.is_a?(Contentful::Link)
-        result = nil
-      elsif result.respond_to?(:fields) && result.send(:fields).empty?
-        result = nil
-      elsif result.respond_to?(:invalid?) && result.invalid?
-        result = nil
-      end
+    def nillable?(name, value)
+      value.nil? &&
+        self.class.return_nil_for_empty_attribute_fields &&
+        self.class.return_nil_for_empty_attribute_fields.include?(name)
+    end
 
-      if result.nil?
-        # if self.class.rescue_from_no_attribute_fields.member?()
-        # end
-        if self.class.return_nil_for_empty_attribute_fields && self.class.return_nil_for_empty_attribute_fields.include?(method)
-          return nil
-        else
-          raise ContentfulModel::AttributeNotFoundError, "no attribute #{method} found"
-        end
-      else
-        # if there's no coercion specified, return the result
-        if self.class.coercions[method].nil?
-          return result
-        #if there's a coercion specified for the field and it's a proc, pass the result
-        #to the proc
-        elsif self.class.coercions[method].is_a?(Proc)
-          return self.class.coercions[method].call(result)
-        #provided the coercion is in the COERCIONS constant, call the proc on that
-        elsif !self.class::COERCIONS[self.class.coercions[method]].nil?
-          return self.class::COERCIONS[self.class.coercions[method]].call(result)
-        else
-          #... or just return the result
-          return result
+    def define_fields_methods
+      fields.keys.each do |name|
+        define_singleton_method name do
+          result = filter_invalids(
+            self.class.coerce_value(name, fields[name])
+          )
+
+          return nil if nillable?(name, result)
+
+          result
         end
       end
     end
 
-    def respond_to_missing?(method, private=false)
-      if fields[:"#{method.to_s.camelize(:lower)}"].nil?
-         super
-      else
-        true
-      end
+    def override_getters
+      define_sys_methods
+      define_fields_methods
     end
 
-    def cache_key(*timestamp_names)
-      if timestamp_names.present?
-        raise ArgumentError, "ContentfulModel::Base models don't support named timestamps."
-      end
-
-      "#{self.class.to_s.underscore}/#{self.id}-#{self.updated_at.utc.to_s(:number)}"
+    def respond_to_missing?(method, private = false)
+      key = fields.keys.detect { |k| k.to_s.underscore == method.to_s.underscore }
+      return super if key.nil?
+      true
     end
 
     class << self
-      attr_accessor :content_type_id, :coercions, :return_nil_for_empty_attribute_fields
+      attr_accessor :content_type_id, :coercions, :return_nil_for_empty_attribute_fields, :client
 
       def descendents
         ObjectSpace.each_object(Class).select { |klass| klass < self }
       end
 
-      def add_entry_mapping
-        unless ContentfulModel.configuration.entry_mapping.has_key?(@content_type_id)
-          ContentfulModel.configuration.entry_mapping[@content_type_id] = self.to_s.constantize
+      def discovered_includes
+        @discovered_includes ||= []
+      end
+
+      def discovered_include_level
+        @discovered_include_level ||= nil
+        return @discovered_include_level unless @discovered_include_level.nil?
+
+        # Recreate content type tree
+        includes = {}
+        discovered_includes.each do |klass|
+          # Recursively find includes - remove self from reference lists
+          includes[klass] = klass.constantize.discovered_includes.reject { |i| i == to_s } + [klass]
         end
+
+        include_level = includes.values.map(&:size).max # Longest include chain
+        return @discovered_include_level = 1 if include_level.nil? || include_level.zero?
+        return @discovered_include_level = 10 if include_level >= 10
+        @discovered_include_level = include_level + 1
+      end
+
+      # Add a class to the known referenced classes
+      def include_discovered(klass)
+        # This should be nil already in most cases,
+        # but if another class is defined in Runtime after a query was already run, we want to make sure this is reset
+        @discovered_include_level = nil
+
+        discovered_includes << klass unless discovered_includes.include?(klass)
+      end
+
+      def mapping?
+        ContentfulModel.configuration.entry_mapping.key?(@content_type_id)
+      end
+
+      def add_entry_mapping
+        ContentfulModel.configuration.entry_mapping[@content_type_id] = to_s.constantize unless mapping?
       end
 
       def client
         # add an entry mapping for this content type
-        self.add_entry_mapping
+        add_entry_mapping
         if ContentfulModel.use_preview_api
           @preview_client ||= ContentfulModel::Client.new(ContentfulModel.configuration.to_hash)
         else
@@ -123,14 +147,31 @@ module ContentfulModel
         @coercions
       end
 
-      def return_nil_for_empty(*fields)
+      def coerce_value(field_name, value)
+        return value if coercions.nil?
+
+        coercion = coercions[field_name]
+
+        case coercion
+        when Symbol, String
+          coercion = Contentful::Field::KNOWN_TYPES[coercion.to_s]
+          return coercion.new(value).coerce unless coercion.nil?
+        when Proc
+          coercion[value]
+        else
+          value
+        end
+      end
+
+      def return_nil_for_empty(*nillable_fields)
         @return_nil_for_empty_attribute_fields ||= []
 
-        fields.each do |field|
+        nillable_fields.each do |field|
           define_method field do
             begin
-              super()
-            rescue ContentfulModel::AttributeNotFoundError
+              result = super()
+              result.present? ? result : nil
+            rescue NoMethodError
               nil
             end
           end