cachetastic 1.7.4 → 2.0.0

data/lib/cachetastic.rb

@@ -6,17 +6,26 @@ require 'yaml'
 require 'zlib'
 require 'pp'
 require 'drb'
-# require 'mack_ruby_core_extensions'
-require 'application_configuration'
+require 'configatron'
 begin
   require 'memcache'
 rescue Exception => e
   # if you don't have memcache installed, don't 
   # blow up, print a message, and you can't use
   # the memcache adapter.
-  puts "Warning: You don't have the memcache gem installed which means you can't use the Cachetastic::Adapters::Memcache adapter."
+  puts "CACHETASTIC: Warning: You don't have the memcache gem installed which means you can't use the Cachetastic::Adapters::Memcache adapter."
 end
 
+class Object
+  # Uses <code>define_method</code> to create an empty for the method parameter defined.
+  # That method will then raise MethodNotImplemented. This is useful for creating interfaces
+  # and you want to stub out methods that others need to implement.
+  def self.needs_method(meth)
+    define_method(meth) do
+      raise NoMethodError.new("The interface you are using requires you define the following method '#{meth}'")
+    end
+  end
+end
 
 module Cachetastic #:nodoc:#
   module Caches #:nodoc:#
@@ -31,26 +40,30 @@ end
 module ActiveRecord #:nodoc:#
 end
 
-home = File.dirname(__FILE__)
+home = File.join(File.dirname(__FILE__), 'cachetastic')
+
+require File.join(home, 'connection')
+require File.join(home, 'logger')
+require File.join(home, 'caches/base')
+require File.join(home, 'caches/page_cache')
+require File.join(home, 'caches/rails_session_cache')
+require File.join(home, 'caches/mack_session_cache')
+require File.join(home, 'errors/unsupported_adapter')
+require File.join(home, 'adapters/base')
+require File.join(home, 'adapters/store_object')
+require File.join(home, 'adapters/memcache')
+require File.join(home, 'adapters/local_memory')
+require File.join(home, 'adapters/file_base')
+require File.join(home, 'adapters/file')
+require File.join(home, 'adapters/html_file')
+require File.join(home, 'adapters/drb')
+require File.join(home, 'cacheable')
+require File.join(home, 'rails_extensions/active_record_base')
+require File.join(home, 'rails_extensions/cgi_session_store')
 
-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')
+configatron.cachetastic_default_options.set_default(:debug, false)
+configatron.cachetastic_default_options.set_default(:adapter, :local_memory)
+configatron.cachetastic_default_options.set_default(:logger, ::Logger.new(STDOUT))
 
 #--
 # http://rdoc.sourceforge.net/doc/index.html

data/lib/{adapters/cachetastic_adapters_base.rb → cachetastic/adapters/base.rb}

@@ -14,35 +14,35 @@
 # * valid? - used to test whether or not the store is still valid. If this returns false a new instance of the adapter is created by Cachetastic::Connection
 class Cachetastic::Adapters::Base
   
-  attr_reader :all_options
-  attr_reader :store_options
-  attr_reader :servers
+  # attr_reader :all_options
+  # attr_reader :store_options
+  # attr_reader :servers
   attr_reader :name
-  attr_reader :logging
+  # attr_reader :logging
   attr_reader :logger
   
   def initialize(name)
     @name = name
-    configure
+    @logger = Cachetastic::Logger.new(configuration.retrieve(:logger, ::Logger.new(STDOUT)))
     setup
     if self.debug?
       self.logger.debug(self.name, :self, self.inspect)
-      self.logger.debug(self.name, :options, self.all_options.inspect)
     end
   end
   
-  # foo bar
-  [:setup, :set, :get, :delete, :expire_all, :stats, "valid?"].each do |meth|
-    define_method(meth) do |*args|
-      raise MethodNotImplemented.new(meth)
-    end
-  end
+  needs_method :setup
+  needs_method :set
+  needs_method :get
+  needs_method :delete
+  needs_method :expire_all
+  needs_method :stats
+  needs_method :valid?
   
   # Returns true/or falsed based on whether or not the debug setting is set to true in the
   # configuration file. If the config setting is set, then false is returned.
   def debug?
     ivar_cache(:debug) do
