tennpipes-memory 3.6.6

data/lib/tennpipes-memory/helpers/cache_object.rb

@@ -0,0 +1,23 @@
+module Tennpipes
+  module Cache
+    module Helpers
+      module ObjectCache
+        def cache_object(key, opts = {})
+          if settings.caching?
+            began_at = Time.now
+            if value = settings.cache[key.to_s]
+              logger.debug "GET Object", began_at, key.to_s if defined?(logger)
+            else
+              value = yield
+              settings.cache.store(key.to_s, value, opts)
+              logger.debug "SET Object", began_at, key.to_s if defined?(logger)
+            end
+            value
+          else
+            yield
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tennpipes-memory/helpers/cache_store.rb

@@ -0,0 +1,16 @@
+module Tennpipes
+  module Cache
+    module Helpers
+      module CacheStore
+        def expire(*key)
+          if key.size == 1 and (key.first.is_a?(String) or key.first.is_a?(Symbol))
+            settings.cache.delete(key.first)
+          else
+            settings.cache.delete(self.class.url(*key))
+          end
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/tennpipes-memory/helpers/fragment.rb

@@ -0,0 +1,71 @@
+module Tennpipes
+  module Cache
+    module Helpers
+      ##
+      # Whereas page-level caching, described in the first section of this document, works by
+      # grabbing the entire output of a route, fragment caching gives the developer fine-grained
+      # control of what gets cached. This type of caching occurs at whatever level you choose.
+      #
+      # Possible uses for fragment caching might include:
+      #
+      # - a 'feed' of some items on a page
+      # - output fetched (by proxy) from an API on a third-party site
+      # - parts of your page which are largely static/do not need re-rendering every request
+      # - any output which is expensive to render
+      #
+      module Fragment
+        include Tennpipes::Helpers::OutputHelpers
+
+        ##
+        # This helper is used anywhere in your application you would like to associate a fragment
+        # to be cached. It can be used in within a route:
+        #
+        # @param [String] key
+        #   cache key
+        # @param [Hash] opts
+        #   cache options, e.g :expires
+        # @param [Proc]
+        #   Execution result to store in the cache
+        #
+        # @example
+        #   # Caching a fragment
+        #   class MyTweets < Tennpipes::Application
+        #     enable :caching          # turns on caching mechanism
+        #
+        #     controller '/tweets' do
+        #       get :feed, :map => '/:username' do
+        #         username = params[:username]
+        #
+        #         @feed = cache( "feed_for_#{username}", :expires => 3 ) do
+        #           @tweets = Tweet.all( :username => username )
+        #           render 'partials/feedcontent'
+        #         end
+        #
+        #         # Below outputs @feed somewhere in its markup.
+        #         render 'feeds/show'
+        #       end
+        #     end
+        #   end
+        #
+        # @api public
+        def cache(key, opts = {}, &block)
+          if settings.caching?
+            began_at = Time.now
+            if value = settings.cache[key.to_s]
+              logger.debug "GET Fragment", began_at, key.to_s if defined?(logger)
+              concat_content(value.html_safe)
+            else
+              value = capture_html(&block)
+              settings.cache.store(key.to_s, value, opts)
+              logger.debug "SET Fragment", began_at, key.to_s if defined?(logger)
+              concat_content(value)
+            end
+          else
+            value = capture_html(&block)
+            concat_content(value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tennpipes-memory/helpers/page.rb

@@ -0,0 +1,169 @@
+module Tennpipes
+  module Cache
+    ##
+    # Helpers supporting page or fragment caching within a request route.
+    #
+    module Helpers
+      ##
+      # Page caching is easy to integrate into your application. To turn it on, simply provide the
+      # <tt>:cache => true</tt> option on either a controller or one of its routes.
+      # By default, cached content is persisted with a "file store" --that is, in a
+      # subdirectory of your application root.
+      #
+      # @example
+      #   # Setting content expiry time.
+      #   class CachedApp < Tennpipes::Application
+      #     enable :caching          # turns on caching mechanism
+      #
+      #     controller '/blog', :cache => true do
+      #       expires 15
+      #
+      #       get '/entries' do
+      #         # expires 15 => can also be defined inside a single route
+      #         'Just broke up eating twinkies, lol'
+      #       end
+      #
+      #       get '/post/:id' do
+      #         cache_key :my_name
+      #         @post = Post.find(params[:id])
+      #       end
+      #     end
+      #   end
+      #
+      # You can manually expire cache with CachedApp.cache.delete(:my_name)
+      #
+      # Note that the "latest" method call to <tt>expires</tt> determines its value: if
+      # called within a route, as opposed to a controller definition, the route's
+      # value will be assumed.
+      #
+      module Page
+        ##
+        # This helper is used within a controller or route to indicate how often content
+        # should persist in the cache.
+        #
+        # After <tt>seconds</tt> seconds have passed, content previously cached will
+        # be discarded and re-rendered. Code associated with that route will <em>not</em>
+        # be executed; rather, its previous output will be sent to the client with a
+        # 200 OK status code.
+        #
+        # @param [Integer] time
+        #   Time til expiration (seconds)
+        #
+        # @example
+        #   controller '/blog', :cache => true do
+        #     expires 15
+        #
+        #     get '/entries' do
+        #       'Just broke up eating twinkies, lol'
+        #     end
+        #   end
+        #
+        # @api public
+        def expires(time)
+          @route.cache_expires = time
+        end
+
+        ##
+        # This helper is used within a route or route to indicate the name in the cache.
+        #
+        # @param [Symbol] name
+        #   cache key
+        # @param [Proc] block
+        #   block to be evaluated to cache key
+        #
+        # @example
+        #   controller '/blog', :cache => true do
+        #
+        #     get '/post/:id' do
+        #       cache_key :my_name
+        #       @post = Post.find(params[:id])
+        #     end
+        #   end
+        #
+        # @example
+        #     get '/foo', :cache => true do
+        #       cache_key { param[:id] }
+        #       "My id is #{param[:id}"
+        #     end
+        #   end
+        #
+        def cache_key(name = nil, &block)
+          fail "Can not provide both cache_key and a block" if name && block
+          @route.cache_key = name || block
+        end
+
+        CACHED_VERBS = { 'GET' => true, 'HEAD' => true }.freeze
+
+        def self.tennpipes_route_added(route, verb, *)
+          return unless route.cache && CACHED_VERBS[verb]
+
+          route.before_filters do
+            next unless settings.caching?
+            if cached_response = load_cached_response
+              content_type cached_response[:content_type]
+              halt 200, cached_response[:body]
+            end
+          end
+
+          route.after_filters do
+            save_cached_response(route.cache_expires) if settings.caching?
+          end
+        end
+
+        private
+
+        def load_cached_response
+          began_at = Time.now
+          route_cache_key = resolve_cache_key || env['PATH_INFO']
+
+          value = settings.cache[route_cache_key]
+          logger.debug "GET Cache", began_at, route_cache_key if defined?(logger) && value
+
+          value
+        end
+
+        def save_cached_response(cache_expires)
+          return unless @_response_buffer.kind_of?(String)
+
+          began_at = Time.now
+          route_cache_key = resolve_cache_key || env['PATH_INFO']
+
+          content = {
+            :body         => @_response_buffer,
+            :content_type => @_content_type
+          }
+
+          settings.cache.store(route_cache_key, content, :expires => cache_expires)
+
+          logger.debug "SET Cache", began_at, route_cache_key if defined?(logger)
+        end
+
+        ##
+        # Resolve the cache_key when it's a block in the correct context.
+        #
+        def resolve_cache_key
+          key = @route.cache_key
+          key.is_a?(Proc) ? instance_eval(&key) : key
+        end
+
+        module ClassMethods
+          ##
+          # A method to set `expires` time inside `controller` blocks.
+          #
+          # @example
+          #   controller :users do
+          #     expires 15
+          #
+          #     get :show do
+          #       'shown'
+          #     end
+          #   end
+          #
+          def expires(time)
+            @_expires = time
+          end
+        end
+      end
+    end
+  end
+end

data/test/helper.rb

@@ -0,0 +1,24 @@
+ENV['RACK_ENV'] = 'test'
+TENNPIPES_ROOT = File.dirname(__FILE__) unless defined?(TENNPIPES_ROOT)
+
+require 'minitest/autorun'
+require 'minitest/pride'
+require 'rack/test'
+require 'tennpipes-memory'
+
+require 'ext/rack-test-methods'
+
+class MiniTest::Spec
+  include Rack::Test::Methods
+
+  # Sets up a Sinatra::Base subclass defined with the block
+  # given. Used in setup or individual spec methods to establish
+  # the application.
+  def mock_app(base=Tennpipes::Application, &block)
+    @app = Sinatra.new(base, &block)
+  end
+
+  def app
+    Rack::Lint.new(@app)
+  end
+end

data/test/test_moneta_store.rb

@@ -0,0 +1,53 @@
+require File.expand_path(File.dirname(__FILE__) + '/helper')
+
+describe 'Tennpipes::Cache - Moneta store' do
+  def setup
+    @test_key = "val_#{Time.now.to_i}"
+  end
+
+  def teardown
+    Tennpipes.cache.clear
+  end
+
+  class Foo
+    def bar; "bar"; end
+  end
+
+  it "return nil trying to get a value that doesn't exist" do
+    Tennpipes.cache.clear
+    assert_equal nil, Tennpipes.cache[@test_key]
+  end
+
+  it 'set and get an object with marshal' do
+    Tennpipes.cache[@test_key] = Foo.new
+    assert_equal "bar", Tennpipes.cache[@test_key].bar
+  end
+
+  it 'set and get a nil value' do
+    Tennpipes.cache[@test_key] = nil
+    assert_equal '', Tennpipes.cache[@test_key].to_s
+  end
+
+  it 'set and get a raw value' do
+    Tennpipes.cache[@test_key] = 'foo'
+    assert_equal 'foo', Tennpipes.cache[@test_key]
+  end
+
+  it "set a value that expires" do
+    init_time = ( Time.now - 20 )
+    Time.stub(:now, init_time) { Tennpipes.cache.store(@test_key, 'test', :expires => 1) }
+    Time.stub(:now, init_time + 20) { assert_equal nil, Tennpipes.cache[@test_key] }
+  end
+
+  it "be able to cache forever" do
+    Tennpipes.cache.store('forever', 'cached', :expires => false)
+    2.times { |i| assert_equal 'cached', Tennpipes.cache['forever'] }
+  end
+
+  it 'delete a value' do
+    Tennpipes.cache[@test_key] = 'test'
+    assert_equal 'test', Tennpipes.cache[@test_key]
+    Tennpipes.cache.delete(@test_key)
+    assert_equal nil, Tennpipes.cache[@test_key]
+  end
+end

data/test/test_tennpipes_cache.rb

@@ -0,0 +1,478 @@
+require File.expand_path('../helper', __FILE__)
+
+describe "TennpipesCache" do
+  after do
+    tmp = File.expand_path("../tmp", __FILE__)
+    %x[rm -rf #{tmp}]
+  end
+
+  it 'should cache a fragment' do
+    called = false
+    mock_app do
+      register Tennpipes::Cache
+      enable :caching
+      get("/foo"){ cache(:test) { called ? halt(500) : (called = 'test fragment') } }
+    end
+    get "/foo"
+    assert_equal 200, status
+    assert_equal 'test fragment', body
+    get "/foo"
+    assert_equal 200, status
+    assert_equal 'test fragment', body
+    refute_equal called, false
+  end
+
+  it 'should cache a page' do
+    called = false
+    mock_app do
+      register Tennpipes::Cache
+      enable :caching
+      get('/foo', :cache => true){ called ? halt(500) : (called = 'test page') }
+    end
+    get "/foo"
+    assert_equal 200, status
+    assert_equal 'test page', body
+    get "/foo"
+    assert_equal 200, status
+    assert_equal 'test page', body
+    refute_equal false, called
+  end
+
+  it 'should cache HEAD verb' do
+    called_times = 0
+    mock_app do
+      register Tennpipes::Cache
+      enable :caching
+      get('/foo', :cache => true){ called_times += 1; called_times.to_s }
+    end
+    head "/foo"
+    head "/foo"
+    assert_equal 1, called_times
+  end
+
+  it 'should not cache POST verb' do
+    called_times = 0
+    mock_app do
+      register Tennpipes::Cache
+      enable :caching
+      post('/foo', :cache => true){ called_times += 1; called_times.to_s }
+    end
+    post "/foo"
+    assert_equal 1, called_times
+    post "/foo"
+    assert_equal 2, called_times
+  end
+
+  it 'should not cache DELETE verb' do
+    called_times = 0
+    mock_app do
+      register Tennpipes::Cache
+      enable :caching
+      delete('/foo', :cache => true){ called_times += 1; called_times.to_s }
+    end
+    delete "/foo"
+    assert_equal 1, called_times
+    delete "/foo"
+    assert_equal 2, called_times
+  end
+
+  it 'should not cache PUT verb' do
+    called_times = 0
+    mock_app do
+      register Tennpipes::Cache
+      enable :caching
+      put('/foo', :cache => true){ called_times += 1; called_times.to_s }
+    end
+    put "/foo"
+    assert_equal 1, called_times
+    put "/foo"
+    assert_equal 2, called_times
+  end
+
+  it 'should delete from the cache' do
+    called = false
+    mock_app do
+      register Tennpipes::Cache
+      enable :caching
+      get('/foo', :cache => true){ called ? 'test page again' : (called = 'test page') }
+      get('/delete_foo'){ expire('/foo') }
+    end
+    get "/foo"
+    assert_equal 200, status
+    assert_equal 'test page', body
+    get "/delete_foo"
+    get "/foo"
+    assert_equal 200, status
+    assert_equal 'test page again', body
+    refute_equal false, called
+  end
+
+  it 'should accept custom cache keys' do
+    called = false
+    mock_app do
+      register Tennpipes::Cache
+      enable :caching
+      get '/foo', :cache => true do
+        if called
+          "you'll never see me"
+        else
+          cache_key :foo
+          called = 'foo'
+
+          called
+        end
+      end
+
+      get '/bar', :cache => true do
+        if called
+          cache_key :bar
+          called = 'bar'
+
+          called
+        else
+          "you'll never see me"
+        end
+      end
+    end
+    get "/foo"
+    assert_equal 200, status
+    assert_equal 'foo', body
+    assert_equal 'foo', @app.cache[:foo][:body]
+    get "/foo"
+    assert_equal 'foo', body
+
+    get "/bar"
+    assert_equal 200, status
+    assert_equal 'bar', body
+    assert_equal 'bar', @app.cache[:bar][:body]
+    get "/bar"
+    assert_equal 'bar', body
+  end
+
+  it 'should delete based on urls' do
+    called = false
+    mock_app do
+      register Tennpipes::Cache
+      enable :caching
+      get(:foo, :with => :id, :cache => true) { called ? 'test page again' : (called = 'test page') }
+      get(:delete_foo, :with => :id) { expire(:foo, params[:id]) }
+    end
+    get "/foo/12"
+    assert_equal 200, status
+    assert_equal 'test page', body
+    get "/delete_foo/12"
+    get "/foo/12"
+    assert_equal 200, status
+    assert_equal 'test page again', body
+  end
+
+  it 'should allow controller-wide caching' do
+    called = false
+    mock_app do
+      controller :cache => true do
+        register Tennpipes::Cache
+        enable :caching
+        get("/foo"){ called ? halt(500) : (called = 'test') }
+      end
+    end
+    get "/foo"
+    assert_equal 200, status
+    assert_equal 'test', body
+    get "/foo"
+    assert_equal 200, status
+    assert_equal 'test', body
+  end
+
+  it 'should allow controller-wide expires' do
+    called = false
+    mock_app do
+      register Tennpipes::Cache
+      controller :cache => true do
+        enable :caching
+        expires 1
+        get("/foo"){ called ? halt(500) : (called = 'test') }
+      end
+    end
+    get "/foo"
+    assert_equal 200, status
+    assert_equal 'test', body
+    get "/foo"
+    assert_equal 200, status
+    assert_equal 'test', body
+    Time.stub(:now, Time.now + 2) { get "/foo" }
+    assert_equal 500, status
+  end
+
+  it 'should allow cache disabling on a per route basis' do
+    called = false
+    mock_app do
+      register Tennpipes::Cache
+      enable :caching
+      controller :cache => true do
+        get("/foo", :cache => false){ called ? 'test again' : (called = 'test') }
+      end
+    end
+    get "/foo"
+    assert_equal 200, status
+    assert_equal 'test', body
+    get "/foo"
+    assert_equal 200, status
+    assert_equal 'test again', body
+  end
+
+  it 'should allow expiring for pages' do
+    called = false
+    mock_app do
+      register Tennpipes::Cache
+      enable :caching
+      controller :cache => true do
+        get("/foo") {
+          expires 1
+          called ? 'test again' : (called = 'test')
+        }
+      end
+    end
+    get "/foo"
+    assert_equal 200, status
+    assert_equal 'test', body
+    get "/foo"
+    assert_equal 200, status
+    assert_equal 'test', body
+    Time.stub(:now, Time.now + 3) { get "/foo" }
+    assert_equal 200, status
+    assert_equal 'test again', body
+  end
+
+  it 'should allow expiring for fragments' do
+    called = false
+    mock_app do
+      register Tennpipes::Cache
+      enable :caching
+      controller do
+        get("/foo") {
+          expires 1
+          cache(:test, :expires => 2) do
+            called ? 'test again' : (called = 'test')
+          end
+        }
+      end
+    end
+    get "/foo"
+    assert_equal 200, status
+    assert_equal 'test', body
+    get "/foo"
+    assert_equal 200, status
+    assert_equal 'test', body
+    Time.stub(:now, Time.now + 3) { get "/foo" }
+    assert_equal 200, status
+    assert_equal 'test again', body
+  end
+
+  it 'should allow disabling of the cache' do
+    called = false
+    mock_app do
+      register Tennpipes::Cache
+      disable :caching
+      controller :cache => true do
+        get("/foo"){ called ? halt(500) : (called = 'test') }
+      end
+    end
+    get "/foo"
+    assert_equal 200, status
+    assert_equal 'test', body
+    get "/foo"
+    assert_equal 500, status
+  end
+
+  it 'should not cache integer statuses' do
+    mock_app do
+      register Tennpipes::Cache
+      enable :caching
+      get( '/404', :cache => true ) { not_found }
+      get( '/503', :cache => true ) { error 503 }
+      not_found { 'fancy 404' }
+      error( 503 ) { 'fancy 503' }
+    end
+    get '/404'
+    assert_equal 'fancy 404', body
+    assert_equal 404, status
+    assert_equal nil, @app.cache['/404']
+    get '/404'
+    assert_equal 'fancy 404', body
+    assert_equal 404, status
+    get '/503'
+    assert_equal 'fancy 503', body
+    assert_equal 503, status
+    assert_equal nil, @app.cache['/503']
+    get '/503'
+    assert_equal 'fancy 503', body
+    assert_equal 503, status
+  end
+
+  it 'should cache should not hit with unique params' do
+    call_count = 0
+    mock_app do
+      register Tennpipes::Cache
+      enable :caching
+      before do
+        param = params[:test] || 'none'
+        cache_key "foo?#{param}"
+      end
+      get '/foo/:test', :cache => true do
+        param = params[:test] || 'none'
+        call_count += 1
+        "foo?#{param}"
+      end
+    end
+
+    get '/foo/none'
+    get '/foo/none'
+    assert_equal 200, status
+    assert_equal 'foo?none', body
+    assert_equal 1, call_count
+
+    get '/foo/yes'
+    assert_equal 'foo?yes', body
+    assert_equal 2, call_count
+  end
+
+  it 'should resolve block cache keys' do
+    call_count = 0
+    mock_app do
+      register Tennpipes::Cache
+      enable :caching
+
+      get '/foo', :cache => true do
+        cache_key { "key #{params[:id]}" }
+        call_count += 1
+        params[:id]
+      end
+    end
+
+    get '/foo?id=1'
+    get '/foo?id=2'
+    get '/foo?id=2'
+    get '/foo?id=1&something_else=42'
+    get '/foo?id=3&something_else=42'
+
+    assert_equal 3, call_count
+  end
+
+  it 'should raise an error if providing both a cache_key and block' do
+    mock_app do
+      register Tennpipes::Cache
+      enable :caching
+
+      get '/foo', :cache => true do
+        cache_key(:some_key) { "key #{params[:id]}" }
+      end
+    end
+
+    assert_raises(RuntimeError) { get '/foo' }
+  end
+
+  it 'should cache content_type' do
+    called = false
+    mock_app do
+      register Tennpipes::Cache
+      enable :caching
+      get '/foo', :cache => true do
+        content_type :json
+        if called
+          "you'll never see me"
+        else
+          cache_key :foo
+          called = '{"foo":"bar"}'
+
+          called
+        end
+      end
+    end
+    get "/foo"
+    assert_equal 200, status
+    assert_equal '{"foo":"bar"}', body
+    assert_equal '{"foo":"bar"}', @app.cache[:foo][:body]
+    get "/foo"
+    assert_equal '{"foo":"bar"}', body
+    assert_match /json/, last_response.content_type
+  end
+
+  it 'should cache an object' do
+    counter = 0
+    mock_app do
+      register Tennpipes::Cache
+      enable :caching
+      get '/' do
+        result = ''
+        2.times do
+          result = cache_object 'object1' do
+            counter += 1
+            { :foo => 'bar' }
+          end
+        end
+        result[:foo].to_s
+      end
+    end
+    get '/'
+    assert_equal 'bar', body
+    assert_equal 1, counter
+  end
+
+  it 'should allow different expiring times for different pages' do
+    skip
+    called_times_a = 0
+    called_times_b = 0
+    mock_app do
+      register Tennpipes::Cache
+      enable :caching
+      controller :cache => true do
+        get("/foo") do
+          expires 1
+          called_times_a += 1
+          called_times_b.to_s
+        end
+        get("/bar") do
+          expires 3
+          called_times_b += 1
+          called_times_b.to_s
+        end
+      end
+    end
+    Time.stub(:now, Time.now) { get "/foo"; get "/bar" }
+    assert_equal 1, called_times_a
+    assert_equal 1, called_times_b
+    Time.stub(:now, Time.now + 0.5) { get "/foo"; get "/bar" }
+    assert_equal 1, called_times_a
+    assert_equal 1, called_times_b
+    Time.stub(:now, Time.now + 2) { get "/foo"; get "/bar" }
+    assert_equal 2, called_times_a
+    assert_equal 1, called_times_b
+    Time.stub(:now, Time.now + 2.5) { get "/foo"; get "/bar" }
+    assert_equal 2, called_times_a
+    assert_equal 1, called_times_b
+    Time.stub(:now, Time.now + 4) { get "/foo"; get "/bar" }
+    assert_equal 3, called_times_a
+    assert_equal 2, called_times_b
+    Time.stub(:now, Time.now + 5.5) { get "/foo"; get "/bar" }
+    assert_equal 4, called_times_a
+    assert_equal 2, called_times_b
+  end
+
+  it "preserve the app's `caching` setting if set before registering the module" do
+    mock_app do
+      enable :caching
+      register Tennpipes::Cache
+    end
+
+    assert @app.caching
+  end
+
+  it "preserve the app's `cache` setting if set before registering the module" do
+    mock_app do
+      set :cache, Tennpipes::Cache.new(:Memory)
+      register Tennpipes::Cache
+    end
+
+    assert @app.cache.adapter.adapter.is_a?(Moneta::Adapters::Memory)
+  end
+end