kaching 0.0.3

data/lib/kaching/cache_list.rb

@@ -0,0 +1,194 @@
+module Kaching
+  module CacheList
+    def cache_list(attribute, options = {})
+      container_class = self
+      
+      if block_given?
+        self.cache_counter attribute, options do |item|
+          yield(self)
+        end
+      else
+        self.cache_counter attribute, options
+      end
+
+      options = {
+        method_verb:                    nil,
+        list_method_name:               attribute.to_s,
+        item_key:                       :item,
+        polymorphic:                    false,
+        add_alter_methods:              true,
+        reset_cache_method_name:        "reset_list_cache_#{attribute}!",
+        reset_count_cache_method_name:  "reset_count_cache_#{attribute}!"
+      }.merge(options || {})
+
+      if options[:method_verb]
+        options = {
+          add_method_name:                "#{options[:method_verb]}!",
+          remove_method_name:             "un#{options[:method_verb]}!",
+          exists_method_name:             "#{options[:method_verb]}s?",
+          toggle_method_name:             "toggle_#{options[:method_verb]}!",
+        }.merge(options)
+      else
+        singularized_attribute = attribute.to_s.singularize
+        options = {
+          add_method_name:                "add_#{singularized_attribute}!",
+          remove_method_name:             "remove_#{singularized_attribute}!",
+          exists_method_name:             "has_#{singularized_attribute}?",
+          toggle_method_name:             "toggle_#{singularized_attribute}!",
+        }.merge(options)
+      end
+      
+      Kaching.logger.info { "LIST NEW #{self.name} #{options}" }
+
+      list_class = options[:class_name].constantize if options[:class_name]
+      list_class ||= attribute.to_s.singularize.classify.constantize
+
+      item_key_id = "#{options[:item_key]}_id"
+      
+      if options[:polymorphic]
+        item_key_type = "#{options[:item_key]}_type"
+      end
+
+      if options[:add_alter_methods]
+        container_class.send :define_method, options[:add_method_name] do |*args|
+          item, values = args
+          Kaching.logger.info { "LIST ADD #{self.class.name}##{self.id} #{item.class.name}##{item.id}" }
+          
+          values = values ? values.dup : {}
+          
+          values.merge!(options[:item_key] => item)
+          values.merge!(options[:create_options]) if options[:create_options]
+          
+          return nil if self.send(options[:exists_method_name], item)
+
+          list_item = list_class.new(values) 
+          self.send(options[:list_method_name]) << list_item
+          list_item
+        end
+
+        container_class.send :define_method, options[:remove_method_name] do |item|
+          Kaching.logger.info { "LIST REMOVE #{self.class.name}##{self.id} #{item.class.name}##{item.id}" }
+
+          where = { item_key_id => item.id }
+        
+          if options[:polymorphic]
+            where[item_key_type] = item.class.name
+          end
+        
+          self.send(options[:list_method_name]).where(where).destroy_all
+          
+          nil
+        end
+      
+        container_class.send(:define_method, options[:toggle_method_name]) do |*args|
+          item, state = args
+  
+          return unless item
+        
+          if state.nil?
+            state = !self.send(options[:exists_method_name], item)
+          end
+        
+          if state
+            self.send(options[:add_method_name], item)
+          else
+            self.send(options[:remove_method_name], item)
+          end
+        end
+      end
+      
+      container_class.send(:define_method, options[:exists_method_name]) do |item|
+        return false if item == self
+        
+        hash_key = self.kaching_key(attribute, :list)
+        
+        if Kaching.cache_store.hexists(hash_key, "created")
+          Kaching.logger.info { "USING CREATED #{hash_key}" }
+          Kaching.cache_store.hexists hash_key, item.id.to_s
+        else
+          Kaching.logger.info { "NOT CREATED - CREATING #{hash_key}" }
+          
+          # fetch all ids
+          query = block_given? ? yield(self) : self.send(options[:list_method_name])
+          all_ids = container_class.connection.select_values(query.select(item_key_id).to_sql)
+
+          Kaching.logger.info { "FETCH all_ids = #{all_ids.length} | #{all_ids}" }
+
+          no_ids = all_ids.empty?
+
+          ids_with_values_for_hash = all_ids.map { |id|
+            [ id, 1 ]
+          }.flatten
+
+          ids_with_values_for_hash << "created" << 1
+          
+          # store them with "created" key. "created" means that hash was created and it's not only empty.
+          Kaching.cache_store.send :hmset, *[hash_key, ids_with_values_for_hash].flatten
+          
+          if no_ids
+            false
+          else
+            all_ids.include?(item.id)
+          end
+        end
+      end
+      
+      container_class.send :define_method, options[:reset_cache_method_name] do
+        Kaching.cache_store.del(self.kaching_key(attribute, :list))
+        
+        self.send(options[:reset_count_cache_method_name]) if self.respond_to?(options[:reset_count_cache_method_name])
+      end
+
+      container_class.send(:after_commit) do
+        if self.destroyed?
+          Kaching.cache_store.del(self.kaching_key(attribute, :list))
+        end
+      end
+      
+      foreign_key = Kaching._extract_foreign_key_from(attribute, options, container_class)
+      
+      after_commit_method_name = "after_commit_list_#{attribute}"
+      list_class.send(:define_method, after_commit_method_name) do |action|
+        begin
+          Kaching.logger.info { "LIST #{list_class.name} after_commit foreign_key = #{foreign_key}" }
+      
+          belongs_to_item = self.send(foreign_key)
+
+          return unless belongs_to_item
+
+          hash_key = belongs_to_item.kaching_key(attribute, :list)
+          
+          # don't bother managing the list because it's not created yet. let the has_item?() build it with all items, and then on creation it'll update the list
+          return unless Kaching.cache_store.hexists(hash_key, "created")
+          
+          Kaching.logger.info { " > LIST after_commit #{list_class.name} belongs_to(#{foreign_key}) = #{belongs_to_item.class.name}##{belongs_to_item.id} #{action.inspect}" }
+
+          case action
+          when :create
+            Kaching.logger.info { "  > LIST SET #{hash_key} #{self.class.name}##{self.id} type = #{Kaching.cache_store.type(hash_key)}" }
+            
+            Kaching.cache_store.hset(hash_key, self.send(item_key_id), 1)
+          when :destroy
+            Kaching.logger.info { "  > LIST DEL #{hash_key}" }
+      
+            Kaching.cache_store.hdel(hash_key, self.send(item_key_id))
+          end
+        rescue
+          puts $!.message
+          puts $!.backtrace.join("\n")
+          raise $!
+        end
+      end
+      
+      list_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/model_additions.rb

