catche 0.2.1 → 0.2.2

data/README.md

@@ -11,34 +11,54 @@ gem "catche"
 
 ## Controller caching
 
-Controller caching is based on `caches_action` using the method `catche`.
+Catche supports both action and page caching using the Rails methods `caches_action` and `caches_page`.
+
+### Action caching
+
+Catche's `catches_action` uses Rails' `caches_action` and therefore supports all options this method supports.
+
+```ruby
+class ProjectsController < ApplicationController
+  catches_action Project, :index, :show
+end
+```
+
+### Page caching
+
+Catche's `catches_page` uses Rails' `caches_page` and therefore supports all options this method supports.
+
+```ruby
+class ProjectsController < ApplicationController
+  catches_page Project, :index, :show
+end
+```
 
 ### Simple caching
 
 ```ruby
 class ProjectsController < ApplicationController
-  catche Project, :index, :show
+  catches_action Project, :index, :show # or catches_page
 end
 ```
 
-This will result in the following expirations:
+This will result in the following expirations, depending on your routes configuration:
 
 ```ruby
 @project.update_attributes({ :title => 'Update!' }) # or @project.destroy
 
-# => Expires /projects
+# => Expires: /projects
 # => Expires: /projects/1
 ```
 
 ```ruby
 @project.create
 
-# => Expires /projects
+# => Expires: /projects
 ```
 
 ### Associative caching
 
-Catche supports associative (nested) caching.
+Catche supports associative caching.
 
 ```ruby
 class Task < ActiveRecord::Base
@@ -48,7 +68,7 @@ end
 
 ```ruby
 class TasksController < ApplicationController
-  catche Task, :index, :show
+  catches_action Task, :index, :show # or catches_page
 end
 ```
 
@@ -57,7 +77,7 @@ This will result in the following expirations:
 ```ruby
 @task.update_attributes({ :title => 'Update!' }) # or @task.destroy
 
-# => Expires /tasks
+# => Expires: /tasks
 # => Expires: /projects/1/tasks
 # => Expires: /projects/1/tasks/1
 ```
@@ -65,7 +85,7 @@ This will result in the following expirations:
 ```ruby
 @project.tasks.create
 
-# => Expires /tasks
+# => Expires: /tasks
 # => Expires: /projects/1/tasks
 ```
 
@@ -84,7 +104,7 @@ This will result in the following expirations:
 ```ruby
 @task.update_attributes({ :title => 'Update!' }) # or @task.destroy
 
-# => Expires /tasks
+# => Expires: /tasks
 # => Expires: /projects/1/tasks
 # => Expires: /projects/1/tasks/1
 # => Expires: /users/1/tasks
@@ -94,7 +114,7 @@ This will result in the following expirations:
 ```ruby
 @project.tasks.create
 
-# => Expires /tasks
+# => Expires: /tasks
 # => Expires: /projects/1/tasks
 # => Expires: /users/1/tasks
 ```
@@ -104,10 +124,11 @@ This will result in the following expirations:
 ```ruby
 class TasksController < ApplicationController
   catche(
-    Task,                       # Configured cached model
-    :index, :show,              # Actions
+    Task,                         # Configured cached model
+    :index, :show,                # Actions
     {
-      :resource_name => :task,  # Name of your resource, defaults to your model name
+      :resource_name  => :task,   # Name of your resource, defaults to your model name
+      :type           => :action, # Type of caching, :action or :page
     }
   )
 end
@@ -124,12 +145,23 @@ class Task < ActiveRecord::Base
 end
 ```
 
+## How does it work?
+
+Catche intercepts a cached value and tags this value using the unique identifier for the given/loaded resource or collection. Once a resource expires it will expire the tagged cached values, such as the resource itself and the collection it belongs to.
+
+```ruby
+Catche::Tag::Collect.resource(@task) # { :set => ["tasks_1"], :expire => ["tasks_1"] }
+Catche::Tag::Collect.collection_tags(@task, Task) # { :set => ["projects_1_tasks"], :expire => ["tasks", "projects_1_tasks"] }
+```
+
+The tags will point to different cached values, for example pointing to a cached key or a cached filepath.
+
 ## Manually expiring a cache
 
 ```ruby
 @task.expire_resource!
 @task.expire_collection!
-@task.expire.expire_resource_and_collection!
+@task.expire_resource_and_collection!
 ```
 
 ## Supported cache stores
