cachetastic 1.4.2 → 1.5.0

data/README

@@ -1,8 +1,3 @@
-=Gem Requirements:
-* Application Configuration
-* Ruby Extensions
-* Rails Extensions
-
 =Configuration:
 
   cachetastic_default_options:

data/lib/cachetastic.rb

@@ -6,6 +6,7 @@ require 'yaml'
 require 'zlib'
 require 'pp'
 require 'drb'
+require 'application_configuration'
 begin
   require 'memcache'
 rescue Exception => e
@@ -15,6 +16,7 @@ rescue Exception => e
   puts e.message
 end
 
+
 module Cachetastic #:nodoc:#
   module Caches #:nodoc:#
     module ActiveRecord #:nodoc:#

data/test/active_record_test.rb

@@ -0,0 +1,89 @@
+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::Caches::ActiveRecord.const_defined?("ArAlbumCache")
+    album.cache_self
+    assert Cachetastic::Caches::ActiveRecord.const_defined?("ArAlbumCache")
+    assert_equal album, Cachetastic::Caches::ActiveRecord::ArAlbumCache.get(1)
+    
+    song = ArSong.find(1)
+    assert !Cachetastic::Caches::ActiveRecord.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)
+    
+    song.uncache_self
+    assert_nil Cachetastic::Caches::ActiveRecord::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/cachetastic_unit_test.rb

@@ -0,0 +1,74 @@
+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

data/test/config.yml

@@ -0,0 +1,71 @@
+# album_cache_options:
+#   servers:
+#     - 127.0.0.1:11211
+#     
+# doctor_be_cache_options:
+#   adapter: drb
+#   store_options:
+#     host: "druby://127.0.0.1:61676"
+#     
+# doctor_ce_cache_options:
+#   adapter: drb
+#   store_options:
+#     host: "druby://127.0.0.1:61676"
+#     
+# cachetastic_caches_page_cache_options:
+#   default_expiry: <%= 60 * 60 %>
+#   expiry_swing: <%= 60 * 15 %>
+# 
+# cachetastic_caches_rails_session_cache_options:
+#   adapter: local_memory
+#   store_options:
+#     dir: /cachetastic/
+# 
+# memcache_benchmark_cache_options:
+#   debug: false
+#   adapter: memcache
+#   marshall_method: none
+#   store_options:  
+#     c_threshold: 10_000
+#     compression: true
+#     debug: false
+#     readonly: false
+#     urlencode: false
+# 
+my_file_store_cache_options:
+  debug: false
+  adapter: file
+  store_options:
+    dir: "/cachetastic/test"
+#     
+# file_benchmark_cache_options:
+#   debug: false
+#   adapter: file
+#   store_options:
+#     dir: "/cachetastic/benchmark"
+#     
+# local_memory_benchmark_cache_options:
+#   debug: false
+#   adapter: local_memory
+  
+cachetastic_default_options:
+  debug: true
+  adapter: local_memory
+  marshall_method: none
+  default_expiry: 2
+  # buffer: simple
+  # store_options:  
+  #   c_threshold: 10_000
+  #   compression: true
+  #   debug: false
+  #   readonly: false
+  #   urlencode: false
+  logging:
+    # logger_1:
+    #   type: file
+    #   file: log/memcached.log
+    logger_2:
+      type: console
+      level: debug
+  # servers:
+  #   - 127.0.0.1:11211

data/test/data_mapper_test.rb

@@ -0,0 +1,9 @@
+require File.join(File.dirname(__FILE__), "test_helper")
+
+class DataMapperTest < Test::Unit::TestCase
+  
+  def test_truth
+    assert true
+  end
+  
+end

data/test/file_adapter_test.rb

@@ -0,0 +1,49 @@
+require File.join(File.dirname(__FILE__), "test_helper")
+
+class FileAdapterTest < Test::Unit::TestCase
+  
+  def setup
+    FileUtils.rm_rf(c_dir, :verbose => true)
+  end
+  
+  def test_directory_created_if_it_doesnt_exist_on_new
+    assert !File.exists?(c_dir)
+    assert_nil MyFileStoreCache.get(1)
+    assert File.exists?(c_dir)
+    assert MyFileStoreCache.adapter.valid?
+  end
+  
+  def test_invalid_if_directory_is_deleted
+    assert !File.exists?(c_dir)
+    assert_nil MyFileStoreCache.get(1)
+    assert File.exists?(c_dir)
+    FileUtils.rm_rf(c_dir, :verbose => true)
+    assert !Cachetastic::Connection.instance.connections[:my_file_store_cache].valid?
+  end
+  
+  def test_expire_all
+    assert_nil MyFileStoreCache.get(1)
+    MyFileStoreCache.set(1, "hello")
+    assert_equal "hello", MyFileStoreCache.get(1)
+    assert_nil MyFileStoreCache.get(2)
+    MyFileStoreCache.set(2, [1,2,3,4])
+    assert_equal [1,2,3,4], MyFileStoreCache.get(2)
+    MyFileStoreCache.expire_all
+    assert_equal nil, MyFileStoreCache.get(1)
+    assert_equal nil, MyFileStoreCache.get(2)
+  end
+  
+  def test_expiry
+    assert_nil MyFileStoreCache.get(1)
+    MyFileStoreCache.set(1, "hello", 1)
+    assert_equal "hello", MyFileStoreCache.get(1)
+    sleep(3)
+    assert_nil MyFileStoreCache.get(1)
+  end
+  
+  private
+  def c_dir
+    "/cachetastic/test"
+  end
+  
+end

