tiny-cache 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 320a7a13dd6a13cf07103041f4ab468605f7cdd3
+  data.tar.gz: 151040bfb1a27e8954f36d58edf902bc85a62476
+SHA512:
+  metadata.gz: 86800300e15d55916da1a4bdc52ad6de322c0f3030c2a27f00291d8320ceee3f73eb7ef4d011147cb46f5d2f183f2f091c223d083d2ccbb79b58ec29d6531e8f
+  data.tar.gz: 28b0f0586dde4caef37f59c44900ac7d1bb1c692c99d806bfc1a63a50d179c37fb4d09523dae348d9fc42c9484cb34c8c0416e8b1426ae18a36561fec73904b1

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2013 YOURNAME
+
+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,32 @@
+# Tiny Cache
+
+## for Rails3+ model cache
+
+## 使用方法 usage:
+
+* config
+  config/initializers 下新建 tiny_cache.rb
+
+```
+  # -*- encoding : utf-8 -*-
+  TinyCache.configure do |config|
+    config.cache_store = ::Rails.cache
+  end
+```
+
+* 在model 中调用
+```
+module Ruby800
+  class Board < ActiveRecord::Base
+
+    self.acts_as_tiny_cached
+    
+    # self.acts_as_tiny_cached :version => 2, :expires_in => 2.weeks
+
+  end
+end
+```
+
+* 生成的实例方法
+...
+

data/Rakefile

@@ -0,0 +1,25 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+#  begin
+#    require 'rdoc/task'
+#  rescue LoadError
+#    require 'rdoc/rdoc'
+#    require 'rake/rdoctask'
+#    RDoc::Task = Rake::RDocTask
+#  end
+#  
+#  RDoc::Task.new(:rdoc) do |rdoc|
+#    rdoc.rdoc_dir = 'rdoc'
+#    rdoc.title    = 'TinyCache'
+#    rdoc.options << '--line-numbers'
+#    rdoc.rdoc_files.include('README.rdoc')
+#    rdoc.rdoc_files.include('lib/**/*.rb')
+#  end
+
+Bundler::GemHelper.install_tasks
+

data/lib/tasks/tiny_cache_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :tiny_cache do
+#   # Task goes here
+# end

data/lib/tiny-cache.rb

@@ -0,0 +1 @@
+require 'tiny_cache'

data/lib/tiny_cache.rb

@@ -0,0 +1,17 @@
+# -*- encoding : utf-8 -*-
+require 'active_support/all'
+require 'tiny_cache/config'
+require 'tiny_cache/record_marshal'
+
+module TinyCache
+  def self.configure
+    block_given? ? yield(Config) : Config
+  end
+
+  class << self
+    delegate :logger, :cache_store, :cache_key_prefix, :to => Config
+  end
+
+end
+
+require 'tiny_cache/active_record' if defined?(::ActiveRecord)

data/lib/tiny_cache/active_record.rb

@@ -0,0 +1,16 @@
+# -*- encoding : utf-8 -*-
+require "#{File.dirname(__FILE__)}/active_record/base"
+require "#{File.dirname(__FILE__)}/active_record/fetch_by_uniq_key"
+require "#{File.dirname(__FILE__)}/active_record/finder_methods"
+require "#{File.dirname(__FILE__)}/active_record/persistence"
+require "#{File.dirname(__FILE__)}/active_record/belongs_to_association"
+require "#{File.dirname(__FILE__)}/active_record/has_one_association"
+
+if defined?(ActiveRecord::Base)
+  ::ActiveRecord::Base.send(:include,                               ::TinyCache::ActiveRecord::Base)
+  ::ActiveRecord::Base.send(:extend,                                ::TinyCache::ActiveRecord::FetchByUniqKey)
+  ::ActiveRecord::Relation.send(:include,                           ::TinyCache::ActiveRecord::FinderMethods)
+  ::ActiveRecord::Base.send(:include,                               ::TinyCache::ActiveRecord::Persistence)
+  ::ActiveRecord::Associations::BelongsToAssociation.send(:include, ::TinyCache::ActiveRecord::Associations::BelongsToAssociation)
+  ::ActiveRecord::Associations::HasOneAssociation.send(:include,    ::TinyCache::ActiveRecord::Associations::HasOneAssociation)
+end

