contentful_model 0.0.8 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b0c557075e720d6f54dd624f9342c0b9a001909e
-  data.tar.gz: 8c0705dac36560cf57a4c09022e6c0f9ee77c0db
+  metadata.gz: c5c1cf9bc5fe07bc623e3d1bc3d3ae0b8d85c9fb
+  data.tar.gz: 918055df94e083db1816f5fcc527e54e831a2227
 SHA512:
-  metadata.gz: 8b9463610d3aa57d4abde50284b46a9293b70772571aff50d9c3d6b6698087d2ebe606148ffd6067082213e458fd59210761fd9d406e97f8622c9934970dad70
-  data.tar.gz: 8e9ed3329c34045efd4211dae3b5526b1c3abdc64a9c8d35b220e5dc2194f972674e84c9df100d4ea476da29b33cd9a987e07a29e84b8ef74b6ca3850ae34b34
+  metadata.gz: 0a754f0bb73a6909c161f66a24c498d6c4287f50bc0581fe90688973dada28402dab54cf60d2b92bc29e0a9c1fbdf7c6f77d48cb23e78dedd53738fec184205d
+  data.tar.gz: 2423688b78f546b97b64b318772ebe7de72d773bbe7cc0c7da065d3eec039616887525c5ddd7a160d9970ea48540a03aafe2f2a8069dbc8e21abe9d2246ba23a

data/lib/contentful_model.rb

@@ -1,9 +1,7 @@
+require 'require_all'
 require 'contentful'
-require "contentful_model/query"
-require "contentful_model/queries"
-require "contentful_model/chainable_queries"
-require "contentful_model/associations"
-require "contentful_model/base"
+require_rel '.'
+
 require "active_support/all"
 
 module ContentfulModel

data/lib/contentful_model/associations/associations.rb

@@ -0,0 +1,13 @@
+# A module to map relationships, a little like ActiveRecord::Relation
+# This is necessary because Contentful::Link classes are not 2-way, so you can't
+# get the parent from a child.
+module ContentfulModel
+  module Associations
+    def self.included(base)
+      base.include HasMany
+      base.include HasOne
+      base.include BelongsTo
+      base.include BelongsToMany
+    end
+  end
+end

data/lib/contentful_model/associations/belongs_to.rb

@@ -0,0 +1,17 @@
+module ContentfulModel
+  module Associations
+    module BelongsTo
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      module ClassMethods
+        # belongs_to is called on the child, and creates methods for mapping to the parent
+        # @param association_name [Symbol] the singular name of the parent
+        def belongs_to(association_name, opts = {})
+          raise NotImplementedError, "Contentful doesn't have a singular belongs_to relationship. Use belongs_to_many instead."
+        end
+      end
+    end
+  end
+end

data/lib/contentful_model/associations/belongs_to_many.rb

@@ -0,0 +1,69 @@
+module ContentfulModel
+  module Associations
+    module BelongsToMany
+      def self.included(base)
+        base.extend ClassMethods
+      end
+      module ClassMethods
+        # belongs_to_many implements a has_many association from the opposite end, and allows a call to the association name
+        # to return all instances for which this object is a child.
+        #
+        # It's moderately expensive because we have to iterate over every parent, checking whether this instance
+        # is in the children. It requires one API call.
+
+        # class Bar
+        #   belongs_to_many :foos, class_name: Foo, inverse_of: :special_bars
+        # end
+
+        # In this example, children on the parent are accessed through an association called special_bars.
+
+        # @param association_names [Symbol] plural name of the class we need to search through, to find this class
+        # @param options [true, Hash] options
+        def belongs_to_many(association_names, opts = {})
+          default_options = {
+            class_name: association_names.to_s.singularize.classify,
+            inverse_of: self.to_s.underscore.to_sym
+          }
+          options = default_options.merge(opts)
+          if self.respond_to?(association_names)
+            self.send(association_names)
+          else
+            define_method "#{association_names}" do
+              parents = instance_variable_get(:"@#{association_names}")
+              if parents.nil?
+                #get the parent class objects as an array
+                parent_objects = options[:class_name].constantize.send(:all).send(:load)
+                #iterate through parent objects and see if any of the children include the same ID as the method
+                parents = parent_objects.select do |parent_object|
+                  #check to see if the parent object responds to the plural or singular.
+                  if parent_object.respond_to?(:"#{options[:inverse_of].to_s.pluralize}")
+                    collection_of_children_on_parent = parent_object.send(:"#{options[:inverse_of].to_s.pluralize}")
+                    #get the collection of children from the parent. This *might* be nil if the parent doesn't have
+                    # any children, in which case, just skip over this parent item and move on to the next.
+                    if collection_of_children_on_parent.nil?
+                      next
+                    else
+                      collection_of_children_on_parent.collect(&:id).include?(id)
+                    end
+                  else
+                    #if it doesn't respond to the plural, assume singular
+                    child_on_parent = parent_object.send(:"#{options[:inverse_of]}")
+                    # Do the same skipping routine on nil.
+                    if child_on_parent.nil?
+                      next
+                    else
+                      child_on_parent.send(:id) == id
+                    end
+
+                  end
+                end
+                instance_variable_set(:"@#{association_names}",parents)
+              end
+              parents
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/contentful_model/associations/has_many.rb

