sequel-cacheable 0.0.7 → 1.0.0

data/.gitignore

@@ -0,0 +1,53 @@
+# rcov generated
+coverage
+coverage.data
+
+# rdoc generated
+rdoc
+
+# yard generated
+doc
+.yardoc
+
+# bundler
+.bundle
+
+# jeweler generated
+pkg
+
+Gemfile.lock
+dump.rdb
+tmp
+
+# Have editor/IDE/OS specific files you need to ignore? Consider using a global gitignore:
+#
+# * Create a file at ~/.gitignore
+# * Include files you want ignored
+# * Run: git config --global core.excludesfile ~/.gitignore
+#
+# After doing this, these files will be ignored in all your git projects,
+# saving you from having to 'pollute' every project you touch with them
+#
+# Not sure what to needs to be ignored for particular editors/OSes? Here's some ideas to get you started. (Remember, remove the leading # of the line)
+#
+# For MacOS:
+#
+#.DS_Store
+
+# For TextMate
+#*.tmproj
+#tmtags
+
+# For emacs:
+#*~
+#\#*
+#.\#*
+
+# For vim:
+#*.swp
+
+# For redcar:
+#.redcar
+
+# For rubinius:
+#*.rbc

data/.pryrc

@@ -0,0 +1,17 @@
+require 'rubygems'
+require 'bundler'
+Bundler.require(:default, :development)
+
+$: << "#{Dir.pwd}/lib"
+require 'sequel-cacheable'
+
+DB = Sequel.sqlite
+DB.create_table(:mock) do
+  primary_key :id, :auto_increment => true
+  String :name
+end
+
+require 'memcache/null_server'
+class Mock < Sequel::Model(:mock)
+  plugin :cacheable, Redis.new(server: 'localhost:6379'), :query_cache => true
+end

data/.rbenv-version

@@ -0,0 +1 @@
+1.9.3-p327

data/.travis.yml

@@ -1,5 +1,8 @@
+services:
+  - memcached
+  - redis-server
 bundler_args: --without development
-script: bundle exec rake spec
+script: bundle exec rspec
 language: ruby
 rvm:
   - 1.8.7

data/Gemfile

@@ -1,30 +1,28 @@
-source "http://rubygems.org"
-# Add dependencies required to use your gem here.
-# Example:
-#   gem "activesupport", ">= 2.3.5"
+source :rubygems
 
-# Add dependencies to develop your gem here.
-# Include everything needed to run rake, tests, features, etc.
+gem 'bundler'
+gem 'rake'
 
-gem 'sequel', '~> 3.34'
-gem 'msgpack', '~> 0.4.6'
-gem 'hashr', '~> 0.0.19'
+gemspec
 
 group :development, :test do
-  gem "bundler", ">= 1.0.0"
+  gem 'rspec', "~> 2.12.0"
+  gem 'yard', "~> 0.8.3"
+  gem 'rdoc', "~> 3.12"
+  gem 'simplecov', "~> 0.7.1", :require => false
 
-  gem "rspec", "~> 2"
-  gem "yard", "~> 0.7"
-  gem "rdoc", "~> 3.12"
-  gem "jeweler", "~> 1.8.3"
-  gem 'simplecov', "~> 0.6.1", :require => false
+  gem 'guard', '~> 1.6.1'
+  gem 'guard-rspec', '~> 2.3.3'
+  gem 'terminal-notifier'
+  gem 'listen', '~> 0.7.0'
 
-  gem "guard", '~> 1.0.0'
-  gem "guard-rspec", '~> 0.7'
-  gem "growl"
-
-  gem "sqlite3"
-  gem "memcache"
-  gem "redis"
-  gem "queencheck"
+  gem 'sqlite3'
+  gem 'dalli'
+  gem 'memcache'
+  gem 'hiredis'
+  gem 'redis', :require => ['redis', 'redis/connection/hiredis']
+  gem 'pry'
+  gem 'pry-doc'
+  gem 'forgery'
+  gem 'tapp'
 end

data/Procfile

@@ -0,0 +1,2 @@
+memcached: memcached
+redis: redis-server

data/README.rdoc

