contentful_model 0.2.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: cb158dcb23427ac8201185b1201a237ba7dfa0a5
-  data.tar.gz: 7f4e3ac0d68637daf9bb60662c85476ea6e8916a
+SHA256:
+  metadata.gz: 7627c9489ee307874ad678255845eda746e36b0ff2b23cbfb3a352959a06d2da
+  data.tar.gz: 46cfc93b06df11246596c6629191ab66bcad7023de9b56b1a55ba60ab06c5a9d
 SHA512:
-  metadata.gz: 6a69c4da7a8cb02d67af7e4685bcff46f363d4fe63137d30a6a554f7d6c464314ae5980ea3bd2955d61145ee1120b5235675059e5e25c11b2ea986648b983017
-  data.tar.gz: a6b37e8649735c82a5ee6f7439291ceb45b21597e3fc8c0dfe0edf8b483b963af10c07f38a5f2272c876bf9cd4ec2ef1e8419c544379964ccaa2f847077a9ed4
+  metadata.gz: c9761a4b040e5cb433c636218b733f07d4efbcdec9227acc629594eeaf887824d0e8306dc384eaa0e1a9af27f1dd5ea32f55795b1c55bdb4293c66fa43f59167
+  data.tar.gz: 111d113b97a8eb7c8d3e345196029e3cd62c5e6a3872c13568be7fcb9f5a69870d686e89b7f644ad8917fcc4bb3c7cb9e1ec408e624c5b399ce25ae8a912e0eb

data/lib/contentful_model.rb

@@ -1,28 +1,32 @@
-require 'require_all'
+require 'active_support/all'
 require 'contentful/management'
 require 'contentful'
-require_rel '.'
 
-require "active_support/all"
+require_relative 'contentful_model/base'
+require_relative 'contentful_model/migrations/migration'
+require_relative 'contentful_model/version'
 
+# ContentfulModel is an ActiveModel-like interface for the Contentful SDK.
 module ContentfulModel
   class << self
-    #accessor to set the preview API for use instead of the production one
+    # accessor to set the preview API for use instead of the production one
     attr_accessor :use_preview_api
 
-    #access the configuration class as ContentfulModel.configuration
+    # access the configuration class as ContentfulModel.configuration
     attr_accessor :configuration
 
-    #block for configuration.
+    # block for configuration.
     def configure
       self.configuration ||= Configuration.new
       yield(configuration)
     end
   end
 
+  # Configuration store for ContentfulModel
   class Configuration
     attr_accessor :access_token,
                   :preview_access_token,
+                  :environment,
                   :space,
                   :entry_mapping,
                   :management_token,
@@ -30,22 +34,22 @@ module ContentfulModel
 
     def initialize
       @entry_mapping ||= {}
+      @environment = 'master'
     end
 
-    #Rather than listing out all the possible attributes as setters, we have a catchall
-    #called 'options' which takes a hash and generates instance vars
-    #@param options [Hash]
+    # Rather than listing out all the possible attributes as setters, we have a catchall
+    # called 'options' which takes a hash and generates instance vars
+    # @param options [Hash]
     def options=(options)
-      options.each do |k,v|
-        instance_variable_set(:"@#{k}",v)
+      options.each do |k, v|
+        instance_variable_set(:"@#{k}", v)
       end
     end
 
-
     # Return the Configuration object as a hash, with symbols as keys.
     # @return [Hash]
     def to_hash
-      Hash[instance_variables.map { |name| [name.to_s.gsub("@","").to_sym, instance_variable_get(name)] } ]
+      Hash[instance_variables.map { |name| [name.to_s.delete('@').to_sym, instance_variable_get(name)] }]
     end
   end
 end

data/lib/contentful_model/asset.rb

@@ -0,0 +1,30 @@
+require_relative 'asset_dimensions'
+
+module ContentfulModel
+  # Module for providing querying capabilities to Asset
+  class Asset < Contentful::Asset
+    include ContentfulModel::AssetDimensions
+
+    class << self
+      def all(query = {})
+        client.assets(query)
+      end
+
+      def find(id)
+        client.asset(id)
+      end
+
+      def client
+        if ContentfulModel.use_preview_api
+          @preview_client ||= ContentfulModel::Client.new(
+            ContentfulModel.configuration.to_hash
+          )
+        else
+          @client ||= ContentfulModel::Client.new(
+            ContentfulModel.configuration.to_hash
+          )
+        end
+      end
+    end
+  end
+end

data/lib/contentful_model/asset_dimension_query.rb

@@ -0,0 +1,70 @@
+module ContentfulModel
+  # Module for extending Asset with Image API capabilities
+  class AssetDimensionQuery
+    attr_reader :asset, :query
+
+    def initialize(asset)
+      @asset = asset
+      @query = {}
+    end
+
+    def resize(width = nil, height = nil)
+      self.width(width) unless width.nil?
+      self.height(height) unless height.nil?
+      self
+    end
+
+    def width(w)
+      query[:w] = w
+      self
+    end
+
+    def height(h)
+      query[:h] = h
+      self
+    end
+
+    def format(fm)
+      query[:fm] = fm
+      self
+    end
+
+    def jpeg_quality(q)
+      query[:fm] = 'jpg'
+      query[:q] = q
+      self
+    end
+
+    def png_8bit
+      query[:fm] = 'png'
+      query[:fl] = 'png8'
+      self
+    end
+
+    def resize_behavior(fit)
+      query[:fit] = fit
+      self
+    end
+
+    def thumbnail_focused_on(f)
+      query[:fit] = 'thumb'
+      query[:f] = f
+      self
+    end
+
+    def rounded_corners(r)
+      query[:r] = r
+      self
+    end
+
+    def padded_background_color(bg)
+      query[:fit] = 'pad'
+      query[:bg] = bg
+      self
+    end
+
+    def load
+      asset.url(query)
+    end
+  end
+end