data/lib/tiny_cache/active_record/base.rb

@@ -0,0 +1,147 @@
+# -*- encoding : utf-8 -*-
+module TinyCache
+  module ActiveRecord
+    module Base
+
+      def self.included base
+        base.class_eval do
+          include ::ActiveSupport::Concern
+
+          extend ClassMethods
+          include InstanceMethods
+
+          class << self
+            alias_method_chain :update_counters, :tiny_cache
+          end
+        end
+      end
+
+      module ClassMethods
+        def tiny_cache_options
+          @tiny_cache_options ||= {
+            :expires_in => 1.week,
+            :version    => 0
+          }
+        end
+
+        def acts_as_tiny_cached(*args)
+          options = args.extract_options!
+
+          @tiny_cache_enabled = true
+
+          if options.key?(:expires_in)
+            self.tiny_cache_options[:expires_in] = options[:expires_in]
+          end
+
+          if options.key?(:version)
+            self.tiny_cache_options[:version] = options[:version]
+          end
+
+          after_commit :expire_tiny_cache, :on => :destroy
+          after_commit :update_tiny_cache, :on => :update
+          after_commit :write_tiny_cache,  :on => :create
+        end
+
+        def update_counters_with_tiny_cache(id, counters)
+          update_counters_without_tiny_cache(id, counters).tap do
+            Array(id).each{|i| expire_tiny_cache(i)}
+          end
+        end
+
+        # 是否启用cache
+        def tiny_cache_enabled?
+          !!@tiny_cache_enabled
+        end
+
+        # 不启用cache
+        def without_tiny_cache
+          old, @tiny_cache_enabled = @tiny_cache_enabled, false
+
+          yield if block_given?
+        ensure
+          @tiny_cache_enabled = old
+        end
+
+        def cache_store
+          ::TinyCache::Config.cache_store
+        end
+
+        def logger
+          ::TinyCache::Config.logger
+        end
+
+        def tiny_cache_key_prefix
+          ::TinyCache::Config.cache_key_prefix
+        end
+
+        def tiny_cache_version
+          tiny_cache_options ? tiny_cache_options[:version] : ''
+        end
+
+        def tiny_cache_key(id)
+          "#{tiny_cache_key_prefix}/models/#{self.name}/#{id}/#{tiny_cache_version}"
+        end
+
+        def read_tiny_cache(id)
+          RecordMarshal.load(TinyCache.cache_store.read(tiny_cache_key(id))) if self.tiny_cache_enabled?
+        end
+
+        def expire_tiny_cache(id)
+          TinyCache.cache_store.delete(tiny_cache_key(id)) if self.tiny_cache_enabled?
+        end
+
+      end
+
+      module InstanceMethods
+        def try_load_from_tiny_cache
+          self.class.read_tiny_cache(self.id) || self
+        end
+
+        # 缓存的key
+        def tiny_cache_key
+          self.class.tiny_cache_key(self.id)
+        end
+
+        def expire_tiny_cache
+          self.class.expire_tiny_cache(self.id)
+        end
+
+        def tiny_cache_method_fetch *args, &block
+          options = args.extract_options!
+
+          self.class.cache_store.fetch self.tiny_cache_method_key(args), options do
+            block.call
+          end
+        end
+
+        def tiny_cache_method_expire *args
+          args.extract_options!
+
+          self.class.cache_store.delete self.tiny_cache_method_key(args)
+        end
+
+        def tiny_cache_method_key args
+          "#{self.tiny_cache_key}/method_fetch/#{args.join('/')}"
+        end
+
+        def refresh_tiny_cache_updated_at
+          self.updated_at = Time.now
+        end
+
+        def tiny_cache_expires_in
+          self.class.tiny_cache_options[:expires_in]
+        end
+
+        def write_tiny_cache
+          if self.class.tiny_cache_enabled?
+            ::TinyCache.cache_store.write(
+              self.tiny_cache_key, RecordMarshal.dump(self), :expires_in => tiny_cache_expires_in
+            )
+          end
+        end
+
+        alias update_tiny_cache write_tiny_cache
+      end
+    end
+  end
+end