@@ -0,0 +1,56 @@
+require 'logger'
+require 'kaching/cache_counter'
+require 'kaching/cache_list'
+
+module Kaching
+  # def self.attributes
+  #   @attributes ||= []
+  # end
+
+  def self.cache_store
+    Kaching::StorageProviders.Redis
+  end
+  
+  def self.logger
+    @logger ||= begin
+      logger = Logger.new(ENV['ATTRIBUTE_CACHE_LOG'] ? $stdout : '/dev/null')
+      logger.level = Logger::INFO
+      logger
+    end
+  end
+  
+  def self._extract_foreign_key_from(attribute, options, container_class)
+    foreign_key = options[:foreign_key]
+            
+    if !foreign_key
+      reflection = container_class.reflections[attribute]
+      foreign_key = reflection.options[:foreign_key] if reflection
+    end
+
+    foreign_key = if foreign_key
+      foreign_key.gsub(/_id$/, "")
+    else
+      container_class.name.underscore.singularize
+    end
+    
+    foreign_key
+  end
+  
+  module ModelAdditions
+    module ClassMethods
+      include CacheCounter
+      include CacheList
+    end
+  
+    module InstanceMethods
+      def kaching_key(attribute, type)
+        "Kaching::#{type}::#{self.class.name.underscore.singularize}::#{self.id}::#{attribute}"
+      end
+    end
+    
+    def self.included(receiver)
+      receiver.extend         ClassMethods
+      receiver.send :include, InstanceMethods
+    end
+  end
+end

data/lib/kaching/railtie.rb

@@ -0,0 +1,9 @@
+module Kaching
+  class Railtie < Rails::Railtie
+    initializer 'attrubute_cache.model_additions' do
+      ActiveSupport.on_load :active_record do
+        include ModelAdditions
+      end
+    end
+  end
+end

data/lib/kaching/storage_providers/memory.rb

