merb-cache 0.9.7 → 0.9.8

data/spec/spec_helper.rb

@@ -1,84 +1,81 @@
-$TESTING=true
-$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
-require "rubygems"
-require "merb-core"
+$:.push File.join(File.dirname(__FILE__), '..', 'lib')
 
-require "merb-cache"
-require File.dirname(__FILE__) / "controller"
+# Deps
+require 'rubygems'
+require 'merb-core'
+require 'merb-action-args'
+require File.join(File.dirname(__FILE__), '..', 'lib', 'merb-cache')
 
-require "merb-haml"
+# We want logging!
+Merb.logger = Merb::Logger.new(File.join(File.dirname(__FILE__), '..', 'log', 'merb_test.log'))
 
-def set_database_adapter(adapter)
-  config_file = File.dirname(__FILE__) / "config/database.yml"
-  config = IO.read(config_file)
-  config.gsub!(/:adapter:\s+.*$/, ":adapter: #{adapter}")
-  File.open(config_file, "w+") do |c| c.write(config) end
+Merb.start :environment => "test", :adapter => "runner"
+
+require "merb-core/test"
+Spec::Runner.configure do |config|
+  config.include Merb::Test::Helpers
+  #config.include Merb::Test::ControllerHelper
+  config.include Merb::Test::RouteHelper
 end
 
-def use_cache_store(store, orm = nil)
-  Merb::Plugins.config[:merb_cache] = {
-    :store => store,
-    :cache_directory => File.dirname(__FILE__) / "tmp/cache",
-    :cache_html_directory => File.dirname(__FILE__) / "tmp/html",
-    :no_tracking => false
-  }
-  FileUtils.rm_rf(Dir.glob(File.dirname(__FILE__) / "/tmp"))
-  case store
-  when "dummy"
-  when "file"
-  when "memory"
-  when "memcache"
-    require "memcache"
-  when "database"
-    case orm
-    when "datamapper"
-      Merb.environment = "test"
-      Merb.logger = Merb::Logger.new("log/merb_test.log")
-      set_database_adapter("sqlite3")
-      require "merb_datamapper"
-    when "activerecord"
-      Merb.logger = Merb::Logger.new("log/merb_test.log")
-      set_database_adapter("sqlite3")
-      require "merb_activerecord"
-    when "sequel"
-      set_database_adapter("sqlite")
-      require "merb_sequel"
-    else
-      raise "Unknown orm: #{orm}"
+class DummyStore < Merb::Cache::AbstractStore
+  cattr_accessor :vault
+  attr_accessor  :options
+  
+  def initialize(config = {})
+    super(config)
+    @options = config
+    @@vault = {}
+  end
+
+  def writable?(*args)
+    true
+  end
+
+  def read(key, parameters = {})
+        
+    if @@vault.keys.include?(key)
+      @@vault[key].find {|data, timestamp, conditions, params| params == parameters}
     end
-  else
-    raise "Unknown cache store: #{store}"
   end
-end
 
-store = "file"
-case ENV["STORE"] || store
-when "file"
-  use_cache_store "file"
-when "memory"
-  use_cache_store "memory"
-when "memcache"
-  use_cache_store "memcache"
-when "datamapper"
-  use_cache_store "database", "datamapper"
-when "sequel"
-  use_cache_store "database", "sequel"
-when "activerecord"
-  use_cache_store "database", "activerecord"
-when "dummy"
-  use_cache_store "dummy"
-else
-  puts "Invalid cache store: #{ENV["store"]}"
-  exit
-end
+  def data(key, parameters = {})
+    read(key, parameters)[0] if read(key, parameters)
+  end
 
-require "fileutils"
-FileUtils.mkdir_p(Merb::Plugins.config[:merb_cache][:cache_html_directory])
-FileUtils.mkdir_p(Merb::Plugins.config[:merb_cache][:cache_directory])
+  def time(key, parameters = {})
+    read(key, parameters)[1] if read(key, parameters)
+  end
 
-Merb.start :environment => "test", :adapter => "runner"
+  def conditions(key, parameters = {})
+    read(key, parameters)[2] if read(key, parameters)
+  end
 