@@ -0,0 +1,44 @@
+module ContentfulModel
+  module Associations
+    module HasMany
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      module ClassMethods
+        # has_many is called on the parent model
+        #
+        # e.g
+        # class Foo
+        #   has_many :bars, class_name: "Something"
+        # end
+        # The only reason for this method is that we might want to specify a relationship which is different
+        # from the name of the model we're calling. If you specify a class_name, the method called on the parent will
+        # be that. e.g. .somethings in this example
+        # @param association_names [Symbol] the name of the child model, as a plural symbol
+        def has_many(association_names, options = {})
+          default_options = {
+            class_name: association_names.to_s.singularize.classify
+          }
+          options = default_options.merge(options)
+          define_method association_names do
+            begin
+              # try calling the association name directly on the superclass - will be picked up by
+              # ContentfulModel::Base#method_missing and return a value if there is one for the attribute
+              super()
+            rescue ContentfulModel::AttributeNotFoundError
+              # If AttributeNotFoundError is raised, that means that the association name isn't available on the object.
+              # We try to call the class name (pluralize) instead, or give up and return an empty collection
+              if options[:class_name].pluralize.underscore.to_sym != association_names
+                self.send(options[:class_name].pluralize.underscore.to_sym)
+              else
+                #return an empty collection if the class name was the same as the association name and there's no attribute on the object.
+                []
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/contentful_model/associations/has_one.rb

@@ -0,0 +1,42 @@
+module ContentfulModel
+  module Associations
+    module HasOne
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      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.
+        # 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.
+        def has_one(association_name, options = {})
+          default_options = {
+            class_name: association_name.to_s.classify
+          }
+          options = default_options.merge(options)
+          # 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 probably end up at ContentfulModel::Base#method_missing
+              super()
+            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
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/contentful_model/base.rb

@@ -12,12 +12,22 @@ module ContentfulModel
     def method_missing(method, *args, &block)
       result = fields[:"#{method.to_s.camelize(:lower)}"]
       if result.nil?
-        super
+        raise ContentfulModel::AttributeNotFoundError, "no attribute #{method} found"
       else
+        # if there's no coercion specified, return the result
         if self.class.coercions[method].nil?
           return result
-        else
+
+        #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
         end
       end
     end
@@ -67,8 +77,12 @@ module ContentfulModel
         client.content_type(@content_type_id)
       end
 
-      def coerce_field(coercions_hash)
-        self.coercions = coercions_hash
+      def coerce_field(*coercions)
+        @coercions ||= {}
+        coercions.each do |coercions_hash|
+          @coercions.merge!(coercions_hash)
+        end
+        @coercions
       end
 
     end

data/lib/contentful_model/errors.rb

@@ -0,0 +1,4 @@
+module ContentfulModel
+  class AssociationError < StandardError; end
+  class AttributeNotFoundError < StandardError; end
+end

data/lib/contentful_model/version.rb

@@ -1,3 +1,3 @@
 module ContentfulModel
-  VERSION = "0.0.8"
+  VERSION = "0.1.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: contentful_model
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.1.0
 platform: ruby
 authors:
 - Error Creative Studio
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-24 00:00:00.000000000 Z
+date: 2015-02-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: contentful
@@ -52,6 +52,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: require_all
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: A wrapper around the Contentful gem to give you a base class to inherit
   your models from
 email:
@@ -63,9 +77,14 @@ files:
 - MIT-LICENSE
 - Rakefile
 - lib/contentful_model.rb
-- lib/contentful_model/associations.rb
+- lib/contentful_model/associations/associations.rb
+- lib/contentful_model/associations/belongs_to.rb
+- lib/contentful_model/associations/belongs_to_many.rb
+- lib/contentful_model/associations/has_many.rb
+- lib/contentful_model/associations/has_one.rb
 - lib/contentful_model/base.rb
 - lib/contentful_model/chainable_queries.rb
+- lib/contentful_model/errors.rb
 - lib/contentful_model/queries.rb
 - lib/contentful_model/query.rb
 - lib/contentful_model/version.rb

data/lib/contentful_model/associations.rb

@@ -1,61 +0,0 @@
-# A module to map relationships, a little like ActiveRecord::Relation
-# This is necessary because Contentful::Link classes are not 2-way, so you can't
-# get the parent from a child.
-module ContentfulModel
-  module Associations
-    def self.included(base)
-      base.extend ClassMethods
-    end
-
-    module ClassMethods
-      # has_many is called on the parent model, and sets an instance var on the child
-      # which is named the plural of the class this module is mixed into.
-      #
-      # e.g
-      # class Foo
-      #   has_many :bars
-      # end
-      # @param classname [Symbol] the name of the child model, as a plural symbol
-      def has_many(classname)
-        #define an instance method called the same as the arg passed in
-        #e.g. bars()
-        define_method "#{classname}" do
-          # call bars() on super, and for each, call bar=(self)
-          super().collect do |instance|
-            instance.send(:"#{self.class.to_s.singularize.camelize(:lower)}=",self)
-            #return the instance to the collect() method
-            instance
-          end
-        end
-      end
-
-      # has_one is called on the parent model, and sets a single instance var on the child
-      # it's conceptually identical to `has_many()`
-      # which is named the singular of the class this module is mixed into
-      def has_one(classname)
-        define_method "#{classname}" do
-          super().send(:"#{self.class.to_s.singularize.camelize(:lower)}=",self)
-          instance
-        end
-      end
-
-
-      # belongs_to is called on the child, and creates methods for mapping to the parent
-      # @param classname [Symbol] the singular name of the parent
-      def belongs_to(classname)
-        raise ArgumentError, "belongs_to requires a class name as a symbol" unless classname.is_a?(Symbol)
-        define_method "#{classname}" do
-          #this is where we need to return the parent class
-          self.instance_variable_get(:"@#{classname}")
-        end
-
-        define_method "#{classname}=" do |instance|
-          #this is where we need to set the class name
-          self.instance_variable_set(:"@#{classname}",instance)
-        end
-
-
-      end
-    end
-  end
-end