@@ -0,0 +1,42 @@
+module Kaching
+  module StorageProviders
+    class Memory
+      class << self
+        def data
+          @data ||= {}
+        end
+        
+        def get(key)
+          Kaching.logger.info "CACHE read #{key} = #{data[key]}"
+          data[key]
+        end
+        
+        def set(key, value)
+          Kaching.logger.info "CACHE write #{key} = #{value}"
+          data[key] = value
+        end
+        
+        def del(key)
+          data.delete(key)
+        end
+        
+        def fetch(key, &block)
+          Kaching.logger.info "CACHE fetch #{key} = #{data[key].inspect}"
+          get(key) || set(key, block.call)
+        end
+        
+        def incr(key)
+          data[key] ||= 0
+          Kaching.logger.info "CACHE inc #{key} = #{data[key] + 1}"
+          data[key] += 1
+        end
+        
+        def decr(key)
+          data[key] ||= 0
+          Kaching.logger.info "CACHE dec #{key} = #{data[key] - 1}"
+          data[key] -= 1
+        end
+      end
+    end
+  end
+end

data/lib/kaching/storage_providers/redis.rb

@@ -0,0 +1,26 @@
+require 'redis'
+
+module Kaching
+  module StorageProviders
+    def self.Redis
+      if @redis && !@redis.respond_to?(:fetch)
+        def @redis.fetch(key, &block)
+          value = get(key)
+      
+          if !value
+            value = block.call
+            set(key, value)
+          end
+      
+          value
+        end
+      end
+      
+      @redis
+    end
+    
+    def self.Redis=(adapter)
+      @redis = adapter
+    end
+  end
+end

data/lib/kaching/version.rb

@@ -0,0 +1,3 @@
+module Kaching
+  VERSION = "0.0.3"
+end

data/spec/lib/cache_counter_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+
+describe Kaching::CacheCounter do
+  let(:user) { User.create }
+  
+  it "should create method on user" do
+    user.should respond_to(:articles_count)
+    user.should respond_to(:reset_count_cache_articles!)
+  end
+  
+  it "should return up-to-date count with method" do
+    user.articles_count.should == 0
+    user.articles << Article.new
+    user.articles_count.should == 1
+    user.articles << Article.new
+    user.articles_count.should == 2
+  end
+  
+  it "should update count" do
+    user.articles_count.should == 0
+    user.articles << Article.new
+
+    Kaching.cache_store.get(user.kaching_key(:articles, :count)).to_i.should == 1
+
+    user.reset_count_cache_articles!
+    
+    Kaching.cache_store.get(user.kaching_key(:articles, :count)).should be_blank
+    
+    user.articles_count.should == user.articles_count
+
+    Kaching.cache_store.get(user.kaching_key(:articles, :count)).to_i.should == 1
+  end
+  
+  it "should return up-to-date count for user with items" do
+    user.articles << Article.new
+    user.articles << Article.new
+    user.articles_count.should == 2
+    
+    id = user.id
+    
+    user = User.find(id)
+    user.articles_count.should == 2
+  
+    user.articles << Article.new
+    user.articles_count.should == 3
+  end
+  
+  it "should fetch count where not exists yet (_count method wasn't called and inserted new record)" do
+    user.articles << Article.new
+    user.articles << Article.new
+    user.articles_count.should == 2
+    user.reset_count_cache_articles!
+    
+    user.articles << Article.new
+    user.articles_count.should == 3
+  end
+  
+  it "should use count blocks if passed" do
+    user.following_users_count.should == 0
+    Follow.create(user_id: user.id, item: User.create)
+    user.following_users_count.should == 1
+    Follow.create(user_id: user.id, item: User.create)
+    user.following_users_count.should == 2
+  end
+  
+  context "with blocks" do
+    it "should use count blocks if passed and show up-to-date count for existing user" do
+      Follow.create!(user_id: user.id, item: User.create)
+      Follow.create!(user_id: user.id, item: User.create)
+      user.following_users_count.should == 2
+  
+      id = user.id
+      
+      user = User.find(id)
+      user.following_users_count.should == 2
+
+      Follow.create!(user_id: user.id, item: User.create)
+      user.following_users_count.should == 3
+    end
+
+    it "should use count blocks if passed, other side of association" do
+      follower = User.create
+
+      user.follower_users_count.should == 0
+    
+      Follow.create(user_id: follower.id, item: user)
+      user.follower_users_count.should == 1
+    end
+  end
+  
+  context "custom options" do
+    it "should find belongs_to by options" do
+      user.cars_count.should == 0
+      car = Car.create!(driver: user)
+      user.cars.count.should == 1
+      user.cars_count.should == 1
+    end
+  end
+end

data/spec/lib/cache_list_spec.rb