-require "merb-core/test"
-Spec::Runner.configure do |config|
-  config.include Merb::Test::RequestHelper  
+  def write(key, data = nil, parameters = {}, conditions = {})
+    (@@vault[key] ||= []) << [data, Time.now, conditions, parameters]
+    true
+  end
+
+  def fetch(key, parameters = {}, conditions = {}, &blk)
+    @@vault[[key, parameters]] ||= blk.call
+  end
+
+  def exists?(key, parameters = {})
+    @@vault.has_key? [key, parameters]
+  end
+
+  def delete(key, parameters = {})
+    @@vault.delete([key, parameters]) unless @@vault[[key, parameters]].nil?
+  end
+
+  def delete_all
+    @@vault = {}
+  end
 end
+
+#TODO change this to a work queue per class called in an after aspect
+class Merb::Controller
+  def run_later
+    yield
+  end
+end

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification 
 name: merb-cache
 version: !ruby/object:Gem::Version 
-  version: 0.9.7
+  version: 0.9.8
 platform: ruby
 authors: 
-- Alex Boussinet
+- Ben Burkert
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2008-09-09 00:00:00 +03:00
+date: 2008-10-06 00:00:00 +03:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -20,10 +20,10 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.9.7
+        version: 0.9.8
     version: 
 description: Merb plugin that provides caching (page, action, fragment, object)
-email: alex.boussinet@gmail.com
+email: ben@benburkert.com
 executables: []
 
 extensions: []
@@ -38,35 +38,46 @@ files:
 - Rakefile
 - TODO
 - lib/merb-cache
-- lib/merb-cache/cache-action.rb
-- lib/merb-cache/cache-fragment.rb
-- lib/merb-cache/cache-page.rb
-- lib/merb-cache/cache-store
-- lib/merb-cache/cache-store/database-activerecord.rb
-- lib/merb-cache/cache-store/database-datamapper.rb
-- lib/merb-cache/cache-store/database-sequel.rb
-- lib/merb-cache/cache-store/database.rb
-- lib/merb-cache/cache-store/dummy.rb
-- lib/merb-cache/cache-store/file.rb
-- lib/merb-cache/cache-store/memcache.rb
-- lib/merb-cache/cache-store/memory.rb
-- lib/merb-cache/merb-cache.rb
-- lib/merb-cache/merbtasks.rb
+- lib/merb-cache/cache.rb
+- lib/merb-cache/core_ext
+- lib/merb-cache/core_ext/enumerable.rb
+- lib/merb-cache/core_ext/hash.rb
+- lib/merb-cache/merb_ext
+- lib/merb-cache/merb_ext/controller.rb
+- lib/merb-cache/stores
+- lib/merb-cache/stores/fundamental
+- lib/merb-cache/stores/fundamental/abstract_store.rb
+- lib/merb-cache/stores/fundamental/file_store.rb
+- lib/merb-cache/stores/fundamental/memcached_store.rb
+- lib/merb-cache/stores/strategy
+- lib/merb-cache/stores/strategy/abstract_strategy_store.rb
+- lib/merb-cache/stores/strategy/action_store.rb
+- lib/merb-cache/stores/strategy/adhoc_store.rb
+- lib/merb-cache/stores/strategy/gzip_store.rb
+- lib/merb-cache/stores/strategy/page_store.rb
+- lib/merb-cache/stores/strategy/sha1_store.rb
 - lib/merb-cache.rb
-- spec/config
-- spec/config/database.yml
-- spec/controller.rb
 - spec/log
-- spec/log/merb_test.log
-- spec/merb-cache-action_spec.rb
-- spec/merb-cache-fragment_spec.rb
-- spec/merb-cache-page_spec.rb
-- spec/merb-cache_spec.rb
+- spec/merb-cache
+- spec/merb-cache/cache_spec.rb
+- spec/merb-cache/core_ext
+- spec/merb-cache/core_ext/enumerable_spec.rb
+- spec/merb-cache/core_ext/hash_spec.rb
+- spec/merb-cache/merb_ext
+- spec/merb-cache/merb_ext/controller_spec.rb
+- spec/merb-cache/stores
+- spec/merb-cache/stores/fundamental
+- spec/merb-cache/stores/fundamental/abstract_store_spec.rb
+- spec/merb-cache/stores/fundamental/file_store_spec.rb
+- spec/merb-cache/stores/fundamental/memcached_store_spec.rb
+- spec/merb-cache/stores/strategy
+- spec/merb-cache/stores/strategy/abstract_strategy_store_spec.rb
+- spec/merb-cache/stores/strategy/action_store_spec.rb
+- spec/merb-cache/stores/strategy/adhoc_store_spec.rb
+- spec/merb-cache/stores/strategy/gzip_store_spec.rb
+- spec/merb-cache/stores/strategy/page_store_spec.rb
+- spec/merb-cache/stores/strategy/sha1_store_spec.rb
 - spec/spec_helper.rb
