cachetastic 1.5.0 → 1.6.0

data/lib/cachetastic.rb

@@ -19,39 +19,37 @@ end
 
 module Cachetastic #:nodoc:#
   module Caches #:nodoc:#
-    module ActiveRecord #:nodoc:#
-    end
   end
   module Adapters #:nodoc:#
   end
   module Errors #:nodoc:#
   end
-  module Helpers #:nodoc:#
-    module ActiveRecord #:nodoc:#
-    end
+  module Cacheable
   end
 end
 module ActiveRecord #:nodoc:#
 end
 
-require 'cachetastic_connection'
-require 'cachetastic_logger'
-require 'caches/cachetastic_caches_base'
-require 'caches/cachetastic_caches_page_cache'
-require 'caches/cachetastic_caches_rails_session_cache'
-require 'caches/cachetastic_caches_mack_session_cache'
-require 'errors/cachetastic_errors_unsupported_adapter'
-require 'adapters/cachetastic_adapters_base'
-require 'adapters/cachetastic_adapters_store_object'
-require 'adapters/cachetastic_adapters_memcache'
-require 'adapters/cachetastic_adapters_local_memory'
-require 'adapters/cachetastic_adapters_file_base'
-require 'adapters/cachetastic_adapters_file'
-require 'adapters/cachetastic_adapters_html_file'
-require 'adapters/cachetastic_adapters_drb'
-require 'helpers/cachetastic_helpers_active_record'
-require 'rails_extensions/cachetastic_active_record_base'
-require 'rails_extensions/cgi_session_cachetastic_store'
+home = File.dirname(__FILE__)
+
+require File.join(home, 'cachetastic_connection')
+require File.join(home, 'cachetastic_logger')
+require File.join(home, 'caches/cachetastic_caches_base')
+require File.join(home, 'caches/cachetastic_caches_page_cache')
+require File.join(home, 'caches/cachetastic_caches_rails_session_cache')
+require File.join(home, 'caches/cachetastic_caches_mack_session_cache')
+require File.join(home, 'errors/cachetastic_errors_unsupported_adapter')
+require File.join(home, 'adapters/cachetastic_adapters_base')
+require File.join(home, 'adapters/cachetastic_adapters_store_object')
+require File.join(home, 'adapters/cachetastic_adapters_memcache')
+require File.join(home, 'adapters/cachetastic_adapters_local_memory')
+require File.join(home, 'adapters/cachetastic_adapters_file_base')
+require File.join(home, 'adapters/cachetastic_adapters_file')
+require File.join(home, 'adapters/cachetastic_adapters_html_file')
+require File.join(home, 'adapters/cachetastic_adapters_drb')
+require File.join(home, 'cachetastic_cacheable')
+require File.join(home, 'rails_extensions/cachetastic_active_record_base')
+require File.join(home, 'rails_extensions/cgi_session_cachetastic_store')
 
 #--
 # http://rdoc.sourceforge.net/doc/index.html

data/lib/cachetastic_cacheable.rb

