acts_as_method_cacheable 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f01e9ffdf60462d98a0e9d5455058695747e9868
+  data.tar.gz: 0aeeb3f23e738298155f413a5db56f35f6a027d6
+SHA512:
+  metadata.gz: 450aa54f8f59e259f089ae21b5284efde4190ad6113df9f2f6f6a4514e4eba18c0df5f0e41631c181ea32924c00672303694772c2d429a87985d7ff93e69fcfc
+  data.tar.gz: dd58518b62a70508fe5512b1281112533e467df3abba958d553143dd2769862fcfdcad20775ad086e5b0a1c09dcd6c59d32cab2871136dc353488d8343f8af45

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+db/*sqlite3

data/Gemfile

@@ -0,0 +1,5 @@
+#source 'https://rubygems.org'
+source 'http://ruby.taobao.org'
+
+# Specify your gem's dependencies in acts_as_method_cacheable.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Ben Cao
+
+MIT License
+
+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.md

@@ -0,0 +1,67 @@
+## acts_as_method_cacheable
+
+Instead of writing def expensive { @cached_expensive ||= original_expensive }, now you can write instance.cache_method(:expensive) instead. Also support nested cache method for associations.
+*This gem depend on ActiveSupport/ActiveRecord*
+
+## Currernt Limitation
+*ONLY support method with no params*
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'acts_as_method_cacheable'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install acts_as_method_cacheable
+
+## Usage
+
+### cache method in class level, all instances will have the method cached
+*NOTE!! MUST put acts_as_method_cacheable in the last of the class file*
+```ruby
+class Post < ActiveRecord::Base
+  def expensive_method
+    # balababa
+  end
+  acts_as_method_cacheable :methods => :expensive_method
+end
+```
+
+### cache methods for a instance only
+```ruby
+post = Post.find(xxx)
+post.cache_method(:expensive_method)
+post.cache_method([:expensive_method1, :expensive_method2])
+```
+
+### cache methods for a instance and its associations
+```ruby
+post = Post.find(xxx)
+post.cache_method([:expensive_method3, :comments => :comment_expensive_method])
+```
+
+### reload - will clear cache of all cached methods(both class/instance level)
+```ruby
+post = Post.find(xxx)
+post.cache_method(:expensive_method)
+post.expensive_method  # expensive
+post.expensive_method  # cheap!
+post.reload
+post.expensive_method  # expensive
+```
+
+### reset cached method for a instance
+```ruby
+post = Post.find(xxx)
+post.cache_method(:expensive_method)
+post.expensive_method  # expensive
+post.expensive_method  # cheap!
+post.reset_cache(:expensive_method)
+post.expensive_method  # expensive
+```

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/acts_as_method_cacheable.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'acts_as_method_cacheable/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "acts_as_method_cacheable"
+  spec.version       = ActsAsMethodCacheable::VERSION
+  spec.authors       = ["Ben Cao"]
+  spec.email         = ["benb88@gmail.com"]
+  spec.description   = "Make cache methods on ActiveRecord easy!"
+  spec.summary       = "Instead of writing def expensive { @cached_expensive ||= original_expensive }, now you can write instance.cache_method(:expensive) instead. Also support nested cache method for associations."
+  spec.homepage      = "https://github.com/bencao/acts_as_method_cacheable"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake", "~> 10.0.4"
+  spec.add_development_dependency "rspec", "~> 2.13.0"
+  spec.add_development_dependency "mocha", "~> 0.13.3"
+  spec.add_development_dependency "sqlite3", "~> 1.3.7"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "pry-theme"
+  spec.add_development_dependency "pry-nav"
+  spec.add_dependency "activesupport", "~> 3.2.13"
+  spec.add_dependency "activerecord", "~> 3.2.13"
+end

data/db/database.yml

@@ -0,0 +1,5 @@
+development:
+   adapter: sqlite3
+   database: db/data.sqlite3
+   pool: 5
+   timeout: 5000

data/lib/acts_as_method_cacheable.rb

@@ -0,0 +1,131 @@
+require "acts_as_method_cacheable/version"
+
+module ActsAsMethodCacheable
+  extend ActiveSupport::Concern
+
+  included do
+    def self.acts_as_method_cacheable(opts = {})
+      unless class_variable_defined?(:@@cached_methods)
+        cattr_accessor :cached_methods
+        self.cached_methods = []
+
+        attr_accessor :instance_cache_methods
+
+        define_method "reload_with_cacheable" do |*params|
+          cached_methods.each { |method| reset_cache(method) }
+          self.instance_cache_methods && self.instance_cache_methods.each { |method| reset_cache(method) }
+          reload_without_cacheable(params)
+        end
+
+        alias_method_chain :reload, :cacheable
+
+        include Internal
+      end
+      [opts[:methods]].compact.flatten.each do |method|
+        cache_method(method)
+      end
+    end
+  end
+
+  module Internal
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      # cache_method :expensive_method
+      #
+      # currently don't support method with params, it's complex to serialize params as a key
+      # no param method covers most of our use cases
+      private
+      def cache_method(method)
+        raise "#{method} not defined in class #{self.to_s}" unless method_defined?(method)
+        raise "method with params is not supported by acts_as_method_cacheable yet!" unless self.new.method(method.to_sym).arity === 0
+
+        return if self.cached_methods.include?(method)
+
+        self.cached_methods.push(method)
+
+        define_method "#{method}_with_cacheable" do
+          unless cache_var_defined?(method)
+            cache_var_set(method, send("#{method}_without_cacheable".to_sym))
+          end
+          cache_var_get(method)
+        end
+        alias_method_chain method, :cacheable
+      end
+
+    end
+
+    def reset_cache(method)
+      remove_instance_variable(cache_var_name(method)) if cache_var_defined?(method)
+    end
+
+    # instance version cache_method
+    # cache_method(:expensive_method)
+    # cache_method([:expensive_method, :expensive_method2])
+    # cache_method([:expensive_method, :expensive_method2])
+    # cache_method([:expensive_method, :sub_associations => :expensive_method2])
+    def cache_method(args)
+      normalized_args = args.is_a?(Array) ? args : [args]
+
+      self_items = normalized_args.select{ |item| item.is_a?(Symbol) }
+      self_items.each { |self_item| _cache_method(self_item) }
+
+      children_items = normalized_args.select{ |item| item.is_a?(Hash) }
+      children_items.each do |child_item|
+        child, child_args = child_item.keys.first, child_item.values.first
+        child_instances = send(child)
+        child_instances = [child_instances] unless child_instances.respond_to?(:each)
+        child_instances.each do |instance|
+          instance.cache_method(child_args)
+        end
+      end
+      self
+    end
+
+    private
+
+    def cache_var_name(method)
+      "@cached_var_for_method_#{method}".to_sym
+    end
+
+    def cache_var_set(method, value)
+      instance_variable_set(cache_var_name(method), value)
+    end
+
+    def cache_var_get(method)
+      instance_variable_get(cache_var_name(method))
+    end
+
+    def cache_var_defined?(method)
+      instance_variable_defined?(cache_var_name(method))
+    end
+
+    # method which only accept a symbol as parameter
+    def _cache_method(method)
+      raise "#{method} not defined in class #{self.class.to_s}" unless self.class.method_defined?(method)
+      raise "method with params is not supported by acts_as_method_cacheable yet!" unless method(method.to_sym).arity === 0
+
+      return if cached_methods.include?(method)
+
+      self.instance_cache_methods ||= []
+
+      return if self.instance_cache_methods.include?(method)
+
+      self.instance_cache_methods.push(method)
+
+      self.instance_eval <<-CACHEEND, __FILE__, __LINE__ + 1
+        class << self
+          def #{method}
+            unless cache_var_defined?(:#{method})
+              cache_var_set(:#{method}, super)
+            end
+            cache_var_get(:#{method})
+          end
+        end
+      CACHEEND
+    end
+  end
+
+end
+
+ActiveRecord::Base.send(:include, ActsAsMethodCacheable)

data/lib/acts_as_method_cacheable/version.rb

@@ -0,0 +1,3 @@
+module ActsAsMethodCacheable
+  VERSION = "0.1.0"
+end

data/spec/acts_as_method_cacheable_spec.rb

@@ -0,0 +1,216 @@
+require 'spec_helper.rb'
+
+class Schema < ActiveRecord::Migration
+  def change
+    create_table :posts do |t|
+      t.string :title
+      t.string :date
+    end
+
+    create_table :comments do |t|
+      t.string :content
+      t.string :author
+      t.string :date
+      t.references :post
+    end
+  end
+end
+schema = Schema.new
+schema.down
+schema.up
+
+require 'acts_as_method_cacheable'
+
+class Post < ActiveRecord::Base
+  has_many :comments
+
+  def comment_authors
+    comments.map(&:author).join(" ")
+  end
+
+  def comment_contents
+    comments.map(&:content).join(" ")
+  end
+
+  def comment_dates
+    comments.map(&:date).join(" ")
+  end
+
+  def comment_signatures
+    comments.map(&:signature).join(" ")
+  end
+
+  acts_as_method_cacheable :methods => [:comment_authors, :comment_contents]
+end
+
+class Comment < ActiveRecord::Base
+  belongs_to :post
+
+  def signature
+    sub_signature
+  end
+
+  def sub_signature
+    "cool!"
+  end
+
+  acts_as_method_cacheable
+end
+
+describe ActsAsMethodCacheable do
+
+  before(:each) do
+    @post = Post.create!(:title => 'test', :date => '2013-04-04')
+    @post.comments.create!(:content => 'ct1', :author => 'ben', :date => '2013-04-05')
+    @post.comments.create!(:content => 'ct2', :author => 'feng', :date => '2013-04-06')
+    @comment1, @comment2 = @post.comments.to_a
+  end
+
+  context "class" do
+    it "should return the same result as without cache" do
+      @post.comment_authors.should == @comment1.author + " " + @comment2.author
+      @post.comment_authors.should == @comment1.author + " " + @comment2.author
+    end
+
+    it "should return the correct result for multiple cache_method" do
+      @post.comment_authors.should == @comment1.author + " " + @comment2.author
+      @post.comment_authors.should == @comment1.author + " " + @comment2.author
+      @post.comment_contents.should == @comment1.content + " " + @comment2.content
+      @post.comment_contents.should == @comment1.content + " " + @comment2.content
+    end
+
+    it "should cache method for a class" do
+      @comment1.expects(:author).once
+      @post.comment_authors
+      @comment1.expects(:author).never
+      @post.comment_authors
+    end
+
+    it "should clear cache when reload" do
+      @post.comment_authors
+      @post.reload
+      @comment1 = @post.comments.to_a.first
+      @comment1.expects(:author).once
+      @post.comment_authors
+    end
+
+    it "should raise exception when trying to cache a non-existing method" do
+      expect {
+        Post.class_eval do
+          acts_as_method_cacheable :methods => [:not_exist_method]
+        end
+      }.to raise_error(Exception, "not_exist_method not defined in class Post")
+    end
+
+    it "should raise exception when trying to cache a method with params" do
+      expect {
+        Post.class_eval do
+          def method_with_params(a, b)
+            a + b
+          end
+          acts_as_method_cacheable :methods => :method_with_params
+        end
+      }.to raise_error(Exception, "method with params is not supported by acts_as_method_cacheable yet!")
+    end
+  end
+
+  context "instance" do
+    def assert_for_no_cache_case
+      post = Post.find(@post.id)
+      comment1 = post.comments.to_a.first
+
+      post.comment_dates
+      comment1.expects(:date).once
+      post.comment_dates
+
+      post.comment_signatures
+      comment1.expects(:sub_signature).once
+      post.comment_signatures
+    end
+
+    it "should return the same result as not cache" do
+      post1 = Post.find(@post.id)
+      post1.cache_method(:comment_dates)
+      post2 = Post.find(@post.id)
+      post1.comment_dates.should == post2.comment_dates
+
+      post1 = Post.find(@post.id)
+      post1.cache_method({:comments => :signature})
+      post2 = Post.find(@post.id)
+      post1.comment_signatures.should == post2.comment_signatures
+    end
+
+    it "should cache specific method for a instance" do
+      post = Post.find(@post.id)
+      post.cache_method(:comment_dates)
+
+      comment1, comment2 = post.comments.to_a
+      comment1.expects(:date).once
+      post.comment_dates
+      comment1.expects(:date).never
+      post.comment_dates
+
+      assert_for_no_cache_case
+    end
+
+    it "should cache methods for a instances and its children instances" do
+      post = Post.find(@post.id)
+      post.cache_method([:comment_dates, {:comments => :signature}])
+
+      comment1 = post.comments.to_a.first
+
+      comment1.expects(:date).once
+      post.comment_dates
+      comment1.expects(:date).never
+      post.comment_dates
+
+      comment1.expects(:sub_signature).once
+      post.comment_signatures
+      comment1.expects(:sub_signature).never
+      post.comment_signatures
+
+      assert_for_no_cache_case
+    end
+
+    it "should clear cached after reload" do
+      post = Post.find(@post.id)
+      post.cache_method([:comment_dates, {:comments => :signature}])
+
+      comment1, comment2 = post.comments.to_a
+
+      comment1.expects(:date).once
+      post.comment_dates
+
+      comment1.expects(:sub_signature).once
+      post.comment_signatures
+
+      post.reload
+      comment1, comment2 = post.comments.to_a
+
+      comment1.expects(:date).once
+      post.comment_dates
+
+      comment1.expects(:sub_signature).once
+      post.comment_signatures
+    end
+
+    it "should raise exception when trying to cache a non-existing method" do
+      expect {
+        post = Post.find(@post.id)
+        post.cache_method :not_exist_method
+      }.to raise_error(Exception, "not_exist_method not defined in class Post")
+    end
+
+    it "should raise exception when trying to cache a method with params" do
+      expect {
+        Post.class_eval do
+          def method_with_params(a, b)
+            a + b
+          end
+        end
+        post = Post.find(@post.id)
+        post.cache_method(:method_with_params)
+      }.to raise_error(Exception, "method with params is not supported by acts_as_method_cacheable yet!")
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+require 'active_support'
+require 'active_record'
+require 'sqlite3'
+require 'pry'
+
+ActiveRecord::Base.configurations = YAML::load(IO.read('db/database.yml'))
+ActiveRecord::Base.establish_connection('development')
+
+RSpec.configure do |config|
+  # == Mock Framework
+  # If you prefer to use mocha, flexmock or RR, uncomment the appropriate line:
+  config.mock_with :mocha
+end

metadata

@@ -0,0 +1,199 @@
+--- !ruby/object:Gem::Specification
+name: acts_as_method_cacheable
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ben Cao
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 10.0.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 10.0.4
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.13.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.13.0
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.13.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.13.3
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.7
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.7
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-theme
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-nav
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.13
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.13
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.13
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.13
+description: Make cache methods on ActiveRecord easy!
+email:
+- benb88@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- acts_as_method_cacheable.gemspec
+- db/database.yml
+- lib/acts_as_method_cacheable.rb
+- lib/acts_as_method_cacheable/version.rb
+- spec/acts_as_method_cacheable_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/bencao/acts_as_method_cacheable
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.0.rc.2
+signing_key: 
+specification_version: 4
+summary: Instead of writing def expensive { @cached_expensive ||= original_expensive
+  }, now you can write instance.cache_method(:expensive) instead. Also support nested
+  cache method for associations.
+test_files:
+- spec/acts_as_method_cacheable_spec.rb
+- spec/spec_helper.rb