flagpole_sitta 0.9.2 → 0.9.4

data/README.rdoc

@@ -14,13 +14,16 @@ The rottenness and evil in me.
 
 ===This gem should be considered in beta.
 
+===Before You Use read This.
+https://github.com/rovermicrover/FlagpoleSitta/wiki/Before-You-Use-Read-This
+
 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!
 
 http://www.harveydanger.com/contribute.php
 
 My grammar ability's are fail. So if something doesn't make sense in the docs don't be afraid to point it out and/or submit a patch. Because to me it all looks right.....
 
-This gem has also only so far been tested with Memcache using the Dalli gem. File System caching and memory caching are not recommended. Redis/Memcache are defiantly suggested and strongly encouraged for this gem.
+File System caching and memory caching are not recommended. Redis/Memcache are defiantly suggested and strongly encouraged for this gem. If your using a cloud solution redis more then memecached for reasons stated in the "Before you use read this." seciton of the wiki.
 
 == Inspiration
 

data/app/helpers/flagpole_sitta_helper.rb

@@ -108,64 +108,73 @@ module FlagpoleSittaHelper
       "@" + (options[:section] ? options[:section] : 'body') + "_calls"
     )
 
-    if hash = Rails.cache.read(key)
+    hash = benchmark("Read fragment #{key} :: FlagpoleSitta") do
+      hash = FlagpoleSitta::CommonFs.flagpole_cache_read(key)
+    end
+
+    if hash
       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
-
-        if calls
-          calls.each do |c|
-            if instance_variable_get("@#{c[0]}").nil?
-              instance_variable_set("@#{c[0]}", c[1].call())
+      content = benchmark("Write fragment #{key} :: FlagpoleSitta") do
+        #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
+
+          if calls
+            calls.each do |c|
+              if instance_variable_get("@#{c[0]}").nil?
+                instance_variable_set("@#{c[0]}", c[1].call())
+              end
             end
           end
-        end
-
-        yield
 
-      end
-
-      #AR - If the cache is an index or includes an index
-      #then models_in_index should be passed with all the
-      #models that could show up in the index.
-      #Then on save of any model include here this index will be cleared.
-      #This can also be used for fragments where there are just so many objects,
-      #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.
+          yield
 
-      associated = Array.new
+        end
 
-      if options[:models_in_index].class.eql?(Array)
-        options[:models_in_index].each_index do |i|
-          m = options[:models_in_index][i]
-          if options[:scope]
-            scope = options[:scope][i]
+        #AR - If the cache is an index or includes an index
+        #then models_in_index should be passed with all the
+        #models that could show up in the index.
+        #Then on save of any model include here this index will be cleared.
+        #This can also be used for fragments where there are just so many objects,
+        #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]
+            if options[:scope]
+              scope = options[:scope][i]
+            end
+            processed_model = m.respond_to?(:constantize) ? m.constantize : m
+            associated << update_index_array_cache(processed_model, key, scope)
           end