-      (self.all_options["debug"] == true || false)
+      configuration.retrieve(:debug, false)
     end
   end
   
@@ -57,29 +57,22 @@ class Cachetastic::Adapters::Base
     puts s
   end
   
+  def configuration
+    Cachetastic::Adapters::Base.configuration(self.name)
+  end
+  
   class << self
-    # Merges options for the store in the configuration file with the cachetastic_default_options 
-    # found in the configuration file, and returns the results.
-    # Options need to be specified in the configuration file as the methodized name of the cache with
+    # Returns either the options
+    # Options need to be specified in configatrion as the methodized name of the cache with
     # _options attached at the end.
     # Examples:
     #   Cachetastic::Caches::PageCache # => cachetastic_caches_page_cache_options
     #   MyAwesomeCache # => my_awesome_cache_options
-    def get_options(name)
-      options = (app_config.cachetastic_default_options || {})
-      options = {"adapter" => "local_memory"}.merge(options)
-      options = options.merge(app_config.send(name.methodize + "_options") || {})
-      options
+    def configuration(name)
+      name = "#{name}_options"
+      conf = configatron.retrieve(name, configatron.cachetastic_default_options)
+      conf
     end
   end
   
-  private
-  def configure
-    @all_options = Cachetastic::Adapters::Base.get_options(self.name)
-    @store_options = (self.all_options["store_options"] || {})
-    @servers = self.all_options["servers"]
-    @logging = (self.all_options["logging"] || {})
-    @logger = Cachetastic::Logger.new(self.logging, self.name)
-  end
-  
 end

data/lib/{adapters/cachetastic_adapters_drb.rb → cachetastic/adapters/drb.rb}

@@ -18,8 +18,8 @@ class Cachetastic::Adapters::Drb < Cachetastic::Adapters::Base
   end
 
   def setup
-    self.all_options["marshall_method"] = "ruby"
-    self.drb_store = DRbObject.new_with_uri(self.store_options["host"])
+    # self.all_options["marshall_method"] = "ruby"
+    self.drb_store = DRbObject.new_with_uri(configuration.servers)
   end
   
   def expire_all

data/lib/{adapters/cachetastic_adapters_file_base.rb → cachetastic/adapters/file_base.rb}

@@ -6,7 +6,7 @@ class Cachetastic::Adapters::FileBase < Cachetastic::Adapters::Base
   attr_reader :hashed_keys
   
   def setup
-    @directory = File.join(self.store_options["dir"], self.name.to_s)
+    @directory = File.join(self.configuration.store_options.dir, self.name.to_s)
     FileUtils.mkdir_p(self.directory, :verbose => self.debug?)
     @hashed_keys = {}
   end

data/lib/{adapters/cachetastic_adapters_memcache.rb → cachetastic/adapters/memcache.rb}

@@ -20,7 +20,7 @@
 class Cachetastic::Adapters::Memcache < Cachetastic::Adapters::Base
   
   def setup
-    self.conn = MemCache.new(self.servers, self.store_options.merge({:namespace => self.namespace}))
+    self.conn = MemCache.new(configuration.servers, configuration.store_options.to_hash.merge({:namespace => self.namespace}))
     self.version = self.get_version(self.name)
   end
   
@@ -71,7 +71,7 @@ class Cachetastic::Adapters::Memcache < Cachetastic::Adapters::Base
         end
       end
       if memcached_tool_found
-        app_config.memcache_servers.each do |server|
+        configuration.memcache_servers.each do |server|
           puts `memcached_tool #{server}`
         end
       end
@@ -91,7 +91,7 @@ class Cachetastic::Adapters::Memcache < Cachetastic::Adapters::Base
   
   def ns_versions
     ivar_cache do
-      ns_conn = MemCache.new(self.servers, self.store_options.merge({:namespace => :namespace_versions}))
+      ns_conn = MemCache.new(configuration.servers, configuration.store_options.to_hash.merge({:namespace => :namespace_versions}))
     end
   end
   

data/lib/{caches/cachetastic_caches_base.rb → cachetastic/caches/base.rb}

@@ -91,7 +91,7 @@ class Cachetastic::Caches::Base
     # used.
     # If there is an expiry_swing set in the config file it will be +/- to the
     # expiry time. See also: calculate_expiry_time