@@ -144,6 +176,7 @@ Want support for more? Just fork and open up a pull request.
 
 ## Roadmap
 
+* Page cache (caches_page)
 * View cache
 
 ## License

data/lib/catche/controller.rb

@@ -1 +1,60 @@
-require 'catche/controller/base'
+module Catche
+  module Controller
+
+    extend ActiveSupport::Concern
+    extend ActiveSupport::Autoload
+
+    eager_autoload do
+      autoload :Action
+      autoload :Page
+    end
+
+    include Action, Page
+
+    included do
+
+      class_attribute :catche_model,
+                      :catche_resource_name,
+                      :catche_constructed_tags
+
+    end
+
+    module ClassMethods
+
+      # Caches a controller action.
+      #
+      #   catche Project, :index, :resource_name => :project
+      def catche(model, *args)
+        options = args.extract_options!
+
+        self.catche_model = model
+        self.catche_resource_name = options[:resource_name] || self.catche_model.name.downcase.to_sym
+
+        case options[:type]
+          when :page then caches_page *args, options
+          else            caches_action *args, options
+        end
+      end
+
+      def catche?
+        self.catche_model.present?
+      end
+
+    end
+
+    def catche_tags
+      return @catche_tags if ! @catche_tags.nil?
+
+      if resource = Catche::ResourceLoader.fetch_one(self, self.class.catche_resource_name)
+        tags = Catche::Tag::Collect.resource(resource)
+        @catche_tags = tags[:set]
+      else
+        tags = Catche::Tag::Collect.collection(self, self.class.catche_model)
+        @catche_tags = tags[:set]
+      end
+    end
+
+  end
+end
+
+ActionController::Base.send :include, Catche::Controller

data/lib/catche/controller/action.rb

@@ -0,0 +1,30 @@
+module Catche
+  module Controller
+    module Action
+
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+
+        # Caches an action in Rails.cache
+        # See ActionController `caches_action` for more information
+        #
+        #   catches_action Project, :index
+        def catches_action(model, *args)
+          catche model, *args, :type => :action
+        end
+
+      end
+
+      def _save_fragment(name, options={})
+        if self.class.catche?
+          key = fragment_cache_key(name)
+          Catche::Tag.tag_view! key, *catche_tags
+        end
+
+        super
+      end
+
+    end
+  end
+end

data/lib/catche/controller/page.rb

@@ -0,0 +1,35 @@
+module Catche
+  module Controller
+    module Page
+
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+
+        # Caches an action by file
+        # See ActionController `caches_page` for more information
+        #
+        #   catches_action Project, :index
+        def catches_page(model, *args)
+          catche model, *args, :type => :page
+        end
+
+        def cache_page(content, path, extension = nil, gzip = Zlib::BEST_COMPRESSION)
+          if self.catche?
+            Catche::Tag.tag_page! page_cache_path(path, extension), *catche_constructed_tags
+          end
+
+          super
+        end
+
+      end
+
+      def cache_page(content = nil, options = nil, gzip = Zlib::BEST_COMPRESSION)
+        self.class.catche_constructed_tags = catche_tags
+        super
+      end
+
+
+    end
+  end
+end

data/lib/catche/expire.rb

@@ -0,0 +1,17 @@
+require 'catche/expire/view'
+require 'catche/expire/page'
+
+module Catche
+  module Expire
+
+    class << self
+
+      def expire!(data)
+        Catche::Expire::View.expire! *data[:views]
+        Catche::Expire::Page.expire! *data[:pages]
+      end
+
+    end
+
+  end
+end

data/lib/catche/expire/page.rb