-          processed_model = m.respond_to?(:constantize) ? m.constantize : m
-          associated << update_index_array_cache(processed_model, key, scope)
+        elsif options[:models_in_index]
+          processed_model = options[:models_in_index].respond_to?(:constantize) ? options[:models_in_index].constantize : options[:models_in_index]
+          associated << update_index_array_cache(processed_model, key, options[: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]
-        associated << update_index_array_cache(processed_model, key, options[:scope])
-      end
 
-      #AR - Create a link between each declared object and the cache.
+        #AR - Create a link between each declared object and the cache.
 
-      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|
-            associated << update_show_array_cache(options[:model][i], key, options[:route_id][i])
+        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|
+              associated << update_show_array_cache(options[:model][i], key, options[:route_id][i])
+            end
+          else
+            associated << update_show_array_cache(main_model, key, main_route_id)
           end
-        else
-          associated << update_show_array_cache(main_model, key, main_route_id)
         end
-      end
 
-      Rails.cache.write(key, {:content => content, :associated => associated})
+        FlagpoleSitta::CommonFs.flagpole_cache_write(key, {:content => content, :associated => associated})
+
+        content
+
+      end
 
     end
 

data/lib/flagpole_sitta/bracket_retrieval.rb

@@ -22,18 +22,31 @@ module FlagpoleSitta
 
     #After update destroy old cache and write new one.
     def br_update alive
+
       clazz = self.class
 
-      Rails.cache.delete("#{clazz}/BracketRetrieval/#{self.send(self.class.key_field + "_was")}")
+      key = clazz.get_br_key(self.send(self.class.key_field + "_was"))
+
+      FlagpoleSitta::CommonFs.flagpole_cache_delete(key)
 
       if alive
-        Rails.cache.write("#{clazz}/BracketRetrieval/#{self.send(self.class.key_field)}", self.send(self.class.value_field))
+        key = clazz.get_br_key(self.send(self.class.key_field))
+        value = self.send(self.class.value_field)
+        FlagpoleSitta::CommonFs.flagpole_cache_write(key, value)
       end
       
     end
 
     module ClassMethods
 
+      def get_br_key key
+
+        clazz = self
+
+        "#{clazz}/BracketRetrieval/#{key}"
+
+      end
+
       #Will look up the object chain till it finds what it was set to, or not set too.
       def safe_content?
         result = @_safe_content || (self.superclass.respond_to?(:safe_content?) ? self.superclass.safe_content? : nil) || false
@@ -58,7 +71,7 @@ module FlagpoleSitta
       def [] key 
         clazz = self
         #If its in cache return that, unless blank, then return nil.
-        if value = Rails.cache.read("#{clazz}/BracketRetrieval/#{key}") || Rails.cache.exist?("#{clazz}/BracketRetrieval/#{key}")
+        if value = FlagpoleSitta::CommonFs.flagpole_cache_read(get_br_key(key)) || FlagpoleSitta::CommonFs.flagpole_cache_exist?(get_br_key(key))
           if value.present?
             value = self.safe_content? ? value.html_safe : value
           else
@@ -70,13 +83,13 @@ module FlagpoleSitta
         #Else if the object is in the database put it into the cache then return it.
         elsif obj = self.send("find_by_#{self.key_field}", key)
           value = obj.send(self.value_field)
-          Rails.cache.write("#{clazz}/BracketRetrieval/#{key}", value)
+          FlagpoleSitta::CommonFs.flagpole_cache_write(get_br_key(key), value)
           value = value && self.safe_content? ? value.html_safe : value
         #Else create the corresponding object as blank, and return nil.
         #The last line there is why this extension should never be used with user generated content.
         else
           rec = self.create(self.key_field.to_sym => key, self.value_field.to_sym => self.default_value)
-          Rails.cache.write("#{clazz}/BracketRetrieval/#{key}", rec.send(self.value_field))
+          FlagpoleSitta::CommonFs.flagpole_cache_write(get_br_key(key), rec.send(self.value_field))
           value = nil
         end
         value

data/lib/flagpole_sitta/cache_sitta.rb

@@ -16,6 +16,10 @@ module FlagpoleSitta
 
     module ClassMethods
 
+      def clazz
+        self
+      end
+
       #Determines if its for an index array or show array.
       def mid_key_gen route_id
         if route_id
@@ -25,29 +29,42 @@ module FlagpoleSitta
         end
       end
 
-      #Creates the 'array' in the cache.
-      def initialize_array_cache route_id = nil
+      #Options :emptystack will make it generate a key for the emptystack instead of the general cache array.
+      def array_cache_key_gen key, route_id, options={}
 
         mid_key = mid_key_gen route_id
 
-        clazz = self
+        model = options[:model] || clazz
+
+
+        if options[:emptystack]
+          "#{model}/#{mid_key}/EmptyStack/#{key}"
+        else
+          "#{model}/#{mid_key}/#{key}"
+        end
+
+      end
+
+      #Creates the 'array' in the cache.
+      def initialize_array_cache route_id = nil
+
+        flag_key = array_cache_key_gen "Flag", route_id
 
         flag = {:space => -1, :empty => -1}
 
-        Rails.cache.write("#{clazz}/#{mid_key}/Flag", flag)
+        FlagpoleSitta::CommonFs.flagpole_cache_write(flag_key, flag)
 
         flag
 
       end
 
       #Updates the 'array' in the cache.
+      #Options :route_id which determines the type of mid_key
       def update_array_cache key, options={}
 
-        mid_key = mid_key_gen options[:route_id]
+        flag_key = array_cache_key_gen "Flag", options[:route_id]
 
-        clazz = self
-
-        flag = Rails.cache.read("#{clazz}/#{mid_key}/Flag")
+        flag = FlagpoleSitta::CommonFs.flagpole_cache_read(flag_key)
 
         #AR - If it doesn't exist start the process of creating it
         if flag.nil?
@@ -56,9 +73,11 @@ module FlagpoleSitta
 
         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]}")
