arid_cache 0.0.5

data/lib/arid_cache/store.rb

@@ -0,0 +1,84 @@
+module AridCache
+  class Store < Hash
+    extend ActiveSupport::Memoizable
+    
+    # AridCache::Store::Blueprint
+    #
+    # Stores options and blocks that are used to generate results for finds
+    # and counts.
+    Blueprint = Struct.new(:key, :klass, :proc, :opts)  do
+
+      def initialize(key, klass, proc=nil, opts={})
+        self.key = key
+        self.klass = klass
+        self.proc = proc
+        self.opts = opts
+      end
+            
+      def klass=(value) # store the base class of *value*
+        self['klass'] = value.is_a?(Class) ? value.name : value.class.name
+      end
+      
+      def klass
+        self['klass'].constantize unless self['klass'].nil?
+      end 
+      
+      def opts=(value)
+        self['opts'] = value.symbolize_keys! unless !value.respond_to?(:symbolize_keys)
+      end    
+      
+      def opts
+        self['opts'] || {}
+      end
+      
+      def proc(object=nil)
+        if self['proc'].nil? && !object.nil?
+          self['proc'] = key
+        else
+          self['proc']
+        end
+      end 
+    end
+    
+    def has?(object, key)
+      self.include?(object_store_key(object, key))
+    end
+    
+    # Empty the proc store
+    def delete!
+      delete_if { true }
+    end 
+
+    def self.instance
+      @@singleton_instance ||= self.new
+    end
+
+    def find(object, key)
+      self[object_store_key(object, key)]
+    end
+    
+    def add(object, key, proc, opts)
+      store_key = object_store_key(object, key)
+      self[store_key] = AridCache::Store::Blueprint.new(key, object, proc, opts)
+    end
+    
+    def find_or_create(object, key)
+      store_key = object_store_key(object, key)
+      if self.include?(store_key)
+        self[store_key]
+      else
+        self[store_key] = AridCache::Store::Blueprint.new(key, object)
+      end
+    end
+    
+    protected
+    
+    def initialize
+    end
+    
+    def object_store_key(object, key)
+      (object.is_a?(Class) ? object.name.downcase : object.class.name.pluralize.downcase) + '-' + key.to_s
+    end
+    memoize :object_store_key
+  end 
+end

data/lib/arid_cache.rb

@@ -0,0 +1,47 @@
+dir = File.dirname(__FILE__)
+$LOAD_PATH.unshift dir unless $LOAD_PATH.include?(dir)
+
+require 'arid_cache/helpers'
+require 'arid_cache/store'
+require 'arid_cache/active_record'
+require 'arid_cache/cache_proxy'
+
+module AridCache
+  extend AridCache::Helpers
+  class Error < StandardError; end
+
+  def self.cache
+    AridCache::CacheProxy
+  end
+
+  def self.clear_all_caches
+    AridCache::CacheProxy.clear_all_caches
+  end 
+  
+  def self.clear_class_caches(object)
+    AridCache::CacheProxy.clear_class_caches(object)
+  end 
+      
+  def self.clear_instance_caches(object)
+    AridCache::CacheProxy.clear_instance_caches(object)
+  end  
+    
+  def self.store
+    AridCache::Store.instance
+  end
+  
+  # The old method of including this module, if you don't want to
+  # extend active record.  Just add 'include AridCache' to your
+  # model class.
+  def self.included(base)
+    base.send(:include, AridCache::ActiveRecord)
+  end
+  
+  # Initializes ARID Cache for Rails.
+  #
+  # This method is called by `init.rb`,
+  # which is run by Rails on startup.
+  def self.init_rails
+    ::ActiveRecord::Base.send(:include, AridCache::ActiveRecord)
+  end
+end

data/rails/init.rb

@@ -0,0 +1 @@
+Kernel.load File.join(File.dirname(__FILE__), '..', 'init.rb')

data/spec/arid_cache_spec.rb

@@ -0,0 +1,7 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "AridCache" do
+  it "fails" do
+    fail "hey buddy, you should probably rename this file and start specing for real"
+  end
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'arid_cache'
+require 'spec'
+require 'spec/autorun'
+
+require 'rubygems'
+require 'will_paginate'
+
+Spec::Runner.configure do |config|
+  
+end

data/tasks/arid_cache_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :arid_cache do
+#   # Task goes here
+# end

data/test/arid_cache_test.rb

