flagpole_sitta 0.7.3 → 0.8.0

data/README.rdoc

@@ -147,6 +147,14 @@ This also means if your just showing objects in an index you don't even have to
 
 :index_only => true, tells the helper to not bother trying to associated this cache with anyone item in particular.
 
+You could also pass it :scope which will add a 'scope' to a :models_in_index cache, which will cause the cache to only be destroyed if an object with in its 'scope' is create, updated or destroyed. Like :model and :route_id for each model there must be a corresponding route_id. If you don't want a scope on every model then just do something like the following
+
+  - cache_sitta :models_in_index => [Blog, Setting], :scope => [@scope, nil] :index_only => true, :section => "body" do
+
+The 'scope' can only be arguments for a where call. Which means it will either be a hash, record object, string, or an array.
+
+Scopes should be used sparling because in order to verify them on save they require a call to the database, and while it boils down to a call by id, they can still add up if you don't pay attention.
+
 == existence_hash
 
 If you might have already figured out the overall strategy of this gem has a weakness. Namely how do you deal with instances where, the object being routed to doesn't exist. See if your not querying the database until your already in the view then you can't exactly redirect with out some crazy stuff going on. You could put some if statements in your view to show a 404 if the objects are nil, but the  issue with that is that you would still end up with a bunch of pointless caches. This can all be avoided by creating a 'hash' in the cache which you can use to check for the existence of an object. This 'hash' too is updated on save/destory. Also the hash really isn't hash but rather a bunch of cache keys held together by a flag key. Lets use the page example from above.
@@ -166,27 +174,21 @@ A quick note you only actually have to pass :route_id once if your using both ca
 
   class PagesController < ApplicationController
 
-    if Page.get_existence_hash(params[:url])
-
-      def show
+    def show
 
-        @page_call = lambda {
+      if Page.get_existence_hash(params[:url])
+        calls_sitta :name => "page", :section => "body" do
           if params[:url]
             @page = Page.find_by_url params[:url]
           else
             @page = Page.find_by_url 'home'
           end
-        }
-
-        @body_calls = [
-          ['page', @page_call]
-        ]
-
+        end
+      else
+        redirect_to :action => 'home'
+        flash[:notice] = "The Page you are looking for doesn't exist"
       end
 
-    else
-      redirect_to :action => 'home'
-      flash[:notice] = "The Page you are looking for doesn't exist"
     end
 
   end

data/app/helpers/flagpole_sitta_helper.rb

@@ -1,11 +1,11 @@
 module FlagpoleSittaHelper
 
-  def update_index_array_cache model, key
-    model.try(:update_array_cache, key)
+  def update_index_array_cache model, key, scope=nil
+    model.try(:update_array_cache, key, :scope => scope)
   end
 
   def update_show_array_cache model, key, route_id
-    model.try(:update_array_cache, key, route_id)
+    model.try(:update_array_cache, key, :route_id => route_id)
   end
 
   ##
@@ -55,9 +55,13 @@ module FlagpoleSittaHelper
   #That way your caching each possible version of the page
   #instead of just one.
   #
-  #:calls_args
-  #Any args you want to pass to your calls. Can only take one argument.
-  #The best idea is to pass an option hash.
+  #:scope which will add a 'scope' to a :models_in_index cache, 
+  #which will cause the cache to only be destroyed if an object with in its 'scope' is create, 
+  #updated or destroyed. Like :model and :route_id for each model there must be a corresponding route_id. 
+  #If you don't want a scope on every model then just make the index model's scope nil.
+  #The 'scope' can only be arguments for a where call. Which means it will either be a hash or an array.
+  #Scopes should be used sparling because in order to verify them on save they require a call to the database, 
+  #and while it boils down to a call by id, they can still add up if you don't pay attention.
   def cache_sitta  options={}, &block
 
     if options[:route_id].class.eql?(Array)
@@ -120,11 +124,7 @@ module FlagpoleSittaHelper
         if calls
           calls.each do |c|
             if instance_variable_get("@#{c[0]}").nil?