-- spec/views
-- spec/views/cache_controller
-- spec/views/cache_controller/action1.html.erb
-- spec/views/cache_controller/action2.html.haml
 has_rdoc: true
 homepage: http://merbivore.com
 post_install_message: 

data/lib/merb-cache/cache-action.rb

@@ -1,144 +0,0 @@
-class Merb::Cache
-  cattr_accessor :cached_actions
-  self.cached_actions = {}
-end
-
-module Merb::Cache::ControllerClassMethods
-  # Mixed in Merb::Controller. Provides methods related to action caching.
-
-  # Registers an action for action caching via before and after filters.
-  #
-  # ==== Parameters
-  # action<Symbol>:: The name of the action to register.
-  # from_now<~minutes>:: The number of minutes (from now) the cache should persist.
-  # opts<Hash>::
-  #   Filter options (see <tt>Filter Options</tt> in <tt>Merb::AbstractController</tt>). The filters created apply :only
-  #   to specified <tt>action</tt>.
-  #
-  # ==== Examples
-  #   cache_action :mostly_static
-  #   cache_action :barely_dynamic, 10
-  #   cache_action :list, :if => Proc.new { |controller| !controller.params[:id].empty? }
-  #   cache_action :show, :unless => proc { |controller| !controller.params[:id].empty? }
-  def cache_action(action, from_now = nil, opts = {})
-    cache_actions([action, from_now, opts])
-  end
-
-  # Register multiple actions for action caching via before and after filters.
-  #
-  # ==== Parameter
-  # actions<Symbol,Array[Symbol,~minutes],Hash>:: See #cache_action.
-  #
-  # ==== Example
-  #   cache_actions(
-  #     :mostly_static,
-  #     [:barely_dynamic, 10],
-  #     [:conditional, { :if => proc { |controller| controller.params[:id].empty? } }]
-  #   )
-  def cache_actions(*actions)
-    actions.each do |action, from_now, opts|
-      from_now, opts = nil, from_now if Hash === from_now
-      opts ||= {}
-
-      before("cache_#{action}_before", opts.merge(:only => action))
-      after("cache_#{action}_after", opts.merge(:only => action))
-      alias_method "cache_#{action}_before", :cache_action_before
-      alias_method "cache_#{action}_after", :cache_action_after
-
-      _actions = Merb::Cache.cached_actions[controller_name] ||= {}
-      _actions[action] = from_now
-    end
-    true
-  end
-end
-
-module Merb::Cache::ControllerInstanceMethods
-  # Mixed in Merb::Controller. Provides methods related to action caching
-
-  # Checks whether a cache entry exists
-  #
-  # ==== Parameter
-  # options<String,Hash>:: The options that will be passed to #key_for
-  #
-  # ==== Returns
-  # true if the cache entry exists, false otherwise
-  #
-  # ==== Example
-  #   cached_action?(:action => 'show', :params => [params[:page]])
-  def cached_action?(options)
-    key = Merb::Controller._cache.key_for(options, controller_name, true)
-    Merb::Controller._cache.store.cached?(key)
-  end
-
-  # Expires the action identified by the key computed after the parameters
-  #
-  # ==== Parameter
-  # options<String,Hash>:: The options that will be passed to #expire_key_for
-  #
-  # ==== Examples
-  #   expire_action(:action => 'show', :controller => 'news')
-  #   expire_action(:action => 'show', :match => true)
-  def expire_action(options)
-    Merb::Controller._cache.expire_key_for(options, controller_name, true) do |key, match|
-      if match
-        Merb::Controller._cache.store.expire_match(key)
-      else
-        Merb::Controller._cache.store.expire(key)
-      end
-    end
-    true
-  end
-
-  # You can call this method if you need to prevent caching the action
-  # after it has been rendered.
-  def abort_cache_action
-    @capture_action = false
-  end
-
-  private
-
-  # Called by the before and after filters. Stores or recalls a cache entry.
-  # The key is based on the result of request.path
-  # If the key with "/" then it is removed
-  # If the key is "/" then it will be replaced by "index"
-  #
-  # ==== Parameters
-  # data<String>:: the data to put in cache using the cache store
-  #
-  # ==== Examples
-  #   If request.path is "/", the key will be "index"
-  #   If request.path is "/news/show/1", the key will be "/news/show/1"
-  #   If request.path is "/news/show/", the key will be "/news/show"
-  def _cache_action(data = nil)
-    controller = controller_name
-    action = action_name.to_sym
-    actions = Merb::Controller._cache.cached_actions[controller]
-    return unless actions && actions.key?(action)
-    path = request.path.chomp("/")
-    path = "index" if path.empty?
-    if data
-      from_now = Merb::Controller._cache.cached_actions[controller][action]
-      Merb::Controller._cache.store.cache_set(path, data, from_now)
-    else
-      @capture_action = false
-      _data = Merb::Controller._cache.store.cache_get(path)
-      throw(:halt, _data) unless _data.nil?
-      @capture_action = true
-    end
-    true
-  end
-
-  # before filter
-  def cache_action_before
-    # recalls a cached entry or set @capture_action to true in order
-    # to grab the response in the after filter
-    _cache_action
-  end
-
-  # after filter
-  def cache_action_after
-    # takes the body of the response and put it in cache
-    # if the cache entry expired, if it doesn't exist or status is 200
-    _cache_action(body) if @capture_action && status == 200
-  end
-end

