prismic.io 1.1.1 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 262cbc2bac7da40a5f91810b4b1e3d3325676f0b
-  data.tar.gz: fb939276c43de3b25a2f949119650035536afcd2
+  metadata.gz: 7458128990b44cfa6672a1397197a242585a7798
+  data.tar.gz: 45459748f9aa40d54a83b02e0443be5724afb4dc
 SHA512:
-  metadata.gz: e87f7f3f8eb76161cf56b94dbf919215b85963d3dce8f67ff0383987abbcb67f18ab807b14834a2a810f4c5c87fc00ec7f29873b59558c2ddcde1dfddef7340b
-  data.tar.gz: 14f537c21d1ecee4c18204174e64236911a268f71b49412c4ca4190d984a3f08fab97a36556585329f42e2aa37f42e3a5aa80587a2938389fc1cc40cc5ce2028
+  metadata.gz: 23f7794c5ce0d2a6b1b458024faf710a14495c41904a84e72ed752b8e2813fd976fce0cca8c23f68cbe55de3722c8b8dc6daa73067bfa39b6ffdb613c74e85f9
+  data.tar.gz: 4510b80711bb3097e254cf0485f4888f7f2d858a20d28b7a77557cb2a2dc654a21dfcdd291996ea874919f7c7fb3b2aebbdcd31b62995b961f1320dc96cf6bc4

data/Gemfile

@@ -5,6 +5,7 @@ gemspec
 
 group :test do
   gem "codeclimate-test-reporter", require: nil
+  gem 'hashery', '~> 2.1.1'
   gem "yajl-ruby", require: 'yajl', platforms: [:ruby_19, :ruby_20, :ruby_21]
 end
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    prismic.io (1.1.1)
+    prismic.io (1.2.0)
 
 GEM
   remote: https://rubygems.org/
@@ -9,6 +9,7 @@ GEM
     codeclimate-test-reporter (0.4.1)
       simplecov (>= 0.7.1, < 1.0.0)
     diff-lcs (1.2.4)
+    hashery (2.1.1)
     mini_portile (0.5.1)
     multi_json (1.8.0)
     nokogiri (1.6.0)
@@ -36,6 +37,7 @@ PLATFORMS
 DEPENDENCIES
   bundler (~> 1.3)
   codeclimate-test-reporter
+  hashery (~> 2.1.1)
   nokogiri (~> 1.6)
   prismic.io!
   rspec (~> 2.14)

data/README.md

@@ -63,6 +63,11 @@ Knowing all that, here is typical code written with the Ruby kit:
  * A typical fragment manipulation looks like this: `doc['article.image'].get_view('icon').url`
  * A typical fragment serialization to HTML looks like this: `doc['article.body'].as_html(@link_resolver)`
 