+          empty_key = array_cache_key_gen flag[:empty], options[:route_id], :emptystack => true
+
+          i = FlagpoleSitta::CommonFs.flagpole_cache_read(empty_key)
           #Sense its going to be used remove its reference from the Stack.
-          Rails.cache.delete("#{clazz}/#{mid_key}/EmptyStack/#{flag[:empty]}")
+          FlagpoleSitta::CommonFs.flagpole_cache_delete(empty_key)
           #Update the empty on flag to now hit the newest none used container on the stack.
           flag[:empty] = flag[:empty] - 1
         else
@@ -68,30 +87,31 @@ module FlagpoleSitta
         end
        
         #AR - write out the new index at the end of the array
-        Rails.cache.write("#{clazz}/#{mid_key}/#{i}", {:key => key, :scope => options[:scope]})
+        array_key = array_cache_key_gen i, options[:route_id]
+        FlagpoleSitta::CommonFs.flagpole_cache_write(array_key, {:key => key, :scope => options[:scope]})
 
         #AR - update flag in the cache
-        Rails.cache.write("#{clazz}/#{mid_key}/Flag", flag)
+        flag_key = array_cache_key_gen "Flag", options[:route_id]
+        FlagpoleSitta::CommonFs.flagpole_cache_write(flag_key, flag)
 
-        "#{clazz}/#{mid_key}/#{i}"
+        key
 
       end
 
       #Loops through the array in the cache.
       def each_cache route_id = nil, &block
 
-        mid_key = mid_key_gen route_id
-
-        clazz = self
+        flag_key = array_cache_key_gen "Flag", route_id
 
-        flag = Rails.cache.read("#{clazz}/#{mid_key}/Flag")
+        flag = FlagpoleSitta::CommonFs.flagpole_cache_read(flag_key)
 
         #AR - If there aren't any index do nothing.
         #Else wise loop through every index.
         #If it actually does exist then yield.
         if flag
           for i in 0..flag[:space] do
-            hash = Rails.cache.read("#{clazz}/#{mid_key}/#{i}")
+            array_key = array_cache_key_gen i, route_id
+            hash = FlagpoleSitta::CommonFs.flagpole_cache_read(array_key)
             if hash
               yield hash
             end
@@ -105,10 +125,6 @@ module FlagpoleSitta
       #Nukes all corresponding caches for a given array.
       def destroy_array_cache options={}
 
-        mid_key = mid_key_gen options[:route_id]
-
-        clazz = self
-
         i = 0
 
         each_cache options[:route_id] do |hash|
@@ -117,9 +133,10 @@ module FlagpoleSitta
             #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]
+              associated = FlagpoleSitta::CommonFs.flagpole_cache_read(hash[:key])[:associated]
+              puts hash[:key]
               #Destroy the actually cache
-              Rails.cache.delete(hash[:key])
+              FlagpoleSitta::CommonFs.flagpole_cache_delete(hash[:key])
               associated.each do |a|
                 #Get the base key
                 base_key = a.gsub(/\/[^\/]*\z/, "")
@@ -128,39 +145,42 @@ module FlagpoleSitta
                 #Get its location in the 'Array'
                 n = a.split("/").last
                 # Check in case of cache failure
-                if flag = Rails.cache.read(flag_key)
+                if flag = FlagpoleSitta::CommonFs.flagpole_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)
+                  FlagpoleSitta::CommonFs.flagpole_cache_write(empty_stack_key, n)
                   #Update the flag
-                  Rails.cache.write(flag_key, flag)
+                  FlagpoleSitta::CommonFs.flagpole_cache_write(flag_key, flag)
                 end
 
                 #Finally get rid of the associated cache object.
-                Rails.cache.delete(a)
+                FlagpoleSitta::CommonFs.flagpole_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)
+              key = array_cache_key_gen i, options[:route_id]
+              FlagpoleSitta::CommonFs.flagpole_cache_write(key, hash)
               i = i + 1
             end
           end
         end
 