data/lib/merb-cache/cache-fragment.rb

@@ -1,95 +0,0 @@
-module Merb::Cache::ControllerInstanceMethods
-  # Mixed in Merb::Controller. Provides methods related to fragment caching
-
-  # Checks whether a cache entry exists
-  #
-  # ==== Parameter
-  # options<String,Hash>:: The options that will be passed to #key_for
-  #
-  # ==== Returns
-  # true if the cache entry exists, false otherwise
-  #
-  # ==== Example
-  #   cached_action?("my_key")
-  def cached?(options)
-    key = Merb::Controller._cache.key_for(options, controller_name)
-    Merb::Controller._cache.store.cached?(key)
-  end
-
-  # ==== Example
-  #   In your view:
-  #   <%- cache("my_key") do -%>
-  #     <%= partial :test, :collection => @test %>
-  #   <%- end -%>
-  def cache(options, from_now = nil, &block)
-    key = Merb::Controller._cache.key_for(options, controller_name)
-    Merb::Controller._cache.store.cache(self, key, from_now, &block)
-  end
-
-  # Fetch data from cache
-  #
-  # ==== Parameter
-  # options<String,Hash>:: The options that will be passed to #key_for
-  #
-  # ==== Returns
-  # data<Object,NilClass>::
-  #   nil is returned if the cache entry is not found
-  #
-  # ==== Example
-  #   if cache_data = cache_get("my_key")
-  #     @var1, @var2 = *cache_data
-  #   else
-  #     @var1 = MyModel.big_query1
-  #     @var2 = MyModel.big_query2
-  #     cache_set("my_key", nil, [@var1, @var2])
-  #   end
-  def cache_get(options)
-    key = Merb::Controller._cache.key_for(options, controller_name)
-    Merb::Controller._cache.store.cache_get(key)
-  end
-
-  # Store data to cache
-  #
-  # ==== Parameter
-  # options<String,Hash>:: The options that will be passed to #key_for
-  # object<Object>:: The object(s) to put in cache
-  # from_now<~minutes>::
-  #   The number of minutes (from now) the cache should persist
-  #
-  # ==== Returns
-  # data<Object,NilClass>::
-  #   nil is returned if the cache entry is not found
-  #
-  # ==== Example
-  #   if cache_data = cache_get("my_key")
-  #     @var1, @var2 = *cache_data
-  #   else
-  #     @var1 = MyModel.big_query1
-  #     @var2 = MyModel.big_query2
-  #     cache_set("my_key", nil, [@var1, @var2])
-  #   end
-  def cache_set(options, object, from_now = nil)
-    key = Merb::Controller._cache.key_for(options, controller_name)
-    Merb::Controller._cache.store.cache_set(key, object, from_now)
-  end
-
-  # Expires the entry identified by the key computed after the parameters
-  #
-  # ==== Parameter
-  # options<String,Hash>:: The options that will be passed to #key_for
-  #
-  # ==== Examples
-  #   expire("my_key")
-  #   expire(:key => "my_", :match => true)
-  #   expire(:key => "my_key", :params => [session[:me], params[:ref]])
-  def expire(options)
-    Merb::Controller._cache.expire_key_for(options, controller_name) do |key, match|
-      if match
-        Merb::Controller._cache.store.expire_match(key)
-      else
-        Merb::Controller._cache.store.expire(key)
-      end
-    end
-    true
-  end
-end