data/test/test_helper.rb

@@ -0,0 +1,90 @@
+require "test/unit"
+require File.join(File.dirname(__FILE__), "..", "lib", "cachetastic")
+require 'rubygems'
+require 'mack_ruby_core_extensions'
+require 'active_record'
+require 'data_mapper'
+
+# place common methods, assertions, and other type things in this file so
+# other tests will have access to them.
+
+app_config.load_file(File.join(File.dirname(__FILE__), "config.yml"))
+
+class MyTempOptionsCache < Cachetastic::Caches::Base
+end
+
+class YourTempOptionsCache < Cachetastic::Caches::Base
+end
+
+class MyFileStoreCache < Cachetastic::Caches::Base
+end
+
+class FooBarCache < Cachetastic::Caches::Base
+end
+
+class ArAlbumCache < Cachetastic::Caches::Base
+  class << self
+    def get(key, num)
+      logger.info(key, num)
+      super(key) do
+        a = []
+        num.times do
+          a << ArAlbum.find(1)
+        end
+        set(key, a)
+      end
+    end # get
+  end # self
+end # AlbumCache
+
+
+#---- AR:
+AR_DB = File.join(Dir.pwd, "ar_test.db")
+puts "AR_DB: #{AR_DB}"
+ActiveRecord::Base.establish_connection({:adapter => "sqlite3", :database => AR_DB})
+
+class ArAlbum < ActiveRecord::Base
+  def some_numbers(arr)
+    cacher(:some_numbers) do
+      arr << :yippie
+    end
+  end
+end
+class ArSong < ActiveRecord::Base
+end
+
+class ArMigration < ActiveRecord::Migration
+  def self.up
+    create_table :ar_albums do |t|
+      t.column :title, :string
+      t.column :artist, :string
+    end
+    create_table :ar_songs do |t|
+      t.column :title, :string
+      t.column :album_id, :integer
+    end
+  end
+  def self.down
+    drop_table :ar_songs
+    drop_table :ar_albums
+  end
+end
+
+#---- DB: 
+DM_DB = File.join(File.dirname(__FILE__), "dm_test.db")
+DataMapper::Database.setup({:adapter => "sqlite3", :database => DM_DB})
+
+class DmAlbum < DataMapper::Base
+  property :title, :string
+  property :artist, :string
+  def some_numbers(arr)
+    cacher(:some_numbers) do
+      arr << :yippie
+    end
+  end
+end
+
+class DmSong < DataMapper::Base
+  property :title, :string
+  property :album_id, :integer
+end

metadata

@@ -1,29 +1,44 @@
 --- !ruby/object:Gem::Specification 
 name: cachetastic
 version: !ruby/object:Gem::Version 
-  version: 1.4.2
+  version: 1.5.0
 platform: ruby
 authors: 
 - markbates
-autorequire: 
-- cachetastic
+autorequire: cachetastic
 bindir: bin
 cert_chain: []
 
-date: 2008-03-26 00:00:00 -04:00
+date: 2008-06-03 00:00:00 -04:00
 default_executable: 
-dependencies: []
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: mack_ruby_core_extensions
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: application_configuration
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: A very simple, yet very powerful caching framework for Ruby.
+email: mark@mackframework.com
+executables: []
 
-description: "cachetastic was developed by: markbates"
-email: 
-executables: 
-- cachetastic_drb_server
 extensions: []
 
-extra_rdoc_files: 
-- README
+extra_rdoc_files: []
+
 files: 
-- README
 - lib/adapters/cachetastic_adapters_base.rb
 - lib/adapters/cachetastic_adapters_drb.rb
 - lib/adapters/cachetastic_adapters_file.rb
@@ -43,17 +58,12 @@ files:
 - lib/helpers/cachetastic_helpers_active_record.rb
 - lib/rails_extensions/cachetastic_active_record_base.rb
 - lib/rails_extensions/cgi_session_cachetastic_store.rb
-- lib/tasks/rubyforge_config.yml
-has_rdoc: true
-homepage: 
-post_install_message: 
-rdoc_options: 
-- --title
-- Cachetastic-RDoc
-- --main
 - README
