flagpole_sitta 0.6.0 → 0.7.0

data/README.rdoc

@@ -1,8 +1,11 @@
 = 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.
 
 ♫~♫~♫~♫~♫~♫~♫~♫~♫~♫~♫~♫~♫~♫~♫~♫~♫~♫~♫~♫~♫~♫~♫
@@ -17,7 +20,23 @@ 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.
+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.
+
+== Inspiration
+
+My insperation for this project came from the following post on github
+
+http://stackoverflow.com/a/1035832/1436131
+
+On a project I was handling things like the OP was, which of course has a chance of failure if between the controller and the view the cache expires or is deleted.
+
+That post also lead me to the following depericated ruby gem.
+
+https://github.com/evan/interlock
+
+I looked at it and decided it didn't meet my needs even if I where to get it updated. Which lead me to decided to create my own.
+
+PS feel free to vote up the above answer on stackoverflow, I know I have!
 
 == Installation
 
@@ -31,6 +50,12 @@ OR
 
 Then bundle install.
 
+== Special Thanks
+
+Taha Mukaddam
+https://github.com/tmkdam
+For his feedback and help on this gem.
+
 == cache_sitta
 
 Flagpole Sitta is a gem thats main purpose is to make it easier to effectively fragment cache in dynamic fashions in Rails.
@@ -55,17 +80,13 @@ For a simple application you could do something like this.
 
     def show
 
