flagpole_sitta 0.5.9 → 0.6.0

data/README.rdoc

@@ -1,11 +1,8 @@
 = FlagpoleSitta
 
 I had visions, I was in them,
-
 I was looking into the mirror
-
 To see a little bit clearer
-
 The rottenness and evil in me.
 
 ♫~♫~♫~♫~♫~♫~♫~♫~♫~♫~♫~♫~♫~♫~♫~♫~♫~♫~♫~♫~♫~♫~♫
@@ -14,27 +11,31 @@ The rottenness and evil in me.
 
 ===This gem should be considered in early beta and highly unstable. Do not use in a production app!
 
-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 submits 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 there albums, its good stuff!
+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
 
-Another note on a personal level, I have some learning disabilities that make it so I frequently make grammar mistake, and once and a while just drop random articles out of my sentences. All this only happens when writing. So if something doesn't make sense in the docs don't be afraid to point it out or submit a patch. Because to me it all looks right.....
+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 adapter. File System caching and memory caching are not recommended.Redis/Memcache are defiantly suggested and strongly encouraged for this gem.
+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.
 
 == Installation
 
-For now add the following line to your gemfile
+Very simple, in your gemfile
 
-gem 'flagpole_sitta', :git => "git://github.com/rovermicrover/FlagpoleSitta.git"
+  gem 'flagpole_sitta'
+
+OR
+
+  gem 'flagpole_sitta', :git => "git://github.com/rovermicrover/FlagpoleSitta.git"
 
 Then bundle install.
 
-== About
+== cache_sitta
 
-Flagpole Sitta is a gem that main purpose is to make it easier to effectively fragment cache in dynamic fashions in Rails.
+Flagpole Sitta is a gem thats main purpose is to make it easier to effectively fragment cache in dynamic fashions in Rails.
 
-When ever a cache is created it is associated with any model and/or record you tell it to be from the view helper method. When that model and/or record is updated all it's associated cache's are cleared. 
+When ever a cache is created it is associated with any model and/or record you tell it to be from the view helper method. When that model and/or record is updated all it's associated caches are cleared. 
 
 Flagpole also expects you to put all your database calls into Procs/Lamdbas. This makes it so that your database calls wont have to happen unless your cache hasn't been created. Thus speeding up response time and reducing database traffic.
 
@@ -42,23 +43,31 @@ For a simple application you could do something like this.
 
 === PageModel
 
-  cache_sitta :route_id => "url"
+  class Page < ActiveRecord::Base
+
+    cache_sitta :route_id => "url"
+
+  end
 
 === PagesController
 
-  def show
+  class PagesController < ApplicationController
 
-    @page_call = lambda {
-      if params[:url]
-        @page = Page.find_by_url params[:url]
-      else
-        @page = Page.find_by_url 'home'
-      end
-    }
+    def show
 
-    @body_calls = [
-      ['page', @page_call]
-    ]
+      @page_call = lambda {
+        if params[:url]
+          @page = Page.find_by_url params[:url]
+        else
+          @page = Page.find_by_url 'home'
+        end
+      }
+
+      @body_calls = [
+        ['page', @page_call]
+      ]
+
+    end
 
   end
 
@@ -67,7 +76,7 @@ For a simple application you could do something like this.
   - cache_sitta :model => Page, :route_id => params[:url], :section => "body" do
     = @page.content.try(:html_safe)
 
-First off lets look at @body_calls. The if you don't provide cache_sitta :calls, then it will look for @#{:section}_calls. So in this case it will look for @body_calls.
+First off lets look at @body_calls. If you don't provide cache_sitta :calls, then it will look for @#{:section}_calls. So in this case it will look for @body_calls.
 
 Second off @body_calls is an array of arrays. This is because you can have multiple calls, and each call must be given a target instance variable ('page') and a call object (@page_call). So in this instance the cache_sitta helper will do 
 
@@ -83,19 +92,27 @@ For an index page you could do something like the following for a simple app.
 
 === BlogModel
 
-  cache_sitta :route_id => "url"
+  class Blog < ActiveRecord::Base
+
+    cache_sitta
+
+  end
 
 === BlogsController
 
-  def index
+  class BlogsController < ApplicationController
+
+    def index
 
-    @blogs_call = lambda {
-      @blogs = Blog.all
-    }
+      @blogs_call = lambda {
+        @blogs = Blog.all
+      }
 
-    @body_calls = [
-      ['blogs', @blogs_call]
-    ]
+      @body_calls = [
+        ['blogs', @blogs_call]
+      ]
+
+    end
 
   end
 
@@ -107,12 +124,78 @@ For an index page you could do something like the following for a simple app.
       etc
       etc
 