-              if options[:calls_args] && (c.parameters.length > 0)
-                instance_variable_set("@#{c[0]}", c[1].call(options[:calls_args]))
-              else
-                instance_variable_set("@#{c[0]}", c[1].call())
-              end
+              instance_variable_set("@#{c[0]}", c[1].call())
             end
           end
         end
@@ -142,13 +142,17 @@ module FlagpoleSittaHelper
       #any of the model types involved are updated.
 
       if options[:models_in_index].class.eql?(Array)
-        options[:models_in_index].each do |m|
-          processed_m = m.respond_to?(:constantize) ? m.constantize : m
-          update_index_array_cache(processed_m, key)
+        options[:models_in_index].each_index do |i|
+          m = options[:models_in_index][i]
+          if options[:scope]
+            scope = options[:scope][i]
+          end
+          processed_model = m.respond_to?(:constantize) ? m.constantize : m
+          update_index_array_cache(processed_model, key, scope)
         end
       elsif options[:models_in_index]
         processed_model = options[:models_in_index].respond_to?(:constantize) ? options[:models_in_index].constantize : options[:models_in_index]
-        update_index_array_cache(options[:models_in_index], key)
+        update_index_array_cache(processed_model, key, options[:scope])
       end
 
       #AR - Create a link between each declared object and the cache.

data/lib/flagpole_sitta/cache_sitta.rb

@@ -10,6 +10,7 @@ module FlagpoleSitta
 
     included do
       before_save :cache_sitta_save
+      after_save :cache_sitta_after_save
       before_destroy :cache_sitta_destory
     end
 
@@ -40,9 +41,9 @@ module FlagpoleSitta
       end
 
       #Updates the 'array' in the cache.
-      def update_array_cache key, route_id = nil
+      def update_array_cache key, options={}
 
-        mid_key = mid_key_gen route_id
+        mid_key = mid_key_gen options[:route_id]
 
         clazz = self
 
@@ -50,14 +51,14 @@ module FlagpoleSitta
 
         #AR - If it doesn't exist start the process of creating it
         if flag.nil?
-          flag = initialize_array_cache route_id
+          flag = initialize_array_cache options[:route_id]
         end
 
         #AR - update the array's end point
         flag[:space] = flag[:space] + 1
        
         #AR - write out the new index at the end of the array
-        Rails.cache.write("#{clazz}/#{mid_key}/#{flag[:space]}", {:key => key})
+        Rails.cache.write("#{clazz}/#{mid_key}/#{flag[:space]}", {:key => key, :scope => options[:scope]})
 
         #AR - update flag in the cache
         Rails.cache.write("#{clazz}/#{mid_key}/Flag", flag)
@@ -72,19 +73,16 @@ module FlagpoleSitta
         clazz = self
 
         flag = Rails.cache.read("#{clazz}/#{mid_key}/Flag")
-        
-        #AR - If it doesn't exist start the process of creating it
-        if flag.nil?
-          flag = initialize_array_cache route_id
-        end
 
         #AR - If there aren't any index do nothing.
         #Else wise loop through every index.
         #If it actually does exist then yield.
-        for i in 0..flag[:space] do
-          hash = Rails.cache.read("#{clazz}/#{mid_key}/#{i}")
-          if hash
-            yield hash[:key]
+        if flag
+          for i in 0..flag[:space] do
+            hash = Rails.cache.read("#{clazz}/#{mid_key}/#{i}")
+            if hash
+              yield hash
+            end
           end
         end
 
@@ -93,19 +91,32 @@ module FlagpoleSitta
       end
 
       #Nukes all corresponding caches for a given array.
-      def destroy_array_cache route_id = nil
+      def destroy_array_cache options={}
 
-        mid_key = mid_key_gen route_id
+        mid_key = mid_key_gen options[:route_id]
 
         clazz = self
 
-        each_cache route_id do |key|
-          if key.present?
-            Rails.cache.delete(key)
+        i = 0
+
+        each_cache options[:route_id] do |hash|
+          if hash.present?
+            if hash[:scope].nil? || options[:obj].in_scope(hash[:scope])
+              Rails.cache.delete(hash[:key])
+            else
+              Rails.cache.write("#{clazz}/#{mid_key}/#{i}", hash)
+              i = i + 1
+            end
           end
         end
 
