benny_cache 0.0.1

data/lib/benny_cache/config.rb

@@ -0,0 +1,21 @@
+module BennyCache
+  class Config
+    @@_store = nil
+
+    def self.store
+      return @@_store if @@_store
+
+      if const_defined?('Rails') && Rails.cache
+        @@_store = Rails.cache
+      else
+        @@_store =  BennyCache::Cache.new
+      end
+
+      @@_store
+    end
+
+    def self.store=(store)
+      @@_store = store
+    end
+  end
+end

data/lib/benny_cache/model.rb

@@ -0,0 +1,264 @@
+require 'digest/sha1'
+
+module BennyCache
+  module Model
+
+    def self.included(base)
+      base.instance_eval {
+        include BennyCache::Base
+      }
+
+      base.extend BennyCache::Model::ClassMethods
+
+      unless base.class_variable_defined? :@@BENNY_MODEL_INDEXES
+        base.class_variable_set(:@@BENNY_MODEL_INDEXES, [])
+      end
+
+      unless base.class_variable_defined? :@@BENNY_DATA_INDEXES
+        base.class_variable_set(:@@BENNY_DATA_INDEXES, [])
+      end
+
+      unless base.class_variable_defined? :@@BENNY_METHOD_INDEXES
+        base.class_variable_set(:@@BENNY_METHOD_INDEXES, [])
+      end
+
+      if base.respond_to? :after_save
+        base.after_save :benny_model_cache_delete
+      end
+
+      if base.respond_to? :after_destroy
+        base.after_destroy :benny_model_cache_delete
+      end
+
+      def benny_model_cache_delete
+        ns = self.class.get_benny_model_ns
+        key = "#{ns}/#{self.id}"
+
+        BennyCache::Config.store.delete(key)
+        self.class.class_variable_get(:@@BENNY_MODEL_INDEXES).each do |idx|
+
+          if idx.is_a?(Symbol)
+            key =  "#{ns}/#{idx}/" + idx.to_s.gsub(/(\w+)/) { self.send($1) }
+          elsif idx.is_a?(String)
+            key =  "#{ns}/" +  idx.to_s.gsub(/:(\w+)/) { "#{self.send($1) }" }
+          end
+
+          BennyCache::Config.store.delete(key)
+        end
+      end
+
+      def benny_data_cache(data_index, &block)
+        full_index = self.class.benny_data_cache_full_index(self.id, data_index)
+        BennyCache::Config.store.fetch(full_index, &block)
+      end
+    end
+
+    module ClassMethods
+
+      ##
+      # Clear the a data cache from a given model
+      def benny_data_cache_delete(model_id, data_index)
+        full_index = self.benny_data_cache_full_index(model_id, data_index)
+        BennyCache::Config.store.delete(full_index)
+      end
+
+      # Clear the a method cache from a given model
+      def benny_method_cache_delete(model_id, data_index)
+        full_index = self.benny_method_cache_full_index(model_id, data_index)
+
+        keys = BennyCache::Config.store.fetch(full_index)
+
+        unless (keys.nil?  || keys.empty?)
+          keys.each do |key|
+            BennyCache::Config.store.delete(key)
+          end
+        end
+        BennyCache::Config.store.delete(full_index)
+
+      end
+
+      def benny_data_cache_full_index(model_id, data_index) # :nodoc:
+        raise "undefined cache data key '#{data_index}'" unless self.class_variable_get(:@@BENNY_DATA_INDEXES).include?(data_index.to_s)
+        ns = self.get_benny_model_ns
+        full_index = "#{ns}/#{model_id}/data/#{data_index.to_s}"
+      end
+
+      def benny_method_cache_full_index(model_id, method_index) # :nodoc:
+        raise "undefined cache method key '#{method_index}'" unless self.class_variable_get(:@@BENNY_METHOD_INDEXES).include?(method_index.to_s)
+        ns = self.get_benny_model_ns
+        full_index = "#{ns}/#{model_id}/method/#{method_index.to_s}"
+      end
+
+      # For each benny cached method, we store an array cached results. Each result
+      # is unique to the parameters used during the method call.
+      # Meaning: foo.bar(:baz) and foo.bar(:bin) are stored as two separate
+      # results, with their own key in the benny cache. Additionally,
+      # these various keys associated with foo.bar are stored as an
+      # separate array in their own cache entry.
+      # When it's time to clear the all the foo.bar cached results, we will
+      # have an array of keys to reference.
+      def benny_method_store_method_args_index(base_method_index, args_method_index)
+        method_sig_ary = BennyCache::Config.store.fetch(base_method_index) { [] }
+        unless method_sig_ary.include?(args_method_index)
+          method_sig_ary.push(args_method_index)
+          BennyCache::Config.store.write(base_method_index, method_sig_ary)
+        end
+      end
+
+      def benny_method_store_method_args_indexes_delete(model_id, method_name)
+        base_method_index = self.benny_method_cache_full_index(model_id, method_name)
+
+        method_sig_ary = BennyCache::Config.store.fetch(base_method_index) { [] }
+        method_sig_ary.each do |args_method_index|
+          BennyCache::Config.store.clear(args_method_index)
+        end
+        BennyCache::Config.store.clear(base_method_index)
+      end
+
+      ##
+      # Declares one or more caching indexes for instances of this class.
+      # You do not have to declare an :id index, but if you will be referencing or loading
+      # models by other indexes, declare them here.
+      #
+      # Explicit declarations are needed so BennyCache knows which cache keys to clear
+      # on a relevant change.
+      #
+      # Valid options are symbols of other methods, or for multiple-field indexes, an array
+      # of :symbols
+      #  class Agent
+      #    benny_model_index :user_id
+      #    # internally works like Agent.where(:user_id => user_id ).first when referenced
+      #  end
+      #
+      # or
+      #
+      #  class Location
+      #    benny_model_index [:x, :y]
+      #    # internally works like Locaion.where(:x => x, :y => y ).first when referenced
+      #  end
+      #
+      # You can include many indexes in the declaration:
+      #
+      #  class Foo
+      #    benny_model_index :bar, :baz, [:zip, :zap]
+      #  end
+
+      def benny_model_index(*options)
+        index_keys = options.map do |idx|
+          if idx.is_a?(Array)
+              idx.map{ |jdx| "#{jdx.to_s}/:#{jdx.to_s}"}.join("/")
+          else
+             "#{idx.to_s}/:#{idx.to_s}"
+          end
+        end
+        self.class_variable_get(:@@BENNY_MODEL_INDEXES).push(*index_keys)
+      end
+
+      def benny_data_index(*options)
+        self.class_variable_get(:@@BENNY_DATA_INDEXES).push(*(options.map(&:to_s)))
+      end
+
+      def benny_method_args_sig(*options)
+        sig =  ''
+        options.each { |arg|
+            if arg.respond_to?(:id)
+              sig += "#{arg.class}/##{arg.id}"
+            elsif arg.is_a?(Array)
+              arg.each do |val|
+                sig += benny_method_args_sig(*val)
+              end
+            elsif arg.is_a?(Hash)
+              arg.keys.sort.each do |key|
+                sig += benny_method_args_sig(key)  + benny_method_args_sig(*(arg[key]))
+              end
+            else
+              sig += Digest::SHA1.hexdigest(Marshal.dump(arg))
+            end
+        }
+        sig
+      end
+
+      def benny_method_index(*options)
+        self.class_variable_get(:@@BENNY_METHOD_INDEXES).push(*(options.map(&:to_s)))
+
+        options.each do |method_name|
+
+          define_method "#{method_name}_with_benny_cache" do |*method_opts|
+            @_benny_method_local_cache ||= {}
+            #puts "benny cache method: #{method_name}_with_benny_cache  #{method_opts.inspect}"
+
+            model_id = self.id
+            base_method_index = self.class.benny_method_cache_full_index(model_id, method_name)
+
+            sig = self.class.benny_method_args_sig(*method_opts)
+
+            args_method_index = "#{base_method_index}/args/#{sig}"
+
+            self.class.benny_method_store_method_args_index(base_method_index, args_method_index)
+
+            return @_benny_method_local_cache[args_method_index] if @_benny_method_local_cache[args_method_index]
+
+            return_data = BennyCache::Config.store.fetch(args_method_index) {
+              self.send("#{method_name}_without_benny_cache", *method_opts)
+            }
+
+            @_benny_method_local_cache[args_method_index] = return_data
+            return_data
+
+          end
+          alias_method "#{method_name}_without_benny_cache", method_name
+          alias_method method_name, "#{method_name}_with_benny_cache"
+          alias_method "#{method_name}!", "#{method_name}_without_benny_cache"
+
+        end
+
+      end
+
+      ##
+      # Retrieves a model from the cache. If the model is no in the cache, BennyCache will load it from the database
+      # and store in the cache.
+      #
+      #  agent = Agent.benny_model_cache(1)
+      #
+      # If the agent with id of 1 is not in the cache, it will make an ActiveRecord call to popuplate the cache,
+      # and return the model, like so:
+      #   Agent.find(1)
+      #
+      # If you have declared separate data indexes, you can pass a hash and and BennyCache will use
+      # ActiveRelation#where to populate the hash
+      #
+      #   Agent.benny_model_cache(:user_id => 999)
+      #
+      # To populate cache, BennyCache will call
+      #
+      #  Agent.where(:user_id => 999)
+      #
+      def benny_model_cache(options)
+        ns = self.get_benny_model_ns
+
+        if options.is_a?(Hash)
+          key_format = []
+          key = []
+          options.keys.sort.each do  |k|
+            key_format << "#{k.to_s}/:#{k.to_s}"
+            key << "#{k.to_s}/#{options[k].to_s}"
+          end
+
+          key = key.join('/')
+
+          key_format = key_format.join('/')
+
+          raise "undefined cache key format #{ns}/#{key_format}" unless self.class_variable_get(:@@BENNY_MODEL_INDEXES).include?(key_format)
+
+          BennyCache::Config.store.fetch("#{ns}/#{key}") {
+            self.where(options).first
+          }
+        else # should be a number/id
+          BennyCache::Config.store.fetch("#{ns}/#{options}") {
+            self.find(options)
+          }
+        end
+      end
+    end
+  end
+end

