contentful_middleman 1.2.0 → 1.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 25dc16eb8eaa65244fc568404d2e3cf413c8dd34
-  data.tar.gz: e0ab36f581ddb8e6848e4aa3e9b0e4dd0611c70a
+  metadata.gz: db0206f855bb8bfb8c037a5aabc0c0d1b668db0a
+  data.tar.gz: bfc915bd5b1d17c43f8c339fda06af0fa594417a
 SHA512:
-  metadata.gz: 8f46e858aa74ed09a603e7e16b27d18d8c62dae561c7952e75fc30f106a8768b0e1363b5dff5905301cbb98b9d37149fab6cb1382188c67112cd1af4f08ce5fe
-  data.tar.gz: 4a1948b0b9a1e0a40ca1afbf76413b4ad86275ee61590fa63ee1c71fc4bc04cc3360c5ee690a1bed9e7103506307fed28608c05eb97fbe237ea10ca40edbbf40
+  metadata.gz: 5661015434c5c51b32aeab1c1c735eaee5cc41f053c2e618e15bde6ab874743af5877ab594fcdad6659b2602cdf0c56bab443368398efae8a3c9c63cfc68f005
+  data.tar.gz: 0a23c10c9ee693e9c3a2f1f8dcf28232c3025ebf0528c055d7e0a9841bcd6448b0ce169a43b8937af36ff654e442f0cee9fdd7885f7688b9ef931c2ece593715

data/.travis.yml

@@ -6,7 +6,13 @@ rvm:
 
 script: "bundle exec rake test"
 
+before_install: gem install bundler -v 1.10.6
+
 env: TEST=true JRUBY_OPTS='--2.0'
 notifications:
   slack:
     secure: MMWxqKMT4m2UhZ+Ix4wgCs1nLvu9hUFCbyV/qJWmIFif7V4GUKXi6h9krMqGqBAd3YV3pP/InPlw3QoKBUGIAIr5GzDpSnU5ACv7E61v548qViEvPBqsfhRHha2M164rUHn32tpejJnIizVUyND/hIzNviIrab+G8uOaZXUtB5I=
+
+matrix:
+  allow_failures:
+    - rvm: jruby

data/CHANGELOG.md

@@ -1,6 +1,19 @@
 # Change Log
 ## Unreleased
 