@@ -0,0 +1,22 @@
+module Catche
+  module Expire
+    module Page
+
+      class << self
+
+        # Expires cache by deleting the associated files
+        # Uses the same flow as defined in `expire_page` in ActionController
+        #
+        #   Catche::Expire::Page.expire!('/public/projects.html')
+        def expire!(*paths)
+          paths.each do |path|
+            File.delete(path) if File.exist?(path)
+            File.delete(path + '.gz') if File.exist?(path + '.gz')
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/catche/expire/view.rb

@@ -0,0 +1,20 @@
+module Catche
+  module Expire
+    module View
+
+      class << self
+
+        # Expires cache by deleting the associated keys
+        #
+        #   Catche::Expire::View.expire!('projects')
+        def expire!(*keys)
+          keys.each do |key|
+            Catche.adapter.delete key
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/catche/tag.rb

@@ -12,52 +12,69 @@ module Catche
       tags.flatten.compact.uniq.join(DIVIDER)
     end
 
-    def tag!(key, *tags)
+    # Tags a view
+    def tag_view!(view, *tags)
+      tag_type! :views, view, *tags
+    end
+    alias :tag_fragment! :tag_view!
+
+    # Tags a page cache
+    def tag_page!(page, *tags)
+      tag_type! :pages, page, *tags
+    end
+
+    # Dynamic method for tagging a type of stored cache
+    #
+    #   Catche::Tag.tag_type!(:views, 'example.com/projects', 'projects')
+    def tag_type!(scope, value, *tags)
       tags.each do |tag|
-        keys      = fetch_tag(tag)
-        key_tags  = fetch_key(key)
+        data      = fetch_tag(tag)
+
+        # Set up key names
         tag_key   = stored_key(:tags, tag)
-        key_key   = stored_key(:keys, key)
+        type_key  = stored_key(scope, value)
 
-        Catche.adapter.write(tag_key, keys << key)
-        Catche.adapter.write(key_key, key_tags << tag_key)
+        # Current tags
+        type_tags = fetch_type(scope, value)
+
+        # Append new value to scoped data
+        data[scope] ||= []
+        data[scope] << value
+        tag_data  = data
+
+        # Append new tag key
+        type_data = type_tags << tag_key
+
+        Catche.adapter.write(tag_key, tag_data)
+        Catche.adapter.write(type_key, type_data)
       end
     end
 
     def expire!(*tags)
-      expired_keys = []
-
       tags.each do |tag|
-        keys = fetch_tag(tag)
-        expired_keys += keys
-
-        keys.each do |key|
-          # Expires the cached value
-          Catche.adapter.delete key
-
-          # Removes the tag from the tag list in case it's never used again
-          Catche.adapter.write(
-              stored_key(:keys, key),
-              fetch_key(key).delete(stored_key(:tags, tag))
-            )
-        end
-
+        Catche::Expire.expire! fetch_tag(tag)
         Catche.adapter.delete stored_key(:tags, tag)
       end
-
-      expired_keys
     end
 
     protected
 
       def fetch_tag(tag)
-        Catche.adapter.read stored_key(:tags, tag), []
+        Catche.adapter.read stored_key(:tags, tag), {}
       end
 
       def fetch_key(key)
         Catche.adapter.read stored_key(:keys, key), []
       end
 
+      def fetch_type(type, value)
+        Catche.adapter.read stored_key(type, value), []
+      end
+
+      def fetch_path(path)
+        Catche.adapter.read stored_key(:paths, path), []
+      end
+
       def stored_key(scope, value)
         join_keys KEY, scope.to_s, value.to_s
       end

data/lib/catche/tag/collect.rb

@@ -6,7 +6,7 @@ module Catche
 
         # Collects resource tags for a given resource
         #
-        #   Catche::Tag::Tagger.resource_tags(@task)
+        #   Catche::Tag::Collect.resource_tags(@task)
         #   => { :set => ["tasks_1"], :expire => ["tasks_1"] }
         def resource(resource)
           set_tags    = []
@@ -23,7 +23,7 @@ module Catche
 
         # Collects collection tags for a given context, for example a controller
         #