+
+        flag_key = array_cache_key_gen "Flag", options[:route_id]
         #If everything was deleted destroy the flag.
         if i == 0
-          Rails.cache.delete("#{clazz}/#{mid_key}/Flag")
+          FlagpoleSitta::CommonFs.flagpole_cache_delete(flag_key)
         #Else update the flag
         else
-          flag = Rails.cache.read("#{clazz}/#{mid_key}/Flag")
+          flag = FlagpoleSitta::CommonFs.flagpole_cache_read(flag_key)
           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)
+          FlagpoleSitta::CommonFs.flagpole_cache_write(flag_key, flag)
         end
       end
 
@@ -184,21 +204,21 @@ module FlagpoleSitta
       # Also have to go through all its super objects till the super objects aren't cache sittaed
       # this is because the new updated object for a sub class, could have also been in a cache for
       # said sub class, but also in a cache for its super.
-      clazz = original_clazz
-      while(clazz.respond_to? :destroy_array_cache)
+      cur_clazz = original_clazz
+      while(cur_clazz.respond_to? :destroy_array_cache)
 
         #AR - Clear all caches related to the old route_id
-        clazz.destroy_array_cache(:route_id => self.try(:send, ("#{clazz.route_id}_was")).to_s)
+        cur_clazz.destroy_array_cache(:route_id => self.try(:send, ("#{cur_clazz.route_id}_was")).to_s)
         #AR - Clear all caches related to the new route_id just in case