+## 1.3.1
+### Fixed
+* Middleman not loading extension due to `@app` reassignment
+
+## 1.3.0 [YANKED]
+### Added
+* Added PreviewProxy for caching Preview API results
+* Added `#with_preview` view helper for Preview API calls in real-time with a small cache
+* Added `:webhook_controller` to extension options to be able to customize the Webhook Handler
+
+### Changed
+* Moved Webhook Integration to `before_server` hook to avoid multiple Webhook server instances running
+
 ## 1.2.0
 ### Added
 * Include `:all_entries` option to `activate` block for getting over 1000 entries[#45](https://github.com/contentful-labs/contentful_middleman/issues/45)

data/Gemfile

@@ -7,11 +7,9 @@ gem "middleman-core", '~> 3.4'
 # Specify your gem's dependencies in contentful_middleman.gemspec
 gemspec
 
-gem "rake"
 gem "yard"
 
 # Test tools
-gem "rspec"
 gem "simplecov"
 
 gem "cane", :platforms => [:mri_19, :mri_20], :require => false

data/README.md

@@ -6,6 +6,11 @@ Contentful Middleman is a [Middleman](http://middlemanapp.com/) extension to use
 
 Experience the power of Middleman while staying sane as a developer by letting end-users edit content in a web-based interface.
 
+> The main release works for Middleman v3 - The most used version
+>
+> If you are using Middleman v4, consider trying out our [experimental branch](https://github.com/contentful/contentful_middleman/tree/dl/upgrade-to-v4).
+> Feel free to communicate with us if you are experiencing any bugs.
+
 
 ## Installation
 Add the following line to the Gemfile of your Middleman project:
@@ -54,6 +59,7 @@ use_preview_api     | Boolean to toggle the used API. Set it to `false` to use `
 all_entries         | Boolean to toggle multiple requests to the API for getting over 1000 entries. This uses a naive approach and can get rate limited. When using this, have in mind adding an `order` in your `:cda_query` . Default order is `order: 'sys.createdAt'`
 rebuild_on_webhook  | Boolean to toggle Webhook server. Server will run in port 5678, and will be expecting to receive Contentful Webhook calls on `/receive`
 webhook_timeout     | Integer (in seconds) for wait time after Webhook received for rebuilding. Only used if `:rebuild_on_webhook` is true. Defaults to 300 seconds
+webhook_controller  | Class for handling Webhook response, defaults to `::ContentfulMiddleman::WebhookHandler`
 
 You can activate the extension multiple times to import entries from different spaces.
 
@@ -183,7 +189,7 @@ data into your templates.
 Consider that we have data stored under `data/partners/partner`. Then in our templates we could use that data like
 this:
 
-```html
+```erb
 <h1>Partners</h1>
 <ol>
   <% data.partners.partner.each do |id, partner| %>
@@ -213,7 +219,7 @@ Then you have the following methods of accessing locales:
 
 You can access your localized fields by fetching the locale directly from the data
 
-```html
+```erb
 <h1>Partners</h1>
 <ol>
   <% data.partners.partner.each do |id, partner| %>
@@ -226,7 +232,7 @@ You can access your localized fields by fetching the locale directly from the da
 
 You can also map an specific locale for all entry fields using `localize_entry`
 
-```html
+```erb
 <h1>Partners</h1>
 <ol>
   <% data.partners.partner.each do |id, partner| %>
@@ -240,7 +246,7 @@ You can also map an specific locale for all entry fields using `localize_entry`
 
 The `localize` helper will map an specific locale to a field of your entry
 
-```html
+```erb
 <h1>Partners</h1>
 <ol>
   <% data.partners.partner.each do |id, partner| %>
@@ -257,7 +263,7 @@ Or, you can use `localize_value` or `localize_array` if you want more granularit
 > This method is discouraged, as `localize` achieves the same goal and is a field-type
 agnostic wrapper of these methods.
 
-```html
+```erb
 <h1>Partners</h1>
 <ol>
   <% data.partners.partner.each do |id, partner| %>
@@ -272,3 +278,53 @@ If your fields are not localized, the value of the field will be returned.
 In case of the field being localized but no value being set for a given entry, it will use
 a fallback locale, by default is `en-US` but can be specified as an additional
 parameter in all the mentioned calls.
+
+### Preview API Helper
+
+You can use the `#with_preview` helper to try your Preview API content without having to
+generate the entire `data` structures.
+
+This generates a new Preview Contentful Client and has a cache that will store your objects
+in memory until they are considered to need refresh.
+
+It can be used like a Contentful Client:
+
+```erb
+<% with_preview(space: 'cfexampleapi', access_token: 'b4c0n73n7fu1') do |preview| %>
+  <% entry = preview.entry('nyancat') %>
+
+  <p>Name: <%= entry.name %></p>
+<% end %>
+```
+
+If you want to clear the cache to force a refresh:
+
+```erb
+<% with_preview(space: 'cfexampleapi', access_token: 'b4c0n73n7fu1') do |preview| %>
+  <% preview.clear_cache %>
+<% end %>
+```
+
+#### Caching Rules
+
+* Every preview client will be cached by Space/Access Token combination
+* Only `entry`, `entries`, `asset` and `assets` will be cached
+* Every call will be cached by it's query parameters and ID (if ID is applicable)
+* Each call will be considered, by default, stale after 3 tries or 2 hours
+* Cache can be cleared by calling `#clear_cache`, this applies per preview client
+
+#### Caching Configuration
+
+You can configure `:tries` and `:expires_in` in the `#with_preview` call like this:
+
+```erb
+<% with_preview(
+     space: 'cfexampleapi',
+     access_token: 'b4c0n73n7fu1',
+     tries: 20,                                                      # Set Tries to 20 before stale
+     expires_in: ContentfulMiddleman::Tools::PreviewProxy.minutes(5) # Set Expiration to 5 minutes
+   ) do |preview| %>
+  <!-- do your stuff -->
+<% end %>
+```
+

data/contentful_middleman.gemspec

@@ -19,7 +19,7 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
 
   # The version of middleman-core your extension depends on
-  s.add_dependency("middleman-core", ["~> 3.3"])
+  s.add_dependency("middleman-core", ["~> 3.4"])
 
   # Additional dependencies
   s.add_dependency("contentful", '~> 0.8')

data/lib/contentful_middleman/core.rb

@@ -40,9 +40,23 @@ module ContentfulMiddleman
     option :webhook_timeout, 300,
       "Wait time before rebuild after receiving a Webhook call"
 
+    option :webhook_controller, ::ContentfulMiddleman::WebhookHandler,
+      "Controller for managing Webhook callbacks"
+
 
     helpers ContentfulMiddleman::Helpers
 
+    attr_reader :middleman_app
+    def initialize(app, options_hash = {}, &block)
+      super
+      @middleman_app = app
+
+      this = self # Hack due to context change
+      app.before_server do
+        this.webhook_options
+      end
+    end
+
     #
     # Middleman hooks
     #
@@ -50,8 +64,10 @@ module ContentfulMiddleman
       massage_options
 
       ContentfulMiddleman.instances << (ContentfulMiddleman::Instance.new self)
+    end
 
-      webhook_options
+    def webhook_options
+      ::ContentfulMiddleman::WebhookHandler.start(options) if options.rebuild_on_webhook
     end
 
     private
@@ -84,9 +100,5 @@ module ContentfulMiddleman
 
       options.content_types = new_content_types_options
     end
-
-    def webhook_options
-      ::ContentfulMiddleman::WebhookHandler.start(options) if options.rebuild_on_webhook
-    end
   end
 end

data/lib/contentful_middleman/helpers.rb

@@ -1,3 +1,5 @@
+require 'contentful_middleman/tools/preview_proxy'
+
 module ContentfulMiddleman
   module Helpers
     def contentful_instances
@@ -32,5 +34,16 @@ module ContentfulMiddleman
       end
       value
     end
+
+    def with_preview(space: '', access_token: '', tries: 3, expires_in: ContentfulMiddleman::Tools::PreviewProxy.hours(2), &block)
+      preview_client = ContentfulMiddleman::Tools::PreviewProxy.instance(
+        space: space,
+        access_token: access_token,
+        tries: tries,
+        expires_in: expires_in
+      )
+
+      block.call(preview_client)
+    end
   end
 end

data/lib/contentful_middleman/tools/preview_proxy.rb

@@ -0,0 +1,131 @@
+require 'contentful'
+
+module ContentfulMiddleman
+  module Tools
+    class PreviewProxy < ::Contentful::Client
+      @@instances = []
+      def self.instance(space: '', access_token: '', tries: 3, expires_in: hours(2))
+        possible_instance = @@instances.detect { |i| i[:space] == space && i[:access_token] == access_token }
+        if possible_instance.nil?
+          preview_client = PreviewProxy.new(space: space, access_token: access_token, tries: tries, expires_in: expires_in)
+          @@instances << {space: space, access_token: access_token, instance: preview_client}
+        else
+          preview_client = possible_instance[:instance]
+        end
+
+        preview_client
+      end
+
+      def self.days(amount)
+        amount
+      end
+
+      def self.hours(amount)
+        amount / 24.0
+      end
+
+      def self.minutes(amount)
+        hours(amount) / 60.0
+      end
+
+      def self.seconds(amount)
+        minutes(amount) / 60.0
+      end
+
+      CACHE_MAPPINGS = {
+        entries: {
+          cache: :cached_entry_collection
+        },
+        assets: {
+          cache: :cached_asset_collection
+        },
+        entry: {
+          cache: :cached_entries
+        },
+        asset: {
+          cache: :cached_assets
+        }
+      }
+
+      def initialize(space: '', access_token: '', tries: 3, expires_in: self.class.hours(2))
+        super(
+          space: space,
+          access_token: access_token,
+          dynamic_entries: :auto,
+          preview: true
+        )
+
+        @cache_tries = tries
+        @expires_in = expires_in
+
+        clear_cache
+      end
+
+      def entries(query = {})
+        cache(:entries, ->(query, id) { super(query) }, query)
+      end
+
+      def entry(id, query = {})
+        cache(:entry, ->(query, id) { super(id, query) }, query, id)
+      end
+
+      def assets(query = {})
+        cache(:assets, ->(query, id) { super(query) }, query)
+      end
+
+      def asset(id, query = {})
+        cache(:asset, ->(query, id) { super(id, query) }, query, id)
+      end
+
+      def clear_cache
+        @cached_entry_collection = {}
+        @cached_asset_collection = {}
+
+        @cached_entries = {}
+        @cached_assets = {}
+      end
+
+      private
+
+      def cache(name, super_call, query = {}, id = '')
+        mapping = CACHE_MAPPINGS[name]
+
+        if should_fetch_from_api?(name, query: query, id: id)
+          instance_variable_get("@#{mapping[:cache]}")[cache_key(name, query, id)] ||= {}
+          instance_variable_get("@#{mapping[:cache]}")[cache_key(name, query, id)][:tries] = 0
+          instance_variable_get("@#{mapping[:cache]}")[cache_key(name, query, id)][:expires] = DateTime.now + @expires_in
+
+          new_resources = super_call.call(query, id)
+          instance_variable_get("@#{mapping[:cache]}")[cache_key(name, query, id)][:data] = new_resources
+          return new_resources
+        end
+
+        instance_variable_get("@#{mapping[:cache]}")[cache_key(name, query, id)][:tries] += 1
+        instance_variable_get("@#{mapping[:cache]}")[cache_key(name, query, id)][:data]
+      end
+
+      def cache_key(name, query = {}, id = '')
+        mapping = CACHE_MAPPINGS[name]
+
+        Marshal.dump(collection?(name) ? query : query.merge(cache_id: id))
+      end
+
+      def collection?(name)
+        name.to_s.end_with?('s')
+      end
+
+      def should_fetch_from_api?(name, query: {}, id: '')
+        mapping = CACHE_MAPPINGS[name]
+
+        cache = instance_variable_get("@#{mapping[:cache]}")
+        key = cache_key(name, query, id)
+
+        return true unless cache.key?(key)
+        return true if cache[key][:tries] >= @cache_tries
+        return true if cache[key][:expires] <= DateTime.now
+
+        false
+      end
+    end
+  end
+end

data/lib/contentful_middleman/version.rb

@@ -1,3 +1,3 @@
 module ContentfulMiddleman
-  VERSION = "1.2.0"
+  VERSION = "1.3.1"
 end

data/lib/contentful_middleman/webhook_handler.rb

@@ -14,7 +14,7 @@ module ContentfulMiddleman
         config[:endpoints] = [{
           endpoint: '/receive',
           timeout: options.webhook_timeout,
-          controller: ::ContentfulMiddleman::WebhookHandler
+          controller: options.webhook_controller
         }]
         logger = Logger.new(STDOUT)
         logger.level = Logger::INFO

data/spec/contentful_middleman/core_spec.rb

@@ -68,21 +68,20 @@ describe ContentfulMiddleman::Core do
 
         expect(ContentfulMiddleman.instances.size).to eq(1)
       end
+    end
+    describe 'webhook handler' do
+      it 'does not get called if rebuild_on_webhook is false' do
+        expect(ContentfulMiddleman::WebhookHandler).not_to receive(:start)
 
-      describe 'webhook handler' do
-        it 'does not get called if rebuild_on_webhook is false' do
-          expect(ContentfulMiddleman::WebhookHandler).not_to receive(:start)
-
-          subject.after_configuration
-        end
+        subject.middleman_app.run_hook(:before_server)
+      end
 
-        it 'gets called if rebuild_on_webhook is true' do
-          options.rebuild_on_webhook = true
+      it 'gets called if rebuild_on_webhook is true' do
+        options.rebuild_on_webhook = true
 
-          expect(ContentfulMiddleman::WebhookHandler).to receive(:start)
+        expect(ContentfulMiddleman::WebhookHandler).to receive(:start)
 
-          subject.after_configuration
-        end
+        subject.middleman_app.run_hook(:before_server)
       end
     end
   end

data/spec/contentful_middleman/helpers_spec.rb

@@ -95,5 +95,22 @@ describe ContentfulMiddleman::Helpers do
         })
       end
     end
+
+    describe 'preview helpers' do
+      describe '#with_preview' do
+        it 'creates a preview client' do
+          vcr('helpers/preview') {
+            subject.with_preview(space: 'cfexampleapi', access_token: 'b4c0n73n7fu1') do |preview|
+              expect(preview).to be_a ::Contentful::Client
+              expect(preview).to be_a ::ContentfulMiddleman::Tools::PreviewProxy
+
+              preview_entries = preview.entries
+              expect(preview_entries.size).to eq 11
+              expect(preview_entries).to be_a ::Contentful::Array
+            end
+          }
+        end
+      end
+    end
   end
 end