-        #   Catche::Tag::Tagger.collection_tags(controller, Task)
+        #   Catche::Tag::Collect.collection_tags(controller, Task)
         #   => { :set => ["projects_1_tasks"], :expire => ["tasks", "projects_1_tasks"] }
         def collection(context, resource_class, include_base=true)
           associations      = Catche::ResourceLoader.fetch(context, *resource_class.catche_associations)

data/lib/catche/version.rb

@@ -1,3 +1,3 @@
 module Catche
-  VERSION = "0.2.1"
+  VERSION = "0.2.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: catche
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-22 00:00:00.000000000Z
+date: 2012-06-23 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
-  requirement: &70193875371180 !ruby/object:Gem::Requirement
+  requirement: &70222481972780 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: 3.2.0
   type: :runtime
   prerelease: false
-  version_requirements: *70193875371180
+  version_requirements: *70222481972780
 - !ruby/object:Gem::Dependency
   name: sqlite3
-  requirement: &70193875370760 !ruby/object:Gem::Requirement
+  requirement: &70222481972240 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70193875370760
+  version_requirements: *70222481972240
 - !ruby/object:Gem::Dependency
   name: rspec-rails
-  requirement: &70193875370300 !ruby/object:Gem::Requirement
+  requirement: &70222481971660 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70193875370300
+  version_requirements: *70222481971660
 - !ruby/object:Gem::Dependency
   name: capybara
-  requirement: &70193875369880 !ruby/object:Gem::Requirement
+  requirement: &70222481971120 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,10 +54,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70193875369880
+  version_requirements: *70222481971120
 - !ruby/object:Gem::Dependency
   name: guard-rspec
-  requirement: &70193875369460 !ruby/object:Gem::Requirement
+  requirement: &70222481970640 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,10 +65,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70193875369460
+  version_requirements: *70222481970640
 - !ruby/object:Gem::Dependency
   name: guard-spork
-  requirement: &70193875369040 !ruby/object:Gem::Requirement
+  requirement: &70222481970160 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -76,7 +76,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70193875369040
+  version_requirements: *70222481970160
 description: ''
 email:
 - mail@arjen.me
@@ -86,8 +86,12 @@ extra_rdoc_files: []
 files:
 - lib/catche/adapter/base.rb
 - lib/catche/adapter.rb
-- lib/catche/controller/base.rb
+- lib/catche/controller/action.rb
+- lib/catche/controller/page.rb
 - lib/catche/controller.rb
+- lib/catche/expire/page.rb
+- lib/catche/expire/view.rb
+- lib/catche/expire.rb
 - lib/catche/model/base.rb
 - lib/catche/model.rb
 - lib/catche/railtie.rb

data/lib/catche/controller/base.rb

@@ -1,57 +0,0 @@
-module Catche
-  module Controller
-    module Base
-
-      extend ActiveSupport::Concern
-
-      included do
-
-        class_attribute :catche_model,
-                        :catche_resource_name
-
-      end
-
-      module ClassMethods
-
-        # Caches a controller action by tagging it.
-        # Supports any option parameters caches_action supports.
-        #
-        #   catche Project, :index, :resource_name => :project
-        def catche(model, *args)
-          options = args.extract_options!
-
-          self.catche_model = model
-          self.catche_resource_name = options[:resource_name] || self.catche_model.name.downcase.to_sym
-
-          # Use Rails caches_action to pass along the tag
-          caches_action(*args, options.merge({ :catche => true }))
-        end
-
-      end
-
-      def catche_tags
-        return @catche_tags if ! @catche_tags.nil?
-
-        if resource = Catche::ResourceLoader.fetch_one(self, self.class.catche_resource_name)
-          tags = Catche::Tag::Collect.resource(resource)
-          @catche_tags = tags[:set]
-        else
-          tags = Catche::Tag::Collect.collection(self, self.class.catche_model)
-          @catche_tags = tags[:set]
-        end
-      end
-
-      def _save_fragment(name, options={})
-        if options[:catche]
-          key = fragment_cache_key(name)
-          Catche::Tag.tag! key, *catche_tags
-        end
-
-        super
-      end
-
-    end
-  end
-end
-
-ActionController::Base.send :include, Catche::Controller::Base