flagpole_sitta 0.8.0 → 0.9.0

data/README.rdoc

@@ -12,7 +12,7 @@ The rottenness and evil in me.
 
 == Preface
 
-===This gem should be considered in early beta and highly unstable. Do not use in a production app!
+===This gem should be considered in beta.
 
 This gem was inspired in part by the song Flagpole Sitta by Harvey Danger. So if you like the gem and are wanting to help out please either donate your time and submit some patches, or donate to the band who wrote the song. They put there last two albums out there all open source like, only asking that those that could donate after downloading. While your donating, if you choose to do so, don't be afraid to download their albums, its good stuff!
 
@@ -221,7 +221,7 @@ Also if for what ever reason you have made your app multi threaded this gem will
 
 http://stackoverflow.com/a/1390978/1436131
 
-===This gem should be considered in early beta and highly unstable. Do not use in a production app!
+===This gem should be considered in beta.
 
 MIT License 
 

data/app/helpers/flagpole_sitta_helper.rb

@@ -108,18 +108,14 @@ module FlagpoleSittaHelper
       "@" + (options[:section] ? options[:section] : 'body') + "_calls"
     )
 
-    if content = Rails.cache.read(key)
-      #Do nothing the content is ready to render
+    if hash = Rails.cache.read(key)
+      content = hash[:content]
     else
       #NOTE This is not safe for .builder xml files, and using capture here is why.
       #Its either this or a really complicated hack, from the rails source code, which
       #at the moment I don't feel comfortable using. Waiting for an official solution for
       #the ability to use capture with .builders.
       content = capture do
-        #AR - If call_path is an array render each one, other
-        #wise just render call_path, because it must
-        #be a string or array by this point or something went
-        #terribly terribly wrong.
 
         if calls
           calls.each do |c|
@@ -141,6 +137,8 @@ module FlagpoleSittaHelper
       #that while its not an index, there isn't a clear way expect to nuke it when
       #any of the model types involved are updated.
 
+      associated = Array.new
+
       if options[:models_in_index].class.eql?(Array)
         options[:models_in_index].each_index do |i|
           m = options[:models_in_index][i]
@@ -148,11 +146,11 @@ module FlagpoleSittaHelper
             scope = options[:scope][i]
           end
           processed_model = m.respond_to?(:constantize) ? m.constantize : m
-          update_index_array_cache(processed_model, key, scope)
+          associated << 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(processed_model, key, options[:scope])
+        associated << update_index_array_cache(processed_model, key, options[:scope])
       end
 
       #AR - Create a link between each declared object and the cache.
@@ -160,14 +158,14 @@ module FlagpoleSittaHelper
       if !options[:index_only] && options[:route_id]
         if options[:route_id].class.eql?(Array) && options[:model].class.eql?(Array)
           options[:model].each_index do |i|
-            update_show_array_cache(options[:model][i], key, options[:route_id][i])
+            associated << update_show_array_cache(options[:model][i], key, options[:route_id][i])
           end
         else
-          update_show_array_cache(main_model, key, main_route_id)
+          associated << update_show_array_cache(main_model, key, main_route_id)
         end
       end
 
-      Rails.cache.write(key, content)
+      Rails.cache.write(key, {:content => content, :associated => associated})
 
     end
 

data/lib/flagpole_sitta/cache_sitta.rb

@@ -32,7 +32,7 @@ module FlagpoleSitta
 
         clazz = self
 
-        flag = {:space => - 1}
+        flag = {:space => -1, :empty => -1}
 
         Rails.cache.write("#{clazz}/#{mid_key}/Flag", flag)
 
@@ -54,15 +54,27 @@ module FlagpoleSitta
           flag = initialize_array_cache options[:route_id]
         end
 
-        #AR - update the array's end point
-        flag[:space] = flag[:space] + 1
+        if flag[:empty] > -1
+          #Find any empty container to use by popping it off of the top of the "stack".
+          i = Rails.cache.read("#{clazz}/#{mid_key}/EmptyStack/#{flag[:empty]}")
+          #Sense its going to be used remove its reference from the Stack.
+          Rails.cache.delete("#{clazz}/#{mid_key}/EmptyStack/#{flag[:empty]}")
+          #Update the empty on flag to now hit the newest none used container on the stack.
+          flag[:empty] = flag[:empty] - 1
+        else
+          #AR - update the array's end point
+          flag[:space] = flag[:space] + 1
+          i = flag[:space]
+        end
        
         #AR - write out the new index at the end of the array
-        Rails.cache.write("#{clazz}/#{mid_key}/#{flag[:space]}", {:key => key, :scope => options[:scope]})
+        Rails.cache.write("#{clazz}/#{mid_key}/#{i}", {:key => key, :scope => options[:scope]})
 
         #AR - update flag in the cache
         Rails.cache.write("#{clazz}/#{mid_key}/Flag", flag)
 
+        "#{clazz}/#{mid_key}/#{i}"
+
       end
 
       #Loops through the array in the cache.
@@ -100,9 +112,37 @@ module FlagpoleSitta
         i = 0
 
         each_cache options[:route_id] do |hash|
+          #A Check in Case there is some type of cache failure
           if hash.present?
+            #If it has no scope, or it falls in scope
             if hash[:scope].nil? || options[:obj].in_scope(hash[:scope])
+              #Get all the associated.
+              associated = Rails.cache.read(hash[:key])[:associated]
+              #Destroy the actually cache
               Rails.cache.delete(hash[:key])