+#### Configuring Alternative API Caches
+
+The default cache stores data in-memory, in the server. You may want to use a different cache, for example to share it between several servers (with memcached or similar). A null cache (does no caching) is also available if you need a predictible behavior for testing or VCR. To use it (or any other compliant cache), simply add `api_cache => Prismic::BasicNullCache.new`
+to the options passed to `Prismic.api`.
+
 ### Changelog
 
 Need to see what changed, or to upgrade your kit? We keep our changelog on [this repository's "Releases" tab](https://github.com/prismicio/ruby-kit/releases).

data/lib/prismic/api.rb

@@ -27,18 +27,6 @@ module Prismic
       !!cache
     end
 
-    # Calls the given block if the provided key is not already cached
-    #
-    # If the cache is disabled, the block is always called
-    #
-    # @param key [String] the cache's key to test
-    # @yieldparam key [String] the key
-    #
-    # @return the return of the given block
-    def caching(key)
-      cache ? cache.get(key){ yield(key) } : yield(key)
-    end
-
     # Returns the master {Ref reference}
     # @api
     #
@@ -121,7 +109,7 @@ module Prismic
     end
 
     # Fetch the API information from the Prismic.io server
-    def self.get(url, access_token=nil, http_client=Prismic::DefaultHTTPClient, api_cache=Prismic::DefaultApiCache)
+    def self.get(url, access_token=nil, http_client=Prismic::DefaultHTTPClient, api_cache=Prismic::DefaultCache)
       data = {}
       data['access_token'] = access_token if access_token
       cache_key = url + (access_token ? ('#' + access_token) : '')
@@ -152,8 +140,10 @@ module Prismic
       http_client = opts[:http_client] || Prismic::DefaultHTTPClient
       access_token = opts[:access_token]
       cache = opts[:cache]
+      api_cache = opts[:api_cache]
+      api_cache = Prismic::DefaultCache unless api_cache
       cache ||= Prismic::DefaultCache unless !cache
-      resp = get(url, access_token, http_client)
+      resp = get(url, access_token, http_client, api_cache)
       json = JSON.load(resp.body)
       parse_api_response(json, access_token, http_client, cache)
     end

data/lib/prismic/cache/lru.rb

@@ -1,16 +1,13 @@
 # encoding: utf-8
+
+require 'hashery'
+
 module Prismic
   # This is a simple cache class provided with the prismic.io Ruby kit.
   #
-  # It is pretty dumb but effective:
+  # It is pretty dumb but effective: * everything is stored in memory,
   #
-  # * everything is stored in memory,
-  # * invalidation: not needed for prismic.io documents (they are eternally
-  #   immutable), but we don't want the cache to expand indefinitely; therefore
-  #   all cache but the new master ref is cleared when a new master ref gets
-  #   published.
-  #
-  # If you need a smarter caching (for instance, caching in files), you can
+  # If you need a smarter caching (for instance, rely on memcached), you can
   # extend this class and replace its methods, and when creating your API object
   # like this for instance: Prismic.api(url, options), pass the name of the
   # class you created as a :cache option. Therefore, to use this simple cache,
@@ -18,26 +15,12 @@ module Prismic
   # Prismic::DefaultCache)`
   class LruCache
 
-    # Based on http://stackoverflow.com/questions/1933866/efficient-ruby-lru-cache
-    # The Hash are sorted, so the age is represented by the key order
-
-    # Returns the cache object holding the responses to "results" queries (lists
-    # of documents). The object that is stored as a cache_object is what is
-    # returned by {Prismic::JsonParser.results_parser} (so that we don't have to
-    # parse anything again, it's stored already parsed).
-    #
-    # @return [Hash<String,Object>]
+    # @return [LRUHash<String,Object>]
     attr_reader :intern
 
-    # Returns the maximum of keys to store
-    #
-    # @return [Fixum]
-    attr_reader :max_size
-
     # @param max_size [Fixnum] (100) The default maximum of keys to store
     def initialize(max_size=100)
-      @intern = {}
-      @max_size = max_size
+      @intern = Hashery::LRUHash.new(max_size)
     end
 
     # Add a cache entry.
@@ -46,58 +29,56 @@ module Prismic
     # @param value [Object] The value to store
     #
     # @return [Object] The stored value
-    def store(key, value)
-      @intern.delete(key)
-      @intern[key] = value
-      if @intern.length > @max_size
-        @intern.delete(@intern.first[0])
-      end
+    def set(key, value, expired_in = nil)
+      @intern.store(key, { :data => value, :expired_in => expired_in = expired_in && Time.now.getutc.to_i + expired_in })
       value
     end
-    alias :[]= :store
 
-    # Update the maximun number of keys to store
-    #
-    # Prune the cache old oldest keys if the new max_size is older than the keys
-    # number.
-    #
-    # @param max_size [Fixnum] The new maximun number of keys to store
-    def max_size=(max_size)
-      raise ArgumentError.new(:max_size) if max_size < 1
-      @max_size = max_size
-      if @max_size < @intern.size
-        @intern.keys[0 .. (@max_size-@intern.size)].each { |k|
-          @intern.delete(k)
-        }
-      end
+    def []=(key, value)
+      set(key, value, nil)
     end
 
     # Get a cache entry
     #
-    # A block can be provided: it will be used to compute (and store) the value
-    # if the key is missing.
-    #
     # @param key [String] The key to fetch
     #
     # @return [Object] The cache object as was stored
     def get(key)
-      found = true
-      value = @intern.delete(key){ found = false }
-      if found
-        @intern[key] = value
+      return delete(key) if expired?(key)
+      include?(key) ? @intern[key][:data] : nil
+    end
+    alias :[] :get
+
+    def get_or_set(key, value = nil, expired_in = nil)
+      if include?(key) && !expired?(key)
+        return get(key)
       else
-        self[key] = yield(key)
+        set(key, block_given? ? yield : value, expired_in)
       end
     end
-    alias :[] :get
+
+    def delete(key)
+      @intern.delete(key)
+      nil
+    end
 
     # Checks if a cache entry exists
     #
     # @param key [String] The key to test
     #
     # @return [Boolean]
-    def include?(key)
-      @intern.include?(key)
+    def has_key?(key)
+      @intern.has_key?(key)
+    end
+    alias :include? :has_key?
+
+    def expired?(key)
+      if include?(key) && @intern[key][:expired_in] != nil
+        expired_in = @intern[key][:expired_in]
+        expired_in && expired_in < Time.now.getutc.to_i
+      else
+        false
+      end
     end
 
     # Invalidates all entries
@@ -125,6 +106,18 @@ module Prismic
 
   end
 
+  # Available as an api cache for testing purposes (no caching)
+  class BasicNullCache
+    def get(key)
+    end
+
+    def set(key, value = nil, expired_in = nil)
+      block_given? ? yield : value
+    end
+    alias_method :get_or_set, :set
+
+  end
+
   # This default instance is used by the API to avoid creating a new instance
   # per request (which would make the cache useless).
   DefaultCache = LruCache.new

data/lib/prismic/version.rb

@@ -1,6 +1,6 @@
 # encoding: utf-8
 module Prismic
 
-  VERSION = '1.1.1'
+  VERSION = '1.2.0'
 
 end

data/lib/prismic.rb

@@ -292,7 +292,10 @@ module Prismic
       # cache_key is a mix of HTTP URL and HTTP method
       cache_key = form_method+'::'+form_action+'?'+data.map{|k,v|"#{k}=#{v}"}.join('&')
 
-      api.caching(cache_key) {
+      from_cache = api.has_cache? && api.cache.get(cache_key)
+      if (from_cache)
+        from_cache
+      else
         if form_method == 'GET' && form_enctype == 'application/x-www-form-urlencoded'
           data['access_token'] = api.access_token if api.access_token
           data.delete_if { |k, v| v.nil? }
@@ -300,6 +303,10 @@ module Prismic
           response = api.http_client.get(form_action, data, 'Accept' => 'application/json')
 
           if response.code.to_s == '200'
+            ttl = (response['Cache-Control'] || '').scan(/max-age\s*=\s*(\d+)/).flatten.first
+            if ttl != nil && api.has_cache?
+              api.cache.set(cache_key, response.body, ttl.to_i)
+            end
             response.body
           else
             body = JSON.load(response.body) rescue nil
@@ -312,7 +319,7 @@ module Prismic
         else
           raise UnsupportedFormKind, "Unsupported kind of form: #{form_method} / #{enctype}"
         end
-      }
+      end
     end
 
     # Specify a parameter for this form
@@ -621,4 +628,3 @@ require 'prismic/predicates'
 require 'prismic/experiments'
 require 'prismic/json_parsers'
 require 'prismic/cache/lru'
-require 'prismic/cache/basic'

data/spec/cache_spec.rb

@@ -49,19 +49,6 @@ describe "Cache's" do
       it 'can return all keys' do
         @cache.keys.should == %w(fake_key1 fake_key2 fake_key3)
       end
-      it 'deletes oldest key when updating max_size' do
-        @cache.max_size = 1
-        @cache.size.should == 1
-        @cache.include?('fake_key1').should be_false
-        @cache.include?('fake_key2').should be_false
-        @cache.include?('fake_key3').should be_true
-      end
-      it 'deletes oldest key when adding new one (at max_size)' do
-        @cache['fake_key4'] = 4
-        @cache.max_size = 3
-        @cache.size.should == 3
-        @cache.include?('fake_key1').should be_false
-      end
       it 'keeps readed keys alive' do
         @cache['fake_key1']
         @cache['fake_key4'] = 4
@@ -83,25 +70,37 @@ describe "Cache's" do
       end
     end
   end
+
+  describe 'configurable api cache' do
+    let(:api_cache) { Prismic::BasicNullCache.new }
+    it 'uses api_cache if provided' do
+      expect(api_cache).to receive(:get_or_set).with("https://lesbonneschoses.prismic.io/api", nil, 5).and_call_original.once
+      Prismic.api("https://lesbonneschoses.prismic.io/api", api_cache: api_cache)
+    end
+    it 'uses default cache if not provided' do
+      expect(Prismic::DefaultCache).to receive(:get_or_set).with("https://lesbonneschoses.prismic.io/api", nil, 5).and_call_original.once
+      Prismic.api("https://lesbonneschoses.prismic.io/api")
+    end
+  end
 end
 
-describe "Basic Cache's" do
+describe "LRU Cache's" do
 
   it 'set & get value' do
-    cache = Prismic::BasicCache.new
+    cache = Prismic::LruCache.new
     cache.set('key', 'value')
     cache.get('key').should == 'value'
   end
 
   it 'set with expiration value & get value' do
-    cache = Prismic::BasicCache.new
+    cache = Prismic::LruCache.new
     cache.set('key', 'value', 1)
     sleep(2)
     cache.get('key').should == nil
   end
 
   it 'set with expiration and a block' do
-    cache = Prismic::BasicCache.new
+    cache = Prismic::LruCache.new
     cache.get_or_set('key', nil, 1){ 'value' }
     cache.get_or_set('key', nil, 1){ 'othervalue' }.should == 'value'
     sleep(2)
@@ -109,13 +108,13 @@ describe "Basic Cache's" do
   end
 
   it 'set & test value' do
-    cache = Prismic::BasicCache.new
+    cache = Prismic::LruCache.new
     cache.set('key', 'value')
     cache.include?('key').should == true
   end
 
   it 'get or set value' do
-    cache = Prismic::BasicCache.new
+    cache = Prismic::LruCache.new
     cache.set('key', 'value')
     cache.get('key').should == 'value'
     cache.get_or_set('key', 'value1')
@@ -125,7 +124,7 @@ describe "Basic Cache's" do
   end
 
   it 'set, delete & get value' do
-    cache = Prismic::BasicCache.new
+    cache = Prismic::LruCache.new
     cache.set('key', 'value')
     cache.get('key').should == 'value'
     cache.delete('key')
@@ -133,7 +132,7 @@ describe "Basic Cache's" do
   end
 
   it 'set, clear & get value' do
-    cache = Prismic::BasicCache.new
+    cache = Prismic::LruCache.new
     cache.expired?('key')
     cache.set('key', 'value')
     cache.set('key1', 'value1')
@@ -141,9 +140,30 @@ describe "Basic Cache's" do
     cache.get('key').should == 'value'
     cache.get('key1').should == 'value1'
     cache.get('key2').should == 'value2'
-    cache.clear()
+    cache.clear!
     cache.get('key').should == nil
     cache.get('key1').should == nil
     cache.get('key2').should == nil
   end
 end
+
+describe 'BasicNullCache' do
+  subject { Prismic::BasicNullCache.new }
+  it 'always misses' do
+    subject.get('key').should == nil
+    subject.set('key', 'value').should == 'value'
+    subject.get('key').should == nil
+  end
+  it 'set uses value if no block' do
+    subject.set('key', 'value').should == 'value'
+  end
+  it 'set uses block if provided' do
+    subject.set('key', 'value'){'value2'}.should == 'value2'
+  end
+  it 'get_or_set uses value if no block' do
+    subject.get_or_set('key', 'value').should == 'value'
+  end
+  it 'get_or_set uses block if provided' do
+    subject.get_or_set('key', 'value'){'value2'}.should == 'value2'
+  end
+end

data/spec/doc_spec.rb

@@ -293,7 +293,7 @@ describe 'Documentation' do
       # startgist:388900d4e9e7a444e0a2:prismic-cache.rb
       # You can pass any object implementing the same methods as the BasicCache
       # https://github.com/prismicio/ruby-kit/blob/master/lib/prismic/cache/basic.rb
-      cache = Prismic::BasicCache.new
+      cache = Prismic::LruCache.new
       api = Prismic::api('https://lesbonneschoses.cdn.prismic.io/api', { :cache => cache })
       # The Api will use the custom cache object
       # endgist

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: prismic.io
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.2.0
 platform: ruby
 authors:
 - Étienne Vallette d'Osia
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-09 00:00:00.000000000 Z
+date: 2015-06-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -87,7 +87,6 @@ files:
 - gulpfile.js
 - lib/prismic.rb
 - lib/prismic/api.rb
-- lib/prismic/cache/basic.rb
 - lib/prismic/cache/lru.rb
 - lib/prismic/experiments.rb
 - lib/prismic/form.rb

data/lib/prismic/cache/basic.rb

@@ -1,66 +0,0 @@
-# encoding: utf-8
-module Prismic
-
-  class BasicCacheEntry
-
-    attr_reader :expired_in
-    attr_reader :data
-
-    def initialize(data, expired_in)
-      @data = data
-      @expired_in = expired_in
-    end
-  end
-
-  class BasicCache
-
-    attr_reader :cache
-    attr_reader :expirations
-
-    def initialize(data = {})
-      @cache = {}
-    end
-
-    def get(key)
-      return delete(key) if expired?(key)
-      include?(key) ? @cache[key].data : nil
-    end
-
-    def set(key, value = nil, expired_in = nil)
-      data = block_given? ? yield : value
-      expired_in = expired_in && Time.now.getutc.to_i + expired_in
-      entry = BasicCacheEntry.new(data, expired_in)
-      @cache[key] = entry
-      entry.data
-    end
-
-    def include?(key)
-      @cache.keys.include?(key)
-    end
-
-    def get_or_set(key, value = nil, expired_in = nil)
-      return get(key) if include?(key) && !expired?(key)
-      set(key, block_given? ? yield : value, expired_in)
-    end
-
-    def delete(key)
-      @cache.delete(key)
-      nil
-    end
-
-    def expired?(key)
-      if include?(key)
-        expired_in = @cache[key].expired_in
-        expired_in && expired_in < Time.now.getutc.to_i
-      else
-        false
-      end
-    end
-
-    def clear()
-      @cache = {}
-    end
-  end
-
-  DefaultApiCache = BasicCache.new
-end