cachetastic 2.1.4 → 3.0.0

data/lib/cachetastic/caches/mack_session_cache.rb

@@ -1,3 +0,0 @@
-# Used for storing Mack sessions.
-class Cachetastic::Caches::MackSessionCache < Cachetastic::Caches::Base
-end

data/lib/cachetastic/caches/page_cache.rb

@@ -1,6 +0,0 @@
-# Used by the Mongrel Page Cache Handler gem for page caching.
-# Future functionality may be added to this class to allow for
-# things such as deleting a certain page/set of pages based on
-# regex, etc...
-class Cachetastic::Caches::PageCache < Cachetastic::Caches::Base
-end

data/lib/cachetastic/caches/rails_session_cache.rb

@@ -1,12 +0,0 @@
-# Used for storing Rails sessions.
-class Cachetastic::Caches::RailsSessionCache < Cachetastic::Caches::Base
-  
-  class << self
-    
-    def unsupported_adapters
-      [Cachetastic::Adapters::File]
-    end
-    
-  end
-  
-end

data/lib/cachetastic/connection.rb

@@ -1,24 +0,0 @@
-# This class caches adapter objects for each cache in the system.
-class Cachetastic::Connection
-  include Singleton
-  
-  attr_accessor :connections
-  
-  def initialize
-    self.connections = {}
-  end
-  
-  # Takes the name of the cache, that's been methodized, and returns back the adapter object associated with the cache.
-  # If the adapter object doesn't exist or if the adapter is no longer valid (adapter.valid?) a new one is
-  # created and returned.
-  def get(name)
-    name = name.to_sym
-    conn = self.connections[name]
-    return conn if conn && conn.valid?
-    adapter = Cachetastic::Adapters::Base.configuration(name).adapter.to_s.camelcase
-    conn = "Cachetastic::Adapters::#{adapter}".constantize.new(name)
-    self.connections[name.to_sym] = conn
-    return conn
-  end
-  
-end

data/lib/cachetastic/errors/unsupported_adapter.rb

@@ -1,7 +0,0 @@
-class Cachetastic::Errors::UnsupportedAdapter < Exception
-  
-  def initialize(cache_name, adapter)
-    super("#{cache_name} does not support the use of the #{adapter} adapter!")
-  end
-  
-end

data/lib/cachetastic/rails_extensions/active_record_base.rb

@@ -1,24 +0,0 @@
-class ActiveRecord::Base
-  
-  include Cachetastic::Cacheable
-  
-  def cachetastic_key
-    self.id
-  end
-  
-  # Returns an object from the cache for a given key.
-  # If the object returned is nil and the self_populate parameter is true
-  # then the key will be used to try and find the object in the database,
-  # set the object into the cache, and then return the object.
-  def self.get_from_cache(key, self_populate = false)
-    res = cache_class.get(key)
-    if res.nil? && self_populate
-      res = self.name.constantize.find(key)
-      unless res.nil?
-        res.cache_self
-      end
-    end
-    res
-  end
-  
-end

data/lib/cachetastic/rails_extensions/cgi_session_store.rb

@@ -1,59 +0,0 @@
-require 'cgi'
-require 'cgi/session'
-
-class CGI #:nodoc:#
-  class Session #:nodoc:#
-    # Allows Rails to use Cachetastic for it's session store.
-    # The setting below needs to happen AFTER the gem has been required, obviously!
-    # In Rails 1.2.6 this is AFTER the initializer block.
-    #   ActionController::Base.session_store = :cachetastic_store
-    class CachetasticStore
-
-
-      def check_id(id) #:nodoc:#
-        /[^0-9a-zA-Z]+/ =~ id.to_s ? false : true
-      end
-      
-      def initialize(session, options = {}) #:nodoc:#
-        id = session.session_id
-        unless check_id(id)
-          raise ArgumentError, "session_id '%s' is invalid" % id
-        end
-        
-        @session_key = id
-        
-        @session_data = {}
-      end
- 
-      # Restore session state from the session's memcache entry.
-      #
-      # Returns the session state as a hash.
-      def restore #:nodoc:#
-        @session_data = Cachetastic::Caches::RailsSessionCache.get(@session_key) do
-          {}
-        end
-      end
-
-      # Save session state to the session's memcache entry.
-      def update #:nodoc:#
-        Cachetastic::Caches::RailsSessionCache.set(@session_key, @session_data)
-      end
-    
-      # Update and close the session's memcache entry.
-      def close #:nodoc:#
-        update
-      end
-
-      # Delete the session's memcache entry.
-      def delete #:nodoc:#
-        Cachetastic::Caches::RailsSessionCache.delete(@session_key)
-        @session_data = {}
-      end
-      
-      def data #:nodoc:#
-        @session_data
-      end
-
-    end
-  end
-end