@@ -0,0 +1,202 @@
+module Cachetastic
+  # Include this module into an Object to achieve simplistic Object level caching.
+  # When including this module you *MUST* create an instance level method called cachetastic_key and 
+  # have it return a valid key! If you return nil from the cachetastic_key method you will not be
+  # able to use the cache_self and uncache_self methods.
+  # 
+  # Example:
+  #   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 Cacheable
+    
+    module ClassAndInstanceMethods
+      # Returns the Cachetastic::Caches::Base object associated with the object.
+      # If a cache hasn't been defined the one will be created on the fly.
+      # The cache for the object is expected to be defined as:
+      # Cachetastic::Cacheable::{CLASS_NAME_HERE}Cache
+      # 
+      # Example:
+      #   class Person
+      #     include Cachetastic::Cacheable
+      #     attr_accessor :name
+      #     def cachetastic_key
+      #       self.name
+      #     end
+      #   end
+      # 
+      #  Person.cache_class # => Cachetastic::Cacheable::PersonCache
+      def cache_class
+        n = self.class.name
+        n = self.name if n == "Class"
+        # puts "n: #{n}"
+        c_name = "Cachetastic::Cacheable::#{n}Cache"
+        unless Cachetastic::Cacheable.const_defined?("#{n}Cache")
+          # puts "we need to create a cache for: #{c_name}"
+          eval %{
+            class #{c_name} < Cachetastic::Caches::Base
+            end
+          }
+        end
+        c_name.constantize
+      end
+    
+      # How much did I want to call this method cache?? It originally was that, but
+      # in Rails 2.0 they decided to use that name, so I had to rename this method.
+      # This method will attempt to get an object from the cache for a given key.
+      # If the object is nil and a block is given the block will be run, and the results
+      # of the block will be automatically cached.
+      # 
+      # Example:
+      #   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
+      # 
+      # Person.new.always_the_same(1,2) # => 3
+      # Person.new.always_the_same(2,2) # => 3
+      # Person.new.always_the_same(3,3) # => 3
+      # Person.cacher("always_the_same") # => 3
+      # Person.get_from_cache("always_the_same") # => 3
+      # Cachetastic::Cacheable::PersonCache.get("always_the_same") # => 3
+      # 
+      # Person.cacher("say_hi") {"Hi There"} # => "Hi There"
+      # Person.get_from_cache("say_hi") # => "Hi There"
+      # Cachetastic::Cacheable::PersonCache.get("say_hi") # => "Hi There"
+      def cacher(key, expiry = 0)
+        cache_class.get(key) do
+          if block_given?
+            res = yield
+            cache_class.set(key, res, expiry)
+          end
+        end
+      end
+    
+      # Expires the entire cache associated with this objects's cache.
+      # 
+      # Example:
+      #   class Person
+      #     include Cachetastic::Cacheable
+      #     attr_accessor :name
+      #     def cachetastic_key
+      #       self.name
+      #     end
+      #   end
+      # 
+      #   Person.set_into_cache(1, "one")
+      #   Person.get_from_cache(1) # => "one"
+      #   Person.expire_all
+      #   Person.get_from_cache(1) # => nil
+      #   Person.set_into_cache(1, "one")
+      #   Person.get_from_cache(1) # => "one"
+      #   Cachetastic::Cacheable::PersonCache.expire_all
+      #   Person.get_from_cache(1) # => nil
+      def expire_all
+        cache_class.expire_all
+      end
+    end
+    
+    # --------------------------
+    # Instance only methods:
+    
+    # Unless the object's cachetastic_key method returns nil this method will store
+    # the object in the cache using the object's cachetastic_key as the key.
+    # You *MUST* create an instance level method called cachetastic_key and 
+    # have it return a valid key! If you return nil from the cachetastic_key method you will not be
+    # able to use the cache_self and uncache_self methods.
+    # 
+    # Example:
+    #   class Person
+    #     include Cachetastic::Cacheable
+    #     attr_accessor :name
+    #     def cachetastic_key
+    #       self.name
+    #     end
+    #   end
+    # 
+    #   Person.get_from_cache("Mark Bates") # => nil
+    #   p = Person.new
+    #   p.name = "Mark Bates"
+    #   p.cache_self
+    #   Person.get_from_cache("Mark Bates") # => "Mark Bates"
+    def cache_self
+      cache_class.set(self.cachetastic_key, self) unless self.cachetastic_key.nil?
+    end
+
+    # Unless the object's cachetastic_key method returns nil this method will delete
+    # the object in the cache using the object's cachetastic_key as the key.
+    # You *MUST* create an instance level method called cachetastic_key and 
+    # have it return a valid key! If you return nil from the cachetastic_key method you will not be
+    # able to use the cache_self and uncache_self methods.
+    # 
+    # Example:
+    #   class Person
+    #     include Cachetastic::Cacheable
+    #     attr_accessor :name
+    #     def cachetastic_key
+    #       self.name
+    #     end
+    #   end
+    # 
+    #   Person.get_from_cache("Mark Bates") # => nil
+    #   p = Person.new
+    #   p.name = "Mark Bates"
+    #   p.cache_self
+    #   Person.get_from_cache("Mark Bates") # => "Mark Bates"
+    #   p.uncache_self
+    #   Person.get_from_cache("Mark Bates") # => nil
+    def uncache_self
+      cache_class.delete(self.cachetastic_key) unless self.cachetastic_key.nil?
+    end
+    
+    # --------------------------
+    
+    def self.included(klass) # :nodoc:
+      klass.send(:include, ClassAndInstanceMethods)
+      klass.extend(ClassOnlyMethods)
+      klass.extend(ClassAndInstanceMethods)
+    end
+    
+    module ClassOnlyMethods
+      # 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 get_from_cache(key, &block)
+        cache_class.get(key, &block)
+      end
+
+      # Deletes an object from the cache for a given key.
+      def delete_from_cache(key)
+        cache_class.delete(key)
+      end
+
+      # Sets an object into the cache for a given key.
+      def set_into_cache(key, value, expiry = 0)
+        cache_class.set(key, value, expiry)
+      end
+    end # ClassMethods
+    
+  end # Cacheable
+end # Cachetastic