+              associated.each do |a|
+                #Get the base key
+                base_key = a.gsub(/\/[^\/]*\z/, "")
+                #Get the flag. Capture the god damn flag!
+                flag_key = base_key + "/Flag"
+                #Get its location in the 'Array'
+                n = a.split("/").last
+                # Check in case of cache failure
+                if flag = Rails.cache.read(flag_key)
+                  #Add an empty spot to the 'Array'
+                  flag[:empty] = flag[:empty] + 1
+                  empty_stack_key = base_key + "/EmptyStack/" + flag[:empty].to_s
+                  #Save the empty spot location to the 'Stack'
+                  Rails.cache.write(empty_stack_key, n)
+                  #Update the flag
+                  Rails.cache.write(flag_key, flag)
+                end
+
+                #Finally get rid of the associated cache object.
+                Rails.cache.delete(a)
+
+              end
+            #Else It is not in scope so the cache lives to fight another day!
             else
               Rails.cache.write("#{clazz}/#{mid_key}/#{i}", hash)
               i = i + 1
@@ -110,11 +150,16 @@ module FlagpoleSitta
           end
         end
 
+        #If everything was deleted destroy the flag.
         if i == 0
           Rails.cache.delete("#{clazz}/#{mid_key}/Flag")
+        #Else update the flag
         else
           flag = Rails.cache.read("#{clazz}/#{mid_key}/Flag")
-          flag[:space => (i - 1)]
+          flag[:space] = (i - 1)
+          #Sense we moved through every object and moved all the remaining objects down
+          #there should be no empty spaces.
+          flag[:empty] = -1
           Rails.cache.write("#{clazz}/#{mid_key}/Flag", flag)
         end
       end

data/lib/flagpole_sitta/existence_hash.rb

@@ -21,13 +21,13 @@ module FlagpoleSitta
         #the 'container' goes, it starts at 0, so thats why 1 is subtracted. The count is well the count. They should start out the same. 
         count = superclazz.count
 
-        flag = {:space => (count - 1), :count => count}
+        flag = {:space => (count - 1), :count => count, :empty => -1}
 
         Rails.cache.write("#{superclazz}/ExistenceHash/Flag", flag)
         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.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/#{m.class}/#{m.send(m.class.route_id).to_s}", {:type => m.has_attribute?('type') ? m.type : m.class, :pos => i, :num => m.has_attribute?('num') ? m.num : 0})
           Rails.cache.write("#{superclazz}/ExistenceHash/#{i}", {:key => m.send(m.class.route_id).to_s, :type => m.class})
           i = i + 1
         end
@@ -135,7 +135,11 @@ module FlagpoleSitta
 
     #Updates the 'hash' on save of any of its records.
     def update_existence_hash alive
-      clazz = self.class
+      #Get the Current Class and the Old Class in case the object changed classes.
+      #If its the base object, ie type is nil, then return class as the old_clazz.
+      #If the object doesn't have the type field assume it can't change classes.
+      new_clazz = self.has_attribute?('type') ? (self.type || self.class) : self.class
+      old_clazz = self.has_attribute?('type') ? (self.type_was || self.class) : self.class
       superclazz = self.class.get_super_with_existence_hash
 
       #Old key is where it was, and new is where it is going.
@@ -147,28 +151,43 @@ module FlagpoleSitta
       if flag.nil?
         flag = self.class.initialize_existence_hash
       end
-
-      #If it had a route_id before it most of existed. So get its old values from the existence hash.
-      #If there was nothing it didn't exist so create a new one. Also it only creates a new one if alive is set to true.
-      #This check is overkill really, but its just to be safe.
       
+      #If its a new record add it to the 'hash'
       if self.new_record?
         flag[:count] = flag[:count] + 1
-        flag[:space] = flag[:space] + 1
-        hash = {:type => self.has_attribute?('type') ? self.type : self.class, :num => 0, :pos => flag[:space]}
+        #if there are empty containers use them
+        if flag[:empty] > -1
+          #Find any empty container to use by popping it off of the top of the "stack".
+          i = Rails.cache.read("#{superclazz}/ExistenceHash/EmptyStack/#{flag[:empty]}")
+          #Sense its going to be used remove its reference from the Stack.
+          Rails.cache.delete("#{superclazz}/ExistenceHash/EmptyStack/#{flag[:empty]}")
+          #Update the empty on flag to now hit the newest none used container on the stack.
+          flag[:empty] = flag[:empty] - 1
+        #Else add a space to the end.
+        else
+          #AR - update the array's end point
+          flag[:space] = flag[:space] + 1
+          i = flag[:space]
+        end
+        hash = {:type => self.has_attribute?('type') ? self.type : self.class, :num => self.has_attribute?('num') ? self.num : 0, :pos => i}
+      #If its an already existing record them get its existence hash, and then remove it from the cache.
       else
         hash = self.class.get_existence_hash(self.send("#{self.class.route_id}_was"))
-        Rails.cache.delete("#{superclazz}/ExistenceHash/#{clazz}/#{old_key}")
+        hash[:type] = new_clazz
+        Rails.cache.delete("#{superclazz}/ExistenceHash/#{old_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/#{clazz}/#{new_key}", hash)
-        Rails.cache.write("#{superclazz}/ExistenceHash/#{hash[:pos]}", {:key => new_key, :type => clazz})
+        Rails.cache.write("#{superclazz}/ExistenceHash/#{new_clazz}/#{new_key}", hash)
+        Rails.cache.write("#{superclazz}/ExistenceHash/#{hash[:pos]}", {:key => new_key, :type => new_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]
           flag[:space] = flag[:space] - 1
+        else
+          flag[:empty] = flag[:empty] + 1
+          Rails.cache.write("#{superclazz}/ExistenceHash/EmptyStack/#{flag[:empty]}", hash[:pos])
         end
         flag[:count] = flag[:count] - 1
         Rails.cache.delete("#{superclazz}/ExistenceHash/#{hash[:pos]}")

data/lib/flagpole_sitta/version.rb

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

metadata

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