-      @page_call = lambda {
+      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
 
     end
 
@@ -76,17 +97,15 @@ 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. 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 calls_sitta. The view helper method cache_sitta will look for its calls at @#{:section}_calls. The method calls_sitta in the controller will append its provided block or proc (:block => yourproc) to @#{:section}_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 
-
-    @page = @page_call.call
+Second off @#{:section}_calls is an array of arrays. This is because you can have multiple calls, and each call must be given a target instance variable ie name ('page' in this instance) and a call object (the provide proc or block). They must also be ordered thus the array and not a hash.
 
 You can also pass your calls options by providing :calls_args to the helper. You must though set up your calls to expect an options hash.
 
 :route_id and :model must be provide so that the cache can be associated with the correct object, and the cache clear when its supposed to.
 
-:route_id must also be a unquie field on the model, other wise the cache won't connect properly to the object.
+:route_id must also be a unique field on the model, other wise the cache won't connect properly to the object.
 
 For an index page you could do something like the following for a simple app.
 
@@ -104,13 +123,9 @@ For an index page you could do something like the following for a simple app.
 
     def index
 
-      @blogs_call = lambda {
+      calls_sitta :name => "blogs", :section => "body" do
         @blogs = Blog.all
-      }
-
-      @body_calls = [
-        ['blogs', @blogs_call]
-      ]
+      end
 
     end
 
@@ -200,6 +215,10 @@ This amounts to a very small specific cache_sitta call. For now its suggested to
 
 More examples to come in the wiki, and in the coming example app.
 
+Also if for what ever reason you have made your app multi threaded this gem will break. If your interested in possible making it multithread safe the following link has some good info.
+
+http://stackoverflow.com/a/1390978/1436131
+
 ===This gem should be considered in early beta and highly unstable. Do not use in a production app!
 
 MIT License 

data/app/helpers/flagpole_sitta_helper.rb

@@ -8,24 +8,25 @@ module FlagpoleSittaHelper
     model.try(:update_array_cache, key, route_id)
   end
 
+  ##
   #AR - cache_sitta helper
   #NOTE This is not safe for .builder xml files.
   #Options
-  #-------
+  #
   #:section
   #The section of the page the cache represents. This is
   #best used in connection with -content_for. Can be any
   #string you want it to be. If not provided will default to
   #body. Also looks for the calls using sections. Will assume calls
   #are in the instance variable '@#{options[:section]_calls'
-  #-------
+  #
   #:model
   #The model of the object, or objects that you want to link
   #the cache too. Pass the actually model, or an array of models.
   #Must also have a corresponding route_id. If model is an array, 
   #route_id must also be an array of equal length. model[i] is 
   #connected to route_id[i].
-  #-------
+  #
   #:route_id
   #The unique identifier of the object, most likely what you route on
   #for showing the object or objects that you want to link
@@ -33,7 +34,7 @@ module FlagpoleSittaHelper
   #Must also have a corresponding model. If route_id is an array, 
   #model must also be an array of equal length. model[i] is 
   #connected to route_id[i].
-  #-------
+  #
   #:models_in_index
   #Use this if the fragment you are rendering is an index
   #pass it all the different types of models/classes could be
@@ -41,19 +42,19 @@ module FlagpoleSittaHelper
   #sitta enabled. The cache for the used index pages will then be
   #wiped clear when anyone of these models/classes has an object
   #created or updated.
-  #-------
+  #
   #:index_only
   #Use this if the cache should not be associated with any object,
   #but rather only a model. Use this if your cache is an index, or
   #can be 'random'.
-  #-------
+  #
   #:sub_route_id
   #Use this if options on the url can result in a difference in
   #the cache. So if you had an page where you could pass
   #in a year and month would be a great place for this.
   #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.

data/flagpole_sitta.gemspec

@@ -1,7 +1,5 @@
 require File.expand_path("../lib/flagpole_sitta/version", __FILE__)
 
-# Provide a simple gemspec so you can easily use your enginex
-# project in your rails apps through git.
 Gem::Specification.new do |s|
   s.name = "flagpole_sitta"
   s.version = FlagpoleSitta::VERSION
@@ -16,8 +14,7 @@ Gem::Specification.new do |s|
   s.executables = `git ls-files`.split("\n").map{|f| f =~ /^bin\/(.*)/ ? $1 : nil}.compact
   s.require_path = 'lib'
 
-  #add dependecy here and in the engine file as a required.
-
+  #Dependencies
   s.add_dependency('dalli')
 
 end

data/lib/flagpole_sitta/bracket_retrieval.rb

@@ -1,9 +1,10 @@
 module FlagpoleSitta
+  ##
+  #Used for getting and caching settings or html fragments stored in the database.
   module BracketRetrieval
 
     extend ActiveSupport::Concern
 
-    #When forcing a call back into a class from a module you must do it inside an include block
     included do
       validates_uniqueness_of (@_key_field || "name").to_sym
       validates_presence_of (@_key_field || "name").to_sym
@@ -19,13 +20,16 @@ module FlagpoleSitta
       self.br_update(false)
     end
 
+    #After update destroy old cache and write new one.
     def br_update alive
-      downcased = self.class.name.downcase
-      #Checks to make sure Controller Caching is on
-      if Rails.application.config.action_controller.perform_caching
-        Rails.cache.delete("#{downcased}/#{self.send(self.class.key_field + "_was")}")
-        Rails.cache.write("#{downcased}/#{self.send(self.class.key_field)}", self.send(self.class.value_field))
+      clazz = self.class
+
+      Rails.cache.delete("#{clazz}/BracketRetrieval/#{self.send(self.class.key_field + "_was")}")
+
+      if alive
+        Rails.cache.write("#{clazz}/BracketRetrieval/#{self.send(self.class.key_field)}", self.send(self.class.value_field))
       end
+      
     end
 
     module ClassMethods
@@ -45,20 +49,16 @@ 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.
+      #Will look up the object chain till it finds what it was set to, or not set too. 
+      #Default value cannot be nil.
       def default_value
         result = @_default_value || (self.superclass.respond_to?(:default_value) ? self.superclass.default_value : nil) || ""
       end
 
       def [] key 
-        downcased = self.to_s.downcase
-        #If its in cache return that, unless blank, then return nil
-        #elsif the object is in the database put it into the cache
-        #then return it.
-        #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.
-        if value = Rails.cache.read("#{downcased}/#{key}") || Rails.cache.exist?("#{downcased}/#{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.present?
             value = self.safe_content? ? value.html_safe : value
           else
@@ -67,13 +67,16 @@ module FlagpoleSitta
             #thus the reason for this odd nested if statement.
             value = nil
           end
+        #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("#{downcased}/#{key}", value)
+          Rails.cache.write("#{clazz}/BracketRetrieval/#{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("#{downcased}/#{key}", rec.send(self.value_field))
+          Rails.cache.write("#{clazz}/BracketRetrieval/#{key}", rec.send(self.value_field))
           value = nil
         end
         value

data/lib/flagpole_sitta/cache_sitta.rb

@@ -1,8 +1,13 @@
 module FlagpoleSitta
+  ##
+  #CacheSitta's 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 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.
   module CacheSitta
     extend ActiveSupport::Concern
 
-    #When forcing a call back into a class from a module you must do it inside an include block
     included do
       before_save :cache_sitta_save
       before_destroy :cache_sitta_destory
@@ -10,6 +15,7 @@ module FlagpoleSitta
 
     module ClassMethods
 
+      #Determines if its for an index array or show array.
       def mid_key_gen route_id
         if route_id
           mid_key = "#{route_id}/ShowArray"
@@ -18,6 +24,7 @@ module FlagpoleSitta
         end
       end
 
+      #Creates the 'array' in the cache.
       def initialize_array_cache route_id = nil
 
         
@@ -33,6 +40,7 @@ module FlagpoleSitta
 
       end
 
+      #Updates the 'array' in the cache.
       def update_array_cache key, route_id = nil
 
         mid_key = mid_key_gen route_id
@@ -57,6 +65,7 @@ module FlagpoleSitta
 
       end
 
+      #Loops through the array in the cache.
       def each_cache route_id = nil, &block
 
         mid_key = mid_key_gen route_id
@@ -84,6 +93,7 @@ module FlagpoleSitta
 
       end
 
+      #Nukes all corresponding caches for a given array.
       def destroy_array_cache route_id = nil
 
         mid_key = mid_key_gen route_id
@@ -107,6 +117,7 @@ module FlagpoleSitta
       self.cache_work(false)
     end
 
+    #Updates the cache after update of any cache sittaed item.
     def cache_work(alive)
       original_clazz = self.class
       # Also have to go through all its super objects till the super objects aren't cache sittaed

data/lib/flagpole_sitta/controller_sitta.rb

@@ -0,0 +1,91 @@
+module FlagpoleSitta
+  module ControllerSitta
+
+    extend ActiveSupport::Concern
+
+    ##
+    #Creates adds the block or provided proc or lamdba to the given
+    #section or sections call array. These calls backs are then used by
+    #the cache_sitta view helper.
+    #
+    #:section the section or sections the block will be connected too. Array or String.
+    #
+    #:name the name of the instance variable the returned value of the block String
+    #will be stored at. Ie 'blog' would result in @blog.
+    #
+    #:block you can pass in an already defined proc or lamdba instead of a block. Proc pr lamdba
+    #
+    def calls_sitta options={}, &block
+
+      options[:section] ? (section = options[:section]) : (section = "body")
+
+      options[:name] ? (name = options[:name]) : (name = "object")
+
+      if section.class.eql?(Array)
+        section.each do |s|
+          if options[:block]
+            calls_sitta_set(s, name, options[:block])
+          else
+            calls_sitta_set(s, name, block)
+          end
+        end
+      else
+        if options[:block]
+          calls_sitta_set(section, name, options[:block])
+        else
+          calls_sitta_set(section, name, block)
+        end
+      end
+
+    end
+
+    ##
+    #Takes the predefined blocks from one section and adds them to one or more other sections.
+    #
+    #:frome_section from where you want to copy. String
+    #
+    #:to_section the section or sections you want to copy to. String or Array.
+    def calls_sitta_append options={}
+
+      calls_sitta_init options[:from_section]
+
+      if options[:to_section].class.eql?(Array)
+        options[:to_section].each do |s|
+          calls_sitta_init s
+          instance_variable_set("@#{s}_calls",
+            instance_variable_get("@#{s}_calls") + instance_variable_get("@#{options[:from_section]}_calls")
+          )
+        end
+      else
+        calls_sitta_init options[:to_section]
+        instance_variable_set("@#{options[:to_section]}_calls",
+          instance_variable_get("@#{options[:to_section]}_calls") + instance_variable_get("@#{options[:from_section]}_calls")
+        )
+      end
+
+    end
+
+    ##
+    # Make sure the instance variable has the correct starting value.
+    def calls_sitta_init section
+      if !instance_variable_defined?("@#{section}_calls")
+        instance_variable_set("@#{section}_calls", [])
+      end
+    end
+
+    ##
+    # A method to help dry out calls_sitta
+    def calls_sitta_set section, name, block
+      
+      calls_sitta_init section
+
+      instance_variable_set("@#{section}_calls",
+        instance_variable_get("@#{section}_calls") + [[name, block]]
+      )
+    end
+
+  end
+
+end
+
+ActionController::Base.send(:include, FlagpoleSitta::ControllerSitta)

data/lib/flagpole_sitta/existence_hash.rb

@@ -1,4 +1,6 @@
 module FlagpoleSitta
+  ##
+  #A ‘hash’ in the cache which you can use to check for the existence of an object
   module ExistenceHash
 
     extend ActiveSupport::Concern
@@ -10,30 +12,56 @@ module FlagpoleSitta
 
     module ClassMethods
 
+      #Creates the 'hash' in the cache.
+      def initialize_existence_hash
+
+        superclazz = get_super_with_existence_hash
+
+        #Used to emulate an array, keeps the stored count and space. The space is not actually a count of existing entries, but rather how long
+        #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}
+
+        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.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})
+          i = i + 1
+        end
+
+        flag
+
+      end
+
+      #Gets a value from the 'hash' in the cache given a key.
       def get_existence_hash key
 
-        dcname = get_super_with_existence_hash.name.downcase
+        superclazz = get_super_with_existence_hash
         #Try to find the hash
-        flag = Rails.cache.read("#{dcname}_existence_hash_flag")
+        flag = Rails.cache.read("#{superclazz}/ExistenceHash/Flag")
         #If it doesn't exist start the process of creating it
         if flag.nil?
           initialize_existence_hash
         end
 
-        Rails.cache.read("#{dcname}_existence_hash/#{key}")
+        Rails.cache.read("#{superclazz}/ExistenceHash/#{key}")
 
       end
 
+      #Increments a value from the 'hash' in the cache given a key.
       def increment_existence_hash key
           
-        dcname = get_super_with_existence_hash.name.downcase
+        superclazz = get_super_with_existence_hash
         #Try to find the hash
         hash = get_existence_hash key
 
         #Update the hash key if it exists
         if hash
           hash[:num] = hash[:num] + 1
-          Rails.cache.write("#{dcname}_existence_hash/#{key}", hash)
+          Rails.cache.write("#{superclazz}/ExistenceHash/#{key}", hash)
         end
 
         #Return the value
@@ -41,55 +69,12 @@ module FlagpoleSitta
 
       end
 
-      def get_super_with_existence_hash
-
-        if @_existence_hash_main_class.nil?
-
-          c = self
-          #Get the original super class that declares the existence hash
-
-          while(c.superclass.respond_to? :get_existence_hash)
-            c = c.superclass
-          end
-
-          @_existence_hash_main_class = c
-
-        end
-
-        @_existence_hash_main_class
-
-      end
-
-      def initialize_existence_hash
-
-        c = get_super_with_existence_hash
-
-        dcname = c.name.downcase
-
-        #Used to emulate an array, keeps the stored count and space. The space is not actually a count of existing entries, but rather how long
-        #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 = c.count
-
-        flag = {:space => (count - 1), :count => count}
-
-        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}_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
-
-        flag
-
-      end
-
+      #Goes through each entry in the hash returning a key and value
       def each_existence_hash &block
 