data/lib/cachetastic/ruby_extensions/kernel.rb

@@ -1,25 +0,0 @@
-module Kernel # :nodoc:
-  
-  def retryable(options = {}, &block) # :nodoc:
-    opts = { :tries => 1, :on => Exception }.merge(options)
-
-    retries = opts[:tries]
-    retry_exceptions = [opts[:on]].flatten
-    
-    x = %{
-      begin
-        return yield
-      rescue #{retry_exceptions.join(", ")} => e
-        retries -= 1
-        if retries > 0
-          retry
-        else
-          raise e
-        end
-      end        
-    }
-
-    eval(x, &block)
-  end
-  
-end

data/lib/cachetastic/ruby_extensions/object.rb

@@ -1,22 +0,0 @@
-class Object
-  
-  # Override this method in your object if you use the Cachetastic::Cacheable module.
-  def cachetastic_key
-    raise NoMethodError.new('cachetastic_key')
-  end
-  
-  unless respond_to?(:ivar_cache)
-    def ivar_cache(var_name = nil, &block)
-      if var_name.nil?
-        call = caller[0]
-        var_name = call[(call.index('`')+1)...call.index("'")]
-      end
-      var = instance_variable_get("@#{var_name}")
-      unless var
-        return instance_variable_set("@#{var_name}", yield) if block_given?
-      end
-      instance_variable_get("@#{var_name}")
-    end
-  end
-  
-end

data/lib/cachetastic/ruby_extensions/string.rb

