sequel-cacheable 0.0.7 → 1.0.0

data/lib/sequel-cacheable.rb

@@ -1,223 +1,30 @@
 require 'sequel'
-require 'hashr'
 require 'msgpack'
 
+require 'sequel-cacheable/version'
+require 'sequel-cacheable/packer'
+require 'sequel-cacheable/driver'
+require 'sequel-cacheable/class_methods'
+require 'sequel-cacheable/instance_methods'
+require 'sequel-cacheable/dataset_methods'
+
 module Sequel::Plugins
   module Cacheable
     def self.configure(model, store, options = {})
       model.instance_eval do
-        @cache_store = store
-        @cache_store_type = Hashr.new({
-          :set_with_ttl => store.respond_to?(:set) ? store.method(:set).arity != 2 : false,
-          :delete_method => (
-            (store.respond_to?(:del) && :del) ||
-            (store.respond_to?(:delete) && :delete) ||
-            (raise NoMethodError, "#{store.class} is not implemented delete method")
-          )
-        })
-        @cache_options = Hashr.new(options, {
+        @cache_options = {
           :ttl => 3600,
-          :ignore_exception => false,
           :pack_lib => MessagePack,
-          :query_cache => store.respond_to?(:keys)
-        })
-      end
-    end
-
-    module ClassMethods
-      attr_reader :cache_store
-      attr_reader :cache_store_type
-      attr_reader :cache_options
-      
-      def inherited(subclass)
-        super
-        cache = [@cache_store, @cache_store_type, @cache_options]
-        subclass.instance_eval do
-          @cache_store = cache[0]
-          @cache_store_type = cache[1]
-          @cache_options = cache[2]
-        end
-      end
-
-      def cache_set(key, obj, ttl = nil)
-        return obj if obj.nil?
-
-        ttl = ttl || cache_options.ttl
-        if cache_options.pack_lib?
-          obj = obj.map{|o| o.id } if obj.kind_of?(Array)
-          obj = cache_options.pack_lib.pack(obj)
-        end
-
-        args = [key, obj]
-        args << ttl if cache_store_type.set_with_ttl?
-        cache_store.set(*args)
-        unless cache_store_type.set_with_ttl?
-          cache_store.expire(key, ttl)
-        end
-      end
-
-      def cache_get(key)
-        if cache_options.ignore_exceptions?
-          obj = cache_store.get(key) rescue nil
-        else
-          obj = cache_store.get(key)
-        end
-
-        if obj && cache_options.pack_lib?
-          obj = restore_cache(cache_options.pack_lib.unpack(obj))
-        end
-
-        obj
-      end
-
-      def cache_mget(*keys)
-        if cache_options.ignore_exceptions?
-          objs = cache_store.mget(*keys) rescue nil
-        else
-          objs = cache_store.mget(*keys)
-        end
-
-        if objs && cache_options.pack_lib?
-          objs.map!{|obj| 
-            key = keys.shift
-            (obj && restore_cache(cache_options.pack_lib.unpack(obj))) ||
-              model[key.sub(/^#{model}::/, '')]
-          }
-        end
-
-        objs || []
-      end
-
-      def cache_del(key)
-        cache_store.send(cache_store_type.delete_method, key)
-      end
-
-      def cache_set_get(key, ttl = nil)
-        if (val = cache_get(key)).nil?
-          val = yield
-          cache_set(key, val, ttl)
-        end
-        val
-      end
-
-      def restore_cache(object)
-        return object if object.nil?
-
-        return cache_mget(*object.map{|id| "#{model}::#{id}" }) if object.kind_of?(Array)
-
-        object.keys.each do | key |
-          value = object.delete(key)
-          key = key.to_sym rescue key
-          case db_schema[key][:type]
-          when :date
-            value = Date.new(*value)
-          when :time
-            value = Sequel::SQLTime.at(value[0], value[1])
-          when :datetime
-            value = Time.at(value[0], value[1])
-          when :decimal
-            value = BigDecimal.new(value)
-          when :integer
-            value = value.to_i
-          end
-          object[key] = value
-        end
-        new(object, true)
-      end
-
-      def clear_query_cache
-        return unless cache_options.query_cache?
-        cache_store.keys("#{model.name}::Query::*").each do | key |
-          cache_del(key)
-        end
-      end
-
-      def primary_key_lookup(key)
-        cache_set_get("#{model}::#{key}") do
-          super(key)
-        end
-      end
-    end
-
-    module InstanceMethods
-      def msgpack_hash
-        hash = {}
-        @values.each_pair do | key, value |
-          case value
-          when Date
-            value = [value.year, value.mon, value.mday, value.start]
-          when Sequel::SQLTime, Time
-            value = [value.to_i, value.usec]
-          when BigDecimal, Bignum
-            value = value.to_s
-          end
-          hash[key] = value
-        end
-        hash
-      end
-
-      def to_msgpack(*args)
-        msgpack_hash.to_msgpack
-      end
-
-      def after_initialize
-        store_cache unless id.nil?
-        super
-      end
-
-      def after_update
-        restore_cache
-        super
-      end
-
-      def delete
-        delete_cache
-        super
-      end
-
-      def destroy(*args)
-        delete_cache
-        super(*args)
-      end
-
-      def store_cache
-        model.cache_set(cache_key, self)
-      end
-
-      def delete_cache
-        model.cache_del(cache_key)
-        model.clear_query_cache
-      end
-
-      def restore_cache
-        delete_cache
-        store_cache
-      end
-
-      def cache_key
-        "#{self.class.name}::#{self.id.to_s}"
-      end
-    end
-
-    module DatasetMethods
-      def all(*args)
-        if model.cache_options.query_cache? && @row_proc.kind_of?(Class) && @row_proc.included_modules.include?(Sequel::Model::InstanceMethods)
-          @row_proc.cache_set_get(query_to_cache_key) { super(*args) }
-        else
-          super(*args)
-        end
-      end
-
-      def first(*args)
-        if model.cache_options.query_cache? && @row_proc.kind_of?(Class) && @row_proc.included_modules.include?(Sequel::Model::InstanceMethods)
-          @row_proc.cache_set_get(query_to_cache_key) { super(*args) }
-        else
-          super(*args)
-        end
-      end
-
-      def query_to_cache_key
-        model.name + '::Query::' + select_sql.gsub(/ /, '_')
+          :query_cache => false
+        }.merge(options)
+        @cache_driver = Driver.factory(
+          store,
+          Packer.factory(@cache_options[:pack_lib])
+        )
+        @caches = {
+          :instance => [],
+          :query => []
+        }
       end
     end
   end

data/sequel-cacheable.gemspec

@@ -1,98 +1,22 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
-# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'sequel-cacheable/version'
 
-Gem::Specification.new do |s|
-  s.name = "sequel-cacheable"
-  s.version = "0.0.7"
+Gem::Specification.new do |gem|
+  gem.name          = "sequel-cacheable"
+  gem.version       = Sequel::Plugins::Cacheable::VERSION
+  gem.authors       = ["Sho Kusano"]
+  gem.email         = ["rosylilly@aduca.org"]
+  gem.description   = %q{This plug-in caching mechanism to implement the Model of the Sequel}
+  gem.summary       = %q{This plug-in caching mechanism to implement the Model of the Sequel}
+  gem.homepage      = "https://github.com/rosylilly/sequel-cacheable"
+  gem.license       = "MIT"
 
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Sho Kusano <rosylilly>"]
-  s.date = "2012-05-01"
-  s.description = "This plug-in caching mechanism to implement the Model of the Sequel"
-  s.email = "rosylilly@aduca.org"
-  s.extra_rdoc_files = [
-    "LICENSE.txt",
-    "README.rdoc"
-  ]
-  s.files = [
-    ".document",
-    ".rspec",
-    ".travis.yml",
-    "Gemfile",
-    "Gemfile.lock",
-    "Guardfile",
-    "LICENSE.txt",
-    "README.rdoc",
-    "Rakefile",
-    "VERSION",
-    "lib/sequel-cacheable.rb",
-    "sequel-cacheable.gemspec",
-    "spec/lib/sequel-cacheable_spec.rb",
-    "spec/spec_helper.rb"
-  ]
-  s.homepage = "http://github.com/rosylilly/sequel-cacheable"
-  s.licenses = ["MIT"]
-  s.require_paths = ["lib"]
-  s.rubygems_version = "1.8.22"
-  s.summary = "This plug-in caching mechanism to implement the Model of the Sequel"
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
 
-  if s.respond_to? :specification_version then
-    s.specification_version = 3
-
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<sequel>, ["~> 3.34"])
-      s.add_runtime_dependency(%q<msgpack>, ["~> 0.4.6"])
-      s.add_runtime_dependency(%q<hashr>, ["~> 0.0.19"])
-      s.add_development_dependency(%q<bundler>, [">= 1.0.0"])
-      s.add_development_dependency(%q<rspec>, ["~> 2"])
-      s.add_development_dependency(%q<yard>, ["~> 0.7"])
-      s.add_development_dependency(%q<rdoc>, ["~> 3.12"])
-      s.add_development_dependency(%q<jeweler>, ["~> 1.8.3"])
-      s.add_development_dependency(%q<simplecov>, ["~> 0.6.1"])
-      s.add_development_dependency(%q<guard>, ["~> 1.0.0"])
-      s.add_development_dependency(%q<guard-rspec>, ["~> 0.7"])
-      s.add_development_dependency(%q<growl>, [">= 0"])
-      s.add_development_dependency(%q<sqlite3>, [">= 0"])
-      s.add_development_dependency(%q<memcache>, [">= 0"])
-      s.add_development_dependency(%q<redis>, [">= 0"])
-      s.add_development_dependency(%q<queencheck>, [">= 0"])
-    else
-      s.add_dependency(%q<sequel>, ["~> 3.34"])
-      s.add_dependency(%q<msgpack>, ["~> 0.4.6"])
-      s.add_dependency(%q<hashr>, ["~> 0.0.19"])
-      s.add_dependency(%q<bundler>, [">= 1.0.0"])
-      s.add_dependency(%q<rspec>, ["~> 2"])
-      s.add_dependency(%q<yard>, ["~> 0.7"])
-      s.add_dependency(%q<rdoc>, ["~> 3.12"])
-      s.add_dependency(%q<jeweler>, ["~> 1.8.3"])
-      s.add_dependency(%q<simplecov>, ["~> 0.6.1"])
-      s.add_dependency(%q<guard>, ["~> 1.0.0"])
-      s.add_dependency(%q<guard-rspec>, ["~> 0.7"])
-      s.add_dependency(%q<growl>, [">= 0"])
-      s.add_dependency(%q<sqlite3>, [">= 0"])
-      s.add_dependency(%q<memcache>, [">= 0"])
-      s.add_dependency(%q<redis>, [">= 0"])
-      s.add_dependency(%q<queencheck>, [">= 0"])
-    end
-  else
-    s.add_dependency(%q<sequel>, ["~> 3.34"])
-    s.add_dependency(%q<msgpack>, ["~> 0.4.6"])
-    s.add_dependency(%q<hashr>, ["~> 0.0.19"])
-    s.add_dependency(%q<bundler>, [">= 1.0.0"])
-    s.add_dependency(%q<rspec>, ["~> 2"])
-    s.add_dependency(%q<yard>, ["~> 0.7"])
-    s.add_dependency(%q<rdoc>, ["~> 3.12"])
-    s.add_dependency(%q<jeweler>, ["~> 1.8.3"])
-    s.add_dependency(%q<simplecov>, ["~> 0.6.1"])
-    s.add_dependency(%q<guard>, ["~> 1.0.0"])
-    s.add_dependency(%q<guard-rspec>, ["~> 0.7"])
-    s.add_dependency(%q<growl>, [">= 0"])
-    s.add_dependency(%q<sqlite3>, [">= 0"])
-    s.add_dependency(%q<memcache>, [">= 0"])
-    s.add_dependency(%q<redis>, [">= 0"])
-    s.add_dependency(%q<queencheck>, [">= 0"])
-  end
+  gem.add_dependency 'sequel', '~> 3.42'
+  gem.add_dependency 'msgpack', '~> 0.5.1'
 end
-

data/spec/lib/sequel-cacheable/driver/dalli_driver_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe Sequel::Plugins::Cacheable::DalliDriver do
+  let(:store) { DalliCli }
+
+  include_examples :driver
+end
+

data/spec/lib/sequel-cacheable/driver/memcache_driver_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe Sequel::Plugins::Cacheable::MemcacheDriver do
+  let(:store) { MemcacheCli }
+
+  include_examples :driver
+end

data/spec/lib/sequel-cacheable/driver/redis_driver_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe Sequel::Plugins::Cacheable::RedisDriver do
+  let(:store) { RedisCli }
+
+  include_examples :driver
+end
+

data/spec/lib/sequel-cacheable/driver_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe Sequel::Plugins::Cacheable::Driver do
+  let(:store) { RedisCli }
+
+  include_examples :driver
+
+  describe '.factory' do
+    subject { described_class.factory(store) }
+
+    context 'when Memcache' do
+      let(:store) { MemcacheCli }
+
+      it { should be_a(Sequel::Plugins::Cacheable::MemcacheDriver) }
+    end
+
+    context 'when Dalli' do
+      let(:store) { DalliCli }
+
+      it { should be_a(Sequel::Plugins::Cacheable::DalliDriver) }
+    end
+
+    context 'when Redis' do
+      let(:store) { RedisCli }
+
+      it { should be_a(Sequel::Plugins::Cacheable::RedisDriver) }
+    end
+
+    context 'when Unkown Store' do
+      let(:store) { mock }
+
+      it { should be_a(Sequel::Plugins::Cacheable::Driver) }
+    end
+  end
+end

data/spec/lib/sequel-cacheable_spec.rb

@@ -1,247 +1,5 @@
 require 'spec_helper'
 
-class RedisModel < Sequel::Model(:spec)
-end
-
-class MemcacheModel < Sequel::Model(:spec)
-  plugin :cacheable, MemcacheCli
-end
-
-QueenCheck::Arbitrary(Float, Fixnum.arbitrary.gen)
-QueenCheck::Arbitrary(String, QueenCheck::Gen.quadratic(200).bind { | length |
-    if length.zero?
-      QueenCheck::Gen.unit("")
-    else
-      QueenCheck::Gen.rand.resize(1, length).fmap { | r |
-        str = []
-        r.times { str << QueenCheck::Alphabet.arbitrary.gen.value(0)[0] }
-        str.join()
-      }
-    end
-  })
-
 describe Sequel::Plugins::Cacheable do
-  QueenCheck("Generate Test Datas",
-  String, Fixnum, Float, Bignum, Boolean) do |string, fixnum, float, bignum, boolean|
-    float = float * 1.0 / (10 ** (rand(4) + 1))
-    RedisModel.create({
-      :string => string,
-      :integer => fixnum,
-      :float => float,
-      :bignum => bignum,
-      :numeric => BigDecimal(float.to_s),
-      :date => Date.today,
-      :datetime => DateTime.now,
-      :time => Time.now,
-      :bool => boolean
-    })
-    true
-  end
-
-  context "NoNameClass" do
-    before {
-      @model = Class.new(Sequel::Model(:rspec))
-    }
-
-    it "should raise NoMethodError if the delete method is not found" do 
-      proc {
-        @model.plugin :cacheable, 1
-      }.should raise_error(NoMethodError)
-    end
-  end
-
-  context MemcacheModel do
-    subject { MemcacheModel }
-
-    its("cache_store") { should == MemcacheCli }
-    its("cache_store_type.set_with_ttl?") { should be_true }
-    its("cache_store_type.delete_method") { should == :delete }
-    its("cache_options.ttl") { should == 3600 }
-    its("cache_options.ignore_exceptions") { should be_false }
-    its("cache_options.pack_lib") { should == MessagePack }
-
-    describe "cache control" do
-      it "set" do
-        MemcacheModel.cache_set('MemcacheModel::test', MemcacheModel[1])
-      end
-
-      it "get" do
-        cache = MemcacheModel.cache_get('MemcacheModel::test')
-        cache.should == MemcacheModel[1]
-      end
-
-      it "del" do
-        MemcacheModel.cache_del('MemcacheModel::test')
-        MemcacheModel.cache_get('MemcacheModel::test').should be_nil
-      end
-    end
-
-    describe "act as cache" do
-      context "Model[40]" do
-        before do
-          @obj = MemcacheModel[40]
-        end
-
-        it "stored cache" do
-          MemcacheModel.cache_get(@obj.cache_key).should == @obj
-        end
-
-        it "restoreble cache data" do
-          cached = MessagePack.unpack(MemcacheCli.get(@obj.cache_key))
-          cached['string'].should == @obj.string
-          Time.at(cached['time'][0], cached['time'][1]).should === @obj.time
-        end
-
-        it "update cache data" do
-          @obj.string = 'modified++'
-          cached = MessagePack.unpack(MemcacheCli.get(@obj.cache_key))
-          cached['string'].should_not == @obj.string
-          @obj.save
-          cached = MessagePack.unpack(MemcacheCli.get(@obj.cache_key))
-          cached['string'].should == @obj.string
-        end
-
-        it "delete cache data" do
-          cache_key = @obj.cache_key; @obj.delete
-          MemcacheCli.get(cache_key).should be_nil
-          MemcacheModel[40].should be_nil
-        end
-
-        it "destroy cache data" do
-          @obj = MemcacheModel[41]
-          cache_key = @obj.cache_key; @obj.destroy
-          MemcacheCli.get(cache_key).should be_nil
-          MemcacheModel[41].should be_nil
-        end
-      end
-    end
-
-    describe "query cache" do
-      it "get" do
-        MemcacheModel.all.should == MemcacheModel.all
-      end
-
-      pending "not supported query cache on Memcache Client"
-    end
-  end
-
-  context RedisModel do
-    subject { RedisModel }
-
-    it "should raise LoadError if the plugin is not found" do
-      proc{ RedisModel.plugin :something_or_other}.should raise_error(LoadError)
-    end
-
-    its("columns") { should == [:id,:string,:integer,:float,:bignum,:numeric,:date,:datetime,:time,:bool] }
-
-    its("plugins") {
-      should_not include(Sequel::Plugins::Cacheable)
-      RedisModel.plugin :cacheable, RedisCli
-      should include(Sequel::Plugins::Cacheable)
-    }
-
-    its("cache_store") { should == RedisCli }
-    its("cache_store_type.set_with_ttl?") { should be_false }
-    its("cache_store_type.delete_method") { should == :del }
-    its("cache_options.ttl") { should == 3600 }
-    its("cache_options.ignore_exceptions") { should be_false }
-    its("cache_options.pack_lib") { should == MessagePack }
-
-    describe "cache control" do
-      it "set" do
-        RedisModel.cache_set('RedisModel::test', RedisModel[1])
-      end
-
-      it "get" do
-        RedisModel.cache_get('RedisModel::test').should == RedisModel[1]
-      end
-
-      it "del" do
-        RedisModel.cache_del('RedisModel::test')
-        RedisModel.cache_get('RedisModel::test').should be_nil
-      end
-    end
-
-    describe "act as cache" do
-      context "Model[50]" do
-        before do
-          @obj = RedisModel[50]
-        end
-
-        it "unstored cache on new" do
-          before_count = RedisCli.keys.length
-          RedisModel.new({:string => 'test'})
-          RedisCli.keys.length.should == before_count
-        end
-
-        it "stored cache" do
-          RedisModel.cache_get(@obj.cache_key).should == @obj
-        end
-
-        it "restoreble cache data" do
-          cached = MessagePack.unpack(RedisCli.get(@obj.cache_key))
-          cached['string'].should == @obj.string
-          Time.at(cached['time'][0], cached['time'][1]).should === @obj.time
-        end
-
-        it "update cache data" do
-          @obj.string = 'modified++'
-          cached = MessagePack.unpack(RedisCli.get(@obj.cache_key))
-          cached['string'].should_not == @obj.string
-          @obj.save
-          cached = MessagePack.unpack(RedisCli.get(@obj.cache_key))
-          cached['string'].should == @obj.string
-        end
-
-        it "delete cache data" do
-          @obj.delete
-          RedisCli.keys(@obj.cache_key).should == []
-          RedisModel[50].should be_nil
-        end
-
-        it "destroy cache data" do
-          @obj = RedisModel[51]
-          @obj.delete
-          RedisCli.keys(@obj.cache_key).should == []
-          RedisModel[51].should be_nil
-        end
-      end
-    end
-
-    describe "query cache" do
-      it "set and get" do
-        RedisModel.clear_query_cache
-        models = RedisModel.limit(3).all
-        cache_key = RedisCli.keys('RedisModel::Query::*')[0]
-        RedisModel.cache_get(cache_key).should == models
-      end
-
-      it "clear on update" do
-        RedisModel.clear_query_cache
-        RedisModel.all
-        cache_key = RedisCli.keys('RedisModel::Query::*')
-        cache_key.should_not be_empty
-        RedisModel[2].save({:string => 'test++'})
-        RedisCli.keys('RedisModel::Query::*').should be_empty
-      end
-
-      it "clear on delete" do
-        RedisModel.clear_query_cache
-        RedisModel.all
-        cache_key = RedisCli.keys('RedisModel::Query::*')
-        cache_key.should_not be_empty
-        RedisModel[2].delete
-        RedisCli.keys('RedisModel::Query::*').should be_empty
-      end
-
-      it "cacheout rescue" do
-        RedisModel.clear_query_cache
-        caches = RedisModel.limit(20).all
-        cache_key = RedisCli.keys('RedisModel::Query::*')[0]
-        cache = caches[rand(caches.length-1)]
-        RedisModel.cache_del(cache.cache_key)
-        RedisModel.cache_get(cache_key).should == caches
-      end
-    end
-  end
+  it { should be_const_defined(:VERSION) }
 end

data/spec/models/dalli_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe DalliModel do
+  it_should_behave_like :cacheable
+end

data/spec/models/memcache_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe MemcacheModel do
+  it_should_behave_like :cacheable
+end

data/spec/models/redis_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe RedisModel do
+  it_should_behave_like :cacheable
+end