memorize 0.1.0

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Roger Leite
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.textile

@@ -0,0 +1,75 @@
+h2. Memorize:
+
+Allows Rails applications to do and control cache of actions.
+With Memorize, you can expires your actions, calling a method in your model (or a CustomClass).
+if you've suffered with Rails _caches_action_ and is tired of trying to expire your cache, Memorize is for you !
+See below my 'code-explanation':
+
+<pre>
+<code>
+
+  class Article < ActiveRecord::Base
+    extend Memorize::Keys
+    [...]
+  end
+  
+  class TestController < ApplicationController
+  
+    #'classic' case of index, with categories, pagination and format support.
+    memorize_action :index, :key_builder => Article, :params => [:category, :page, :format]
+  
+    #case of id, slug ... etc. Accessing a resource with identification.
+    memorize_action :show,  :key_builder => Article, :key_param => :slug, :params => [:page, :format]
+  
+    #case of 'custom' key, if you want to use a 'home made' solution. (here Memorize don't know how expires)
+    memorize_action :custom, :cache_path => lambda { |controller| "my_key" }
+  
+    [...]
+  end
+  
+  class ArticleSweeper < ActionController::Caching::Sweeper
+    observe Article
+    def after_save(article)
+      Article.cache_entries(:index).each { |key| Rails.cache.delete(key) }
+      Article.cache_entries(:show, :key => article.slug).each { |key| Rails.cache.delete(key) }
+  
+      Rails.cache.delete("my_key")  #Memorize does not handle custom keys
+    end
+  end
+
+</pre>
+</code>
+
+h2. More
+
+Memorize is designed to be simple and objetive.
+Used and tested for *Rails 2.3.x*
+
+h2. Install
+
+Just execute:
+<pre><code>  sudo gem install memorize</code></pre>
+
+And add to your environment.
+
+*Important*: you can configure Memorize cache_store, adding a _memorize.rb_ to your _config/initializers_. Example:
+
+<pre>
+<code>
+  #Some examples to set Memorize cache_store:
+  Memorize.cache_store = Rails.cache
+  #Memorize.cache_store = ActiveSupport::Cache.lookup_store(:memory_store)
+  #Memorize.cache_store = ActiveSupport::Cache.lookup_store(:mem_cache_store, '127.0.0.1:11211')
+  
+  #Your models can be 'Keys factories'
+  #ActiveRecord::Base.extend Memorize::Keys
+</code>
+</pre>
+
+h2. Bugs and Feedback
+
+If you find any issues, use Github issues tracker.
+
+Copyright (c) 2010 Roger Leite
+"1up4dev":http://1up4dev.org
+

data/Rakefile

