acts_as_cached 0.1.0

data/README

@@ -0,0 +1,4 @@
+ActsAsCached
+============
+
+Description goes here

data/lib/acts_as_cached.rb

@@ -0,0 +1,77 @@
+require 'active_record'
+require 'view_extensions'
+
+module Adocca
+  module Acts
+    module ActsAsCached
+
+      class CacheObserver
+
+        # class_name:  The name of the class whose namespace we'll invalidate
+        # id_column:   The column of the monitored object that contains the id
+        #              of the object we'll invalidate
+        # type_column: For polymorphic associations, this is the column of the
+        #              monitored object that contains the class name of the
+        #              associated object. E.g. for trigs, "triggable_type"
+
+        def initialize(class_name, id_column, type_column = nil)
+          @class_name, @id_column, @type_column = class_name, id_column, type_column
+        end
+
+        def update(method_name, object)
+          if method_name == :after_save || method_name == :after_destroy
+            # in case of polymorphic associations, make sure the monitored object
+            # is attached to the right type
+            if @type_column.nil? || object[@type_column] == @class_name
+              namespace = "#{@class_name}:#{object[@id_column]}"
+              #puts 'Invalidating: ' + namespace + ' for change on object ' + object.class.name
+              RAILS_DEFAULT_LOGGER.debug "ActsAsCached, Invalidating namespace: #{namespace}"
+              CACHE.invalidate_namespace(namespace)
+            end
+          end
+          true
+        end
+      end
+
+      def self.append_features(base)
+        super
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def acts_as_cached(options = {})
+          if assocs = options[:depends]
+            assocs = [ assocs ] if assocs.kind_of? Symbol
+
+            assocs.each do |assoc|
+              unless reflection = reflect_on_association(assoc)
+                raise "Association not found"
+              end
+
+              # For trough reflections, we need to observe both the
+              # intermediate model (e.g. Tagging for tags) and the
+              # and the associated (Tag for tags)
+              # For now, only the through reflection since it's pain
+              # in the ASS to do this correctly. This works for tags :)
+              if through = reflection.through_reflection
+                reflection = through
+              end
+
+              if as = reflection.options[:as]
+                type_column = "#{as}_type"
+              else
+                type_column = nil
+              end
+
+              reflection.klass.add_observer CacheObserver.new(self.name, reflection.primary_key_name, type_column)
+            end
+          end
+
+          self.add_observer CacheObserver.new(self.name, self.primary_key.to_sym)
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.send(:include, Adocca::Acts::ActsAsCached)

data/lib/view_extensions.rb

@@ -0,0 +1,83 @@
+require 'set'
+
+ActionView::Base.class_eval do
+  class RenderOptions
+
+    def initialize(*init_values)
+      @set = Set.new(init_values)
+    end
+
+    def <<(key)
+      @set << key
+    end
+
+    def length
+      @set.length
+    end
+
+    alias_method :add, :<<
+
+    def method_missing(name)
+      if name.to_s =~ /(\w+)\?/
+        return @set.include?($1.to_sym)
+      else
+        super
+      end
+    end
+
+    def to_key
+      @set.to_a.collect{ |sym| sym.to_s }.sort.join(':')
+    end
+
+  end
+
+  def render_object(object, view, options = {})
+
+    logger.info "render_cached: object: #{object} view: #{view} options #{options.inspect}"
+
+
+    # XXX validate that object is an acts_as_cached  FIXME
+
+    namespace = "#{object.class.name}:#{object.id}"
+    if render_options = options[:options]
+      key = "#{view}:#{render_options.to_key}"
+    else
+      render_options = RenderOptions.new
+      key = view
+    end
+
+    fragment_proc = Proc.new do
+      partial = options[:partial]
+      class_lower = object.class.name.underscore
+      unless partial
+        if directory = options[:directory]
+          partial = "#{directory}/#{class_lower}_#{view}"
+        else
+          partial = "#{class_lower}_#{view}"
+        end
+      end
+      render :partial => partial, :locals => { class_lower.to_sym => object, :options => render_options }
+    end
+
+    unless options[:cache] == false
+      fragment = cache_value([namespace, key], options[:expiry] || 0, &fragment_proc) 
+    else
+      fragment = fragment_proc.call
+    end
+
+    if transformer = options[:transform]
+      case transformer
+      when Symbol
+        return send(transformer, object, fragment)
+      when Proc
+        return transformer.call(object, fragment)
+      else
+        raise TypeError, "Transformer must be either symbol or proc"
+      end
+    else
+      return fragment
+    end
+
+  end
+end
+

data/test/acts_as_cached_test.rb

@@ -0,0 +1,8 @@
+require 'test/unit'
+
+class ActsAsCachedTest < Test::Unit::TestCase
+  # Replace this with your real tests.
+  def test_this_plugin
+    flunk
+  end
+end

metadata

@@ -0,0 +1,50 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.0
+specification_version: 1
+name: acts_as_cached
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+date: 2006-11-13 00:00:00 +01:00
+summary: Caching helpers for Rails
+require_paths: 
+- lib
+email: 
+homepage: 
+rubyforge_project: 
+description: 
+autorequire: acts_as_cached
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Adocca Entertainment AB
+files: 
+- lib/acts_as_cached.rb
+- lib/view_extensions.rb
+- test/acts_as_cached_test.rb
+- README
+test_files: []
+
+rdoc_options: 
+- --line-numbers
+- --inline-source
+extra_rdoc_files: 
+- README
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+