-- --line-numbers
-- --inline-source
+has_rdoc: false
+homepage: http://www.mackframework.com
+post_install_message: 
+rdoc_options: []
+
 require_paths: 
 - lib
 - lib
@@ -71,10 +81,15 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   version: 
 requirements: []
 
-rubyforge_project: magrathea
-rubygems_version: 1.0.1
+rubyforge_project: 
+rubygems_version: 1.1.1
 signing_key: 
 specification_version: 2
-summary: cachetastic
-test_files: []
-
+summary: A very simple, yet very powerful caching framework for Ruby.
+test_files: 
+- test/active_record_test.rb
+- test/cachetastic_unit_test.rb
+- test/config.yml
+- test/data_mapper_test.rb
+- test/file_adapter_test.rb
+- test/test_helper.rb

data/bin/cachetastic_drb_server

@@ -1,112 +0,0 @@
-require 'thread'
-require 'drb'
-require 'singleton'
-require 'optparse'
-require 'optparse/time'
-require 'ostruct'
-
-# require the necessary gems:
-require 'rubygems'
-gem 'ruby_extensions'
-require 'ruby_extensions'
-gem 'application_configuration'
-require 'application_configuration'
-gem 'cachetastic'
-require 'cachetastic'
-
-$SAFE = 1
-
-SERVER_OPTIONS = OpenStruct.new
-SERVER_OPTIONS.host = "127.0.0.1"
-SERVER_OPTIONS.port = "61676"
-SERVER_OPTIONS.config_file = nil
-SERVER_OPTIONS.verbose = false
-SERVER_OPTIONS.really_verbose = false
-
-opts = OptionParser.new do |opts|
-  
-  opts.on("-h [HOST]") do |v|
-    SERVER_OPTIONS.host = v
-  end
-  
-  opts.on("-p [PORT]", Integer) do |v|
-    SERVER_OPTIONS.port = v
-  end
-  
-  opts.on("-c [CONFIG_FILE]") do |v|
-    SERVER_OPTIONS.config_file = v
-  end
-  
-  opts.on("-v") do |v|
-    SERVER_OPTIONS.verbose = true
-  end
-  
-  opts.on("-rv") do |v|
-    SERVER_OPTIONS.verbose = true
-    SERVER_OPTIONS.really_verbose = true
-  end
-  
-end
-
-opts.parse!(ARGV)
-
-if SERVER_OPTIONS.config_file
-  app_config.load_file(SERVER_OPTIONS.config_file)
-end
-
-module Cachetastic
-  module Drb
-    class Server
-      include Singleton
-
-      def initialize
-        DRb.start_service("druby://#{SERVER_OPTIONS.host}:#{SERVER_OPTIONS.port}", self)
-        puts "Cachetastic::Drb::Server listening for connection..."
-        DRb.thread.join
-      end # initialize
-
-      def get(ns, key)
-        puts "get: #{ns}.#{key}" if SERVER_OPTIONS.verbose
-        puts cache_for_namespace(ns).inspect if SERVER_OPTIONS.really_verbose
-        cache_for_namespace(ns).get(key)
-      end
-
-      def set(ns, key, value, expiry = 0)
-        puts "set: #{ns}.#{key}" if SERVER_OPTIONS.verbose
-        cache_for_namespace(ns).set(key, value)
-        puts cache_for_namespace(ns).inspect if SERVER_OPTIONS.really_verbose
-        value
-      end
-
-      def delete(ns, key, delay = 0)
-        puts "delete: #{ns}.#{key}" if SERVER_OPTIONS.verbose
-        cache_for_namespace(ns).delete(key, delay = 0)
-        puts cache_for_namespace(ns).inspect if SERVER_OPTIONS.really_verbose
-      end
-
-      def expire_all(ns)
-        puts "expire_all: #{ns}" if SERVER_OPTIONS.verbose
-        instance_variable_set("@store_for_#{ns}", Cachetastic::Adapters::LocalMemory.new("store_for_#{ns}"))
-      end
-
-      def ping
-        true
-      end
-
-      private
-      def cache_for_namespace(ns)
-        # puts "@store_for_#{ns}"
-        c = instance_variable_get("@store_for_#{ns}")
-        if c.nil?
-          instance_variable_set("@store_for_#{ns}", Cachetastic::Adapters::LocalMemory.new("store_for_#{ns}"))
-          c = instance_variable_get("@store_for_#{ns}")
-        end
-        c
-      end
-
-    end # Server
-  end # Drb
-end # Cachetastic
-
-# let's start `er up!
-Cachetastic::Drb::Server.instance

data/lib/tasks/rubyforge_config.yml

@@ -1,5 +0,0 @@
---- !ruby/object:RubyForgeConfig 
-gem_name: cachetastic
-package: cachetastic
-project: magrathea
-version: 1.4.2