sequel-query-cache 0.2.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a295f7dea37913880f5a662798aa375f17f80314
+  data.tar.gz: b953a768fd1a58750cf68b5b99b3e1403fc82ed0
+SHA512:
+  metadata.gz: 569ecbb3f9433d70e5c39dece54a2f68efb615a6a323fe145c5d46ccc87664fc7d17cced2d764e934dc02b77a032894eac87dc441c824cf44bfc1275fa97f65d
+  data.tar.gz: 19e2ff8e34d236c8e5a724fca56b1cf8392416ff1e6251dd332b18d8b665e4dee18679416ae04491454aa07f1076c588203a9cdf90f8b3fc694774f4a11a4507

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :development do
+  gem 'pry'
+end

data/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2012-2013 Sho Kusano <rosylilly>
+Copyright (c) 2013 Joshua Hansen <binarypaladin>
+
+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,112 @@
+Sequel Query Cache
+==================
+
+Sequel Query Cache is a Sequel model plugin that allows the results of Sequel datasets to be cached in a key-value store like Memcached or Redis. This plugin is flexible and can easily be adapted to other key-value stores.
+
+Results are serialized for storage by default using JSON or [MessagePack](http://msgpack.org/) if the [MessagePack gem](https://github.com/msgpack/msgpack-ruby) is available. This is also flexible. Any object with a very simple interface can be used to serialize and unserialize data.
+
+Sequel Query Cache was forked from Sho Kusano's [sequel-cacheable gem](https://github.com/rosylilly/sequel-cacheable) and while it has seen substantial internal architectural changes, it maintains the original spirit of being easy to adapt to multiple cache stores and serialization options.
+
+Installation
+------------
+
+Sequel Query Cache requires [Sequel](https://github.com/jeremyevans/sequel) and one of the following gems for accessing cache store:
+
+* [Redis](https://rubygems.org/gems/redis)
+* [Hiredis](https://rubygems.org/gems/hiredis)
+* [Memcached](https://rubygems.org/gems/memcache)
+* [Dalli](https://rubygems.org/gems/dalli)
+
+Additionally, using [MessagePack](https://github.com/msgpack/msgpack-ruby) is strongly encouraged over the JSON default and is necessary when caching binary data.
+
+Configuration
+-------------
+
+First, initialize a cache client.
+
+Using Dalli:
+
+```ruby
+CACHE_CLIENT = Dalli::Client.new('localhost:11211')
+```
+
+Using Redis:
+
+```ruby
+CACHE_CLIENT = Redis.new(host: 'localhost', port: 6379)
+```
+
+Then, apply the plugin to all models:
+
+```ruby
+Sequel::Model.plugin :query_cache, CACHE_CLIENT
+```
+
+Or just a select few:
+
+```ruby
+MyModel.plugin :query_cache, CACHE_CLIENT
+```
+
+Configuration Options
+---------------------
+
+The plugin method also accepts a hash of options as a final argument, like so:
+
+```ruby
+Sequel::Model.plugin :query_cache, CACHE_CLIENT, ttl: 3600
+```
+
+The current options are:
+
+* **ttl**: Time to live. The amount of time before a given cache expires automatically.
+* **serializer**: An object that responds to serialize and unserialize methods for converting Sequel result hashs and models to serialized strings.
+* **cache_by_default**: See below.
+
+Cached Datasets
+---------------
+
+When a dataset is set to have its results cached, if a method that would return results is called (e.g. #first or #all) a check will be made to see if there are any cached results. If there are, the cached results will be used. If there are not, the results will be pulled from the database, cached in the store and then passed to the user.
+
+Whether or not dataset results are cached is determined in one of two ways. The first is to explicitly set a dataset to be cached. For example:
+
+```ruby
+MyModel.cached.all
+```
+
+This will check the cache for results and set them if they do not exist. Caching be be explicitly ignored as well:
+
+```ruby
+MyModel.uncached.all
+```
+
+The second way a determination to cache a dataset is made is by the options set by cache_by_default. By default, these are set to cache the results of any query which has a LIMIT clause set to 1.
+
+For more details on how cache_by_default, see the documentation for Sequel::Plugins::QueryCache and Sequel::Plugins::QueryCache::DatasetMethods.
+
+Caches are automatically deleted when a dataset is updated or deleted.
+
+Cached Models
+---------------
+
+Models have a few additional features on top of their respective dataset. Models can have their caches explicitly set or deleted by calling #cache! or #uncache! on a model instance.
+
+Additionally, models have an #after_save hook that updates caches associated with model instances.
+
+TODO
+----
+
+* The testing suite is completely broken and needs to be updated.
+* Additional documentation and commenting needs to be added to the source, particularly for the functionality of cache_by_default.
+* There is basically no need for this plugin to require the use of models and could be used purely as a dataset extension with a tiny model plugin built on top. This should be implemented at some point.
+
+Thanks
+------
+
+* [Sho Kusano](https://github.com/rosylilly)
+* [Jeremy Watkins](https://github.com/vegasje)
+
+Copyright
+---------
+
+Copyright (c) 2013 Joshua Hansen. See LICENSE for further details.

data/Rakefile

@@ -0,0 +1,2 @@
+# encoding: utf-8
+require "bundler/gem_tasks"

data/lib/sequel-query-cache.rb

@@ -0,0 +1,28 @@
+# coding: utf-8
+require 'sequel'
+require 'sequel-query-cache/version'
+require 'sequel-query-cache/driver'
+require 'sequel-query-cache/class_methods'
+require 'sequel-query-cache/instance_methods'
+require 'sequel-query-cache/dataset_methods'
+
+module Sequel::Plugins
+  module QueryCache
+    def self.configure(model, store, opts={})
+      model.instance_eval do
+        @cache_options = {
+          :ttl => 3600,
+          :cache_by_default => {
+            :always => false,
+            :if_limit => 1
+          }
+        }.merge(opts)
+
+        @cache_driver = Driver.from_store(
+          store,
+          :serializer => @cache_options.delete(:serializer)
+        )
+      end
+    end
+  end
+end

data/lib/sequel-query-cache/class_methods.rb

@@ -0,0 +1,20 @@
+# coding: utf-8
+module Sequel::Plugins
+  module QueryCache
+    module ClassMethods
+      attr_reader :cache_driver, :cache_options
+
+      def cached(opts={})
+        dataset.cached(opts)
+      end
+
+      def not_cached
+        dataset.not_cached
+      end
+
+      def default_cached
+        dataset.default_cached
+      end
+    end
+  end
+end

data/lib/sequel-query-cache/dataset_methods.rb

@@ -0,0 +1,254 @@
+# coding: utf-8
+require 'digest/md5'
+
+module Sequel::Plugins
+  module QueryCache
+    module DatasetMethods
+      CACHE_BY_DEFAULT_PROC = lambda do |ds, opts|
+        if ds.opts[:limit] && opts[:if_limit]
+          return true if
+            (opts[:if_limit] == true) ||
+            (opts[:if_limit] >= ds.opts[:limit])
+        end
+
+        false
+      end
+
+      # Returns the model's cache driver.
+      #--
+      # TODO: Caching should be modified to be a database/dataset extension with
+      # a tiny plugin for the models. However, this works just fine for now.
+      #++
+      def cache_driver
+        model.cache_driver
+      end
+
+      # Copies the model's +cache_options+ and merges them with options provided
+      # by +opts+ if any are provided. Returns the current cache_options.
+      #
+      # <tt>@cache_options</tt> is cloned when the dataset is cloned.
+      def cache_options(opts=nil)
+        @cache_options ||= model.cache_options
+        @cache_options = @cache_options.merge(opts) if opts
+        @cache_options
+      end
+
+      # Determines whether or not to cache a dataset based on the configuration
+      # settings of the plugin.
+      #--
+      # TODO: Specify a place to find those settings. However, where those are
+      # applied is currently in flux. Also, further document how this process
+      # actually works.
+      #++
+      def is_cacheable_by_default?
+        cache_by_default = cache_options[:cache_by_default]
+        return false unless cache_by_default
+        return true if cache_by_default[:always]
+        proc = cache_by_default[:proc] || CACHE_BY_DEFAULT_PROC
+        proc.call(self, cache_by_default)
+      end
+
+      # Determines whether or not a dataset should be cached. If
+      # <tt>@is_cacheable</tt> is set that value will be returned, otherwise the
+      # default value will be returned by #is_cacheable_by_default?
+      def is_cacheable?
+        defined?(@is_cacheable) ? @is_cacheable : is_cacheable_by_default?
+      end
+
+      # Sets the value for <tt>@is_cacheable</tt> which is used as the return
+      # value from #is_cacheable?. <tt>@is_cacheable</tt> is cloned when the
+      # dataset is cloned.
+      #
+      # *Note:* In general, #cached and #not_cached should be used to set this
+      # value. This method exists primarily for their use.
+      def is_cacheable=(is_cacheable)
+        @is_cacheable = !!is_cacheable
+      end
+
+      # Clones the current dataset, sets it to be cached and returns the new
+      # dataset. This is useful for chaining purposes:
+      #
+      #   dataset.where(column1: true).order(:column2).cached.all
+      #
+      # In the above example, the data would always be pulled from the cache or
+      # cached if it wasn't already. The value of <tt>@is_cacheable</tt> is
+      # cloned when a dataset is cloned, so the following example would also
+      # have the same result:
+      #
+      #   dataset.cached.where(column1: true).order(:column2).all
+      #
+      # +opts+ is passed to #cache_options on the new dataset.
+      def cached(opts=nil)
+        c = clone
+        c.cache_options(opts)
+        c.is_cacheable = true
+        c
+      end
+
+      # Clones the current dataset, sets it to not be cached and returns the new
+      # dataset. See #cached for further details and examples.
+      def not_cached
+        c = clone
+        c.is_cacheable = false
+        c
+      end
+
+      # Clones the current dataset, returns the caching state to whatever
+      # would be default for that dataset and returns the new dataset. See
+      # #cached for further details and examples.
+      #
+      # *Note:* This is the "proper" way to clear <tt>@is_cacheable</tt> once
+      # it's been set.
+      def default_cached
+        if defined? @is_cacheable
+          c = clone
+          c.remove_instance_variable(:@is_cacheable)
+          c
+        else
+          self
+        end
+      end
+
+      # Creates a default cache key, which is an MD5 base64 digest of the
+      # the literal select SQL with +Sequel:+ added as a prefix. This value is
+      # memoized because assembling the SQL string and hashing it every time
+      # this method gets called is obnoxious.
+      def default_cache_key
+        @default_cache_key ||= "Sequel:#{Digest::MD5.base64digest(sql)}"
+      end
+
+      # Returns the default cache key if a manual cache key has not been set.
+      # The cache key is used by the storage engines to retrieve cached data.
+      # The default will suffice in almost all instances.
+      def cache_key
+        @cache_key || default_cache_key
+      end
+
+      # Sets a manual cache key for a dataset that overrides the default MD5
+      # hash. This key has no +Sequel:+ prefix, so if that's important, remember
+      # to add it manually.
+      #
+      # *Note:* Setting the cache key manually is *NOT* inherited by cloned
+      # datasets since keys are presumed to be for the current dataset and any
+      # changes, such as where clauses or limits, should result in a new key. In
+      # general, you shouldn't change the cache key unless you have a really
+      # good reason for doing so.
+      def cache_key=(cache_key)
+        @cache_key = cache_key ? cache_key.to_s : nil
+      end
+
+      def clear_cache_keys!
+        remove_instance_variable(:@default_cache_key) if defined? @default_cache_key
+        remove_instance_variable(:@cache_key) if defined? @cache_key
+      end
+
+      # Gets the cache value using the current dataset's key and logs the
+      # action. The underlying driver should return +nil+ in the event that
+      # there is no cached data. Also logs whether there was a hit or miss on
+      # the cache.
+      def cache_get
+        db.log_info("CACHE GET: #{cache_key}")
+        cached_rows = cache_driver.get(cache_key)
+        db.log_info("CACHE #{cached_rows ? 'HIT' : 'MISS'}: #{cache_key}")
+        cached_rows
+      end
+
+      # Sets the cache value using the current dataset's key and logs the
+      # action. In general, this method should not be called directly. It's
+      # exposed because model instances need access to it.
+      #
+      # An +opts+ hash can be passed to override any default options being sent
+      # to the driver. The most common use for this would be to modify the +ttl+
+      # for a cache. However, this should probably be done using #cached rather
+      # than doing anything directly via this method.
+      def cache_set(value, opts={})
+        db.log_info("CACHE SET: #{cache_key}")
+        cache_driver.set(cache_key, value, opts.merge(cache_options))
+      end
+
+      # Deletes the cache value using the current dataset's key and logs the
+      # action.
+      def cache_del
+        db.log_info("CACHE DEL: #{cache_key}")
+        cache_driver.del(cache_key)
+      end
+
+      def cache_clear_on_update
+        @cache_clear_on_update.nil? ? true : @cache_clear_on_update
+      end
+
+      def cache_clear_on_update=(v)
+        @cache_clear_on_update = !!v
+      end
+
+      # Overrides the dataset's existing +update+ method. Deletes an existing
+      # cache after a successful update.
+      def update(values={}, &block)
+        result = super
+        cache_del if is_cacheable? && cache_clear_on_update
+        result
+      end
+
+      # Overrides the dataset's existing +delete+ method. Deletes an existing
+      # cache after a successful delete.
+      def delete(&block)
+        result = super
+        cache_del if is_cacheable?
+        result
+      end
+
+      # Overrides the dataset's existing +fetch_rows+ method. If the dataset is
+      # cacheable it will do one of two things:
+      #
+      # If a cache exists it will yield the cached rows rather query the
+      # database.
+      #
+      # If a cache does not exist it will query the database, store the results
+      # in an array, cache those and then yield the results like the original
+      # method would have.
+      #
+      # *Note:* If you're using PostgreSQL, or another database where +each+
+      # iterates with the cursor rather over the dataset results, you'll lose
+      # that functionality when caching is enabled for a query since the entire
+      # result is iterated first before it is yielded. If that behavior is
+      # important, remember to disable caching for that particular query.
+      def fetch_rows(sql)
+        if is_cacheable?
+          if cached_rows = cache_get
+            # Symbolize the row keys before yielding as they're often strings
+            # when the data is deserialized. Sequel doesn't play nice with
+            # string keys.
+            cached_rows.each{|r| yield r.reduce({}){|h,v| h[v[0].to_sym]=v[1]; h}}
+          else
+            cached_rows = []
+            super(sql){|r| cached_rows << r}
+            cache_set(cached_rows)
+            cached_rows.each{|r| yield r}
+          end
+        else
+          super
+        end
+      end
+
+      # Sets self as the source_dataset on a result if that result supports
+      # source datasets. While it can almost certainly be presumed the result
+      # will, if the dataset's row_proc has been modified for some reason the
+      # result might be different than expected.
+      def each
+        super do |r|
+          r.source_dataset = self if r.respond_to? :source_dataset=
+          yield r
+        end
+      end
+
+      # Overrides the dataset's existing clone method. Clones the existing
+      # dataset but clears any manually set cache key and the memoized default
+      # cache key to ensure it's regenerated by the new dataset.
+      def clone(opts=nil)
+        c = super(opts)
+        c.clear_cache_keys!
+        c
+      end
+    end
+  end
+end

data/lib/sequel-query-cache/driver.rb

@@ -0,0 +1,58 @@
+# coding: utf-8
+module Sequel::Plugins
+  module QueryCache
+    class Driver
+      def self.from_store(store, opts={})
+        case store.class.name
+        when 'Memcache'
+          require 'sequel-query-cache/driver/memcache'
+          MemcacheDriver.new(store, opts)
+        when 'Dalli::Client'
+          require 'sequel-query-cache/driver/dalli'
+          DalliDriver.new(store, opts)
+        else
+          Driver.new(store, opts)
+        end
+      end
+
+      attr_reader :store, :serializer
+
+      def initialize(store, opts={})
+        @store = store
+        @serializer = opts[:serializer] || _default_serializer
+      end
+
+      def get(key)
+        val = store.get(key)
+        val ? serializer.deserialize(val) : nil
+      end
+
+      def set(key, val, opts={})
+        store.set(key, serializer.serialize(val))
+        expire(key, opts[:ttl]) unless opts[:ttl].nil?
+        val
+      end
+
+      def del(key)
+        store.del(key)
+        nil
+      end
+
+      def expire(key, time)
+        store.expire(key, time)
+      end
+
+      private
+
+      def _default_serializer
+        if defined? MessagePack
+          require 'sequel-query-cache/serializer/message_pack'
+          Serializer::MessagePack
+        else
+          require 'sequel-query-cache/serializer/json'
+          Serializer::JSON
+        end
+      end
+    end
+  end
+end

data/lib/sequel-query-cache/driver/dalli.rb

@@ -0,0 +1,18 @@
+# coding: utf-8
+module Sequel::Plugins
+  module QueryCache
+    class DalliDriver < Driver
+      def del(key)
+        store.delete(key)
+      end
+
+      def expire(key, time)
+        if time > 0
+          store.touch(key, time)
+        else
+          store.delete(key)
+        end
+      end
+    end
+  end
+end

data/lib/sequel-query-cache/driver/memcache.rb

@@ -0,0 +1,14 @@
+# coding: utf-8
+module Sequel::Plugins
+  module QueryCache
+    class MemcacheDriver < Driver
+      def del(key)
+        store.delete(key)
+      end
+
+      def expire(key, time)
+        store.set(key, store.get(key), time)
+      end
+    end
+  end
+end

data/lib/sequel-query-cache/instance_methods.rb

@@ -0,0 +1,72 @@
+# coding: utf-8
+module Sequel::Plugins
+  module QueryCache
+    module InstanceMethods
+      # For the purpose of caching, it's helpful to have the dataset that
+      # is actually responsible for creating the model instance since it's
+      # likely that if the instance is updated you'll want the dataset related
+      # to it to be cleaned up. See #recache_source_dataset! for further
+      # information.
+      attr_accessor :source_dataset
+
+      def before_save
+        # Since the cache will be updated after the save is complete there's no
+        # reason to have it deleted by the update process.
+        this.cache_clear_on_update = false
+        super
+      end
+
+      def after_save
+        super
+        recache_source_dataset!
+        cache!
+      end
+
+      def cache_key
+        this.cache_key
+      end
+
+      def cache!(opts={})
+        this.cache_set([self], opts) if this.is_cacheable?
+        self
+      end
+
+      def uncache!
+        this.cache_del if this.is_cacheable?
+        source_dataset.cache_del if source_dataset_cache?
+        self
+      end
+
+      def to_msgpack(io=nil)
+        values.to_msgpack(io)
+      end
+
+      private
+      # There are many instances where the dataset that creates a model instance
+      # is not equal to #this. The two most common instances are when a model
+      # has a unique column that is used on a regular basis to fetch records
+      # (e.g. an email address in a User model) or a foreign key.
+      #
+      # In the event that the source dataset is guaranteed to return only one
+      # result (has a limit statement of 1) it will be cached. If it is not, the
+      # related cached will be cleared in an attempt to clean up potentially
+      # stale queries.
+      def recache_source_dataset!
+        if source_dataset_cache?
+          if source_dataset.opts[:limit] == 1
+            source_dataset.cache_set([self])
+          else
+            source_dataset.cache_del
+          end
+        end
+      end
+
+      def source_dataset_cache?
+        source_dataset &&
+          (source_dataset != this) &&
+          source_dataset.respond_to?(:is_cacheable?) &&
+          source_dataset.is_cacheable?
+      end
+    end
+  end
+end

data/lib/sequel-query-cache/serializer/json.rb

@@ -0,0 +1,24 @@
+# coding: utf-8
+require 'json'
+
+module Sequel::Plugins
+  module QueryCache
+    module Serializer
+      # While this works, if you're using binary data at all, it's not a great
+      # idea and MessagePack is faster.
+      module JSON
+        def self.serialize(obj)
+          binding.pry
+          obj.to_json
+        end
+
+        # Keys are specifically *NOT* symbolized here. This is done by
+        # Sequel::Plugins::Cacheable::DatasetMethods#fetch_rows since only the
+        # top level needs to have symbolized keys for Sequel's purposes.
+        def self.deserialize(string)
+          ::JSON.parse(string)
+        end
+      end
+    end
+  end
+end

data/lib/sequel-query-cache/serializer/message_pack.rb

@@ -0,0 +1,25 @@
+# coding: utf-8
+require 'msgpack'
+
+module Sequel::Plugins
+  module QueryCache
+    module Serializer
+      module MessagePack
+        def self.serialize(obj)
+          obj.to_msgpack
+        end
+
+        def self.deserialize(string)
+          ::MessagePack.unpack(string)
+        end
+      end
+    end
+  end
+end
+
+# Adds #to_msgpack to some common classes for packing purposes.
+[BigDecimal, Bignum, Date, Time, Sequel::SQLTime].each do |klass|
+  unless klass.instance_methods.include? :to_msgpack
+    klass.send(:define_method, :to_msgpack) {|io=nil| to_s.to_msgpack(io)}
+  end
+end

data/lib/sequel-query-cache/version.rb

@@ -0,0 +1,13 @@
+# coding: utf-8
+module Sequel
+  module Plugins
+    module QueryCache
+      MAJOR_VERSION = 0
+      MINOR_VERSION = 2
+      TINY_VERSION  = 1
+      VERSION = [MAJOR_VERSION, MINOR_VERSION, TINY_VERSION].join('.')
+
+      def self.version; VERSION; end
+    end
+  end
+end

data/sequel-query-cache.gemspec

@@ -0,0 +1,28 @@
+require './lib/sequel-query-cache/version'
+
+Gem::Specification.new do |s|
+  s.name          = 'sequel-query-cache'
+  s.version       = Sequel::Plugins::QueryCache::VERSION
+  s.license       = 'MIT'
+
+  s.authors       = ['Joshua Hansen']
+  s.email         = ['joshua@amicus-tech.com']
+  s.homepage      = 'https://github.com/binarypaladin/sequel-query-cache'
+
+  s.summary       = 'A plugin for Sequel that allows dataset results to be cached in Memcached or Redis.'
+  s.description   = s.summary
+
+  s.files = Dir.glob('lib/**/*') + [
+     'Gemfile',
+     'History.md',
+     'LICENSE',
+     'Rakefile',
+     'README.md',
+     'sequel-query-cache.gemspec',
+  ]
+
+  s.test_files    = Dir.glob('spec/**/*')
+  s.require_paths = ['lib']
+
+  s.add_dependency 'sequel', ['>= 3.42', '< 5.0']
+end

data/spec/lib/sequel-query-cache/driver/dalli_driver_spec.rb

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

data/spec/lib/sequel-query-cache/driver/memcache_driver_spec.rb

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

data/spec/lib/sequel-query-cache/driver/redis_driver_spec.rb

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

data/spec/lib/sequel-query-cache/driver_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe Sequel::Plugins::QueryCache::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::QueryCache::MemcacheDriver) }
+    end
+
+    context 'when Dalli' do
+      let(:store) { DalliCli }
+
+      it { should be_a(Sequel::Plugins::QueryCache::DalliDriver) }
+    end
+
+    context 'when Redis' do
+      let(:store) { RedisCli }
+
+      it { should be_a(Sequel::Plugins::QueryCache::RedisDriver) }
+    end
+
+    context 'when Unkown Store' do
+      let(:store) { mock }
+
+      it { should be_a(Sequel::Plugins::QueryCache::Driver) }
+    end
+  end
+end

data/spec/lib/sequel-query-cache_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe Sequel::Plugins::QueryCache do
+  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

data/spec/shared/driver.rb

@@ -0,0 +1,102 @@
+shared_examples :driver do
+  let(:pack_lib) { MessagePack }
+  subject(:driver) { described_class.new(store, pack_lib) }
+
+  let(:key) { 'cache_key' }
+  let(:val) { 100 }
+
+  describe '#set' do
+    subject { driver.set(key, val) }
+
+    it { should == val }
+
+    it 'should be stored in cache' do
+      driver.set(key, val)
+      store.get(key).should_not be_nil
+    end
+
+    context 'with expire' do
+      subject { driver.set(key, val, -1) }
+
+      it 'should be expired cache' do
+        store.get(key).should be_nil
+      end
+    end
+  end
+
+  describe '#get' do
+    before do
+      driver.set(key, val)
+    end
+
+    let(:get_key) { key }
+
+    subject { driver.get(get_key) }
+
+    context 'be found key' do
+      it { should == val }
+    end
+
+    context 'be not found key' do
+      let(:get_key) { 'not_found' }
+
+      it { should be_nil }
+    end
+  end
+
+  describe '#del' do
+    before do
+      driver.set(key, val)
+    end
+
+    subject(:del_method) { driver.del(key) }
+
+    it { should be_nil }
+
+    it 'should be deleted cache' do
+      store.get(key).should_not be_nil
+      del_method
+      store.get(key).should be_nil
+    end
+  end
+
+  describe '#expire' do
+    before do
+      driver.set(key, val)
+    end
+
+    it 'should be expired cache' do
+      store.get(key).should_not be_nil
+      driver.expire(key, -1)
+      store.get(key).should be_nil
+    end
+  end
+
+  describe '#fetch' do
+    subject(:fetch) do
+      driver.fetch(key) { val }
+    end
+
+    context 'be found key' do
+      before do
+        driver.set(key, val)
+      end
+
+      it { should == val }
+
+      it 'should not call #set' do
+        store.should_not_receive(:set)
+        fetch
+      end
+    end
+
+    context 'be not found key' do
+      it { should == val }
+
+      it 'should call #set' do
+        store.should_receive(:set).and_call_original
+        fetch
+      end
+    end
+  end
+end

data/spec/shared/query-cache.rb

@@ -0,0 +1,146 @@
+require 'spec_helper'
+
+shared_examples :cacheable do
+  let(:model) { described_class }
+
+  before do
+    3.times do
+      model.create(
+        :string => Forgery::Basic.text,
+        :integer => rand(255),
+        :float => rand(3000).to_f / 10.0,
+        :bignum => (2 + rand(10)) ** 100,
+        :numeric => BigDecimal(rand(100).to_s),
+        :date => Date.today,
+        :datetime => DateTime.now,
+        :time => Time.now,
+        :bool => rand(2).odd?
+      )
+    end
+  end
+
+  describe 'ClassMethods' do
+    let(:key) { 'cache_key' }
+    let(:value) { model.first }
+
+    describe '#cache_set' do
+      subject(:cache_set) { model.cache_set(key, value) }
+
+      it { should == value }
+
+      it 'should be stored cache' do
+        cache_set
+        model.cache_driver.get("#{model.name}:#{key}").should == value
+      end
+    end
+
+    describe '#cache_get' do
+      before do
+        model.cache_set(key, value)
+      end
+
+      subject { model.cache_get(key) }
+
+      it { should == value }
+    end
+
+    describe '#cache_del' do
+      before do
+        model.cache_set(key, value)
+      end
+
+      subject(:cache_del) { model.cache_del(key) }
+
+      it { should be_nil }
+
+      it 'should be deleted cache' do
+        cache_del
+        model.cache_get("#{model.name}:#{key}").should be_nil
+      end
+    end
+
+    describe '#cache_fetch' do
+      it 'should call driver#fetch' do
+        model.cache_driver.should_receive(:fetch).at_least(1).times.and_call_original
+
+        model.cache_fetch('test') do
+          value
+        end
+      end
+    end
+  end
+
+  describe 'DatasetMethods' do
+    let(:dataset) { model.dataset }
+
+    describe '#all' do
+      subject(:fetch_all) { dataset.all }
+
+      it { should have(3).records }
+
+      it { should == model.all }
+    end
+
+    describe '#first' do
+      subject(:fetch_first) { dataset.first }
+
+      it { should be_kind_of(model) }
+    end
+  end
+
+  describe 'InstanceMethods' do
+    let(:instance) { model.first }
+
+    describe '#after_initialize' do
+      it 'should call #cache!' do
+        model.any_instance.should_receive(:cache!)
+        model.first
+      end
+    end
+
+    describe '#after_update' do
+      it 'should call #recache!' do
+        instance.string = 'hoge'
+        instance.should_receive(:recache!)
+        instance.save
+      end
+    end
+
+    describe '#destroy' do
+      it 'should call #uncache!' do
+        instance.should_receive(:uncache!)
+        instance.destroy
+      end
+    end
+
+    describe '#delete' do
+      it 'should call #uncache!' do
+        instance.should_receive(:uncache!)
+        instance.delete
+      end
+    end
+
+    describe '#cache!' do
+      it 'should call .cache_set' do
+        instance = model.first
+        model.should_receive(:cache_set).with(instance.pk.to_s, instance)
+        instance.cache!
+      end
+    end
+
+    describe '#uncache!' do
+      it 'should call .cache_del' do
+        model.should_receive(:cache_del).at_least(1).times
+        instance.uncache!
+      end
+    end
+
+    describe '#recache!' do
+      it 'should call #uncache! and #cache!' do
+        instance.should_receive(:uncache!)
+        instance.should_receive(:cache!)
+        instance.recache!
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,35 @@
+require 'rubygems'
+require 'bundler'
+Bundler.require(:default, :test)
+
+DB = Sequel.sqlite
+DB.create_table(:spec) do
+  primary_key :id, :auto_increment => true
+  String :string
+  Integer :integer
+  Float :float
+  Bignum :bignum
+  BigDecimal :numeric
+  Date :date
+  DateTime :datetime
+  Time :time, :only_time=>true
+  TrueClass :bool
+end
+
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+Dir["#{File.dirname(__FILE__)}/shared/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  config.after(:each) do
+    RedisCli.flushall
+    MemcacheCli.flush_all
+    DalliCli.flush_all
+  end
+
+  config.around(:each) do |e|
+    DB.transaction do
+      e.run
+      raise Sequel::Rollback
+    end
+  end
+end

data/spec/support/models/dalli.rb

@@ -0,0 +1,5 @@
+DalliCli = Dalli::Client.new('localhost:11211')
+
+class DalliModel < Sequel::Model(:spec)
+  plugin :cacheable, DalliCli, :query_cache => true
+end

data/spec/support/models/memcache.rb

@@ -0,0 +1,5 @@
+MemcacheCli = Memcache.new(:server => 'localhost:11211')
+
+class MemcacheModel < Sequel::Model(:spec)
+  plugin :cacheable, MemcacheCli, :query_cache => true
+end

data/spec/support/models/redis.rb

@@ -0,0 +1,5 @@
+RedisCli = Redis.new(:server => 'localhost:6379')
+
+class RedisModel < Sequel::Model(:spec)
+  plugin :cacheable, RedisCli, :query_cache => true
+end

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification
+name: sequel-query-cache
+version: !ruby/object:Gem::Version
+  version: 0.2.1
+platform: ruby
+authors:
+- Joshua Hansen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.42'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.42'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: A plugin for Sequel that allows dataset results to be cached in Memcached
+  or Redis.
+email:
+- joshua@amicus-tech.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- History.md
+- LICENSE
+- README.md
+- Rakefile
+- lib/sequel-query-cache.rb
+- lib/sequel-query-cache/class_methods.rb
+- lib/sequel-query-cache/dataset_methods.rb
+- lib/sequel-query-cache/driver.rb
+- lib/sequel-query-cache/driver/dalli.rb
+- lib/sequel-query-cache/driver/memcache.rb
+- lib/sequel-query-cache/instance_methods.rb
+- lib/sequel-query-cache/serializer/json.rb
+- lib/sequel-query-cache/serializer/message_pack.rb
+- lib/sequel-query-cache/version.rb
+- sequel-query-cache.gemspec
+- spec/lib/sequel-query-cache/driver/dalli_driver_spec.rb
+- spec/lib/sequel-query-cache/driver/memcache_driver_spec.rb
+- spec/lib/sequel-query-cache/driver/redis_driver_spec.rb
+- spec/lib/sequel-query-cache/driver_spec.rb
+- spec/lib/sequel-query-cache_spec.rb
+- spec/models/dalli_spec.rb
+- spec/models/memcache_spec.rb
+- spec/models/redis_spec.rb
+- spec/shared/driver.rb
+- spec/shared/query-cache.rb
+- spec/spec_helper.rb
+- spec/support/models/dalli.rb
+- spec/support/models/memcache.rb
+- spec/support/models/redis.rb
+homepage: https://github.com/binarypaladin/sequel-query-cache
+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.2.2
+signing_key: 
+specification_version: 4
+summary: A plugin for Sequel that allows dataset results to be cached in Memcached
+  or Redis.
+test_files:
+- spec/lib/sequel-query-cache/driver/dalli_driver_spec.rb
+- spec/lib/sequel-query-cache/driver/memcache_driver_spec.rb
+- spec/lib/sequel-query-cache/driver/redis_driver_spec.rb
+- spec/lib/sequel-query-cache/driver_spec.rb
+- spec/lib/sequel-query-cache_spec.rb
+- spec/models/dalli_spec.rb
+- spec/models/memcache_spec.rb
+- spec/models/redis_spec.rb
+- spec/shared/driver.rb
+- spec/shared/query-cache.rb
+- spec/spec_helper.rb
+- spec/support/models/dalli.rb
+- spec/support/models/memcache.rb
+- spec/support/models/redis.rb
+has_rdoc: