tiny_cache 0.0.1 → 0.0.3

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright 2012 YOURNAME
+Copyright 2013 YOURNAME
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

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

@@ -4,37 +4,22 @@ begin
 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
-
-APP_RAKEFILE = File.expand_path("../test/dummy/Rakefile", __FILE__)
-load 'rails/tasks/engine.rake'
-
 
+#  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
 
-require 'rake/testtask'
-
-Rake::TestTask.new(:test) do |t|
-  t.libs << 'lib'
-  t.libs << 'test'
-  t.pattern = 'test/**/*_test.rb'
-  t.verbose = false
-end
-
-
-task :default => :test

data/lib/tiny_cache.rb

@@ -1,4 +1,17 @@
-require "tiny_cache/engine"
+# -*- 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,18 @@
+# -*- 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"
+require "#{File.dirname(__FILE__)}/active_record/has_many_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)
+  ::ActiveRecord::Associations::HasManyAssociation.send(:include,   ::TinyCache::ActiveRecord::Associations::HasManyAssociation)
+end

data/lib/tiny_cache/active_record/base.rb

@@ -0,0 +1,133 @@
+# -*- 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
+        attr_reader :tiny_cache_options
+
+        def acts_as_tiny_cached(*args)
+          options = args.extract_options!
+
+          @tiny_cache_enabled = true
+          @tiny_cache_options = options
+          @tiny_cache_options[:expires_in] ||= 1.week
+          @tiny_cache_options[:version] ||= 0
+
+          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[: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
+          options = 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 write_tiny_cache
+          if self.class.tiny_cache_enabled?
+            ::TinyCache.cache_store.write(
+              self.tiny_cache_key, RecordMarshal.dump(self), :expires_in => self.class.tiny_cache_options[: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,39 @@
+# -*- encoding : utf-8 -*-
+module TinyCache
+  module ActiveRecord
+    module FetchByUniqKey
+      #
+      # 用来根据属性进行查询缓存, 一般适合是唯一不变的条件
+      # 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