catche 0.1.2 → 0.2

data/README.md

@@ -1,6 +1,6 @@
 # Catche [![Build Status](https://secure.travis-ci.org/Arjeno/catche.png?branch=master)](http://travis-ci.org/Arjeno/catche)
 
-Catche is a caching library for easy and automated resource and collection caching. It basically tags cached outputs and expires them based on configuration.
+Catche is a caching library for Ruby on Rails. It automates automated resource and collection caching/expiration. It basically tags cached outputs and expires those tags based on configuration.
 
 ## Installation
 
@@ -23,21 +23,63 @@ end
 
 ### Associative caching
 
+For advanced usage such as advanced caching you need to configure this in the model.
+
+```ruby
+class Task < ActiveRecord::Base
+  catche :through => :project
+end
+```
+
 ```ruby
 class TasksController < ApplicationController
-  catche Task, :index, :show, :through => :project
+  catche Task, :index, :show
 end
 ```
 
-On resource change this will expire:
+On resource `update` and `destroy` this will expire:
+
+* Resource: `tasks_1`
+* Collection: `tasks`
+* Collection: `projects_1_tasks_1`
+
+On resource `create` this will expire:
+
+* Collection: `tasks`
+* Collection: `projects_1_tasks_1`
+
+You can use as many associations as you would like;
+
+```ruby
+class Task < ActiveRecord::Base
+  catche :through => [:user, :project]
+end
+```
 
-* Resource task
-* Resource task within specific project
+### Advanced configuration
 
-On resource or collection change this will expire:
+```ruby
+class TasksController < ApplicationController
+  catche(
+    Task,                       # Configured cached model
+    :index, :show,              # Actions
+    {
+      :resource_name => :task,  # Name of your resource, defaults to your model name
+    }
+  )
+end
+```
 
-* Collection tasks
-* Collection tasks within specific project
+```ruby
+class Task < ActiveRecord::Base
+  catche(
+    :through        => [:user, :project], # Associations
+    :tag_identifier => :id,               # Unique identifier for the resource
+    :class          => Task,              # Class to use as tag scope
+    :collection_tag => 'tasks',           # Name of the tag scope for this model,
+  )
+end
+```
 
 ## License
 

data/lib/catche.rb

@@ -3,6 +3,7 @@ require 'catche/adapter'
 require 'catche/controller'
 require 'catche/model'
 require 'catche/tag'
+require 'catche/resource_loader'
 
 module Catche
 

data/lib/catche/controller/base.rb

@@ -4,46 +4,47 @@ module Catche
 
       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
-        #   catche Task, :through => :project
+        #   catche Project, :index, :resource_name => :project
         def catche(model, *args)
           options = args.extract_options!
-          object  = Catche::Tag::Object.register!(model, self, options)
-          tag     = Proc.new { |controller| object }
+
+          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, { :tag => tag }.merge(options))
+          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={})
-        key     = fragment_cache_key(name)
-        object  = options[:tag]
-        tags    = []
-
-        if object.present?
-          if object.respond_to?(:call)
-            object = self.instance_exec(self, &object)
-
-            if object.respond_to?(:tags)
-              tags = object.tags(self)
-            else
-              tags = Array.new(object)
-            end
-          else
-            tags = Array.new(object)
-          end
-
-          Catche::Tag.tag! key, *tags
-
-          # Store for future reference
-          @catche_cache_object = object
+        if options[:catche]
+          key = fragment_cache_key(name)
+          Catche::Tag.tag! key, *catche_tags
         end
 
         super

data/lib/catche/model/base.rb

@@ -4,32 +4,72 @@ module Catche
       extend ActiveSupport::Concern
 
       included do
+        class_attribute :catche_class,
+                        :catche_collection_tag,
+                        :catche_tag_identifier,
+                        :catche_associations
+
+        # Expiration callbacks
+
         after_update  :expire_resource_and_collection!
         after_destroy :expire_resource_and_collection!
 
         after_create  :expire_collection!
       end
 
+      module ClassMethods
+
+        # Configures catche
+        #
+        #   catche :through => :project, :catche_class => Task
+        def catche(options={})
+          options = {
+            :class          => self,
+            :tag_identifier => :id,
+            :collection_tag => nil,
+            :associations   => [options[:through]].flatten.compact
+          }.merge(options)
+
+          options.each do |key, value|
+            self.send("catche_#{key}=", value) if self.respond_to?("catche_#{key}")
+          end
+
+          self.catche_collection_tag ||= self.catche_class.name.downcase.pluralize
+        end
+
+        def catche_reset!
+          catche {}
+        end
+
+        def catche_tag
+          self.catche_collection_tag || self.name.downcase.pluralize
+        end
+
+        def catche_tag=(value)
+          self.catche_collection_tag = value
+        end
+
+        def catche_tag_identifier
+          super || :id
+        end
+
+      end
+
+      def catche_tag
+        Tag.join self.class.catche_tag, self.send(:id)
+      end
+
       def expire_resource_and_collection!
         expire_collection!
         expire_resource!
       end
 
       def expire_collection!