data/lib/benny_cache/related.rb

@@ -0,0 +1,58 @@
+module BennyCache
+  module Related
+    def self.included(base) #:nodoc:
+      base.send :include, BennyCache::Base
+
+      base.extend BennyCache::ClassMethods
+      unless(base.class_variable_defined? :@@benny_related_indexes)
+        base.class_variable_set(:@@benny_related_indexes, [])
+      end
+
+      unless(base.class_variable_defined? :@@benny_related_methods)
+        base.class_variable_set(:@@benny_related_methods, [])
+      end
+
+      if base.respond_to?(:after_save)
+        base.after_save :benny_cache_clear_related
+      end
+
+      if base.respond_to?(:after_destroy)
+        base.after_destroy :benny_cache_clear_related
+      end
+    end
+
+    def benny_cache_clear_related
+      self.class.class_variable_get(:@@benny_related_indexes).each do |key|
+        local_field, klass, data_cache = key.split('/')
+        local_field = local_field[1, local_field.length]
+        const = benny_constantize(klass)
+        id = self.send(local_field)
+        const.benny_data_cache_delete(id, data_cache) if id
+      end
+
+      self.class.class_variable_get(:@@benny_related_methods).each do |key|
+        local_field, klass, method_cache = key.split('/')
+        local_field = local_field[1, local_field.length]
+        const = benny_constantize(klass)
+        id = self.send(local_field)
+        const.benny_method_cache_delete(id, method_cache) if id
+      end
+
+    end
+  end
+
+  module ClassMethods
+
+    def benny_related_index(*options)
+      index_keys = options.map {|idx| idx.is_a?(Array) ? idx.map{ |jdx| "#{jdx.to_s}/:#{jdx.to_s}"}.join("/") : idx }
+      self.class_variable_get(:@@benny_related_indexes).push(*index_keys)
+    end
+
+    def benny_related_method(*options)
+      index_keys = options.map {|idx| idx.is_a?(Array) ? idx.map{ |jdx| "#{jdx.to_s}/:#{jdx.to_s}"}.join("/") : idx }
+      self.class_variable_get(:@@benny_related_methods).push(*index_keys)
+    end
+
+
+  end
+end