-    def set(key, value, expiry = (adapter.all_options["default_expiry"] || 0))
+    def set(key, value, expiry = adapter.configuration.retrieve(:default_expiry, 0))
       do_with_logging(:set, key) do
         expiry = calculate_expiry_time(expiry)
         adapter.set(key.to_s, marshall(value), expiry.to_i)
@@ -120,9 +120,7 @@ class Cachetastic::Caches::Base
     # Raises a MethodNotImplemented exception. This method should be overridden
     # in the child class to enable a populating the cache with all things that
     # should be in there. 
-    def populate_all
-      raise MethodNotImplemented.new("populate_all")
-    end
+    needs_method :populate_all
     
     # A convenience method that returns statistics for the underlying Cachetastic::Adapters::Base for the cache.
     def stats
@@ -166,10 +164,10 @@ class Cachetastic::Caches::Base
     
     def marshall(value)
       return value if value.nil?
-      return case adapter.all_options["marshall_method"]
-      when "yaml"
+      return case adapter.configuration.retrieve(:marshall_method, :none).to_sym
+      when :yaml
         YAML.dump(value)
-      when "ruby"
+      when :ruby
         Marshal.dump(value)
       else
         value
@@ -178,10 +176,10 @@ class Cachetastic::Caches::Base
     
     def unmarshall(value)
       return value if value.nil?
-      return case adapter.all_options["marshall_method"]
-      when "yaml"
+      return case adapter.configuration.retrieve(:marshall_method, :none).to_sym
+      when :yaml
         YAML.load(value)
-      when "ruby"
+      when :ruby
         Marshal.load(value)
       else
         value
@@ -192,8 +190,8 @@ class Cachetastic::Caches::Base
     # If the expiry time is set to 60 minutes and the expiry_swing time is set to
     # 15 minutes, this method will return a number between 45 minutes and 75 minutes.
     def calculate_expiry_time(expiry) # :doc:
-      exp_swing = adapter.all_options["expiry_swing"]
-      if exp_swing
+      exp_swing = adapter.configuration.retrieve(:expiry_swing, 0)
+      if exp_swing && exp_swing != 0
         swing = rand(exp_swing.to_i)
         case rand(2)
         when 0
@@ -232,7 +230,7 @@ class Cachetastic::Caches::Base
     
     # make sure people can't instaniate this object!
     def new(*args)
-      raise MethodNotImplemented.new("You can not instaniate this class!")
+      raise NoMethodError.new("You can not instaniate this class!")
     end
     
   end

data/lib/{cachetastic_connection.rb → cachetastic/connection.rb}

@@ -15,7 +15,7 @@ class Cachetastic::Connection
     name = name.to_sym
     conn = self.connections[name]
     return conn if conn && conn.valid?
-    adapter = Cachetastic::Adapters::Base.get_options(name)["adapter"].camelcase
+    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

data/lib/cachetastic/logger.rb

@@ -0,0 +1,49 @@
+# This class handles logging for the caches and their adapters.
+class Cachetastic::Logger
+  
+  # attr_accessor :options
+  # attr_accessor :cache_name
+  attr_accessor :loggers
+  
+  def initialize(loggers)
+    @loggers = [loggers].flatten
+    # self.options = options
+    # self.cache_name = cache_name
+    # self.options.each_pair do |n, opts|
+    #   opts["level"] = (opts["level"] ||= "info").to_sym
+    # end
+  end
+  
+  LOG_LEVELS = [:fatal, :error, :warn, :info, :debug]
+  
+  LOG_LEVELS.each do |level|
+    define_method(level) do |*args|
+      lm = "[CACHE] [#{level.to_s.upcase}]\t#{Time.now.strftime("%m/%d/%y %H:%M:%S")}"
+      exs = []
+      args.each do |arg|
+        if arg.is_a?(Exception)
+          exs << arg
+          continue
+        end
+        lm << "\t" << arg.to_s 
+      end
+      exs.each do |ex|
+        lm << "\n#{ex.message}\n" << ex.backtrace.join("\n")
+      end
+      self.loggers.each do |log|
+        log.send(level, lm)
+      end
+      # self.options.each_pair do |n, opts|
+      #   if LOG_LEVELS.index(opts["level"]) >= LOG_LEVELS.index(level)
+      #     case opts["type"]
+      #     when "file"
+      #       File.open(opts["file"], "a") {|f| f.puts(lm)} 
+      #     when "console"
+      #       puts lm
+      #     end
+      #   end
+      # end
+    end
+  end
+  
+end