@@ -0,0 +1,232 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class AridCacheTest < ActiveSupport::TestCase
+  def setup
+    Rails.cache.clear
+    AridCache.store.delete!
+    get_user
+  end
+
+  test "initializes needed objects" do
+    assert_instance_of AridCache::Store, AridCache.store
+    assert_same AridCache::CacheProxy, AridCache.cache
+  end
+      
+  test "should respond to methods" do
+    assert User.respond_to?(:clear_cache)
+    assert User.first.respond_to?(:clear_cache)    
+    assert_instance_of AridCache::Store, AridCache.store
+  end
+    
+  test "should not clobber model methods" do
+    assert_respond_to User.first, :name
+    assert_respond_to Company.first, :name
+    assert_nothing_raised { User.first.name }
+    assert_nothing_raised { Company.first.name }
+    
+    # Shouldn't mess with your model's method_missing
+    assert_nothing_raised { User.first.is_high? }
+    assert User.first.is_high?  
+  end
+    
+  test "should allow me to cache on the model" do
+    assert_nothing_raised do
+      define_model_cache(User)
+    end
+    #assert_instance_of(Proc, AridCache.store[User.arid_cache_key('companies')].proc)
+  end
+  
+  test "should allow me to cache on the instance" do
+    assert_nothing_raised do
+      define_instance_cache(@user)
+    end
+    #assert_instance_of(Proc, AridCache.store[AridCache.store.store_key@user.arid_cache_key('companies')].proc)
+  end
+    
+  test "should raise an error on invalid dynamic caches" do
+    assert_raises ArgumentError do
+      @user.cached_invalid_companies
+    end
+  end
+  
+  test "should create dynamic caches given valid arguments" do
+    assert_nothing_raised { @user.cached_companies }
+    #assert_instance_of(Proc, AridCache.store[@user.arid_cache_key('companies')].proc)
+  end
+  
+  test "counts queries correctly" do
+    assert_queries(1) { User.all }
+  end
+  
+  test "returns valid results" do
+    @one = @user.cached_companies
+    assert_equal @user.companies, @one
+    assert_equal @user.companies.count, @one.size
+  end
+  
+  test "paginates results" do
+    results = @user.cached_companies(:page => 1, :per_page => 3)
+    assert_kind_of WillPaginate::Collection, results
+    assert_equal 3, results.size
+    assert_equal @user.companies.count, results.total_entries
+    assert_equal 1, results.current_page
+  end
+  
+  test "overrides default paginate options" do
+    results = @user.cached_companies(:page => 1, :per_page => 3)
+    assert_kind_of WillPaginate::Collection, results
+    assert_equal 3, results.size
+    assert_equal @user.companies.count, results.total_entries    
+  end
+  
+  test "works for different pages" do
+    results = @user.cached_companies(:page => 2, :per_page => 3)
+    assert_kind_of WillPaginate::Collection, results
+    assert results.size <= 3
+    assert_equal @user.companies.count, results.total_entries  
+    assert_equal 2, results.current_page  
+  end
+  
+  test "ignores random parameters" do
+    result = @user.cached_companies(:invalid => :params, 'random' => 'values', :user_id => 3)
+    assert_equal @user.companies, result
+  end
+  
+  test "passes on options to find" do
+    actual = @user.cached_companies(:order => 'users.id DESC')
+    expected = @user.companies
+    assert_equal expected, actual
+    assert_equal expected.first, actual.first
+  end
+    
+  test "caches the count when it gets records" do
+    assert_queries(1) do
+      @user.cached_companies
+      @user.cached_companies_count
+    end
+  end
+        
+  test "gets the count only if it's requested first" do
+    count = @user.companies.count
+    assert_queries(1) do
+      assert_equal count, @user.cached_companies_count
+      assert_equal count, @user.cached_companies_count
+    end
+    assert_queries(1) do
+      assert_equal count, @user.cached_companies.size
+      assert_equal count, @user.cached_companies_count
+    end
+  end
+  
+  test "calling cache_ defines methods on the object" do
+    assert !User.method_defined?(:cached_favorite_companies)
+    User.cache_favorite_companies(:order => 'name DESC') do
+      User.companies
+    end
+    assert User.respond_to?(:cached_favorite_companies)
+    assert_nothing_raised do
+      User.method(:cached_favorite_companies)
+    end    
+  end
+
+  test "applies limit and offset" do
+    @user.cached_limit_companies do
+      companies
+    end
+    assert_equal 2, @user.cached_limit_companies(:limit => 2).size
+    assert_equal 3, @user.cached_limit_companies(:limit => 3).size
+    assert_equal @user.companies.all(:limit => 2, :offset => 1), @user.cached_limit_companies(:limit => 2, :offset => 1)
+    assert_equal @user.companies.size, @user.cached_limit_companies.size    
+    User.cached_successful_limit_companies do
+      User.successful
+    end
+    raise User.cached_successful_limit_companies.inspect
+    assert_equal 2, User.cached_successful_limit_companies(:limit => 2).size
+    assert_equal 3, User.cached_successful_limit_companies(:limit => 3).size
+    assert_equal User.successful.all(:limit => 2, :offset => 1), User.cached_successful_limit_companies(:limit => 2, :offset => 1)
+    assert_equal User.successful.size, User.cached_successful_limit_companies.size  
+  end
+  
+  test "pagination should not result in an extra query" do
+    assert_queries(1) do
+      @user.cached_big_companies(:page => 1)
+    end
+    assert_queries(1) do
+      User.cached_companies(:page => 1)
+    end
+  end
+  
+  test "should support a 'force' option" do
+    # ActiveRecord caches the result of the proc, so we need to
+    # use different instances of the user to test the force option.
+    uncached_user = User.first
+    companies = @user.companies
+    size = companies.size
+    assert_queries(1) do
+      assert_equal companies, @user.cached_companies
+      assert_equal size, @user.cached_companies_count
+      assert_equal size, uncached_user.cached_companies_count
+    end
+    assert_queries(2) do
+      assert_equal companies, uncached_user.cached_companies(:force => true)
+      assert_equal size, uncached_user.cached_companies_count(:force => true)
+    end
+  end
+  
+  test "should handle various different model instances" do
+    one = User.first
+    two = User.first :offset => 1
+    assert_not_same one, two
+    assert_equal one.companies, one.cached_companies
+    assert_equal two.companies, two.cached_companies
+  end
+
+  test "should handle arrays of non-active record instances" do
+    assert_equal @user.pet_names, @user.cached_pet_names
+    assert_equal @user.pet_names, @user.cached_pet_names
+    assert_equal @user.pet_names.count, @user.cached_pet_names_count
+  end
+             
+  test "should empty the Rails cache" do
+    define_model_cache(User)
+    @user.cached_companies
+    User.cached_companies
+    assert Rails.cache.exist?(@user.arid_cache_key('companies'))
+    assert Rails.cache.exist?(User.arid_cache_key('companies'))
+    User.clear_cache
+    assert Rails.cache.exist?(@user.arid_cache_key('companies'))
+    assert Rails.cache.exist?(User.arid_cache_key('companies'))   
+  end
+      
+  protected
+
+    def get_user
+      @user = User.first
+      @user.clear_cache
+      define_instance_cache(@user)
+      @user
+    end
+    
+    def assert_queries(num = 1)
+      $query_count = 0
+      yield
+    ensure
+      assert_equal num, $query_count, "#{$query_count} instead of #{num} queries were executed."
+    end
+
+    def assert_no_queries(&block)
+      assert_queries(0, &block)
+    end
+  
+    def define_instance_cache(user)
+      user.cache_companies(:per_page => 2) do
+        user.companies
+      end    
+    end 
+
+    def define_model_cache(model)
+      model.cache_companies(:per_page => 2) do
+        model.companies
+      end    
+    end 
+end