data/lib/contentful_model/asset_dimensions.rb

@@ -0,0 +1,54 @@
+require_relative 'asset_dimension_query'
+
+module ContentfulModel
+  # Module to extend Asset with Image API capabilities
+  module AssetDimensions
+    def query
+      ContentfulModel::AssetDimensionQuery.new(self)
+    end
+
+    def resize(width = nil, height = nil)
+      query.resize(width, height)
+    end
+
+    def width(w)
+      query.width(w)
+    end
+
+    def height(h)
+      query.height(h)
+    end
+
+    def format(fm)
+      query.format(fm)
+    end
+
+    def jpeg_quality(q)
+      query.jpeg_quality(q)
+    end
+
+    def png_8bit
+      query.png_8bit
+    end
+
+    def resize_behavior(fit)
+      query.resize_behavior(fit)
+    end
+
+    def thumbnail_focused_on(f)
+      query.thumbnail_focused_on(f)
+    end
+
+    def rounded_corners(r)
+      query.rounded_corners(r)
+    end
+
+    def padded_background_color(bg)
+      query.padded_background_color(bg)
+    end
+
+    def load
+      query.load
+    end
+  end
+end

data/lib/contentful_model/associations/associations.rb

@@ -1,7 +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.
+require_relative 'belongs_to'
+require_relative 'belongs_to_many'
+require_relative 'has_many'
+require_relative 'has_one'
+require_relative 'has_many_nested'
+
 module ContentfulModel
+  # 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 Associations
     def self.included(base)
       base.include HasMany
@@ -11,4 +17,4 @@ module ContentfulModel
       base.include HasManyNested
     end
   end
-end
+end

data/lib/contentful_model/associations/belongs_to.rb

@@ -1,17 +1,22 @@
 module ContentfulModel
   module Associations
+    # Defines Belongs To association
     module BelongsTo
       def self.included(base)
         base.extend ClassMethods
       end
 
+      # Class method
       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."
+        # @param _association_name [Symbol] the singular name of the parent
+        def belongs_to(_association_name, _opts = {})
+          fail(
+            NotImplementedError,
+            "Contentful doesn't have a singular belongs_to relationship. Use belongs_to_many instead."
+          )
         end
       end
     end
   end
-end
+end

data/lib/contentful_model/associations/belongs_to_many.rb

@@ -1,9 +1,12 @@
 module ContentfulModel
   module Associations
+    # Defines Belongs To Many association
     module BelongsToMany
       def self.included(base)
         base.extend ClassMethods
       end
+
+      # Class method
       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.
@@ -12,17 +15,17 @@ module ContentfulModel
         # is in the children. It requires one API call.
 
         # class Bar
-        #   belongs_to_many :foos, class_name: Foo, inverse_of: :special_bars
+        #   belongs_to_many :foos, class_name: Foo
         # end
 
-        # In this example, children on the parent are accessed through an association called special_bars.
+        # 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
+        # @param opts [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
+            page_size: 100
           }
           options = default_options.merge(opts)
 
@@ -39,55 +42,29 @@ module ContentfulModel
           end
 
           define_method "#{association_names.to_s.singularize}=" do |parent|
-            instance_variable_set(:"@#{association_names.to_s.singularize}",parent)
-            instance_variable_set(:"@loaded_with_parent", true)
-            return self
+            instance_variable_set(:"@#{association_names.to_s.singularize}", parent)
+            instance_variable_set(:@loaded_with_parent, true)
+            self
           end
 
-          define_method "loaded_with_parent?" do
-            instance_variable_get(:"@loaded_with_parent") ? true : false
+          define_method :loaded_with_parent? do
+            instance_variable_get(:@loaded_with_parent) ? true : false
           end
 
-          # Set up the association name (plural)
-          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)
+          define_method association_names do
+            parents = instance_variable_get(:"@#{association_names}")
+            if parents.nil?
+              parents = []
+              options[:class_name].constantize.send(:each_entry, options[:page_size], 'sys.updatedAt', links_to_entry: id) do |parent|
+                parents << parent
               end
-              parents
+
+              instance_variable_set(:"@#{association_names}", parents)
             end
+            parents
           end
         end
       end
     end
   end
-end
+end

data/lib/contentful_model/associations/has_many.rb

@@ -1,10 +1,12 @@
 module ContentfulModel
   module Associations
+    # Defines Has Many association
     module HasMany
       def self.included(base)
         base.extend ClassMethods
       end
 
+      # Class method
       module ClassMethods
         # has_many is called on the parent model
         #
@@ -16,34 +18,34 @@ module ContentfulModel
         # 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
+        # rubocop:disable Style/PredicateName
         def has_many(association_names, options = {})
           default_options = {
             class_name: association_names.to_s.singularize.classify,
-            inverse_of: self.to_s.underscore.to_s
+            inverse_of: to_s.underscore.to_s
           }
           options = default_options.merge(options)
+
+          include_discovered(options[:class_name])
+
           define_method association_names 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 each object in the collection to allow easy
               # reverse recursion without another API call (i.e. finding the Foo which called .bars())
-              super().collect do |child|
-                child.send(:"#{options[:inverse_of]}=",self)
-              end
-            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.
-                []
+              super().each do |child|
+                child.send(:"#{options[:inverse_of]}=", self) if child.respond_to?(:"#{options[:inverse_of]}=")
               end
+            rescue NoMethodError
+              possible_field_name = options[:class_name].pluralize.underscore.to_sym
+              return send(possible_field_name) if possible_field_name != association_names && respond_to?(possible_field_name)
+              []
             end
           end
         end
+        # rubocop:enable Style/PredicateName
       end
     end
   end
-end
+end