-        expire_cache! false
+        Catche::Tag.expire! *Catche::Tag::Collect.collection(self, self.class)[:expire]
       end
 
       def expire_resource!
-        expire_cache!
-      end
-
-      def expire_cache!(set_instance=true)
-        tags = Catche::Tag::Object.find_by_model(self.class).collect do |obj|
-          self.instance_variable_set("@#{obj.options[:resource_name]}", self) if set_instance
-          obj.expiration_tags(self)
-        end.flatten.compact.uniq
-
-        Catche::Tag.expire! *tags
+        Catche::Tag.expire! *Catche::Tag::Collect.resource(self)[:expire]
       end
 
     end

data/lib/catche/resource_loader.rb

@@ -0,0 +1,36 @@
+module Catche
+  class ResourceLoader
+
+    class << self
+
+      # Fetches resources in the given context, for example a controller
+      #
+      #   Catche::Tag::ResourceLoader.fetch(controller, :task)
+      def fetch(context, *names)
+        names.collect do |name|
+          if resource = context.instance_variable_get("@#{name}")
+            resource
+          elsif context.respond_to?(name)
+            begin
+              context.send(name)
+            rescue
+              nil
+            end
+          else
+            nil
+          end
+        end.compact
+      end
+
+      def fetch_one(context, name)
+        fetch(context, name).first
+      end
+
+      def exists?(context, name)
+        fetch_one(context, name).present?
+      end
+
+    end
+
+  end
+end

data/lib/catche/tag.rb

@@ -1,5 +1,4 @@
-require 'catche/tag/object'
-require 'catche/tag/resource'
+require 'catche/tag/collect'
 
 module Catche
   module Tag

data/lib/catche/tag/collect.rb

@@ -0,0 +1,55 @@
+module Catche
+  module Tag
+    class Collect
+
+      class << self
+
+        # Collects resource tags for a given resource
+        #
+        #   Catche::Tag::Tagger.resource_tags(@task)
+        #   => { :set => ["tasks_1"], :expire => ["tasks_1"] }
+        def resource(resource)
+          set_tags    = []
+          expire_tags = []
+
+          set_tags    << resource.catche_tag
+          expire_tags << resource.catche_tag
+
+          {
+            :set    => set_tags.uniq,
+            :expire => expire_tags.uniq
+          }
+        end
+
+        # Collects collection tags for a given context, for example a controller
+        #
+        #   Catche::Tag::Tagger.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)
+          association_tags  = associations.map { |a| a.catche_tag }
+
+          set_tags    = []
+          expire_tags = []
+
+          if association_tags.any?
+            set_tags  << Tag.join(*association_tags, resource_class.catche_tag)
+          else
+            # Without any associations, add just the collection tag
+            set_tags  << resource_class.catche_tag
+          end
+
+          expire_tags << resource_class.catche_tag if include_base
+          expire_tags += set_tags
+
+          {
+            :set    => set_tags.uniq,
+            :expire => expire_tags.uniq
+          }
+        end
+
+      end
+
+    end
+  end
+end

data/lib/catche/version.rb

@@ -1,3 +1,3 @@
 module Catche
-  VERSION = "0.1.2"
+  VERSION = "0.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: catche
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: '0.2'
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-20 00:00:00.000000000Z
+date: 2012-06-22 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
-  requirement: &2160688340 !ruby/object:Gem::Requirement
+  requirement: &70299120119960 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: 3.2.0
   type: :runtime
   prerelease: false
-  version_requirements: *2160688340
+  version_requirements: *70299120119960
 - !ruby/object:Gem::Dependency
   name: sqlite3
-  requirement: &2160687900 !ruby/object:Gem::Requirement
+  requirement: &70299120118620 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2160687900
+  version_requirements: *70299120118620
 - !ruby/object:Gem::Dependency
   name: rspec-rails
-  requirement: &2160687400 !ruby/object:Gem::Requirement
+  requirement: &70299120117540 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2160687400
+  version_requirements: *70299120117540
 - !ruby/object:Gem::Dependency
   name: capybara
-  requirement: &2160686880 !ruby/object:Gem::Requirement
+  requirement: &70299120115880 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,10 +54,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2160686880
+  version_requirements: *70299120115880
 - !ruby/object:Gem::Dependency
   name: guard-rspec
-  requirement: &2160686040 !ruby/object:Gem::Requirement
+  requirement: &70299120113480 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,10 +65,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2160686040
+  version_requirements: *70299120113480
 - !ruby/object:Gem::Dependency
   name: guard-spork
-  requirement: &2160685320 !ruby/object:Gem::Requirement
+  requirement: &70299120112920 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -76,7 +76,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2160685320
+  version_requirements: *70299120112920
 description: ''
 email:
 - mail@arjen.me
@@ -91,8 +91,8 @@ files:
 - lib/catche/model/base.rb
 - lib/catche/model.rb
 - lib/catche/railtie.rb