data/test/console

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+libs = []
+
+libs << 'irb/completion'
+libs << 'test_helper'
+
+exec "#{irb} -Ilib:test#{libs.map{ |l| " -r #{l}" }.join} --simple-prompt"

data/test/db/prepare.rb

@@ -0,0 +1,34 @@
+require 'active_record'
+require 'active_record/fixtures'
+
+# Create an in-memory test database and load the fixures into it
+ActiveRecord::Base.establish_connection(
+  :adapter  => "sqlite3",
+  :database => ":memory:"
+)
+
+# Schema
+ActiveRecord::Base.silence do
+  ActiveRecord::Migration.verbose = false
+  load(File.join(File.dirname(__FILE__), 'schema.rb'))
+end
+
+# Fixtures
+ActiveRecord::Base.silence do
+  Fixtures.create_fixtures(File.join(File.dirname(__FILE__), '..', 'fixtures'), ActiveRecord::Base.connection.tables)
+end
+
+# Models
+Dir[File.join(File.dirname(__FILE__), '..', 'models', '*.rb')].each { |f| require f }
+
+class << ActiveRecord::Base.connection
+  IGNORED_SQL = [/^PRAGMA/, /^SELECT currval/, /^SELECT CAST/, /^SELECT @@IDENTITY/, /^SELECT @@ROWCOUNT/, /^SHOW FIELDS /]
+
+  def execute_with_counting(sql, name = nil, &block)
+    $query_count ||= 0
+    $query_count  += 1 unless IGNORED_SQL.any? { |r| sql =~ r }
+    execute_without_counting(sql, name, &block)
+  end
+
+  alias_method_chain :execute, :counting
+end

data/test/db/schema.rb

@@ -0,0 +1,13 @@
+ActiveRecord::Schema.define do
+  create_table "users", :force => true do |t|
+    t.column "name",  :text
+    t.column "email", :text
+  end
+  
+  create_table "companies", :force => true do |t|
+    t.column "name",  :text
+    t.column "owner_id", :integer
+    t.column "country_id", :integer
+    t.column "employees", :integer    
+  end
+end