-        dcname = get_super_with_existence_hash.name.downcase
+        superclazz = get_super_with_existence_hash
 
-        flag = Rails.cache.read("#{dcname}_existence_hash_flag")
+        flag = Rails.cache.read("#{superclazz}/ExistenceHash/Flag")
 
         if flag.nil?
           flag = initialize_existence_hash
@@ -98,10 +83,10 @@ module FlagpoleSitta
         unless flag[:count] == 0
           for i in 0..flag[:space] do
 
-            value = Rails.cache.read("#{dcname}_existence_hash/#{i}")
+            value = Rails.cache.read("#{superclazz}/ExistenceHash/#{i}")
 
             if value.present?
-              hash = Rails.cache.read("#{dcname}_existence_hash/#{value[:key]}")
+              hash = Rails.cache.read("#{superclazz}/ExistenceHash/#{value[:key]}")
               yield value[:key], hash
             end
 
@@ -112,6 +97,26 @@ module FlagpoleSitta
 
       end
 
+      #Gets its original super class.
+      def get_super_with_existence_hash
+
+        if @_existence_hash_main_class.nil?
+
+          c = self
+          #Get the original super class that declares the existence hash
+
+          while(c.superclass.respond_to? :get_existence_hash)
+            c = c.superclass
+          end
+
+          @_existence_hash_main_class = c
+
+        end
+
+        @_existence_hash_main_class
+
+      end
+
     end
 
     def existence_hash_save_update