data/lib/benny_cache/version.rb

@@ -0,0 +1,3 @@
+module BennyCache
+  VERSION = "0.0.1"
+end

data/spec/models/cache_spec.rb

@@ -0,0 +1,59 @@
+require_relative "../spec_helper"
+describe BennyCache::Cache do 
+  it "is a class" do
+    BennyCache::Cache
+  end
+
+  it "can be instantiated" do
+    c = BennyCache::Cache.new
+    c.should be_true
+  end
+
+  describe do 
+    before(:each) do
+      @c = BennyCache::Cache.new
+      @key = "foo"
+      @val = "bar"
+    end
+
+    methods = %w(fetch read write delete)
+    methods.each do |m|
+      it "should respond to #{m}" do
+        @c.respond_to?(m).should be_true    
+      end
+    end
+
+    it "should write and read keyed data" do
+      @c.write(@key, @val)
+      @c.read(@key).should == @val
+    end
+
+    it "can delete keys" do
+      @c.write(@key, @val)
+      @c.read(@key).should == @val
+      @c.delete(@key)
+      @c.read(@key).should be_nil
+    end
+
+    it "#fetch can set a nil val with a block" do
+      @c.read(@key).should be_nil
+      set_val = @c.fetch(@key) {
+        @val
+      }
+      set_val.should == @val 
+      @c.read(@key).should == @val
+    end
+
+    it "#clear should remove all cached data" do
+      key2 = "baz"
+      val2 = "bin"
+      @c.write(@key, @val)
+      @c.write(key2, val2)
+      @c.read(@key).should == @val
+      @c.read(key2).should == val2
+      @c.clear
+      @c.read(@key).should be_nil
+      @c.read(key2).should be_nil
+    end
+  end
+end