data/test/fixtures/companies.yml

@@ -0,0 +1,6 @@
+<% for digit in 1..15 %>
+acme_<%= digit %>:
+  name: Acme <%= digit %>
+  owner_id: <%= rand(10) %>
+  employees: <%= rand(200) %>
+<% end %>

data/test/fixtures/users.yml

@@ -0,0 +1,5 @@
+<% for digit in 1..10 %>
+user_<%= digit %>:
+  name: Bob <%= digit %>
+  email: bob<%= digit %>@ibm.com
+<% end %>

data/test/models/company.rb

@@ -0,0 +1,5 @@
+
+class Company < ActiveRecord::Base
+  named_scope :owned, :conditions => ['owner_id is not null']
+  belongs_to :owner, :class_name => :User
+end

data/test/models/user.rb

@@ -0,0 +1,23 @@
+require 'arid_cache'
+
+class User < ActiveRecord::Base
+  has_many :companies, :foreign_key => :owner_id
+  named_scope :companies, :joins => :companies
+  named_scope :successful, :joins => :companies, :conditions => 'companies.employees > 50'
+  
+  def big_companies
+    companies.find :all, :conditions => [ 'employees > 20' ]
+  end
+
+  def pet_names
+    ['Fuzzy', 'Peachy']
+  end
+  
+  def method_missing(method, *args)
+    if method == :is_high?
+      true
+    else
+      super
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,48 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'rubygems'
+require 'active_record'
+require 'active_support'
+require 'active_support/test_case'
+require 'test/unit' # required by ActiveSupport::TestCase
+require 'will_paginate'
+require 'ruby-debug'
+
+# Activate ARID Cache
+require 'arid_cache'
+AridCache.init_rails
+
+# Setup logging
+log = File.expand_path(File.join(File.dirname(__FILE__), 'log', 'test.log'))
+RAILS_DEFAULT_LOGGER = ENV["STDOUT"] ? Logger.new(STDOUT) : Logger.new(log)
+
+# Setup an in memory-cache
+RAILS_CACHE = ActiveSupport::Cache.lookup_store(:memory_store)
+
+# Mock Rails
+Rails = Class.new do
+  cattr_accessor :logger, :cache
+  def self.cache
+    return RAILS_CACHE
+  end
+  def self.logger
+    return RAILS_DEFAULT_LOGGER
+  end
+end
+
+# Set loggers for all frameworks
+for framework in ([ :active_record, :action_controller, :action_mailer ])
+  if Object.const_defined?(framework.to_s.camelize)
+    framework.to_s.camelize.constantize.const_get("Base").logger = Rails.logger
+  end
+end
+ActiveSupport::Dependencies.logger = Rails.logger
+Rails.cache.logger = Rails.logger
+
+# Include this last otherwise the logger isn't set properly
+require 'db/prepare'
+
+ActiveRecord::Base.logger.info("#{"="*25} RUNNING UNIT TESTS #{"="*25}\n\t\t\t#{Time.now.to_s}\n#{"="*70}")
+
+

metadata

@@ -0,0 +1,121 @@
+--- !ruby/object:Gem::Specification 
+name: arid_cache
+version: !ruby/object:Gem::Version 
+  version: 0.0.5
+platform: ruby
+authors: 
+- Karl Varga
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-12-25 00:00:00 +08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: will_paginate
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.2.9
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: will_paginate
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: |
+  ARID Cache makes caching easy and effective.  ARID cache supports caching on all your model named scopes, class methods and instance methods right out of the box.  ARID cache prevents caching logic from cluttering your models and clarifies your logic by making explicit calls to cached result sets.
+  ARID Cache is designed for handling large, expensive ActiveRecord collections but is equally useful for caching anything else as well.
+
+email: kjvarga@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- arid_cache.gemspec
+- init.rb
+- lib/arid_cache.rb
+- lib/arid_cache/active_record.rb
+- lib/arid_cache/cache_proxy.rb
+- lib/arid_cache/helpers.rb
+- lib/arid_cache/store.rb
+- rails/init.rb
+- spec/arid_cache_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- tasks/arid_cache_tasks.rake
+- test/arid_cache_test.rb
+- test/console
+- test/db/prepare.rb
+- test/db/schema.rb
+- test/fixtures/companies.yml
+- test/fixtures/users.yml
+- test/log/.gitignore
+- test/models/company.rb
+- test/models/user.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/kjvarga/arid_cache
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Automates efficient caching of your ActiveRecord collections, gives you counts for free and supports pagination.
+test_files: 
+- spec/arid_cache_spec.rb
+- spec/spec_helper.rb
+- test/arid_cache_test.rb
+- test/db/prepare.rb
+- test/db/schema.rb
+- test/models/company.rb
+- test/models/user.rb
+- test/test_helper.rb