-First notice you don't have to pass :route_id if you pass :index_only => true. And you don't have to pass :model if you pass :models_in_index.
+First notice you don't have to pass :route_id and :model if you pass :index_only => true and :models_in_index.
+
+This also means if your just showing objects in an index you don't even have to worry about declaring a route_id(It just defaults to id anyway.)
 
 :models_in_index tells the helper which Model to associated with the index, so if any objects in that model update the index cache gets nuked.
 
 :index_only => true, tells the helper to not bother trying to associated this cache with anyone item in particular.
 
+== 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.
+
+=== PageModel
+
+  class Page < ActiveRecord::Base
+
+    cache_sitta :route_id => "url"
+    has_existence_hash :route_id => "url"
+
+  end
+
+A quick note you only actually have to pass :route_id once if your using both cache_sitta and has_existence_hash. It uses the same class instance variable.
+
+=== PagesController
+
+  class PagesController < ApplicationController
+
+    if Page.get_existence_hash(params[:url])
+
+      def show
+
+        @page_call = lambda {
+          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
+
+  end
+
+This will keep your cache safe from being filled with junk. Though this isn't the only way you can use the 'existence hash' to solve this problem. Another note is that the hash is created the first time that you call for it. If you have a enough objects this can take a while. So its suggest that you warm all 'existence hash'es just in case.
+
+== has_brackets_retrieval
+
+This is best used for settings or html fragments stored in the database. It will look for the object in cache, and then if not there query the database and then create the object in cache. These caches too gets cleared on save/destory of their related objects. If the object isn't in the database, it will create it for you with a default value of an empty string. You can pass it what ever value you want for a default with :default_value. Also it defaults to assuming the content isn't html safe. You can make it return as an html_safe buffer by passing it :safe_content? => true.
+
+=== Setting Model
+
+  class Setting < ActiveRecord::Base
+    has_brackets_retrieval :key => :name, :value => :content
+  end
+
+Key is what you must pass to the brackets on the model. Value is the field it will return.
+
+=== View Example
+
+  %meta{:name => "description", :content => Setting['meta_description']}
+
+This amounts to a very small specific cache_sitta call. For now its suggested to not use this feature for user generated content.
+
 == Footer
 
 More examples to come in the wiki, and in the coming example app.

data/flagpole_sitta.gemspec

@@ -9,8 +9,8 @@ Gem::Specification.new do |s|
   s.authors     = ["Andrew Rove (Rover)"]
   s.email       = ["rovermicrover@gmail.com"]
   s.homepage    = "https://github.com/rovermicrover/FlagpoleSitta"
-  s.summary     = "FlagpoleSitta a gem for effective dynamic caching"
-  s.description = "Flagpole Sitta is a gem that main purpose is to make it easier to effectively fragment cache in dynamic fashions.\n When ever a cache is created it is associated with any model and/or record you tell it to be from the helper method. When that model and/or record is updated all it's associated cache's are cleared.\n Flagpole also expects you to put all your database calls into Procs/Lamdbas. This makes it so that your database calls wont have to happen unless your cache hasn't been created. Thus speeding up response time and reducing database traffic."
+  s.summary     = "FlagpoleSitta is a gem for effective dynamic caching"
+  s.description = "Flagpole Sitta is a gem that main purpose is to make it easier to effectively fragment cache in dynamic fashions in Rails. \nWhen ever a cache is created it is associated with any model and/or record you tell it to be from the view helper method. When that model and/or record is updated all it's associated caches are cleared. \nFlagpole also expects you to put all your database calls into Procs/Lamdbas. This makes it so that your database calls wont have to happen unless your cache hasn't been created. Thus speeding up response time and reducing database traffic."
 
   s.files = `git ls-files`.split("\n")
   s.executables = `git ls-files`.split("\n").map{|f| f =~ /^bin\/(.*)/ ? $1 : nil}.compact

data/lib/flagpole_sitta/bracket_retrieval.rb

@@ -45,6 +45,7 @@ module FlagpoleSitta
         result = @_value_field || (self.superclass.respond_to?(:value_field) ? self.superclass.value_field : nil) || "content"
       end
 
+      #Will look up the object chain till it finds what it was set to, or not set too.
       def default_value
         result = @_default_value || (self.superclass.respond_to?(:default_value) ? self.superclass.default_value : nil) || ""
       end

data/lib/flagpole_sitta/config_sitta.rb

@@ -9,9 +9,9 @@ module FlagpoleSitta
         @_route_id || (self.superclass.respond_to?(:route_id) ? self.superclass.route_id : nil)  || "id"
       end
 
-      def has_existance_hash options = {}
+      def has_existence_hash options = {}
         @_route_id ||= options[:route_id] ? options[:route_id].to_s : @_route_id
-        include FlagpoleSitta::ExistanceHash
+        include FlagpoleSitta::ExistenceHash
       end
 
       def has_brackets_retrieval options = {}

data/lib/flagpole_sitta/{existance_hash.rb → existence_hash.rb}

@@ -1,39 +1,39 @@
 module FlagpoleSitta
-  module ExistanceHash
+  module ExistenceHash
 
     extend ActiveSupport::Concern
 
     included do
-      before_save :existance_hash_save_update
-      before_destroy :existance_hash_destory_update
+      before_save :existence_hash_save_update
+      before_destroy :existence_hash_destory_update
     end
 
     module ClassMethods
 
-      def get_existance_hash key
+      def get_existence_hash key
 
-        dcname = get_super_with_existance_hash.name.downcase
+        dcname = get_super_with_existence_hash.name.downcase
         #Try to find the hash
-        flag = Rails.cache.read("#{dcname}_existance_hash_flag")
+        flag = Rails.cache.read("#{dcname}_existence_hash_flag")
         #If it doesn't exist start the process of creating it
         if flag.nil?
-          initialize_existance_hash
+          initialize_existence_hash
         end
 
-        Rails.cache.read("#{dcname}_existance_hash/#{key}")
+        Rails.cache.read("#{dcname}_existence_hash/#{key}")
 
       end
 
-      def increment_existance_hash key
+      def increment_existence_hash key
           
-        dcname = get_super_with_existance_hash.name.downcase
+        dcname = get_super_with_existence_hash.name.downcase
         #Try to find the hash
-        hash = get_existance_hash key
+        hash = get_existence_hash key
 
         #Update the hash key if it exists
         if hash
           hash[:num] = hash[:num] + 1
-          Rails.cache.write("#{dcname}_existance_hash/#{key}", hash)
+          Rails.cache.write("#{dcname}_existence_hash/#{key}", hash)
         end
 
         #Return the value
@@ -41,28 +41,28 @@ module FlagpoleSitta
 
       end
 
-      def get_super_with_existance_hash
+      def get_super_with_existence_hash
 
-        if @_existance_hash_main_class.nil?
+        if @_existence_hash_main_class.nil?
 
           c = self
           #Get the original super class that declares the existence hash
 
-          while(c.superclass.respond_to? :get_existance_hash)
+          while(c.superclass.respond_to? :get_existence_hash)
             c = c.superclass
           end
 
-          @_existance_hash_main_class = c
+          @_existence_hash_main_class = c
 
         end
 
-        @_existance_hash_main_class
+        @_existence_hash_main_class
 
       end
 
-      def initialize_existance_hash
+      def initialize_existence_hash
 
-        c = get_super_with_existance_hash
+        c = get_super_with_existence_hash
 
         dcname = c.name.downcase
 
@@ -72,12 +72,12 @@ module FlagpoleSitta
 
         flag = {:space => (count - 1), :count => count}
 
-        Rails.cache.write("#{dcname}_existance_hash_flag", flag)
+        Rails.cache.write("#{dcname}_existence_hash_flag", flag)
         i = 0
         c.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("#{dcname}_existance_hash/#{m.send(c.route_id).to_s}", {:type => m.has_attribute?('type') ? m.type : m.class, :pos => i, :num => 0})
-          Rails.cache.write("#{dcname}_existance_hash/#{i}", {:key => m.send(c.route_id).to_s})
+          Rails.cache.write("#{dcname}_existence_hash/#{m.send(c.route_id).to_s}", {:type => m.has_attribute?('type') ? m.type : m.class, :pos => i, :num => 0})
+          Rails.cache.write("#{dcname}_existence_hash/#{i}", {:key => m.send(c.route_id).to_s})
           i = i + 1
         end
 
@@ -85,23 +85,23 @@ module FlagpoleSitta
 
       end
 
-      def each_existance_hash &block
+      def each_existence_hash &block
 
-        dcname = get_super_with_existance_hash.name.downcase
+        dcname = get_super_with_existence_hash.name.downcase
 
-        flag = Rails.cache.read("#{dcname}_existance_hash_flag")
+        flag = Rails.cache.read("#{dcname}_existence_hash_flag")
 
         if flag.nil?
-          flag = initialize_existance_hash
+          flag = initialize_existence_hash
         end
 
         unless flag[:count] == 0
           for i in 0..flag[:space] do
 
-            value = Rails.cache.read("#{dcname}_existance_hash/#{i}")
+            value = Rails.cache.read("#{dcname}_existence_hash/#{i}")
 
             if value.present?
-              hash = Rails.cache.read("#{dcname}_existance_hash/#{value[:key]}")
+              hash = Rails.cache.read("#{dcname}_existence_hash/#{value[:key]}")
               yield value[:key], hash
             end
 
@@ -114,30 +114,30 @@ module FlagpoleSitta
 
     end
 
-    def existance_hash_save_update
-      self.update_existance_hash(true)
+    def existence_hash_save_update
+      self.update_existence_hash(true)
     end
 
-    def existance_hash_destory_update
-      self.update_existance_hash(false)
+    def existence_hash_destory_update
+      self.update_existence_hash(false)
     end
 
-    def update_existance_hash alive
-      c = self.class.get_super_with_existance_hash
+    def update_existence_hash alive
+      c = self.class.get_super_with_existence_hash
       dcname = c.name.downcase
 
       #Old key is where it was, and new is where it is going.
       old_key = self.send("#{self.class.route_id}_was")
       new_key = self.send("#{self.class.route_id}")
 
-      flag = Rails.cache.read("#{dcname}_existance_hash_flag")
+      flag = Rails.cache.read("#{dcname}_existence_hash_flag")
 
       #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 old_key
-        hash = self.class.get_existance_hash(self.send("#{self.class.route_id}_was"))
-        Rails.cache.delete("#{dcname}_existance_hash/#{old_key}")
+        hash = self.class.get_existence_hash(self.send("#{self.class.route_id}_was"))
+        Rails.cache.delete("#{dcname}_existence_hash/#{old_key}")
       elsif alive
         flag[:count] = flag[:count] + 1
         flag[:space] = flag[:space] + 1
@@ -146,17 +146,17 @@ module FlagpoleSitta
 
       #If the record is not being destroyed add new route_id to existence hash
       if alive
-        Rails.cache.write("#{dcname}_existance_hash/#{new_key}", hash)
-        Rails.cache.write("#{dcname}_existance_hash/#{hash[:pos]}", {:key => new_key})
+        Rails.cache.write("#{dcname}_existence_hash/#{new_key}", hash)
+        Rails.cache.write("#{dcname}_existence_hash/#{hash[:pos]}", {:key => new_key})
       else
         if hash[:pos] == flag[:space]
           flag[:space] = flag[:space] - 1
         end
         flag[:count] = flag[:count] - 1
-        Rails.cache.delete("#{dcname}_existance_hash/#{hash[:pos]}")
+        Rails.cache.delete("#{dcname}_existence_hash/#{hash[:pos]}")
       end
 
-      Rails.cache.write("#{dcname}_existance_hash_flag", flag)
+      Rails.cache.write("#{dcname}_existence_hash_flag", flag)
 
     end
 

data/lib/flagpole_sitta/version.rb

@@ -1,3 +1,3 @@
 module FlagpoleSitta
-  VERSION = "0.5.9"
+  VERSION = "0.6.0"
 end

data/lib/flagpole_sitta.rb

@@ -13,7 +13,7 @@ end
 
 require 'flagpole_sitta/bracket_retrieval'
 require 'flagpole_sitta/cache_sitta'
-require 'flagpole_sitta/existance_hash'
+require 'flagpole_sitta/existence_hash'
 require 'flagpole_sitta/engine'
 require 'flagpole_sitta/config_sitta'
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: flagpole_sitta
 version: !ruby/object:Gem::Version
-  version: 0.5.9
+  version: 0.6.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-18 00:00:00.000000000 Z
+date: 2012-07-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dalli
@@ -28,12 +28,13 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 description: ! "Flagpole Sitta is a gem that main purpose is to make it easier to
-  effectively fragment cache in dynamic fashions.\n When ever a cache is created it
-  is associated with any model and/or record you tell it to be from the helper method.
-  When that model and/or record is updated all it's associated cache's are cleared.\n
-  Flagpole also expects you to put all your database calls into Procs/Lamdbas. This
-  makes it so that your database calls wont have to happen unless your cache hasn't
-  been created. Thus speeding up response time and reducing database traffic."
+  effectively fragment cache in dynamic fashions in Rails. \nWhen ever a cache is
+  created it is associated with any model and/or record you tell it to be from the
+  view helper method. When that model and/or record is updated all it's associated
+  caches are cleared. \nFlagpole also expects you to put all your database calls into
+  Procs/Lamdbas. This makes it so that your database calls wont have to happen unless
+  your cache hasn't been created. Thus speeding up response time and reducing database
+  traffic."
 email:
 - rovermicrover@gmail.com
 executables: []
@@ -53,7 +54,7 @@ files:
 - lib/flagpole_sitta/cache_sitta.rb
 - lib/flagpole_sitta/config_sitta.rb
 - lib/flagpole_sitta/engine.rb
-- lib/flagpole_sitta/existance_hash.rb
+- lib/flagpole_sitta/existence_hash.rb
 - lib/flagpole_sitta/version.rb
 - test/dummy/Rakefile
 - test/dummy/app/controllers/application_controller.rb
@@ -113,5 +114,5 @@ rubyforge_project:
 rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
-summary: FlagpoleSitta a gem for effective dynamic caching
+summary: FlagpoleSitta is a gem for effective dynamic caching
 test_files: []