contentful_rails 0.0.9 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9952955574499fc5fd15c613dc0650c2d68d6be4
-  data.tar.gz: f7c079e0b606ee381d58b56a83a9a50f6e5c25e4
+  metadata.gz: 020e69292f25bc884fa90c49bd9a1a8d7182e249
+  data.tar.gz: 45d6590bc12f515276302ac8400b3d3b4c4b80fc
 SHA512:
-  metadata.gz: 48f9f9df90f08dcb70d7a507bb9238a3beadfaf5511acd332d0ff573ec80fa2458bf8727ba5fd8e2a031b3602585a810fd78e79830784f0713ddc71948d4ee5f
-  data.tar.gz: 32aa569a4ffc4c0381ccb4328d1c8c2e80e509b63bc81d42a53bdbb8f2e32c5e292431020e51a11abe3aa85a3f3a0578fb1aa0f9adb695eaad1bafa9706e5121
+  metadata.gz: 2aedf217e1096fcda85385e891706a39be4606bb5696ba3683af33aad0fb414b0f859316ad648fcc01d3dca246e1dac4efdf6847dfd2bc9c1daa644fc31e9955
+  data.tar.gz: dd9de11844ecb8075a8f3a995d272e9ab6678ba9cb1853f44556cb3a7a8ad24716dfc004131935a410efbbfefda945561109a93b18932d286c4f93d905d0f706

data/app/controllers/contentful_rails/webhooks_controller.rb

@@ -16,14 +16,11 @@ class ContentfulRails::WebhooksController < ActionController::Base
     # We can then just use normal Rails russian doll caching without expensive API calls.
     request.format = :json
     update_type = request.headers['HTTP_X_CONTENTFUL_TOPIC']
-    content_type_id = params[:sys][:contentType][:sys][:id]
-    item_id = params[:sys][:id]
-    cache_key = "contentful_timestamp/#{content_type_id}/#{item_id}"
-
-    #delete the cache entry
-    if update_type =~ %r(Entry)
-      Rails.cache.delete(cache_key)
-    end
+
+    # All we do here is publish an ActiveSupport::Notification, which is subscribed to
+    # elsewhere. In this gem are subscription options for timestamp or object caching,
+    # implement your own and subscribe in an initializer.
+    ActiveSupport::Notifications.instrument("Contentful.#{update_type}", params)
 
     #must return an ok
     render nothing: true

data/app/helpers/contentful_rails/markdown_helper.rb

@@ -6,6 +6,7 @@ module ContentfulRails
     # @param renderer_options [Hash] of options from https://github.com/vmg/redcarpet#darling-i-packed-you-a-couple-renderers-for-lunch
     # @param markdown_options [Hash] of options from https://github.com/vmg/redcarpet#and-its-like-really-simple-to-use
     def parse_markdown(markdown_string, renderer_options: {}, markdown_options: {}, image_options: {})