data/lib/rails_extensions/cachetastic_active_record_base.rb

@@ -1,47 +1,20 @@
 class ActiveRecord::Base
   
-  include Cachetastic::Helpers::ActiveRecord # include helpers at instance level
+  include Cachetastic::Cacheable
   
-  class << self
-    include Cachetastic::Helpers::ActiveRecord # include helpers at class level
-    
-    # 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 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
-    
-    # Deletes an object from the cache for a given key.
-    def delete_from_cache(key)
-      cache_class.delete(key)
-    end
-    
-    # Sets an object into the cache for a given key.
-    def set_into_cache(key, value, expiry = 0)
-      cache_class.set(key, value, expiry)
-    end
-    
+  def cachetastic_key
+    self.id
   end
   
-  # Unless the object is a new ActiveRecord object this method will store
-  # the object in the cache using the object's ID as the key.
-  def cache_self
-    cache_class.set(self.id, self) unless self.new_record?
-  end
-  
-  # Unless the object is a new ActiveRecord object this method will delete
-  # the object in the cache using the object's ID as the key.
-  def uncache_self
-    cache_class.delete(self.id) unless self.new_record?
+  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/ruby_extensions/object.rb

@@ -0,0 +1,8 @@
+class Object
+  
+  # Override this method in your object if you use the Cachetastic::Cacheable module.
+  def cachetastic_key
+    raise NoMethodError.new('cachetastic_key')
+  end
+  
+end

data/test/active_record_test.rb

@@ -37,20 +37,20 @@ class ActiveRecordTest < Test::Unit::TestCase
   
   def test_extensions
     album = ArAlbum.find(1)
-    assert !Cachetastic::Caches::ActiveRecord.const_defined?("ArAlbumCache")
+    assert !Cachetastic::Cacheable.const_defined?("ArAlbumCache")
     album.cache_self
-    assert Cachetastic::Caches::ActiveRecord.const_defined?("ArAlbumCache")
-    assert_equal album, Cachetastic::Caches::ActiveRecord::ArAlbumCache.get(1)
+    assert Cachetastic::Cacheable.const_defined?("ArAlbumCache")
+    assert_equal album, Cachetastic::Cacheable::ArAlbumCache.get(1)
     
     song = ArSong.find(1)
-    assert !Cachetastic::Caches::ActiveRecord.const_defined?("ArSongCache")
+    assert !Cachetastic::Cacheable.const_defined?("ArSongCache")
     song.cache_self
-    assert Cachetastic::Caches::ActiveRecord.const_defined?("ArSongCache")
-    assert_equal song, Cachetastic::Caches::ActiveRecord::ArSongCache.get(1)
-    assert_equal album, Cachetastic::Caches::ActiveRecord::ArAlbumCache.get(1)
+    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::Caches::ActiveRecord::ArSongCache.get(1)
+    assert_nil Cachetastic::Cacheable::ArSongCache.get(1)
     
     ac = ArAlbum.get_from_cache(1)
     assert_not_nil ac

data/test/cacheable_test.rb

@@ -0,0 +1,72 @@
+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
+
+class Unknown
+  include Cachetastic::Cacheable
+end
+
+class CacheableTest < Test::Unit::TestCase
+  
+  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}
+  end
+  
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: cachetastic
 version: !ruby/object:Gem::Version 
-  version: 1.5.0
+  version: 1.6.0
 platform: ruby
 authors: 
 - markbates