@@ -0,0 +1,135 @@
+require 'spec_helper'
+
+describe Kaching::CacheList do
+  let(:user) { User.create }
+
+  context "non-polymorphic" do
+    it "should add/remove/has" do
+      movie1 = Movie.create!
+      movie2 = Movie.create!
+    
+      user.has_user_movie?(movie1).should be_false
+      user.add_user_movie!(movie1)
+        
+      user.has_user_movie?(movie1).should be_true
+        
+      user.add_user_movie!(movie2)
+      user.has_user_movie?(movie2).should be_true
+  
+      user.remove_user_movie!(movie1)
+      user.has_user_movie?(movie1).should be_false
+      user.has_user_movie?(movie2).should be_true
+      
+      id = user.id
+        
+      user = User.find(id)
+      user.has_user_movie?(movie1).should be_false
+      user.has_user_movie?(movie2).should be_true
+    end
+  end
+  
+  context "polymorphic" do
+    it "should create method on user" do
+      user.should respond_to(:like!)
+      user.should respond_to(:unlike!)
+      user.should respond_to(:likes?)
+      user.should respond_to(:likes)
+      user.should respond_to(:likes_count)
+    end
+  
+    it "should add/remove/has" do
+      Movie.create!
+      
+      movie1 = Movie.create!
+      movie2 = Movie.create!
+    
+      user.likes_count.should == 0
+      user.likes?(movie1).should be_false
+      user.like!(movie1)
+      user.like!(movie2)
+      user.likes_count.should == 2
+      user.likes?(movie1).should be_true
+      user.likes?(movie2).should be_true
+      user.unlike!(movie1)
+      user.likes_count.should == 1
+      user.likes?(movie1).should be_false
+    
+      id = user.id
+    
+      user = User.find(id)
+      user.likes?(movie1).should be_false
+      user.likes?(movie2).should be_true
+    end
+  
+    it "should support creation/has w/o built-in methods" do
+      movie1 = Movie.create!
+      movie2 = Movie.create!
+    
+      Like.connection.execute "INSERT INTO likes (user_id, item_id, item_type) VALUES (#{user.id}, #{movie1.id}, 'Movie')"
+      Like.create!(user: user, item: movie2)
+    
+      user.likes?(movie1).should be_true
+      user.likes?(movie2).should be_true
+    end
+  
+    it "should toggle" do
+      movie1 = Movie.create!
+  
+      user.likes?(movie1).should be_false
+      user.toggle_like!(movie1)
+      user.likes?(movie1).should be_true
+      
+      user.toggle_like!(movie1)
+      user.likes?(movie1).should be_false
+      
+      user.like!(movie1)
+      user.likes?(movie1).should be_true
+      
+      user.toggle_like!(movie1, false)
+      user.likes?(movie1).should be_false
+      
+      user.toggle_like!(movie1, true)
+      user.likes?(movie1).should be_true
+    end
+      
+    it "should support creation/has w/o built-in methods, by resetting cache after manual insertion" do
+      movie1 = Movie.create!
+    
+      # this creates the cache
+      user.likes?(movie1).should be_false
+    
+      # this doesn't update cache
+      Like.connection.execute "INSERT INTO likes (user_id, item_id, item_type) VALUES (#{user.id}, #{movie1.id}, 'Movie')"
+    
+      user.reset_list_cache_likes!
+      user.likes?(movie1).should be_true
+    end
+  end
+
+  context "two relationships on same model" do
+    it "should manage counts" do
+      follower_user = User.create!
+      followed_user = User.create!
+      
+      follower_user.should respond_to(:follower_users_count)
+      follower_user.should respond_to(:following_users_count)
+      
+      follower_user.follower_users_count.should == 0
+      followed_user.following_users_count.should == 0
+      
+      expect { expect { expect { expect {
+        follower_user.follow! followed_user
+      }.to change(followed_user, :follower_users_count).by(1)
+      }.to change(follower_user, :following_users_count).by(1)
+      }.to_not change(follower_user, :follower_users_count)
+      }.to_not change(followed_user, :following_users_count)
+      
+      expect { expect { expect { expect {
+        follower_user.unfollow! followed_user
+      }.to change(followed_user, :follower_users_count).by(-1)
+      }.to change(follower_user, :following_users_count).by(-1)
+      }.to_not change(follower_user, :follower_users_count)
+      }.to_not change(followed_user, :following_users_count)
+    end
+  end
+end