@@ -1,15 +0,0 @@
-class String
-  
-  unless ''.respond_to?(:camelcase)
-    def camelcase
-      to_s.gsub(/\/(.?)/){ "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/){ $1.upcase }
-    end
-  end
-  
-  unless ''.respond_to?(:constantize)
-    def constantize
-      Module.instance_eval("::#{self}")
-    end
-  end
-  
-end

data/test/active_record_test.rb

@@ -1,89 +0,0 @@
-require File.join(File.dirname(__FILE__), "test_helper")
-
-class ActiveRecordTest < Test::Unit::TestCase
-  
-  def setup
-    ArAlbumCache.expire_all
-    Cachetastic::Caches::Base.expire_all
-    #FileUtils.rm_f(AR_DB, :verbose => true)# if File.exists?(AR_DB)
-    begin
-      ArMigration.down
-    rescue Exception => e
-    end
-    ArMigration.up
-    a = ArAlbum.create(:title => "Abbey Road", :artist => "The Beatles")
-    ArSong.create(:title => "Come Together", :album_id => a.id)
-    ArSong.create(:title => "Something", :album_id => a.id)
-    a = ArAlbum.create(:title => "Help!", :artist => "The Beatles")
-    ArSong.create(:title => "Yesterday", :album_id => a.id)
-    ArSong.create(:title => "Dizzy Miss Lizzie", :album_id => a.id)
-  end
-  
-  def teardown
-    ArMigration.down
-    #FileUtils.rm_f(AR_DB, :verbose => true)# if File.exists?(AR_DB)
-  end
-  
-  def test_album_cache
-    assert true
-    res = ArAlbumCache.get(:recent_albums, 5)
-    assert_not_nil res
-    assert res.is_a?(Array)
-    assert_equal 5, res.size
-    res.each do |r|
-       assert r.is_a?(ArAlbum)
-    end
-  end
-  
-  def test_extensions
-    album = ArAlbum.find(1)
-    # assert !Cachetastic::Cacheable.const_defined?("ArAlbumCache")
-    album.cache_self
-    # assert Cachetastic::Cacheable.const_defined?("ArAlbumCache")
-    assert_equal album, Cachetastic::Cacheable::ArAlbumCache.get(1)
-    
-    song = ArSong.find(1)
-    # assert !Cachetastic::Cacheable.const_defined?("ArSongCache")
-    song.cache_self
-    # assert Cachetastic::Cacheable.const_defined?("ArSongCache")
-    assert_equal song, Cachetastic::Cacheable::ArSongCache.get(1)
-    assert_equal album, Cachetastic::Cacheable::ArAlbumCache.get(1)
-    
-    song.uncache_self
-    assert_nil Cachetastic::Cacheable::ArSongCache.get(1)
-    
-    ac = ArAlbum.get_from_cache(1)
-    assert_not_nil ac
-    assert_equal album, ac
-    
-    ArAlbum.delete_from_cache(1)
-    ac = ArAlbum.get_from_cache(1)
-    assert_nil ac
-    
-    ac = ArAlbum.set_into_cache(1, album)
-    assert_not_nil ac
-    assert_equal album, ac
-    
-    ac = ArAlbum.cacher(:foobar) do
-      ArAlbum.find(2)
-    end
-    
-    assert_not_nil ac
-    assert_equal ArAlbum.find(2), ac
-    
-    ac = ArAlbum.get_from_cache(:foobar)
-    assert_not_nil ac
-    assert_equal ArAlbum.find(2), ac
-    
-    assert_equal [1,2,3,:yippie], ac.some_numbers([1,2,3])
-    assert_equal [1,2,3,:yippie], ArAlbum.get_from_cache(:some_numbers)
-    assert_equal [1,2,3,:yippie], ac.some_numbers([1,2,3,4,5,6])
-    
-    ArAlbum.delete_from_cache(1)
-    ac = ArAlbum.get_from_cache(1)
-    assert_nil ac
-    ac = ArAlbum.get_from_cache(1, true)
-    assert_not_nil ac
-  end
-  
-end

data/test/cacheable_test.rb

@@ -1,88 +0,0 @@
-require File.join(File.dirname(__FILE__), "test_helper")
-
-class Person
-  include Cachetastic::Cacheable
-  
-  attr_accessor :name
-  
-  def cachetastic_key
-    self.name
-  end
-  
-  def always_the_same(x, y)
-    cacher("always_the_same") do
-      x + y
-    end
-  end
-  
-end
-
-module Me
-  class You
-    include Cachetastic::Cacheable
-  end
-end
-
-class Unknown
-  include Cachetastic::Cacheable
-end
-
-class CacheableTest < Test::Unit::TestCase
-  
-  def test_cache_classes_work_with_modules
-    assert !Cachetastic::Cacheable.const_defined?("Me_YouCache")
-    assert Me::You.cache_class == Cachetastic::Cacheable::Me_YouCache
-    assert Cachetastic::Cacheable.const_defined?("Me_YouCache")
-  end
-  
-  def test_cache_classes_are_auto_genned
-    assert !Cachetastic::Cacheable.const_defined?("PersonCache")
-    assert Person.cache_class == Cachetastic::Cacheable::PersonCache
-    assert Cachetastic::Cacheable.const_defined?("PersonCache")
-    assert !Cachetastic::Cacheable.const_defined?("UnknownCache")
-    assert Unknown.cache_class == Cachetastic::Cacheable::UnknownCache
-    assert Cachetastic::Cacheable.const_defined?("UnknownCache")
-  end
-  
-  def test_no_cachetastic_key
-    assert_raise(NoMethodError) { Unknown.new.cachetastic_key }
-    assert_raise(NoMethodError) { Unknown.new.cache_self }
-    assert_raise(NoMethodError) { Unknown.new.uncache_self }
-  end
-  
-  def test_cache_uncache_self
-    p = Person.new
-    p.name = "Mark Bates"
-    assert_nil Cachetastic::Cacheable::PersonCache.get("Mark Bates")
-    p.cache_self
-    assert_equal p, Cachetastic::Cacheable::PersonCache.get("Mark Bates")
-    p.uncache_self
-    assert_nil Cachetastic::Cacheable::PersonCache.get("Mark Bates")
-  end
-  
-  def test_cacher
-    p = Person.new
-    assert_nil Cachetastic::Cacheable::PersonCache.get("always_the_same")
-    assert_equal 4, p.always_the_same(1,3)
-    assert_equal 4, Cachetastic::Cacheable::PersonCache.get("always_the_same")
-    assert_equal 4, p.always_the_same(99,99)
-    assert_equal 4, Person.get_from_cache("always_the_same")
-    assert_nil Cachetastic::Cacheable::PersonCache.get("say_hi")
-    Person.cacher("say_hi") do
-      "hi there"
-    end
-    assert_equal "hi there", Cachetastic::Cacheable::PersonCache.get("say_hi")
-    assert_equal "hi there", Person.get_from_cache("say_hi")
-    assert_equal "hi there", Person.cacher("say_hi")
-  end
-  
-  def test_get_from_cache
-    assert_nil Person.get_from_cache("i should be nil")
-    assert_equal 86, Person.get_from_cache("maxwell smart") {86}
-    x = Person.get_from_cache("my name") do |key|
-      "Mark Bates"
-    end
-    assert_equal "Mark Bates", x
-  end
-  
-end

data/test/cachetastic_unit_test.rb

@@ -1,74 +0,0 @@
-require File.join(File.dirname(__FILE__), "test_helper")
-
-class CachetasticUnitTest < Test::Unit::TestCase
-
-
-  def setup
-    Cachetastic::Caches::Base.expire_all
-  end
-
-  def test_class_cannot_be_instaniate
-    assert_raise(NoMethodError) { Cachetastic::Caches::Base.new }
-  end
-  
-  def test_get
-    assert_nil Cachetastic::Caches::Base.get(:my_articles_test_get)
-    res = Cachetastic::Caches::Base.get(:my_articles_test_get) do
-      "hello mark"
-    end
-    assert_equal "hello mark", res
-    assert_nil Cachetastic::Caches::Base.get(:my_articles_test_get)
-    
-    res = Cachetastic::Caches::Base.get(:my_articles_test_get) do
-      Cachetastic::Caches::Base.set(:my_articles_test_get, "hello mark")
-    end
-    assert_equal "hello mark", res
-    assert_not_nil Cachetastic::Caches::Base.get(:my_articles_test_get)
-    assert_equal "hello mark", Cachetastic::Caches::Base.get(:my_articles_test_get)
-  end
-  
-  def test_set
-    assert true
-    Cachetastic::Caches::Base.set(:my_articles, [1, 2, 3], 15.minutes.from_now)
-    assert_equal [1,2,3], Cachetastic::Caches::Base.get(:my_articles)
-  end
-  
-  def test_delete
-    test_set
-    Cachetastic::Caches::Base.delete(:my_articles)
-    assert_nil Cachetastic::Caches::Base.get(:my_articles)
-  end
-  
-  def test_expire_all
-    a = [1,2,3,4,5,6,7,8,9,10]
-    Cachetastic::Caches::Base.set(:testing_expire_all, a)
-    assert_equal a, Cachetastic::Caches::Base.get(:testing_expire_all)
-    Cachetastic::Caches::Base.expire_all
-    assert_nil Cachetastic::Caches::Base.get(:testing_expire_all)
-  end
-  
-  def test_local_memory_auto_expire
-    res = FooBarCache.get(:pickles)
-    assert_nil res
-    FooBarCache.set(:pickles, "are yummy")
-    res = FooBarCache.get(:pickles)
-    assert_not_nil res
-    assert_equal "are yummy", res
-    sleep(4)
-    res = FooBarCache.get(:pickles)
-    assert_nil res
-  end
-  
-  def test_local_memory_delete
-    res = FooBarCache.get(:pickles)
-    assert_nil res
-    FooBarCache.set(:pickles, "are yummy")
-    res = FooBarCache.get(:pickles)
-    assert_not_nil res
-    assert_equal "are yummy", res
-    FooBarCache.delete(:pickles)
-    res = FooBarCache.get(:pickles)
-    assert_nil res
-  end
-
-end