data/test/config.rb

@@ -0,0 +1,30 @@
+configatron.my_file_store_cache_options.debug = false
+configatron.my_file_store_cache_options.adapter = :file
+configatron.my_file_store_cache_options.store_options.dir = '/cachetastic/test'
+configatron.my_file_store_cache_options.logger = Logger.new(STDOUT)
+
+configatron.cachetastic_default_options.debug = false
+configatron.cachetastic_default_options.adapter = :local_memory
+configatron.cachetastic_default_options.marshall_method = :none
+configatron.cachetastic_default_options.default_expiry = 2
+log = Logger.new(STDOUT)
+log.level = Logger::DEBUG
+configatron.cachetastic_default_options.logger = log
+
+configatron.young_mc_cache_options.debug = true
+configatron.young_mc_cache_options.adapter = :memcache
+configatron.young_mc_cache_options.default_expiry = 2
+configatron.young_mc_cache_options.logger = Logger.new(STDOUT)
+configatron.young_mc_cache_options.servers = "127.0.0.1:11211"
+configatron.young_mc_cache_options.store_options.c_threshold = "10_000"
+configatron.young_mc_cache_options.store_options.compression = true
+configatron.young_mc_cache_options.store_options.debug = false
+configatron.young_mc_cache_options.readonly = false
+configatron.young_mc_cache_options.urlencode = false
+
+configatron.dr_bob_cache_options.debug = true
+configatron.dr_bob_cache_options.adapter = :drb
+configatron.dr_bob_cache_options.default_expiry = 2
+configatron.dr_bob_cache_options.logger = Logger.new(STDOUT)
+configatron.dr_bob_cache_options.servers = "druby://127.0.0.1:61676"
+configatron.dr_bob_cache_options.marshall_method = :ruby

data/test/drb_adapter_test.rb

@@ -0,0 +1,14 @@
+require File.join(File.dirname(__FILE__), "test_helper")
+
+class DrbAdapterTest < Test::Unit::TestCase
+  
+  def test_drb_adapter
+    assert_nil DrBobCache.get(1)
+    assert DrBobCache.adapter.valid?
+    DrBobCache.set(1, :one)
+    assert_equal :one, DrBobCache.get(1)
+    DrBobCache.expire_all
+    assert_nil DrBobCache.get(1)
+  end
+  
+end

data/test/memcache_adapter_test.rb

@@ -0,0 +1,14 @@
+require File.join(File.dirname(__FILE__), "test_helper")
+
+class MemcacheAdapterTest < Test::Unit::TestCase
+  
+  def test_memcache_adapter
+    assert_nil YoungMcCache.get(1)
+    assert YoungMcCache.adapter.valid?
+    YoungMcCache.set(1, :one)
+    assert_equal :one, YoungMcCache.get(1)
+    YoungMcCache.expire_all
+    assert_nil YoungMcCache.get(1)
+  end
+  
+end

data/test/test_helper.rb

@@ -1,14 +1,13 @@
 require "test/unit"
 require File.join(File.dirname(__FILE__), "..", "lib", "cachetastic")
 require 'rubygems'
-require 'mack_ruby_core_extensions'
+require 'mack-facets'
 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"))
+require File.join(File.dirname(__FILE__), "config")
 
 class MyTempOptionsCache < Cachetastic::Caches::Base
 end
@@ -37,6 +36,12 @@ class ArAlbumCache < Cachetastic::Caches::Base
   end # self
 end # AlbumCache
 
+class YoungMcCache < Cachetastic::Caches::Base
+end
+
+class DrBobCache < Cachetastic::Caches::Base
+end
+
 
 #---- AR:
 AR_DB = File.join(Dir.pwd, "ar_test.db")
@@ -68,23 +73,4 @@ class ArMigration < ActiveRecord::Migration
     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