data/lib/tiny_cache/active_record/belongs_to_association.rb

@@ -0,0 +1,37 @@
+# -*- encoding : utf-8 -*-
+module TinyCache
+  module ActiveRecord
+    module Associations
+      module BelongsToAssociation
+        extend ActiveSupport::Concern
+        included do
+          class_eval do
+            alias_method_chain :find_target, :tiny_cache
+          end
+        end
+
+        def association_class
+          @reflection.klass
+        end
+
+        def find_target_with_tiny_cache
+          return find_target_without_tiny_cache unless klass.tiny_cache_enabled?
+          cache_record = klass.read_tiny_cache(tiny_cache_key)
+          return cache_record.tap{|record| set_inverse_instance(record)} if cache_record
+          record = find_target_without_tiny_cache
+
+          record.tap do |r|
+            set_inverse_instance(r)
+            r.write_tiny_cache
+          end if record
+        end
+
+        private
+
+        def tiny_cache_key
+          owner[reflection.foreign_key]
+        end
+      end
+    end
+  end
+end

data/lib/tiny_cache/active_record/fetch_by_uniq_key.rb

@@ -0,0 +1,54 @@
+# -*- encoding : utf-8 -*-
+module TinyCache
+  module ActiveRecord
+    module FetchByUniqKey
+      def tiny_cache_find_by_id id
+        begin
+          record = read_tiny_cache(id)
+          record = self.find_by_id(id) if record.nil?
+          record.write_tiny_cache if record
+          record
+        ensure ::ActiveRecord::RecordNotFound
+          nil
+        end
+      end
+
+      def tiny_cache_find_by_id! id
+        tiny_cache_find_by_id(id) || raise(::ActiveRecord::RecordNotFound)
+      end
+
+      #
+      # 用来根据属性进行查询缓存, 一般适合是唯一不变的条件
+      # eg:
+      #   1. topic.tiny_cache_find_by :uid => 1, :category_id => 2
+      #
+      def tiny_cache_find_by conditions={}
+        uniq_cache_key = tiny_cache_uniq_key(conditions)
+
+        # 根据cache_key获取id
+        if iid = TinyCache.cache_store.read(uniq_cache_key)
+          begin
+            self.find iid
+          ensure ::ActiveRecord::RecordNotFound
+            nil
+          end
+        else
+          record = self.where(conditions).first
+          record.tap do |record|
+            TinyCache.cache_store.write(uniq_cache_key, record.id)
+          end if record
+        end
+      end
+
+      def tiny_cache_find_by! conditions={}
+        tiny_cache_find_by(conditions) || raise(::ActiveRecord::RecordNotFound)
+      end
+
+      private
+
+      def tiny_cache_uniq_key conditions={}
+        "#{::TinyCache::Config.cache_key_prefix}/model_uniq_keys/#{self.name}/#{conditions.sort.inspect}"
+      end
+    end
+  end
+end

data/lib/tiny_cache/active_record/finder_methods.rb