@@ -23,15 +23,16 @@ Caching!
 tested cache_client:
 
 * Redis[https://rubygems.org/gems/redis]
+* Hiredis[https://rubygems.org/gems/hiredis]
 * Memcached[https://rubygems.org/gems/memcache]
+* Dalli[https://rubygems.org/gems/dalli]
 
 options:
 
   {
     :ttl => 3600, # time to live. default 3600
-    :ignore_exception => false, # through exception. default false
     :pack_lib => MessagePack, # cache packing library. This Object should be have pack / unpack method.
-    :query_cache => false # enable query cache. default true if cache client implemented keys method
+    :query_cache => false # enable query cache. default false
   }
 
 == Cache Timing
@@ -48,7 +49,7 @@ options:
   * clear all query caches of model
 
 == Contributing to sequel-cacheable
- 
+
 * Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
 * Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
 * Fork the project.

data/Rakefile

@@ -1,37 +1,2 @@
 # encoding: utf-8
-
-require 'rubygems'
-require 'bundler'
-begin
-  Bundler.setup(:default, :development)
-rescue Bundler::BundlerError => e
-  $stderr.puts e.message
-  $stderr.puts "Run `bundle install` to install missing gems"
-  exit e.status_code
-end
-require 'rake'
-
-require 'jeweler'
-Jeweler::Tasks.new do |gem|
-  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
-  gem.name = "sequel-cacheable"
-  gem.homepage = "http://github.com/rosylilly/sequel-cacheable"
-  gem.license = "MIT"
-  gem.summary = %Q{This plug-in caching mechanism to implement the Model of the Sequel}
-  gem.description = %Q{This plug-in caching mechanism to implement the Model of the Sequel}
-  gem.email = "rosylilly@aduca.org"
-  gem.authors = ["Sho Kusano <rosylilly>"]
-  # dependencies defined in Gemfile
-end
-Jeweler::RubygemsDotOrgTasks.new
-
-require 'rspec/core'
-require 'rspec/core/rake_task'
-RSpec::Core::RakeTask.new(:spec) do |spec|
-  spec.pattern = FileList['spec/**/*_spec.rb']
-end
-
-task :default => :spec
-
-require 'yard'
-YARD::Rake::YardocTask.new
+require "bundler/gem_tasks"

data/lib/sequel-cacheable/class_methods.rb

@@ -0,0 +1,74 @@
+# coding: utf-8
+
+module Sequel::Plugins
+  module Cacheable
+    module ClassMethods
+      attr_reader :cache_driver, :cache_options, :caches
+
+      def inherited(subclass)
+        super
+      end
+
+      def primary_key_lookup(id)
+        cache_fetch(id.to_s) do
+          super
+        end
+      end
+
+      def restore_by_cache(hash)
+        return nil if hash.nil?
+
+        return hash.map{|hs| restore_by_cache(hs) } if hash.is_a?(Array)
+
+        return hash if hash.kind_of?(Sequel::Model)
+
+        hash.keys.each do | key |
+          value = hash.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
+          hash[key] = value
+        end
+
+        return new(hash, true)
+      end
+
+      def cache_key(key)
+        "#{self.name}:#{key}"
+      end
+
+      def cache_set(key, value, ttl = @cache_options[:ttl])
+        @caches[key.match(/\AQuery:/) ? :query : :instance] << key
+        cache_driver.set(cache_key(key), value, ttl)
+      end
+
+      def cache_get(key)
+        restore_by_cache(cache_driver.get(cache_key(key)))
+      end
+
+      def cache_fetch(key, ttl = @cache_options[:ttl], &block)
+        @caches[key.match(/\AQuery:/) ? :query : :instance] << key
+        cache_driver.fetch(cache_key(key), ttl, &block)
+      end
+
+      def cache_del(key)
+        @caches[key.match(/\AQuery:/) ? :query : :instance].delete(key)
+        cache_driver.del(cache_key(key))
+      end
+
+      def cache_clear(type)
+        @caches[type].dup.each {|key| cache_del(key) }
+      end
+    end
+  end
+end

data/lib/sequel-cacheable/dataset_methods.rb

@@ -0,0 +1,53 @@
+# coding: utf-8
+
+module Sequel::Plugins
+  module Cacheable
+    module DatasetMethods
+      def all(*args, &block)
+        if(
+          model &&
+          model.respond_to?(:cache_fetch) &&
+          model.cache_options[:query_cache] &&
+          @row_proc.kind_of?(Class) &&
+          @row_proc.included_modules.include?(Sequel::Model::InstanceMethods)
+        )
+          @row_proc.cache_fetch(cache_key) do
+            super(*args, &block)
+          end
+        else
+          super(*args, &block)
+        end
+      end
+
+      def first(*args)
+        if(
+          model &&
+          model.respond_to?(:cache_fetch) &&
+          model.cache_options[:query_cache] &&
+          @row_proc.kind_of?(Class) &&
+          @row_proc.included_modules.include?(Sequel::Model::InstanceMethods)
+        )
+          @row_proc.cache_fetch("#{cache_key}:first") do
+            super(*args)
+          end
+        else
+          super(*args)
+        end
+      end
+
+      def with_pk(pk)
+        if pk.is_a(Integer)
+          model.cache_fetch(pk.to_s) do
+            super(pk)
+          end
+        else
+          super(pk)
+        end
+      end
+
+      def cache_key
+        "Query:#{select_sql.gsub(/ +/, '_')}"
+      end
+    end
+  end
+end

data/lib/sequel-cacheable/driver/dalli.rb

@@ -0,0 +1,19 @@
+module Sequel::Plugins
+  module Cacheable
+    class DalliDriver < Driver
+      def del(key)
+        @store.delete(key)
+
+        return nil
+      end
+
+      def expire(key, time)
+        if time > 0
+          @store.touch(key, time)
+        else
+          @store.delete(key)
+        end
+      end
+    end
+  end
+end

data/lib/sequel-cacheable/driver/memcache.rb

@@ -0,0 +1,15 @@
+module Sequel::Plugins
+  module Cacheable
+    class MemcacheDriver < Driver
+      def del(key)
+        @store.delete(key)
+
+        return nil
+      end
+
+      def expire(key, time)
+        @store.set(key, @store.get(key), time)
+      end
+    end
+  end
+end

data/lib/sequel-cacheable/driver/redis.rb

@@ -0,0 +1,6 @@
+module Sequel::Plugins
+  module Cacheable
+    class RedisDriver < Driver
+    end
+  end
+end

data/lib/sequel-cacheable/driver.rb

@@ -0,0 +1,56 @@
+module Sequel::Plugins
+  module Cacheable
+    DRIVERS = %w(memcache dalli redis).freeze
+
+    class Driver
+      def self.factory(*args)
+        case args[0].class.name
+        when 'Memcache'
+          MemcacheDriver.new(*args)
+        when 'Dalli::Client'
+          DalliDriver.new(*args)
+        when 'Redis'
+          RedisDriver.new(*args)
+        else
+          Driver.new(*args)
+        end
+      end
+
+      def initialize(store, pack_lib = MessagePackPacker)
+        @store = store
+        @packer = pack_lib
+      end
+
+      def get(key)
+        val = @store.get(key)
+
+        return val.nil? || val.empty? ? nil : @packer.unpack(val)
+      end
+
+      def set(key, val, expire = nil)
+        @store.set(key, @packer.pack(val))
+        expire(key, expire) unless expire.nil?
+
+        return val
+      end
+
+      def del(key)
+        @store.del(key)
+
+        return nil
+      end
+
+      def expire(key, time)
+        @store.expire(key, time)
+      end
+
+      def fetch(key, *args, &block)
+        get(key) || set(key, block.call(*args))
+      end
+    end
+  end
+end
+
+Sequel::Plugins::Cacheable::DRIVERS.each do |driver|
+  require "sequel-cacheable/driver/#{driver}"
+end

data/lib/sequel-cacheable/instance_methods.rb

@@ -0,0 +1,66 @@
+# coding: utf-8
+
+module Sequel::Plugins
+  module Cacheable
+    module InstanceMethods
+      def after_initialize
+        super
+        cache! unless id.nil?
+      end
+
+      def after_save
+        super
+        recache!
+      end
+
+      def delete(*args)
+        uncache!
+        super
+      end
+
+      def destory(*args)
+        uncache!
+        super(*args)
+      end
+
+      def cache!
+        model.cache_set(cache_key, self)
+      end
+
+      def uncache!
+        model.cache_del(cache_key)
+        model.cache_clear(:query)
+      end
+
+      def recache!
+        uncache!
+        cache!
+      end
+
+      def cache_key
+        "#{self.id.to_s}"
+      end
+
+      def to_msgpack(*args)
+        msgpack_hash.to_msgpack
+      end
+
+      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
+      private :msgpack_hash
+    end
+  end
+end

data/lib/sequel-cacheable/packer.rb

@@ -0,0 +1,34 @@
+require 'msgpack'
+
+module Sequel::Plugins
+  module Cacheable
+    class Packer
+      def self.factory(lib)
+        case lib
+        when MessagePack
+          MessagePackPacker.new
+        else
+          Packer.new
+        end
+      end
+
+      def pack(obj)
+        Marshal.dump(obj)
+      end
+
+      def unpack(string)
+        Marshal.load(string)
+      end
+    end
+
+    class MessagePackPacker < Packer
+      def pack(obj)
+        obj.to_msgpack
+      end
+
+      def unpack(string)
+        MessagePack.unpack(string)
+      end
+    end
+  end
+end

data/lib/sequel-cacheable/version.rb

@@ -0,0 +1,7 @@
+module Sequel
+  module Plugins
+    module Cacheable
+      VERSION = '1.0.0'
+    end
+  end
+end