-        Rails.cache.delete("#{clazz}/#{mid_key}/Flag")
+        if i == 0
+          Rails.cache.delete("#{clazz}/#{mid_key}/Flag")
+        else
+          flag = Rails.cache.read("#{clazz}/#{mid_key}/Flag")
+          flag[:space => (i - 1)]
+          Rails.cache.write("#{clazz}/#{mid_key}/Flag", flag)
+        end
       end
 
     end
@@ -114,6 +125,10 @@ module FlagpoleSitta
       self.cache_work(true)
     end
 
+    def cache_sitta_after_save
+      self.post_cache_work
+    end
+
     def cache_sitta_destory
       self.cache_work(false)
     end
@@ -128,15 +143,15 @@ module FlagpoleSitta
       while(clazz.respond_to? :destroy_array_cache)
 
         #AR - Clear all caches related to the old route_id
-        clazz.destroy_array_cache(self.try(:send, ("#{clazz.route_id}_was")).to_s)
+        clazz.destroy_array_cache(:route_id => self.try(:send, ("#{clazz.route_id}_was")).to_s)
         #AR - Clear all caches related to the new route_id just in case
-        clazz.destroy_array_cache(self.try(:send, ("#{clazz.route_id}")).to_s)
+        clazz.destroy_array_cache(:route_id => self.try(:send, ("#{clazz.route_id}")).to_s)
         #AR - If the new and old are the same All that will happen on the second call is that
         #it will write the flag out and then destroy it. A very tiny bit of work
         #for a great amount of extra protection.
 
         # AR - Remember to include models_in_index in your helper call in the corresponding index cache.
-        clazz.destroy_array_cache
+        clazz.destroy_array_cache(:obj => self)
 
         clazz = clazz.superclass
       end
@@ -146,11 +161,33 @@ module FlagpoleSitta
 
     end
 
+    #Sense the current in_scope requires the object to be in the database, this has to be called in case the new version that has been 
+    #saved fits into any cache's scope. The above call to clear index caches is basically the object_was call, while this is just the call 
+    #for the update object.
+    def post_cache_work
+      original_clazz = self.class
+      clazz = original_clazz
+
+      while(clazz.respond_to? :destroy_array_cache)
+        # AR - Remember to include models_in_index in your helper call in the corresponding index cache.
+        clazz.destroy_array_cache(:obj => self)
+
+        clazz = clazz.superclass
+      end
+
+    end
+
     #AR - For Safety this will not recurse upwards for the extra cache maintenance
     def extra_cache_maintenance alive
       method = (@_cache_extra_maintance || Proc.new{})
       method.call
     end
 
+    def in_scope scope
+
+      self.class.where(scope).exists?(self.id)
+
+    end
+
   end
 end

data/lib/flagpole_sitta/engine.rb

@@ -9,4 +9,4 @@ module FlagpoleSitta
       app.middleware.use ::ActionDispatch::Static, "#{root}/public"
     end
   end
-end
+end

data/lib/flagpole_sitta/existence_hash.rb

@@ -27,8 +27,8 @@ module FlagpoleSitta
         i = 0
         superclazz.find_each do |m|
           #Route ID is the key. The POS is used to emulate an array, along with the length stored in the flag.
-          Rails.cache.write("#{superclazz}/ExistenceHash/#{m.send(m.class.route_id).to_s}", {:type => m.has_attribute?('type') ? m.type : m.class, :pos => i, :num => 0})
-          Rails.cache.write("#{superclazz}/ExistenceHash/#{i}", {:key => m.send(m.class.route_id).to_s})
+          Rails.cache.write("#{superclazz}/ExistenceHash/#{m.class}/#{m.send(m.class.route_id).to_s}", {:type => m.has_attribute?('type') ? m.type : m.class, :pos => i, :num => 0})
+          Rails.cache.write("#{superclazz}/ExistenceHash/#{i}", {:key => m.send(m.class.route_id).to_s, :type => m.class})
           i = i + 1
         end
 