data/spec/models/config_spec.rb

@@ -0,0 +1,15 @@
+require_relative "../spec_helper"
+
+require 'mocha_standalone'
+
+describe BennyCache::Config do
+  it "should exist" do
+    BennyCache::Config.should be_true
+  end
+
+  it "should default to a BennyCache::Cache" do
+    BennyCache::Config.store = nil
+    BennyCache::Config.store.class.should == BennyCache::Cache
+  end
+
+end

data/spec/models/model_method_cache_spec.rb

@@ -0,0 +1,85 @@
+require_relative "../spec_helper"
+
+require 'mocha_standalone'
+
+describe BennyCache::Model do
+
+
+  describe "method caching" do
+    before(:each) do
+      @model = ModelCacheFake.new
+      @model.id = 1
+      @model.other_id = 123
+      @model.x = 12
+      @model.y = 36
+      @store = BennyCache::Cache.new
+      BennyCache::Config.store=@store
+    end
+
+    it "should call the original once method if uncached" do
+      @model.expects(:method_to_cache_without_benny_cache).with(:foo).returns(:stuff) # only once!
+      @model.expects(:method_to_cache_without_benny_cache).with(:bar).returns(:other_stuff)
+
+      rv = @model.method_to_cache :foo
+      rv.should == :stuff
+      rv = @model.method_to_cache :foo # should hit cache
+      rv.should == :stuff
+      rv = @model.method_to_cache :bar
+      rv.should == :other_stuff
+
+      model_base_index = "Benny/ModelCacheFake/1/method/method_to_cache"
+      rv = BennyCache::Config.store.read(model_base_index)
+      rv.class.should == Array
+      rv.size.should == 2
+
+      rv[0].should =~ /Benny\/ModelCacheFake\/1\/method\/method_to_cache\/args\/\w+$/
+      rv[1].should =~ /Benny\/ModelCacheFake\/1\/method\/method_to_cache\/args\/\w+$/
+
+      rv[0].should_not == rv[1]
+
+      puts rv.inspect
+    end
+
+    it "should method cache result data structures locally" do
+      data = @model.method_to_cache_with_base_data
+      data.should == [:a, :b, :c]
+      data.push :d
+
+      @model.method_to_cache_with_base_data.should == [:a, :b, :c, :d]
+
+    end
+
+
+    it "should be able to delete the cached method data" do
+      @model.expects(:method_to_cache_without_benny_cache).with(:foo).returns(:stuff) # only once!
+
+      rv = @model.method_to_cache :foo
+      rv.should == :stuff
+      rv = @model.method_to_cache :foo # should hit cache
+      rv.should == :stuff
+      model_base_index = "Benny/ModelCacheFake/1/method/method_to_cache"
+      rv = BennyCache::Config.store.read(model_base_index)
+      rv.size.should == 1
+
+      ModelCacheFake.benny_method_store_method_args_indexes_delete(@model.id, :method_to_cache)
+
+      model_base_index = "Benny/ModelCacheFake/1/method/method_to_cache"
+      rv = BennyCache::Config.store.read(model_base_index)
+      rv.should be_nil
+    end
+
+    it "should use the same cache index for reorder hash params" do
+      @model.expects(:method_to_cache_without_benny_cache).returns(:stuff) # only once!
+
+      rv = @model.method_to_cache :foo => :bar, :baz => :bin
+      rv.should == :stuff
+      rv = @model.method_to_cache :baz => :bin, :foo => :bar # should use same key
+      rv.should == :stuff
+      model_base_index = "Benny/ModelCacheFake/1/method/method_to_cache"
+      rv = BennyCache::Config.store.read(model_base_index)
+      rv.size.should == 1
+    end
+
+  end
+
+end