@@ -0,0 +1,49 @@
+require 'rubygems'
+require 'rubygems/specification'
+require 'rake'
+require 'rake/gempackagetask'
+ 
+GEM = "memorize"
+GEM_VERSION = "0.1.0"
+SUMMARY = "Allows Rails applications to do and control cache of actions"
+AUTHOR = "Roger Leite"
+EMAIL = "roger.barreto@gmail.com"
+HOMEPAGE = "http://1up4dev.org"
+
+spec = Gem::Specification.new do |s|
+  s.name = GEM
+  s.version = GEM_VERSION
+  s.platform = Gem::Platform::RUBY
+  s.summary = SUMMARY
+  s.require_paths = ['lib']
+  s.files = FileList['lib/**/*.rb', '[A-Z]*'].to_a
+  
+  s.author = AUTHOR
+  s.email = EMAIL
+  s.homepage = HOMEPAGE
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+ 
+desc "Install the gem locally"
+task :install => [:package] do
+  sh %{sudo gem install pkg/#{GEM}-#{GEM_VERSION}}
+end
+ 
+desc "Create a gemspec file"
+task :make_spec do
+  File.open("#{GEM}.gemspec", "w") do |file|
+    file.puts spec.to_ruby
+  end
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.test_files = FileList.new('test/**/test_*.rb') do |list|
+    list.exclude 'test/test_helper.rb'
+  end
+  test.libs << 'test'
+  test.verbose = true
+end

data/lib/memorize/action.rb

@@ -0,0 +1,75 @@
+module Memorize
+
+  #  Exemplos de uso:
+  #  
+  #   class TestController < ApplicationController
+  #     memorize_action :index, :key_builder => Article, :params => [:category, :page, :format]
+  #     memorize_action :show,  :key_builder => Article, :key_param => :slug, :params => [:page, :format]
+  #     memorize_action :index, :cache_path => lambda { |controller| "my_key_#{controller.params.to_s}" }
+  #   end
+  
+  module Action
+
+    def memorize_action(*actions)
+      return unless self.perform_caching
+      options = actions.extract_options!
+      filter_options = { :only => actions, :if => options.delete(:if), :unless => options.delete(:unless) }
+
+      memorize_filter = MemorizeFilter.new(options)
+      around_filter(filter_options) do |controller, action|
+        memorize_filter.filter(controller, action)
+      end
+    end
+
+    class MemorizeFilter #:nodoc:
+
+      def initialize(options)
+        @cache_path = options.delete(:cache_path)
+        @key_builder = options.delete(:key_builder)
+        @key_param = options.delete(:key_param)
+        @key_params = options.delete(:params) || []
+      end
+
+      def filter(controller, action)
+        cache_path = eval_cache_path(controller)
+        cached = before(cache_path, controller)
+        unless cached
+          action.call
+          after(cache_path, controller) if caching_allowed?(controller)
+        end
+      end
+
+      def before(cache_path, controller)
+        if (cache = Memorize.cache_store.read(cache_path))
+          options = {:layout => false, :text => cache}
+          controller.__send__(:render, options)
+        end
+        !!cache
+      end
+
+      def after(cache_path, controller)
+        Memorize.cache_store.write cache_path, controller.response.body
+      end
+
+      private
+
+      def eval_cache_path(controller)
+        return @cache_path.call(controller) if @cache_path.respond_to?(:call)
+        unless @key_builder.respond_to?(:cache_key)
+          throw "Invalid 'key_builder' parameter. It should respond to 'cache_key' method."
+        end
+        group = controller.action_name.to_sym
+        key = controller.params[@key_param]
+        params = @key_params.collect { |param| controller.params[param] }
+        @key_builder.cache_key(group, :key => key, :params => params)
+      end
+
+      def caching_allowed?(controller)
+        controller.request.get? && controller.response.status.to_i == 200
+      end
+
+    end
+
+  end
+
+end

data/lib/memorize/keys.rb

@@ -0,0 +1,52 @@
+module Memorize
+
+  #  Memorize padroniza e mantém as entradas associadas a um "grupo" e "key".
+  #  Ao extender o Memorize::Keys, os seguintes métodos ficarão disponíveis:
+  #  
+  #   Model.cache_key(:group_id)
+  #   Model.cache_key(:group_id, :key => "key")
+  #   
+  #   Model.cache_entries(:group_id)
+  #   Model.cache_entries(:group_id, :key => "key")
+  module Keys
+
+    def cache_key(group, options = {})
+      param_key = options.delete(:key)
+      group_key = build_group_key(group, param_key)
+      cache_key = build_cache_key(group, param_key, options.delete(:params))
+      update_cache_entry(group_key, cache_key)
+      cache_key
+    end
+
+    def cache_entries(group, options = {})
+      group_key = build_group_key(group, options.delete(:key))
+      Memorize.cache_store.read(group_key) || []
+    end
+    
+    private
+
+    def update_cache_entry(group_key, cache_key)
+      entries = (Memorize.cache_store.read(group_key) || [])
+      unless entries.include?(cache_key)
+        entries = entries.dup if entries.frozen?
+        entries << cache_key
+        Memorize.cache_store.write(group_key, entries)
+      end
+    end
+
+    def build_cache_key(group, key, *params)
+      cache_key = "#{self.to_s}/#{group.to_s}"
+      cache_key << "/#{key}" if key
+      params = params.flatten.compact
+      cache_key << "/#{params.join("/")}" unless params.blank?
+      cache_key
+    end
+
+    def build_group_key(group, key = nil)
+      group_key = "#{self.to_s}/keys/#{group.to_s}"
+      group_key << "/#{key}" if key
+      group_key
+    end
+  end
+
+end

data/lib/memorize.rb

@@ -0,0 +1,21 @@
+module Memorize
+
+  class << self
+
+    def cache_store
+      @cache_store || ActiveSupport::Cache.lookup_store(:memory_store)
+    end
+
+    def cache_store=(cs)
+      @cache_store = cs
+    end
+
+  end
+
+end
+
+require 'memorize/keys'
+require 'memorize/action'
+
+#add memorize_action to controllers
+ActionController::Base.extend Memorize::Action

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification 
+name: memorize
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Roger Leite
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-16 00:00:00 -03:00
+default_executable: 
+dependencies: []
+
+description: 
+email: roger.barreto@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/memorize/action.rb
+- lib/memorize/keys.rb
+- lib/memorize.rb
+- README.textile
+- MIT-LICENSE
+- Rakefile
+has_rdoc: true
+homepage: http://1up4dev.org
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Allows Rails applications to do and control cache of actions
+test_files: []
+