kaching 0.0.3

data/.gitignore

@@ -0,0 +1,10 @@
+*.gem
+.bundle
+.rvmrc
+Gemfile.lock
+gemfiles/*.lock
+pkg/*
+*.rbc
+tmp/*
+.DS_Store
+test.sqlite3

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format=documentation

data/CHANGELOG.md

@@ -0,0 +1,13 @@
+## v0.0.3
+
+* Rename to "kaching", gem release
+* Bug fixes
+* Better specs
+
+## v0.0.2
+
+* Cache list
+
+## v0.0.1
+
+* Initial release

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in kaching.gemspec
+gemspec

data/README.md

@@ -0,0 +1,216 @@
+# kaching
+
+[![Build Status](https://secure.travis-ci.org/elado/kaching.png)](http://travis-ci.org/elado/kaching)
+
+Doesn't hit the DB for counters and existence of a many-to-many association.
+
+## Quick Intro & Examples
+
+**Q: How does it help me?**
+
+A: The short answer -- Less DB hits. More, faster Redis hits.
+
+### Countrs
+
+```ruby
+# hits DB
+author.articles.count
+
+# first time hits DB and caches into Redis
+author.articles_count
+
+# triggers an after_commit that increases the counter on Redis, doesn't run a count query on the DB
+author.articles.create!(title: "Hello")
+
+# no DB hit. just reads from Redis
+author.articles_count
+```
+
+### Lists
+
+```ruby
+# writes to DB, updates Redis
+user.add_like!(memento)
+
+# no DB hit
+user.likes_count
+
+# no DB hit
+user.has_like?(memento)      # => true
+# no DB hit
+user.has_like?(inception)    # => false
+
+# writes to DB, updates Redis
+user.add_like!(inception)
+
+# no DB hit
+user.has_like?(inception)    # => true
+
+# no DB hit
+user.likes_count             # => 2
+
+# deletes from DB, updates Redis
+user.remove_like(inception)
+
+# no DB hit
+user.has_like?(inception)    # => false
+
+# no DB hit
+user.likes_count             # => 1
+```
+
+
+## Installation
+
+```ruby
+gem 'kaching'
+```
+
+Requires Ruby 1.9.2+.
+
+## Storage options
+
+### Redis
+
+```ruby
+# config/initializers/redis.rb
+$redis = Redis.new
+
+Kaching::StorageProviders.Redis = $redis
+```
+
+## cache_counter
+
+Cache counts of associations.
+
+Adds a count method to a class, and adds an after_commit callback to the countable class.
+
+### Usage
+
+```ruby
+# article.rb
+class Article < ActiveRecord::Base
+  belongs_to :user
+end
+
+# user.rb
+class User < ActiveRecord::Base
+  has_many :articles
+
+  cache_counter :articles
+end
+
+# code
+user = User.create!
+
+user.articles_count # => 0
+
+user.articles.create!(title: "Hello")
+
+user.articles_count # => 1
+```
+
+`cache_counter` adds an after_commit to increase/decrease the counter directly on the data store.
+
+
+#### More Options
+
+Specify a `class_name` and provide a block to return a count for custom operations:
+
+```ruby
+class User < ActiveRecord::Base
+  cache_counter :following_users, class_name: 'Follow' do |user|
+    Follow.where(user_id: user.id, item_type: 'User').count
+  end
+
+  cache_counter :follower_users, class_name: 'Follow', foreign_key: 'item_id' do |user|
+    Follow.where(item_id: user.id, item_type: 'User').count
+  end
+end
+```
+
+## cache_list
+
+Caches presence of items in a list that is belong to antoer item. Automatically adds `cache_counter` on that association.
+
+Example: User can Like stuff. In order to check if a user likes an item, you can run a query like
+
+```ruby
+Like.where(user_id: user.id, item_id: item.id, item_type: item.class.name).exists?
+```
+
+But with many items and checks, this process might take some precious time.
+
+In order to solve that, `kaching` fetches once all liked items and stores them in cache.
+
+`cache_list :likes` generates these methods:
+
+```ruby
+add_like!(item)
+remove_like!(item)
+has_like?(item)              
+likes_count              
+reset_list_cache_likes!
+```
+
+ and from now on you can ask if `user.has_like?(item)`
+
+```ruby
+# like.rb
+class Like < ActiveRecord::Base
+  belongs_to :user
+  belongs_to :user, polymorphic: true
+end
+
+# movie.rb
+class Movie < ActiveRecord::Base
+end
+
+# user.rb
+class User < ActiveRecord::Base
+  has_many :likes
+
+  cache_list :likes
+end
+
+# code
+user = User.create!
+
+memento = Movie.create!(name: "memento")
+inception = Movie.create!(name: "inception")
+
+user.add_like!(memento)      # add_like! is an auto generated method!
+
+user.likes_count             # => 1
+
+user.has_like?(memento)      # => true
+user.has_like?(inception)    # => false
+
+user.add_like!(inception)
+user.has_like?(inception)    # => true
+
+user.likes_count             # => 2
+
+user.remove_like(inception)
+user.has_like?(inception)    # => false
+
+user.likes_count             # => 1
+```
+
+The first time `has_like?` is called, it collects all IDs of likes items and stores them in cache.
+
+The second time just asks the cache, and every creation/deletion of an item updates the cache.
+
+
+### Options
+
+
+```
+item_key						The item name on the list table (like 'movie' for 'movie_id')
+polymorphic						Whether list table is polymorphic (list table contains 'item_id' and 'item_type')
+add_method_name					Name of method to add. Can be customized, for example 'like!' instead of 'add_like!'
+remove_method_name				Name of method to remove. Can be customized, for example 'unlike!' instead of 'removes_like!'
+exists_method_name				Name of method to check if exists. Can be customized, for example 'likes?' instead of 'has_like?'
+reset_list_cache_method_name	Reset cache, after manual insertion
+class_name						Name of class of list table, in case it's different than default
+```

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/kaching.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "kaching/version"
+
+Gem::Specification.new do |s|
+  s.name        = "kaching"
+  s.version     = Kaching::VERSION
+  s.authors     = ["Elad Ossadon"]
+  s.email       = ["elad@ossadon.com"]
+  s.homepage    = ""
+  s.summary     = %q{Cache counters and lists of Rails ActiveRecord in an external storage such as Redis.}
+  s.description = %q{Doesn't hit the DB for counters and existence of a many-to-many association.}
+
+  s.rubyforge_project = "kaching"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # s.add_dependency 'rails', ">= 3.0.0"
+  s.add_dependency 'activerecord', ">= 3.0.0"
+  s.add_dependency 'redis'
+
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'sqlite3'
+end

data/lib/kaching.rb

@@ -0,0 +1,13 @@
+require 'kaching/version'
+require 'active_record'
+require 'kaching/model_additions'
+require 'kaching/storage_providers/memory'
+require 'kaching/storage_providers/redis'
+if defined? Rails
+  require 'kaching/railtie'
+else
+  ActiveRecord::Base.send :include, Kaching::ModelAdditions
+end
+
+module Kaching
+end

data/lib/kaching/cache_counter.rb

@@ -0,0 +1,89 @@
+module Kaching
+  module CacheCounter
+    def cache_counter(attribute, options = {})
+      options = {}.merge(options || {})
+        
+      container_class = self
+        
+      count_method_name = options[:count_method_name] || "#{attribute.to_s}_count"
+      reset_count_method_name = "reset_count_cache_#{attribute.to_s}!"
+      
+      Kaching.logger.info "DEFINE #{container_class.name}##{count_method_name}"
+        
+      container_class.send :define_method, count_method_name do
+        value = Kaching.cache_store.fetch(kaching_key(attribute, :count)) {
+          value = (block_given? ? yield(self) : self.send(attribute))
+          value = value.count unless value.is_a?(Fixnum)
+          
+          Kaching.logger.info "FIRST FETCH #{value}"
+          value
+        }.to_i
+
+        Kaching.logger.info "CALL #{container_class.name}##{count_method_name} = #{value}"
+
+        value
+      end
+      
+      container_class.send :define_method, reset_count_method_name do
+        Kaching.cache_store.del(self.kaching_key(attribute, :count))
+      end
+
+      container_class.send(:after_commit) do
+        if self.destroyed?
+          Kaching.cache_store.del(self.kaching_key(attribute, :count))
+        end
+      end
+        
+      countable_class = options[:class_name].constantize if options[:class_name]
+      countable_class ||= attribute.to_s.singularize.classify.constantize
+        
+      Kaching.logger.info "COUNTABLE DEFINE #{countable_class} after_commit"
+        
+      foreign_key = Kaching._extract_foreign_key_from(attribute, options, container_class)
+
+      after_commit_method_name = "after_commit_#{count_method_name}"
+      countable_class.send(:define_method, after_commit_method_name) do |action|
+        begin
+          Kaching.logger.info "COUNTABLE #{countable_class.name} after_commit foreign_key = #{foreign_key}"
+
+          belongs_to_item = self.send(foreign_key)
+        
+          return unless belongs_to_item
+
+          Kaching.logger.info " > COUNTABLE after_commit #{countable_class.name} belongs_to(#{foreign_key}) = #{belongs_to_item.class.name}##{belongs_to_item.id} | #{action.inspect}"
+          
+          counter_key = belongs_to_item.kaching_key(attribute, :count)
+          
+          if !Kaching.cache_store.exists(counter_key)
+            belongs_to_item.send(count_method_name) # get fresh count from db
+          else
+            case action
+            when :create
+              Kaching.logger.info "  > COUNTABLE INCR #{counter_key}"
+          
+              Kaching.cache_store.incr(counter_key)
+            when :destroy
+              Kaching.logger.info "  > COUNTABLE DECR #{counter_key}"
+
+              Kaching.cache_store.decr(counter_key)
+            end
+          end
+        rescue
+          puts $!.message
+          puts $!.backtrace.join("\n")
+          raise $!
+        end
+      end
+
+      countable_class.send(:after_commit) do
+        action = if self.send(:transaction_include_action?, :create)
+          :create
+        elsif self.destroyed?
+          :destroy
+        end
+
+        self.send(after_commit_method_name, action) if action
+      end
+    end
+  end
+end

data/lib/kaching/cache_counter_onmethod.rb

@@ -0,0 +1,80 @@
+module Kaching
+  module CacheCounter
+    def cache_counter(attribute, options = {})
+      options = {}.merge(options || {})
+        
+      container_class = self
+        
+      count_method_name = options[:count_method_name] || "#{attribute.to_s}_count"
+        
+      Kaching.logger.info "DEFINE #{container_class.name}##{count_method_name}"
+        
+      container_class.send :define_method, count_method_name do
+        value = Kaching.cache_store.fetch(kaching_key(attribute, :count)) {
+          value = (block_given? ? yield(self) : self.send(attribute))
+          value = value.count unless value.is_a?(Fixnum)
+          
+          Kaching.logger.info "FIRST FETCH #{value}"
+          value
+        }.to_i
+
+        Kaching.logger.info "CALL #{container_class.name}##{count_method_name} = #{value}"
+          
+        value
+      end
+
+      container_class.send(:after_commit) do
+        if self.destroyed?
+          Kaching.cache_store.del(self.kaching_key(attribute, :count))
+        end
+      end
+        
+      countable_class = options[:class_name].constantize if options[:class_name]
+      countable_class ||= attribute.to_s.singularize.classify.constantize
+        
+      Kaching.logger.info "COUNTABLE DEFINE #{countable_class} after_commit"
+        
+      foreign_key = Kaching._extract_foreign_key_from(attribute, options, container_class)
+        
+      countable_class.send(:after_create) do
+        Kaching.logger.info "COUNTABLE #{countable_class.name} after_create foreign_key = #{foreign_key}"
+      end
+      
+      countable_class.send(:after_destroy) do
+        Kaching.logger.info "COUNTABLE #{countable_class.name} after_destroy foreign_key = #{foreign_key}"
+      end
+
+        
+      countable_class.send(:after_commit) do
+        begin
+          Kaching.logger.info "COUNTABLE #{countable_class.name} after_commit foreign_key = #{foreign_key}"
+
+          belongs_to_item = self.send(foreign_key)
+          
+          return unless belongs_to_item
+
+          created = self.send(:transaction_include_action?, :create)
+          destroyed = self.destroyed?
+    
+          Kaching.logger.info " > COUNTABLE after_commit #{countable_class.name} belongs_to(#{foreign_key}) = #{belongs_to_item.class.name}##{belongs_to_item.id} | #{created ? 'created' : destroyed ? 'destroyed' : 'none'}"
+            
+          counter_key = belongs_to_item.kaching_key(attribute, :count)
+        
+          if created
+            Kaching.logger.info "  > COUNTABLE INCR #{counter_key}"
+            
+            Kaching.cache_store.incr(counter_key)
+          elsif destroyed
+            Kaching.logger.info "  > COUNTABLE DECR #{counter_key}"
+
+            Kaching.cache_store.decr(counter_key)
+          end
+        rescue Exception => e
+          puts e.message
+          puts e.backtrace
+          raise
+        end
+      end
+    end
+  end
+end