-- lib/catche/tag/object.rb
-- lib/catche/tag/resource.rb
+- lib/catche/resource_loader.rb
+- lib/catche/tag/collect.rb
 - lib/catche/tag.rb
 - lib/catche/version.rb
 - lib/catche.rb
@@ -120,7 +120,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.15
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: Smart collection and resource caching

data/lib/catche/tag/object.rb

@@ -1,138 +0,0 @@
-module Catche
-  module Tag
-    class Object
-
-      class << self
-
-        @@objects = []
-
-        # Returns an existing (duplicate) or new tag object for the given arguments.
-        #
-        #   Catche::Tag::Object.register!(Project, ProjectsController)
-        def register!(model, object, options={})
-          tag_object = find_or_initialize(model, object, options)
-
-          objects << tag_object
-          objects.uniq!
-
-          tag_object
-        end
-        alias :for :register!
-
-        # Finds a previously declared (same) tag object or returns a new one.
-        def find_or_initialize(model, object, options={})
-          new_object = self.new(model, object, options)
-
-          objects.each do |tag_object|
-            return tag_object if tag_object.same?(new_object)
-          end
-
-          new_object
-        end
-
-        def find_by_model(model)
-          objects.select { |tag_object| tag_object.model == model }
-        end
-
-        def find_by_association(association)
-          objects.select { |tag_object| tag_object.associations.include?(association) }
-        end
-
-        def clear
-          @@objects = []
-        end
-
-        def objects
-          @@objects
-        end
-
-      end
-
-      attr_reader :model, :object, :options
-      attr_accessor :associations
-
-      def initialize(model, object, options={})
-        @model = model
-        @object = object
-
-        association = options[:through]
-
-        @options = {
-          :resource_name      => Catche::Tag::Resource.singularize(@model),
-          :collection_name    => Catche::Tag::Resource.pluralize(@model),
-          :associations       => [association].flatten.compact,
-          :bubble             => false,
-          :expire_collection  => true
-        }.merge(options)
-
-        @associations = @options[:associations]
-      end
-
-      # Returns the tags for the given object.
-      # If `bubble` is set to true it will pass along the separate tag for each association.
-      # This means the collection or resource is expired as soon as the association changes.
-      #
-      #   object = Catche::Tag::Object.new(Task, TasksController, :through => [:user, :project])
-      #   object.tags(controller.new) => ['users_1_projects_1_tasks_1']
-      def tags(initialized_object)
-        tags = []
-
-        tags += association_tags(initialized_object) if bubble?
-        tags += expiration_tags(initialized_object)
-
-        tags
-      end
-
-      # The tags that should expire as soon as the resource or collection changes.
-      def expiration_tags(initialized_object)
-        resource  = Catche::Tag::Resource.resource(initialized_object, options[:resource_name])
-        tags      = []
-
-        # Add collection tags when enabled
-        tags << Catche::Tag.join(
-            association_tags(initialized_object),
-            options[:collection_name]
-          ) if resource.nil? && options[:expire_collection]
-
-        tags << Catche::Tag.join(
-            association_tags(initialized_object),
-            identifier_tags(initialized_object)
-          )
-
-        tags.uniq
-      end
-
-      # Identifying tag for the current resource or collection.
-      #
-      #   object = Catche::Tag::Object.new(Task, TasksController)
-      #   object.identifier_tags(controller) => ['tasks', 1]
-      def identifier_tags(initialized_object)
-        Catche::Tag.join options[:collection_name], Catche::Tag::Resource.resource(initialized_object, options[:resource_name]).try(:id)
-      end
-
-      # Maps the given resources names to tags by fetching the resources from the given object.
-      def resource_tags(*resources)
-        resources.map { |resource| Catche::Tag.join(Catche::Tag::Resource.pluralize(resource.class), resource.id) }
-      end
-
-      # Maps association tags.
-      #
-      #   object = Catche::Tag::Object.new(Task, TasksController, :through => [:user, :project])
-      #   object.association_tags(controller) => ['users_1', 'projects_1']
-      def association_tags(initialized_object)
-        resource_tags(*Catche::Tag::Resource.associations(initialized_object, associations))
-      end
-
-      def bubble?
-        options[:bubble]
-      end
-
-      def same?(object)
-        self.model      == object.model &&
-        self.object     == object.object &&
-        self.options    == object.options
-      end
-
-    end
-  end
-end

data/lib/catche/tag/resource.rb

@@ -1,35 +0,0 @@
-module Catche
-  module Tag
-    class Resource
-
-      class << self
-
-        def pluralize(object)
-          object.name.to_s.pluralize.downcase
-        end
-
-        def singularize(object)
-          object.name.to_s.singularize.downcase
-        end
-
-        def resource(object, name)
-          if resource = object.instance_variable_get("@#{name}")
-            return resource
-          elsif object.respond_to?(name)
-            begin
-              return object.send(name)
-            rescue; end
-          end
-
-          nil
-        end
-
-        def associations(object, associations)
-          associations.map { |association| resource(object, association) }.compact
-        end
-
-      end
-
-    end
-  end
-end