@@ -122,41 +127,43 @@ module FlagpoleSitta
       self.update_existence_hash(false)
     end
 
+    #Updates the 'hash' on save of any of its records.
     def update_existence_hash alive
-      c = self.class.get_super_with_existence_hash
-      dcname = c.name.downcase
+      superclazz = self.class.get_super_with_existence_hash
 
       #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}_existence_hash_flag")
+      flag = Rails.cache.read("#{superclazz}/ExistenceHash/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_existence_hash(self.send("#{self.class.route_id}_was"))
-        Rails.cache.delete("#{dcname}_existence_hash/#{old_key}")
-      elsif alive
+      
+      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]}
+      else
+        hash = self.class.get_existence_hash(self.send("#{self.class.route_id}_was"))
+        Rails.cache.delete("#{superclazz}/ExistenceHash/#{old_key}")
       end
 
       #If the record is not being destroyed add new route_id to existence hash
       if alive
-        Rails.cache.write("#{dcname}_existence_hash/#{new_key}", hash)
-        Rails.cache.write("#{dcname}_existence_hash/#{hash[:pos]}", {:key => new_key})
-      else
+        Rails.cache.write("#{superclazz}/ExistenceHash/#{new_key}", hash)
+        Rails.cache.write("#{superclazz}/ExistenceHash/#{hash[:pos]}", {:key => new_key})
+      #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
         end
         flag[:count] = flag[:count] - 1