@@ -52,13 +52,62 @@ files:
 - lib/caches/cachetastic_caches_page_cache.rb
 - lib/caches/cachetastic_caches_rails_session_cache.rb
 - lib/cachetastic.rb
+- lib/cachetastic_cacheable.rb
 - lib/cachetastic_connection.rb
 - lib/cachetastic_logger.rb
 - lib/errors/cachetastic_errors_unsupported_adapter.rb
-- lib/helpers/cachetastic_helpers_active_record.rb
 - lib/rails_extensions/cachetastic_active_record_base.rb
 - lib/rails_extensions/cgi_session_cachetastic_store.rb
+- lib/ruby_extensions/object.rb
 - README
+- doc/classes/ActiveRecord/Base.html
+- doc/classes/Cachetastic/Adapters/Base.html
+- doc/classes/Cachetastic/Adapters/Drb.html
+- doc/classes/Cachetastic/Adapters/File.html
+- doc/classes/Cachetastic/Adapters/FileBase.html
+- doc/classes/Cachetastic/Adapters/HtmlFile.html
+- doc/classes/Cachetastic/Adapters/LocalMemory.html
+- doc/classes/Cachetastic/Adapters/Memcache.html
+- doc/classes/Cachetastic/Cacheable/ClassAndInstanceMethods.html
+- doc/classes/Cachetastic/Cacheable/ClassOnlyMethods.html
+- doc/classes/Cachetastic/Cacheable.html
+- doc/classes/Cachetastic/Caches/Base/RegisteredCaches.html
+- doc/classes/Cachetastic/Caches/Base.html
+- doc/classes/Cachetastic/Caches/MackSessionCache.html
+- doc/classes/Cachetastic/Caches/PageCache.html
+- doc/classes/Cachetastic/Caches/RailsSessionCache.html
+- doc/classes/Cachetastic/Connection.html
+- doc/classes/Cachetastic/Errors/UnsupportedAdapter.html
+- doc/classes/Cachetastic/Logger.html
+- doc/classes/CGI/Session/CachetasticStore.html
+- doc/classes/Object.html
+- doc/created.rid
+- doc/files/lib/adapters/cachetastic_adapters_base_rb.html
+- doc/files/lib/adapters/cachetastic_adapters_drb_rb.html
+- doc/files/lib/adapters/cachetastic_adapters_file_base_rb.html
+- doc/files/lib/adapters/cachetastic_adapters_file_rb.html
+- doc/files/lib/adapters/cachetastic_adapters_html_file_rb.html
+- doc/files/lib/adapters/cachetastic_adapters_local_memory_rb.html
+- doc/files/lib/adapters/cachetastic_adapters_memcache_rb.html
+- doc/files/lib/adapters/cachetastic_adapters_store_object_rb.html
+- doc/files/lib/caches/cachetastic_caches_base_rb.html
+- doc/files/lib/caches/cachetastic_caches_mack_session_cache_rb.html
+- doc/files/lib/caches/cachetastic_caches_page_cache_rb.html
+- doc/files/lib/caches/cachetastic_caches_rails_session_cache_rb.html
+- doc/files/lib/cachetastic_cacheable_rb.html
+- doc/files/lib/cachetastic_connection_rb.html
+- doc/files/lib/cachetastic_logger_rb.html
+- doc/files/lib/cachetastic_rb.html
+- doc/files/lib/errors/cachetastic_errors_unsupported_adapter_rb.html
+- doc/files/lib/rails_extensions/cachetastic_active_record_base_rb.html
+- doc/files/lib/rails_extensions/cgi_session_cachetastic_store_rb.html
+- doc/files/lib/ruby_extensions/object_rb.html
+- doc/files/README.html
+- doc/fr_class_index.html
+- doc/fr_file_index.html
+- doc/fr_method_index.html
+- doc/index.html
+- doc/rdoc-style.css
 has_rdoc: false
 homepage: http://www.mackframework.com
 post_install_message: 
@@ -88,6 +137,7 @@ specification_version: 2
 summary: A very simple, yet very powerful caching framework for Ruby.
 test_files: 
 - test/active_record_test.rb
+- test/cacheable_test.rb
 - test/cachetastic_unit_test.rb
 - test/config.yml
 - test/data_mapper_test.rb