@@ -39,6 +39,8 @@ module FlagpoleSitta
       #Gets a value from the 'hash' in the cache given a key.
       def get_existence_hash key
 
+        clazz = self
+
         superclazz = get_super_with_existence_hash
         #Try to find the hash
         flag = Rails.cache.read("#{superclazz}/ExistenceHash/Flag")
@@ -47,12 +49,14 @@ module FlagpoleSitta
           initialize_existence_hash
         end
 
-        Rails.cache.read("#{superclazz}/ExistenceHash/#{key}")
+        Rails.cache.read("#{superclazz}/ExistenceHash/#{clazz}/#{key}")
 
       end
 
       #Increments a value from the 'hash' in the cache given a key.
       def increment_existence_hash key
+
+        clazz = self
           
         superclazz = get_super_with_existence_hash
         #Try to find the hash
@@ -61,7 +65,7 @@ module FlagpoleSitta
         #Update the hash key if it exists
         if hash
           hash[:num] = hash[:num] + 1
-          Rails.cache.write("#{superclazz}/ExistenceHash/#{key}", hash)
+          Rails.cache.write("#{superclazz}/ExistenceHash/#{clazz}/#{key}", hash)
         end
 
         #Return the value
@@ -72,6 +76,8 @@ module FlagpoleSitta
       #Goes through each entry in the hash returning a key and value
       def each_existence_hash &block
 
+        clazz = self
+
         superclazz = get_super_with_existence_hash
 
         flag = Rails.cache.read("#{superclazz}/ExistenceHash/Flag")
@@ -85,8 +91,8 @@ module FlagpoleSitta
 
             value = Rails.cache.read("#{superclazz}/ExistenceHash/#{i}")
 
-            if value.present?
-              hash = Rails.cache.read("#{superclazz}/ExistenceHash/#{value[:key]}")
+            if value.present? && value[:type].eql?(clazz)
+              hash = Rails.cache.read("#{superclazz}/ExistenceHash/#{value[:type]}/#{value[:key]}")
               yield value[:key], hash
             end
 
@@ -129,6 +135,7 @@ module FlagpoleSitta
 
     #Updates the 'hash' on save of any of its records.
     def update_existence_hash alive
+      clazz = self.class
       superclazz = self.class.get_super_with_existence_hash
 
       #Old key is where it was, and new is where it is going.
@@ -151,13 +158,13 @@ module FlagpoleSitta
         hash = {:type => self.has_attribute?('type') ? self.type : self.class, :num => 0, :pos => flag[:space]}
       else
         hash = self.class.get_existence_hash(self.send("#{self.class.route_id}_was"))
-        Rails.cache.delete("#{superclazz}/ExistenceHash/#{old_key}")
+        Rails.cache.delete("#{superclazz}/ExistenceHash/#{clazz}/#{old_key}")
       end
 
       #If the record is not being destroyed add new route_id to existence hash
       if alive
-        Rails.cache.write("#{superclazz}/ExistenceHash/#{new_key}", hash)
-        Rails.cache.write("#{superclazz}/ExistenceHash/#{hash[:pos]}", {:key => new_key})
+        Rails.cache.write("#{superclazz}/ExistenceHash/#{clazz}/#{new_key}", hash)
+        Rails.cache.write("#{superclazz}/ExistenceHash/#{hash[:pos]}", {:key => new_key, :type => clazz})
       #The following check is needed if for some reason someone does destroy on a none saved record.
       elsif !self.new_record?
         if hash[:pos] == flag[:space]

data/lib/flagpole_sitta/version.rb

@@ -1,3 +1,3 @@
 module FlagpoleSitta
-  VERSION = "0.7.3"
+  VERSION = "0.8.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: flagpole_sitta
 version: !ruby/object:Gem::Version
-  version: 0.7.3
+  version: 0.8.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-24 00:00:00.000000000 Z
+date: 2012-07-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dalli