-        clazz.destroy_array_cache(:route_id => self.try(:send, ("#{clazz.route_id}")).to_s)
+        cur_clazz.destroy_array_cache(:route_id => self.try(:send, ("#{cur_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(:obj => self)
+        cur_clazz.destroy_array_cache(:obj => self)
 
-        clazz = clazz.superclass
+        cur_clazz = cur_clazz.superclass
       end
 
       #AR - For Safety this will not recurse upwards for the extra cache maintenance
@@ -211,13 +231,13 @@ module FlagpoleSitta
     #for the update object.
     def post_cache_work
       original_clazz = self.class
-      clazz = original_clazz
+      cur_clazz = original_clazz
 
-      while(clazz.respond_to? :destroy_array_cache)
+      while(cur_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)
+        cur_clazz.destroy_array_cache(:obj => self)
 
-        clazz = clazz.superclass
+        cur_clazz = cur_clazz.superclass
       end
 
     end

data/lib/flagpole_sitta/common_fs.rb

@@ -0,0 +1,30 @@
+module FlagpoleSitta
+
+  class CommonFs
+
+    class << self
+
+      def app_hash_namespace
+        "#{Rails.application.class.to_s.split("::").first}/#{Rails.env}/"
+      end
+
+      def flagpole_cache_read key
+        Rails.cache.read(app_hash_namespace + key.to_s)
+      end
+
+      def flagpole_cache_write key, value
+        Rails.cache.write(app_hash_namespace + key.to_s, value)
+      end
+
+      def flagpole_cache_delete key
+        Rails.cache.delete(app_hash_namespace + key.to_s)
+      end
+
+      def flagpole_cache_exist? key
+        Rails.cache.exist?(app_hash_namespace + key.to_s)
+      end
+
+    end
+  end
+
+end

data/lib/flagpole_sitta/existence_hash.rb

@@ -12,6 +12,31 @@ module FlagpoleSitta
 
     module ClassMethods
 
+       #Options :emptystack will make it generate a key for the emptystack instead of the general cache array.
+      def eh_key_gen key, options={}
+
+        superclazz = get_super_with_existence_hash
+
+        end_key = end_key_gen key, options[:class]
+
+
+        if options[:emptystack]
+          "#{superclazz}/ExistenceHash/EmptyStack/#{end_key}"
+        else
+          "#{superclazz}/ExistenceHash/#{end_key}"
+        end
+
+      end
+
+      def end_key_gen key, clazz
+        if clazz
+          "#{clazz}/#{key}"
+        else
+          "#{key}"
+        end
+      end
+
+
       #Creates the 'hash' in the cache.
       def initialize_existence_hash
 
@@ -23,12 +48,15 @@ module FlagpoleSitta
 
         flag = {:space => (count - 1), :count => count, :empty => -1}
 
-        Rails.cache.write("#{superclazz}/ExistenceHash/Flag", flag)
+        flag_key = eh_key_gen "Flag"
+        FlagpoleSitta::CommonFs.flagpole_cache_write(flag_key, 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.class.to_s, :pos => i, :num => m.has_attribute?('num') ? (m.num || 0) : 0})
-          Rails.cache.write("#{superclazz}/ExistenceHash/#{i}", {:key => m.send(m.class.route_id).to_s, :type => m.class.to_s})
+          main_key = eh_key_gen m.send(m.class.route_id), :class => m.class
+          FlagpoleSitta::CommonFs.flagpole_cache_write(main_key, {:type => m.class.to_s, :pos => i, :num => m.has_attribute?('num') ? (m.num || 0) : 0})
+          array_key = eh_key_gen i
+          FlagpoleSitta::CommonFs.flagpole_cache_write(array_key, {:key => m.send(m.class.route_id).to_s, :type => m.class.to_s})
           i = i + 1
         end
 
@@ -43,13 +71,15 @@ module FlagpoleSitta
 
         superclazz = get_super_with_existence_hash
         #Try to find the hash
-        flag = Rails.cache.read("#{superclazz}/ExistenceHash/Flag")
+        flag_key = eh_key_gen "Flag"
+        flag = FlagpoleSitta::CommonFs.flagpole_cache_read(flag_key)
         #If it doesn't exist start the process of creating it
         if flag.nil?
           initialize_existence_hash
         end
 
-        Rails.cache.read("#{superclazz}/ExistenceHash/#{clazz}/#{key}")
+        main_key = eh_key_gen key, :class => clazz
+        FlagpoleSitta::CommonFs.flagpole_cache_read(main_key)
 
       end
 
@@ -65,7 +95,8 @@ module FlagpoleSitta
         #Update the hash key if it exists
         if hash
           hash[:num] = hash[:num] + 1
-          Rails.cache.write("#{superclazz}/ExistenceHash/#{clazz}/#{key}", hash)
+          main_key = eh_key_gen key, :class => clazz
+          FlagpoleSitta::CommonFs.flagpole_cache_write(main_key, hash)
         end
 
         #Return the value
@@ -80,7 +111,8 @@ module FlagpoleSitta
 
         superclazz = get_super_with_existence_hash
 
-        flag = Rails.cache.read("#{superclazz}/ExistenceHash/Flag")
+        flag_key = eh_key_gen "Flag"
+        flag = FlagpoleSitta::CommonFs.flagpole_cache_read(flag_key)
 
         if flag.nil?
           flag = initialize_existence_hash
@@ -89,10 +121,12 @@ module FlagpoleSitta
         unless flag[:count] == 0
           for i in 0..flag[:space] do
 
-            value = Rails.cache.read("#{superclazz}/ExistenceHash/#{i}")
+            cur_array_key = eh_key_gen i
+            value = FlagpoleSitta::CommonFs.flagpole_cache_read(cur_array_key)
 
             if value.present? && value[:type].to_s.eql?(clazz.to_s)
-              hash = Rails.cache.read("#{superclazz}/ExistenceHash/#{value[:type]}/#{value[:key]}")
+              cur_main_key = eh_key_gen value[:key], :class => value[:type]
+              hash = FlagpoleSitta::CommonFs.flagpole_cache_read(cur_main_key)
               #This if statement is to make it fail gracefully if the cache has degraded.
               if hash.present?
                 yield value[:key], hash
@@ -149,7 +183,11 @@ module FlagpoleSitta
       new_key = new_clazz.respond_to?(:constantize) ? self.send("#{new_clazz.constantize.route_id}") : nil
       old_key = old_clazz.respond_to?(:constantize) ? self.send("#{old_clazz.constantize.route_id}_was") : nil
 
-      flag = Rails.cache.read("#{superclazz}/ExistenceHash/Flag")
+      new_main_key = superclazz.eh_key_gen new_key, :class => new_clazz
+      old_main_key = superclazz.eh_key_gen old_key, :class => old_clazz
+
+      flag_key = superclazz.eh_key_gen "Flag"
+      flag = FlagpoleSitta::CommonFs.flagpole_cache_read(flag_key)
 
       if flag.nil?
         flag = self.class.initialize_existence_hash
@@ -161,9 +199,10 @@ module FlagpoleSitta
         #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]}")
+          empty_key = superclazz.eh_key_gen flag[:empty], :emptystack => true
+          i = FlagpoleSitta::CommonFs.flagpole_cache_read(empty_key)
           #Sense its going to be used remove its reference from the Stack.
-          Rails.cache.delete("#{superclazz}/ExistenceHash/EmptyStack/#{flag[:empty]}")
+          FlagpoleSitta::CommonFs.flagpole_cache_delete(empty_key)
           #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.
@@ -175,30 +214,33 @@ module FlagpoleSitta
         hash = {:type => new_clazz, :num => self.has_attribute?('num') ? (self.num || 0) : 0, :pos => i}
       #If its an already existing record them get its existence hash, and then remove it from the cache.
       else
-        hash = Rails.cache.read("#{superclazz}/ExistenceHash/#{old_clazz}/#{old_key}")
+        hash = FlagpoleSitta::CommonFs.flagpole_cache_read(old_main_key)
         hash[:type] = new_clazz
       end
 
+      array_main_key = superclazz.eh_key_gen hash[:pos]
+
       #Before new info gets written make sure to delete all the old records just in case. The New location before it gets used too.
-      Rails.cache.delete("#{superclazz}/ExistenceHash/#{new_clazz}/#{new_key}")
-      Rails.cache.delete("#{superclazz}/ExistenceHash/#{old_clazz}/#{old_key}")
-      Rails.cache.delete("#{superclazz}/ExistenceHash/#{hash[:pos]}")
+      FlagpoleSitta::CommonFs.flagpole_cache_delete(new_main_key)
+      FlagpoleSitta::CommonFs.flagpole_cache_delete(old_main_key)
+      FlagpoleSitta::CommonFs.flagpole_cache_delete(array_main_key)
 
       #If the record is not being destroyed add new route_id to existence hash
       if alive
-        Rails.cache.write("#{superclazz}/ExistenceHash/#{new_clazz}/#{new_key}", hash)
-        Rails.cache.write("#{superclazz}/ExistenceHash/#{hash[:pos]}", {:type => new_clazz, :key => new_key})
+        FlagpoleSitta::CommonFs.flagpole_cache_write(new_main_key, hash)
+        FlagpoleSitta::CommonFs.flagpole_cache_write(array_main_key, {:type => new_clazz, :key => new_key})
       else
         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])