@@ -0,0 +1,132 @@
+# -*- encoding : utf-8 -*-
+require "#{File.dirname(__FILE__)}/../arel/wheres"
+
+module TinyCache
+  module ActiveRecord
+    module FinderMethods
+      extend ActiveSupport::Concern
+
+      included do
+        class_eval do
+          alias_method_chain :find_one, :tiny_cache
+          alias_method_chain :find_by_attributes, :tiny_cache
+        end
+      end
+
+      # TODO:
+      def find_by_attributes(match, attributes, *args)
+        conditions = Hash[attributes.map {|a| [a, args[attributes.index(a)]]}]
+        result = where(conditions).send(match.finder)
+
+        if match.bang? && result.nil?
+          raise RecordNotFound, "Couldn't find #{@klass.name} with #{conditions.to_a.collect {|p| p.join(' = ')}.join(', ')}"
+        else
+          yield(result) if block_given?
+          result
+        end
+      end
+
+      # TODO fetch multi ids
+      #
+      # Cacheable:
+      #
+      #     current_user.articles.where(:status => 1).visiable.find(params[:id])
+      #
+      # Uncacheable:
+      #
+      #     Article.where("user_id = '1'").find(params[:id])
+      #     Article.where("user_id > 1").find(params[:id])
+      #     Article.where("articles.user_id = 1").find(prams[:id])
+      #     Article.where("user_id = 1 AND ...").find(params[:id])
+      def find_one_with_tiny_cache(id)
+        return find_one_without_tiny_cache(id) unless tiny_cache_enabled?
+        return find_one_without_tiny_cache(id) unless select_all_column?
+
+        id = id.id if ActiveRecord::Base === id
+
+        # if ::ActiveRecord::IdentityMap.enabled? && cachable? && record = from_identity_map(id)
+        #   return record
+        # end
+
+        if cachable?
+          if record = @klass.read_tiny_cache(id)
+            return record 
+          end
+        end
+
+        if cachable_without_conditions?
+          if record = @klass.read_tiny_cache(id)
+            return record if where_match_with_cache?(where_values, record)
+          end
+        end
+
+        record = find_one_without_tiny_cache(id)
+        record.write_tiny_cache
+        record
+      end
+
+      # TODO cache find_or_create_by_id
+      def find_by_attributes_with_tiny_cache(match, attributes, *args)
+        return find_by_attributes_without_tiny_cache(match, attributes, *args) unless tiny_cache_enabled?
+        return find_by_attributes_without_tiny_cache(match, attributes, *args) unless select_all_column?
+
+        conditions = Hash[attributes.map {|a| [a, args[attributes.index(a)]]}]
+
+        if conditions.has_key?("id")
+          result = wrap_bang(match.bang?) do
+            if conditions.size == 1
+              find_one_with_tiny_cache(conditions["id"])
+            else
+              where(conditions.except("id")).find_one_with_tiny_cache(conditions["id"])
+            end
+          end
+
+          yield(result) if block_given? #edge rails do this bug rails3.1.0 not
+
+          return result
+        end
+
+        find_by_attributes_without_tiny_cache(match, attributes, *args)
+      end
+
+      private
+
+      def wrap_bang(bang)
+        bang ? yield : (yield rescue nil)
+      end
+
+      def cachable?
+        where_values.blank? &&
+          limit_one? && order_values.blank? &&
+          includes_values.blank? && preload_values.blank? &&
+          readonly_value.nil? && joins_values.blank? && !@klass.locking_enabled?
+      end
+
+      def cachable_without_conditions?
+        limit_one? && order_values.blank? &&
+          includes_values.blank? && preload_values.blank? &&
+          readonly_value.nil? && joins_values.blank? && !@klass.locking_enabled?
+      end
+
+      def where_match_with_cache?(where_values, cache_record)
+        condition = TinyCache::Arel::Wheres.new(where_values)
+        return false unless condition.all_equality?
+        condition.extract_pairs.all? do |pair|
+          cache_record.read_attribute(pair[:left]) == pair[:right]
+        end
+      end
+
+      def limit_one?
+        limit_value.blank? || limit_value == 1
+      end
+
+      def select_all_column?
+        select_values.blank?
+      end
+
+      # def from_identity_map(id)
+      #   ::ActiveRecord::IdentityMap.get(@klass, id)
+      # end
+    end
+  end
+end