+      markdown_string ||= ""
       markdown_opts = {
         no_intr_emphasis: true,
         tables: true,

data/lib/contentful_rails.rb

@@ -1,9 +1,10 @@
 require "contentful_rails/engine"
 require "contentful_rails/development_constraint"
-require "contentful_rails/cached_timestamps"
+require 'contentful_rails/caching/timestamps'
 require "contentful_rails/markdown_renderer"
 require "contentful_rails/nested_resource"
 require "contentful_rails/sluggable"
+require "contentful_rails/preview"
 require 'redcarpet'
 
 module ContentfulRails
@@ -17,10 +18,25 @@ module ContentfulRails
   end
 
   class Configuration
-    attr_accessor :authenticate_webhooks, :webhooks_username, :webhooks_password
+    attr_accessor :authenticate_webhooks,
+                  :webhooks_username,
+                  :webhooks_password,
+                  :slug_delimiter,
+                  :perform_caching,
+                  :access_token,
+                  :preview_access_token,
+                  :space,
+                  :contentful_options,
+                  :preview_username,
+                  :preview_password,
+                  :preview_domain,
+                  :enable_preview_domain
 
     def initialize
       @authenticate = true
+      @slug_delimiter = "-"
+      @perform_caching = Rails.configuration.action_controller.perform_caching
+      @contentful_options = {}
     end
   end
 end

data/lib/contentful_rails/caching/timestamps.rb

@@ -0,0 +1,57 @@
+module ContentfulRails
+  module Caching
+    # A module to prepend into ContentfulModel::Base which will allow the model instance
+    # to check the cache for its timestamp before making an expensive API call.
+    # Also includes a module method to remove an existing timestamp.
+    module Timestamps
+      def self.included(base)
+        base.extend ClassMethods
+        base.class_eval do
+          alias_method_chain :updated_at, :caching
+          alias_method_chain :cache_key, :preview
+        end
+      end
+
+      module ClassMethods
+        # Clear an existing timestamp from the cache; called by the subscriber to the Entry notifications
+        # from the WebhooksController.
+        def clear_cache_for(item_id)
+          cache_key = timestamp_cache_key(item_id)
+
+          Rails.cache.delete(cache_key)
+        end
+
+        def timestamp_cache_key(item_id)
+          "contentful_timestamp/#{self.content_type_id}/#{item_id}"
+        end
+      end
+
+
+      # A replacement method for updated_at(), called when this module is included in ContentfulModel::Base
+      def updated_at_with_caching
+        if ContentfulRails.configuration.perform_caching && !ContentfulModel.use_preview_api
+          Rails.cache.fetch(self.timestamp_cache_key) do
+            updated_at_without_caching
+          end
+        else
+          updated_at_without_caching
+        end
+      end
+
+      def timestamp_cache_key
+        self.class.timestamp_cache_key(id)
+      end
+
+      def cache_key_with_preview
+        if ContentfulModel.use_preview_api
+          "preview/#{cache_key_without_preview}"
+        else
+          cache_key_without_preview
+        end
+      end
+
+
+    end
+  end
+end
+

data/lib/contentful_rails/engine.rb

@@ -3,10 +3,25 @@ module ContentfulRails
 
     isolate_namespace ContentfulRails
 
+    config.before_initialize do
+      if ContentfulRails.configuration.nil?
+        ContentfulRails.configure {}
+      end
+    end
+
+    initializer "configure_contentful", before: :add_entry_mappings do
+      ContentfulModel.configure do |config|
+        config.access_token = ContentfulRails.configuration.access_token
+        config.preview_access_token = ContentfulRails.configuration.preview_access_token
+        config.space = ContentfulRails.configuration.space
+        config.options = ContentfulRails.configuration.contentful_options
+      end
+    end
+
     #Iterate through all models which inherit from ContentfulModel::Base
     #and add an entry mapping for them, so calls to the Contentful API return
-    #the appropriate classes.
-    initializer "add_entry_mappings_for_contentful_models" do
+    #the appropriate classes
+    initializer "add_entry_mappings", after: :configure_contentful  do
       if defined?(ContentfulModel)
         Rails.application.eager_load!
         ContentfulModel::Base.descendents.each do |klass|
@@ -15,22 +30,29 @@ module ContentfulRails
       end
     end
 
+    initializer "subscribe_to_webhook_events", after: :add_entry_mappings do
+      ActiveSupport::Notifications.subscribe(/Contentful.*Entry.*/) do |name, start, finish, id, payload|
+        content_type_id = payload[:sys][:contentType][:sys][:id]
+        klass = ContentfulModel.configuration.entry_mapping[content_type_id]
+        klass.send(:clear_cache_for, payload[:sys][:id])
+      end
+    end
+
     initializer "add_contentful_mime_type" do
       Mime::Type.register "application/json", :json, ["application/vnd.contentful.management.v1+json"]
     end
 
-    config.to_prepare do
-      if defined?(::ContentfulModel)
-        ContentfulModel::Base.send(:include, ContentfulRails::CachedTimestamps)
+    initializer "add_preview_support" do
+      ActiveSupport.on_load(:action_controller) do
+        include ContentfulRails::Preview
       end
     end
 
-    #if we're at the end of initialization and there's no config object,
-    #set one up with the default options (i.e. an empty proc)
-    config.after_initialize do
-      if ContentfulRails.configuration.nil?
-        ContentfulRails.configure {}
+    config.to_prepare do
+      if defined?(::ContentfulModel)
+        ContentfulModel::Base.send(:include, ContentfulRails::Caching::Timestamps)
       end
     end
+
   end
 end

data/lib/contentful_rails/markdown_renderer.rb

@@ -5,6 +5,7 @@ require 'redcarpet'
 # You can subclass this in your application, to add or manipulate specific markup to elements in the markdown.
 class ContentfulRails::MarkdownRenderer < Redcarpet::Render::HTML
   include ActionView::Helpers::TagHelper
+  include ActionView::Context
   def initialize(opts)
     @options = opts
     @image_parameters = {

data/lib/contentful_rails/nested_resource.rb

@@ -11,11 +11,15 @@ module ContentfulRails
       # e.g. /grandparent/parent/child
       # @param [Symbol] the field to search by - for example, :slug
       # @param [String] the path as a forward-slash separated string
-      def get_nested_from_path_by(field, path, opts)
-        if opts.present? && opts[:unescape]
-          path = CGI::unescape(path)
-        end
-        root, *children = path.gsub(/^\//, '').split("/")
+      def get_nested_from_path_by(field, path, opts = {})
+        options = {delimiter: '/', unescape: false, prefix: ""}
+        options.merge!(opts)
+
+        path = CGI::unescape(path) if options[:unescape]
+        delimiter = options[:delimiter]
+        prefix = options[:prefix].empty? ? "" : "#{delimiter}#{options[:prefix]}#{delimiter}"
+
+        root, *children = "#{prefix}#{path}".gsub(/^\//, '').split(delimiter)
 
         if field.to_sym == :id
           #we need to call find() to get by ID
@@ -62,8 +66,13 @@ module ContentfulRails
     # @param [Symbol] the field to use to create the path
     # @param [String] the delimiter to use. Defaults to "/"
     # @return [String] the path as a string
-    def nested_path_by(field, delimiter="/")
-      ([self] + ancestors).reverse.collect {|a| a.send(field)}.join(delimiter)
+    def nested_path_by(field, opts = {})
+      options = {delimiter: "/", prefix: ""}
+      options.merge!(opts)
+      delimiter = options[:delimiter]
+      prefix = options[:prefix].empty? ? "" : "#{options[:prefix]}#{delimiter}"
+      path = ([self] + ancestors).reverse.collect {|a| a.send(field)}.join(delimiter).gsub(prefix,"")
+      return delimiter + path
     end
   end
-end
+end

data/lib/contentful_rails/preview.rb

@@ -0,0 +1,53 @@
+module ContentfulRails
+  module Preview
+    extend ActiveSupport::Concern
+
+    included do
+      before_action :check_preview_domain
+      after_action :remove_preview_cache
+      helper_method :preview?
+    end
+    # Check whether the subdomain being presented is the preview domain.
+    # If so, set ContentfulModel to use the preview API, and request a username / password
+    def check_preview_domain
+      # If enable_preview_domain is not enabled, explicitly set use_preview_api false and return
+      unless ContentfulRails.configuration.enable_preview_domain
+        ContentfulModel.use_preview_api = false
+        return
+      end
+
+      #check subdomain matches the configured one - we assume it's first sub.domain.in.the.array
+      if request.subdomains.first == ContentfulRails.configuration.preview_domain
+        authenticated = authenticate_with_http_basic  do |u,p|
+          u == ContentfulRails.configuration.preview_username
+          p == ContentfulRails.configuration.preview_password
+        end
+        # If user is authenticated, we're good to switch to the preview api
+        if authenticated
+          ContentfulModel.use_preview_api = true
+        else
+          #otherwise ask for user / pass
+            request_http_basic_authentication
+        end
+      else
+        #if the subdomain doesn't match the configured one, explicitly set to false
+        ContentfulModel.use_preview_api = false
+        return
+      end
+
+    end
+
+    # If we're in preview mode, we need to remove the preview view caches which were created.
+    # this is a bit of a hack but it's probably not feasible to turn off caching in preview mode.
+    def remove_preview_cache
+      # in preview mode, we alias_method_chain the cache_key method on ContentfulModel::Base to append 'preview/'
+      # to the front of the key.
+      return unless request.subdomain == ContentfulRails.configuration.preview_domain
+      expire_fragment(%r{.*/preview/.*})
+    end
+
+    def preview?
+      ContentfulModel.use_preview_api == true
+    end
+  end
+end

data/lib/contentful_rails/sluggable.rb

@@ -1,19 +1,17 @@
 module ContentfulRails
   module Sluggable
+    extend ActiveSupport::Concern
     # A quick mixin to slugify a field other than 'slug'
     # NOTE that if you include sluggable (and define a slug field) in a class which responds to
     # slug() than you'll get a stack level too deep error.
-    module Sluggable
-      extend ActiveSupport::Concern
 
-      class_methods do
-        attr_accessor :slug_field
-      end
+    class_methods do
+      attr_accessor :slug_field
+    end
 
-      def slug
-        if self.class.slug_field.present?
-          self.send(self.class.slug_field).parameterize(Rails.configuration.x.param_delimiter)
-        end
+    def slug
+      if self.class.slug_field.present?
+        self.send(self.class.slug_field).parameterize(ContentfulRails.configuration.slug_delimiter)
       end
     end
   end

data/lib/contentful_rails/version.rb

@@ -1,3 +1,3 @@
 module ContentfulRails
-  VERSION = "0.0.9"
+  VERSION = "0.2.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: contentful_rails
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 0.2.1
 platform: ruby
 authors:
 - Error Creative Studio
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-22 00:00:00.000000000 Z
+date: 2015-04-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: contentful_model
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: 0.1.5
+        version: 0.1.6
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: 0.1.5
+        version: 0.1.6
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
@@ -65,11 +65,12 @@ files:
 - app/helpers/contentful_rails/markdown_helper.rb
 - config/routes.rb
 - lib/contentful_rails.rb
-- lib/contentful_rails/cached_timestamps.rb
+- lib/contentful_rails/caching/timestamps.rb
 - lib/contentful_rails/development_constraint.rb
 - lib/contentful_rails/engine.rb
 - lib/contentful_rails/markdown_renderer.rb
 - lib/contentful_rails/nested_resource.rb
+- lib/contentful_rails/preview.rb
 - lib/contentful_rails/sluggable.rb
 - lib/contentful_rails/version.rb
 - lib/tasks/contentful_rails_tasks.rake

data/lib/contentful_rails/cached_timestamps.rb

@@ -1,28 +0,0 @@
-module ContentfulRails
-  #A module to prepend into ContentfulModel::Base which will allow the model instance
-  #to check the cache for its timestamp before making an expensive API call
-  module CachedTimestamps
-    def self.included(base)
-      base.class_eval do
-        alias_method_chain :updated_at, :caching
-      end
-    end
-
-    def updated_at_with_caching
-      if Rails.configuration.action_controller.perform_caching
-        Rails.cache.fetch(self.timestamp_cache_key) do
-          updated_at_without_caching
-        end
-      else
-        updated_at_without_caching
-      end
-    end
-
-    def timestamp_cache_key
-      "contentful_timestamp/#{self.class.content_type_id}/#{self.id}"
-    end
-
-  end
-
-end
-