-        Rails.cache.delete("#{dcname}_existence_hash/#{hash[:pos]}")
+        Rails.cache.delete("#{superclazz}/ExistenceHash/#{hash[:pos]}")
       end
 
-      Rails.cache.write("#{dcname}_existence_hash_flag", flag)
+      Rails.cache.write("#{superclazz}/ExistenceHash/Flag", flag)
 
     end
 

data/lib/flagpole_sitta/version.rb

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

data/lib/flagpole_sitta.rb

@@ -16,5 +16,6 @@ require 'flagpole_sitta/cache_sitta'
 require 'flagpole_sitta/existence_hash'
 require 'flagpole_sitta/engine'
 require 'flagpole_sitta/config_sitta'
+require 'flagpole_sitta/controller_sitta'
 
 ActiveRecord::Base.send(:include, FlagpoleSitta::ConfigSitta)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: flagpole_sitta
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-19 00:00:00.000000000 Z
+date: 2012-07-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dalli
@@ -53,6 +53,7 @@ files:
 - lib/flagpole_sitta/bracket_retrieval.rb
 - lib/flagpole_sitta/cache_sitta.rb
 - lib/flagpole_sitta/config_sitta.rb
+- lib/flagpole_sitta/controller_sitta.rb
 - lib/flagpole_sitta/engine.rb
 - lib/flagpole_sitta/existence_hash.rb
 - lib/flagpole_sitta/version.rb