+          empty_key = superclazz.eh_key_gen flag[:empty], :emptystack => true
+          FlagpoleSitta::CommonFs.flagpole_cache_write(empty_key, hash[:pos])
         end
         flag[:count] = flag[:count] - 1
       end
 
-      Rails.cache.write("#{superclazz}/ExistenceHash/Flag", flag)
+      FlagpoleSitta::CommonFs.flagpole_cache_write(flag_key, flag)
 
     end
 

data/lib/flagpole_sitta/version.rb

@@ -1,3 +1,3 @@
 module FlagpoleSitta
-  VERSION = "0.9.2"
+  VERSION = "0.9.4"
 end

data/lib/flagpole_sitta.rb

@@ -8,9 +8,9 @@ module FlagpoleSitta
     yield self
   end
 
-
 end
 
+require 'flagpole_sitta/common_fs'
 require 'flagpole_sitta/bracket_retrieval'
 require 'flagpole_sitta/cache_sitta'
 require 'flagpole_sitta/existence_hash'

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: flagpole_sitta
 version: !ruby/object:Gem::Version 
-  hash: 63
+  hash: 51
   prerelease: 
   segments: 
   - 0
   - 9
-  - 2
-  version: 0.9.2
+  - 4
+  version: 0.9.4
 platform: ruby
 authors: 
 - Andrew Rove (Rover)
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-08-21 00:00:00 Z
+date: 2012-08-28 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: dalli
@@ -55,6 +55,7 @@ files:
 - lib/flagpole_sitta.rb
 - lib/flagpole_sitta/bracket_retrieval.rb
 - lib/flagpole_sitta/cache_sitta.rb
+- lib/flagpole_sitta/common_fs.rb
 - lib/flagpole_sitta/config_sitta.rb
 - lib/flagpole_sitta/controller_sitta.rb
 - lib/flagpole_sitta/engine.rb