the-pantry 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5d98a34b1bfccc46013bd9330cfbb48bb2c34a2e
+  data.tar.gz: e8c1a702702ba0cbefe61de8915b19c5c605e9a4
+SHA512:
+  metadata.gz: f056f5e25806051ecad7f81fb01b436f2122a87116665300eccac0a1a6fc2a8c351721e585bddfc57180fe3cce9f628980f28b887efa95f57d5d2810f72ed487
+  data.tar.gz: 8c5745f26e77259b62b3b20467736918cd4b52ba79ad9687408f90eb7cff6a705d4681feccec4cd1b77c978540f968b903c57392296eb8df9764ee8912ae70c8

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+.idea/*
+.ruby-gemset
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/vendor/bundle/
+sprig-pantry*.gem

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.ruby-version

@@ -0,0 +1 @@
+2.3.1

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+ - 2.3.1
+script: bundle exec rspec
+services:
+  - redis-server

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in pantry.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,68 @@
+PATH
+  remote: .
+  specs:
+    the-pantry (1.0.0)
+      activerecord (~> 4.2)
+      hiredis (~> 0.6)
+      json (~> 1.8)
+      redis (~> 3.2)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (4.2.7.1)
+      activesupport (= 4.2.7.1)
+      builder (~> 3.1)
+    activerecord (4.2.7.1)
+      activemodel (= 4.2.7.1)
+      activesupport (= 4.2.7.1)
+      arel (~> 6.0)
+    activesupport (4.2.7.1)
+      i18n (~> 0.7)
+      json (~> 1.7, >= 1.7.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.3, >= 0.3.4)
+      tzinfo (~> 1.1)
+    arel (6.0.4)
+    builder (3.2.3)
+    database_cleaner (1.4.1)
+    diff-lcs (1.2.5)
+    hiredis (0.6.1)
+    i18n (0.8.0)
+    json (1.8.6)
+    minitest (5.10.1)
+    rake (10.4.2)
+    redis (3.3.3)
+    rspec (3.3.0)
+      rspec-core (~> 3.3.0)
+      rspec-expectations (~> 3.3.0)
+      rspec-mocks (~> 3.3.0)
+    rspec-core (3.3.2)
+      rspec-support (~> 3.3.0)
+    rspec-expectations (3.3.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.3.0)
+    rspec-mocks (3.3.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.3.0)
+    rspec-support (3.3.0)
+    sqlite3 (1.3.10)
+    thread_safe (0.3.5)
+    timecop (0.7.4)
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.3)
+  database_cleaner (~> 1.3)
+  rake (~> 10.0)
+  rspec (~> 3.3)
+  sqlite3 (~> 1.3)
+  the-pantry!
+  timecop (~> 0.7)
+
+BUNDLED WITH
+   1.14.0

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 - 2017 Sprig
+
+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,211 @@
+# Pantry [![Build Status](https://travis-ci.org/eatsprig/the-pantry.svg?branch=master)](https://travis-ci.org/eatsprig/the-pantry)
+
+Pantry provides ActiveRecord model caching in Redis via a mixin. **Before you go to the store, check the pantry!**
+
+Pantry strives to be simple and intuitive. Its philosophy is that a cache should be dumb. You should use a cache to perform basic queries quickly; you should not use it to mimic a relational database. As a result, the query API that Pantry exposes is small and straightforward.
+
+## Features
+
++ Retrieval of a single object from the cache by primary key.
++ Retrieval of multiple objects from the cache by list of primary keys.
++ Retrieval of all cached objects for a model in one fell swoop.
++ Global and model-specific cache invalidation via configuration.
++ Specification of cached object attributes via configuration.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'the-pantry', require: 'pantry'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install the-pantry
+
+## Usage
+
+You can enable caching on your ActiveRecord model by mixing in `Pantry::Stocked`.
+
+Basic example:
+```ruby
+class User
+  include Pantry::Stocked
+end
+```
+
+Full example:
+```ruby
+module UserMethods
+  def full_name
+    "#{first_name} #{last_name}".strip
+  end
+end
+
+module Cache
+  class User < Pantry::DryGood
+    include UserMethods
+  end
+end
+
+class User
+  include Pantry::Stocked
+  include UserMethods
+  
+  stock_by :email
+  
+  class << self
+    def local_key_version
+      123
+    end
+
+    def dry_good_type
+      Cache::User
+    end
+  end
+
+  def pantry_attributes
+    super.merge(
+      "profile_photo_url" => profile_photo.url
+    )
+  end
+end
+
+user = User.find(1) #=> ActiveRecord::Base
+user.full_name #=> Dude Guy
+user.profile_photo.url #=> https://mybucket.s3.amazonaws.com/users/profile_photos/001/me.png
+
+user = User.get(1) #=> Pantry::DryGood
+user.full_name #=> Dude Guy
+user.profile_photo_url #=> https://mybucket.s3.amazonaws.com/users/profile_photos/001/me.png
+```
+
+The following methods will be added to the `User` class:
+
+#### `User.get(id)`
+
+Retrieves a single object, looking first to the cache and then to the database.
+
+#### `User.get_by(attribute_name, attribute_value)`
+
+Retrieves a single object by the value of one of its attributes, looking first to the cache and then to the database. In order to use this method, the model must declare `stock_by` with the desired attribute name.
+
+#### `User.multi_get(ids)`
+
+Retrieves multiple objects, looking first to the cache and then to the database.
+
+#### `User.multi_get_by(attribute_name, attribute_values)`
+
+Retrieves multiple objects by the given list of values for a single attribute. Looks first to the cache and then to the database.
+
+#### `User.multi_get_all`
+
+Retrieves all the objects that exist in the cache. Unlike other methods, this method does not fall back to the database unless the cache for the model in question is completely empty. The `restock?` configuration method (described below) must return `true` in order to use this method.
+
+#### `User.invalidate(id)`
+
+Removes a single entry from the cache.
+
+#### `User.multi_invalidate(ids)`
+
+Removes multiple entries from the cache.
+
+#### `User.restock!`
+
+Writes all model objects to the cache. This is mainly for use in conjunction with models that want to use the `multi_get_all` functionality. This is potentially very expensive, so it should be used with caution.
+
+#### `User.tidy!`
+
+Clears all expired entries from the index key used to serve `multi_get_all` requests. Never calling this method will not affect correctness (i.e. expired entries will never be returned from the index), but your index will grow indefinitely.
+
+## Model Configuration
+
+You can customize the behaviour of the cache by overriding a few configuration options:
+
+Example:
+```ruby
+class User
+  include Pantry::Stocked
+
+  def self.local_key_prefix
+    "my_application_specific_prefix"
+  end
+
+  def self.restock?
+    true
+  end
+
+  def pantry_attributes
+    {
+        "id": id,
+        "nickname": nickname
+    }
+  end
+end
+```
+
+#### `User.local_key_prefix`
+
+Returns the portion of the cache key that is specific to this model. Defaults to the lower-cased class name.
+
+#### `User.local_key_version`
+
+Returns the cache key version of cache objects for this model. Defaults to `1`.
+
+#### `User.key_ttl_s`
+
+Returns the TTL for cache keys for this model. Defaults to the `Pantry.global_key_ttl_s` value (which, by default, is 1 week).
+
+#### `User.restock?`
+
+Returns a boolean indicating whether or not the cache should be eagerly re-populated with a record after a change to that record was committed. This method must be configured to return `true` in order to use the `multi_get_all` method. Defaults to `false`.
+
+#### `User.dry_good_type`
+
+Allows for specifying a class to instantiate when an object is de-serialized from cache. The returned class should quack like `OpenStruct.new` and accept the attributes returned by `pantry_attributes`. This defaults to `Pantry::DryGood`.
+
+#### `User#pantry_attributes`
+
+Returns a hash of attributes to write to the cache.
+
+#### `User.stock_by(attribute_name, unique: false)`
+
+Adds a secondary cache index for the given attribute. This enables the use of `get_by` and `multi_get_by`. The `unique` flag specifies whether or not to create a unique index.
+
+## Global Configuration
+
+Finally, there are global configuration options that you can set on the `Pantry.configuration` hash to manage configuration across all cached models:
+
+```ruby
+# config/initializers/pantry.rb
+
+Pantry.configuration.redis_uri          = "some-redis-host.com:12345" # defaults to "localhost:6379"
+Pantry.configuration.global_key_prefix  = "myapp"                     # defaults to "pantry"
+Pantry.configuration.global_key_version = 123                         # defaults to 1
+Pantry.configuration.global_key_ttl_s   = 30.days                     # defaults to 1 week
+Pantry.configuration.force_cache_misses = true                        # defaults to false
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake rspec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. 
+
+To release a new version:
++ Update the version number in `lib/pantry/version.rb`
++ `git tag -a -m "Version <VERSION_NUMBER>" v<VERSION_NUMBER>`
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "gemfury/tasks"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "pantry"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/pantry/configuration_error.rb

@@ -0,0 +1,3 @@
+module Pantry
+  class ConfigurationError < StandardError; end
+end

data/lib/pantry/dry_good.rb

@@ -0,0 +1,26 @@
+module Pantry
+  class DryGood < OpenStruct
+    include ActiveModel::Serialization
+
+    # Implements required interface method for ActiveModel::Serialization.
+    def attributes
+      to_h.deep_stringify_keys
+    end
+
+    def ==(other)
+      super
+    end
+
+    def hash
+      super
+    end
+
+    # OpenStruct objects don't turn into hashes wrapped in a 'table' key
+    # http://goo.gl/vPjtgz
+    def as_json(options = nil)
+      @table.as_json(options)
+    end
+
+    alias_method :eql?, :==
+  end
+end

data/lib/pantry/stocked.rb

@@ -0,0 +1,518 @@
+module Pantry
+  module Stocked
+    extend ActiveSupport::Concern
+
+    @@includers = []
+
+    def self.includers
+      @@includers
+    end
+
+    included do
+      @@includers << self
+      after_commit -> (record) { self.class.invalidate(record) }
+    end
+
+    module ClassMethods
+
+      def local_key_prefix
+        to_s.downcase
+      end
+
+      def local_key_version
+        1
+      end
+
+      def key_ttl_s
+        Pantry.configuration.global_key_ttl_s
+      end
+
+      def restock?
+        false
+      end
+
+      # Allows the client (the includer of this module) to declare a secondary
+      # index on the given attribute.
+      #
+      # @param attribute [Symbol, String] attribute to stock by, should be an
+      #   attribute of the Class
+      # @param unique [Boolean, nil] Whether or not the declared index is
+      #   unique.
+      # @param &block [Block] The block should behave like a block you'd use
+      #   in a `scope`. It should expect to be chained on to an existing
+      #   scoping chain, and should return a scope.
+      #   Ex. stock_by(:team) { where.not(nickname: "Benji") }
+      def stock_by(attribute, unique: false, &block)
+        secondary_indices[attribute.to_sym] = {
+          unique: !!unique,
+          block: block
+        }
+      end
+
+      # Retrieves a single object, looking first to the cache and then to the
+      # database.
+      #
+      # @param id [Integer] Unique identifier of the desired object.
+      # @return [DryGood] Cached object. This object will have accessors for
+      #   all the attributes returned by `pantry_attributes`.
+      def get(id)
+        multi_get([id])[id]
+      end
+
+      # Retrieves a single object by the value of an indexed attribute.
+      #
+      # @param attribute [String, Symbol] Name of indexed attribute.
+      # @param value [String] Stringified value of the indexed attribute for
+      #   which to fetch the result.
+      # @return [DryGood] Cached object.
+      def get_by(attribute, value)
+        multi_get_by(attribute, [value])[value]
+      end
+
+      # Retrieves multiple objects, looking first to the cache and then to the
+      # database.
+      #
+      # @param ids [Array<Integer>] Unique identifiers of the desired objects.
+      # @return [Hash<Integer, DryGood>] Map from object identifier to cached
+      #   object.
+      def multi_get(ids)
+        cached_records = multi_fetch(ids)
+
+        misses = cached_records.reduce([]) do |memo, (id, cached)|
+          memo << id unless cached
+          memo
+        end
+
+        db_records = misses.any? ? multi_store(where(id: misses).all.to_a) : {}
+
+        ids.reduce({}) do |memo, id|
+          memo[id] = cached_records[id] || db_records[id.to_i]
+          memo
+        end
+      end
+
+      # Retrieves a multiple objects by the values of an indexed attribute.
+      #
+      # @param attribute [String, Symbol] Name of indexed attribute.
+      # @param values [Array<String>] Stringified values of the indexed
+      #   attribute for which to fetch the results.
+      # @return [Hash<String, DryGood>] Map from attribute value to cached
+      #   object.
+      def multi_get_by(attribute, values)
+        cached_records = multi_fetch_by(attribute, values)
+
+        misses = []
+
+        empty_values = cached_records.reduce([]) do |memo, (val, cached)|
+          memo << val if cached.blank?
+          memo
+        end
+
+        if empty_values.any?
+          existences = Pantry.redis.pipelined do
+            empty_values.map do |val|
+              Pantry.redis.exists(secondary_index_cache_key(attribute, val))
+            end
+          end
+
+          empty_values.zip(existences).each do |(val, exists)|
+            unless exists
+              # Explicitly mark the cache miss (since otherwise, i.e. when the
+              # index key exists, an empty array is a valid cache response).
+              cached_records[val] = nil
+
+              misses << val
+            end
+          end
+        end
+
+        db_records = multi_store_by(attribute, misses)
+
+        values.reduce({}) do |memo, val|
+          memo[val] = cached_records[val] || db_records[val]
+          memo
+        end
+      end
+
+      # Retrieves all cached objects for this model class.
+      #
+      # This method should be used with caution: it may have negative
+      # performance consequences if used to retrieve large collections. It is
+      # intended for use on small collections that are important to business
+      # logic but that do not change often. Additionally, method will only work
+      # reliably if `restock?` is set to return `true`.
+      #
+      # @return [Hash<Integer, DryGood>] Map from object identifier to cached
+      #   object.
+      def multi_get_all
+        unless restock?
+          fail ConfigurationError.new(
+            "restock?() must return true in order to use multi_get_all()")
+        end
+
+        if Pantry.configuration.force_cache_misses
+          result = all.reduce({}) do |memo, obj|
+            memo[obj.id] = DryGood.new(JSON.parse(obj.send(:pantry_json)))
+            memo
+          end
+          return result
+        end
+
+        keys = Pantry.redis.zrangebyscore(
+          all_index_cache_key,
+          Time.now.to_i,
+          "+inf")
+        if keys.empty?
+          restock!
+        else
+          multi_fetch(keys.map(&:to_i))
+        end
+      end
+
+      # Invalidates a single cache entry.
+      #
+      # @param obj_or_id [Object, Integer] Object (or primary key identifier for
+      #   the object) whose cache entry we should delete.
+      def invalidate(obj_or_id)
+        multi_invalidate([obj_or_id])
+      end
+
+      # Invalidates a series of cache entries.
+      #
+      # @param objects_or_ids [Array<Object>, Array<Integer>] Objects (or
+      #   primary key identifiers for objects) whose cache entries we should
+      #   delete.
+      def multi_invalidate(objects_or_ids)
+        return if objects_or_ids.empty?
+
+        is_integer_list = objects_or_ids.first.is_a?(Integer)
+
+        objects = objects_or_ids
+        if is_integer_list && (secondary_indices.any? || restock?)
+          objects = where(id: objects_or_ids).all.to_a
+        end
+
+        Pantry.redis.del(
+          objects_or_ids.map { |o| cache_key(is_integer_list ? o : o.id) })
+
+        if secondary_indices.any?
+          invalidate_secondary_indices(objects)
+        end
+
+        if restock?
+          # TODO(lerebear): Make multi_store take optional list of cache keys.
+          # Store anything that we haven't already.
+          multi_store(
+            objects.find_all { |obj| !obj.destroyed? },
+            skip_deserialization: true)
+        end
+
+        nil
+      end
+
+      # We invalidate a key if either of the following is true:
+      #   - The attribute is stocked conditionally (indicated by the presence
+      #     of a block option)
+      #   - The given objects' attributes that are indexed have changed. In
+      #     this case we invalidate both the old and new values for the indexed
+      #     attribute
+      #
+      # @param objects [Array<Object>]
+      def invalidate_secondary_indices(objects)
+        objects_by_dirty_index = secondary_indices
+          .reduce({}) do |memo, (attribute, options_hash)|
+          has_block = options_hash[:block]
+
+          if has_block
+            memo[attribute] = objects
+          else
+            dirty_objects = objects.find_all do |obj|
+              !obj.destroyed? && obj.previous_changes[attribute.to_s].present?
+            end
+
+            if dirty_objects.any?
+              memo[attribute] = dirty_objects
+            end
+          end
+
+          memo
+        end
+
+        Pantry.redis.pipelined do
+          objects_by_dirty_index.each do |attribute, dirty_objs|
+            # Invalidate attribute indices.
+            dirty_objs.each do |o|
+              (o.previous_changes[attribute.to_s] || [o.send(attribute)])
+                .each do |val|
+
+                Pantry.redis.del(secondary_index_cache_key(attribute, val))
+              end
+            end
+          end
+        end
+      end
+
+      # Writes all objects for the model class to the cache.
+      #
+      # This is a utility method for ensuring that the cache is populated for
+      # classes that wish to use the `multi_get_all` functionality`. This method
+      # will only write to the cache if `restock?` is set to return
+      # `true`.
+      #
+      # @return [Hash<Integer, DryGood>, Nil] Map from object identifier to
+      #   cached object, or nil if no objects were written to the cache.
+      def restock!
+        multi_store(all.to_a) if restock?
+      end
+
+      # Clears all expired entries from index keys.
+      #
+      # Entries in an index will never expire unless you call this method. That
+      # should be fine in most cases, and it never affects correctness (because
+      # only non-expired keys are returned by `multi_get_all`). However, this
+      # method can be used to address the concern of the values of index keys
+      # growing too big.
+      #
+      # @return [Integer, Nil] The number of elements that were expired, or nil
+      #   if we aren't using indices.
+      def tidy!
+        # TODO(lerebear): This is no good because you have to call restock!
+        # alongside this to guarantee correctness. Better idea is probably to
+        # just have a clean! method that does both tidy! and restock! for the
+        # all_index_cache_key, and also removes all other attribute index cache
+        # keys at the same time (those will regenerate on the fly). Then make
+        # clear in the docs that you can use clean! on a schedule to help
+        # maintain your cache.
+        Pantry.redis.zremrangebyscore(all_index_cache_key, 0, Time.now.to_i - 1)
+      end
+
+      # Provides a hook for mixers to implement to provide a more specific
+      # class to instantiate when de-serializing from the cache.
+      #
+      # The returned class should quack like `OpenStruct#new`
+      #
+      # @return [Class]
+      def dry_good_type
+        DryGood
+      end
+
+      # Provides a hook for mixers to do pre-processing on the given
+      # objects to improve serialization performance.
+      #
+      # @param objects [Array<ActiveRecord::Base>] the objects fetched from the
+      #   database on a cache miss
+      def before_pantry_serialize(objects)
+      end
+
+      private
+
+      def secondary_indices
+        @indices ||= {}
+      end
+
+      def fetch(id)
+        multi_fetch([id])[id]
+      end
+
+      def multi_fetch(ids)
+        return Hash[ids.zip([nil])] if Pantry.configuration.force_cache_misses
+
+        keys = ids.map { |id| cache_key(id) }
+        cached = keys.length > 0 ? Pantry.redis.mget(keys) : []
+        ids.zip(cached).reduce({}) do |memo, (id, retrieved)|
+          memo[id] = retrieved && restore_deserialized(JSON.parse(retrieved))
+          memo
+        end
+      end
+
+      def multi_fetch_by(attribute, values)
+        is_unique_index = secondary_indices[attribute.to_sym].try(:[], :unique)
+
+        if Pantry.configuration.force_cache_misses
+          return values.reduce({}) do |memo, val|
+            memo[val] = is_unique_index ? nil : []
+            memo
+          end
+        end
+
+        # TODO(lerebear): Create a pipelining helper to avoid pipeline cost for
+        # lists of 1.
+        id_lists = Pantry.redis.pipelined do
+          values.map do |val|
+            Pantry
+              .redis
+              .smembers(secondary_index_cache_key(attribute, val))
+          end
+        end
+
+        id_lists = id_lists.map { |ids| ids.map(&:to_i) }
+        cached = multi_get(id_lists.flatten)
+
+        values.zip(id_lists).reduce({}) do |memo, (val, ids)|
+          memo[val] = \
+            if is_unique_index
+              ids.first && cached[ids.first]
+            else
+              ids.reduce([]) do |acc, id|
+                if (retrieved = cached[id])
+                  acc << retrieved
+                end
+                acc
+              end
+            end
+          memo
+        end
+      end
+
+      def restore_deserialized(attrs)
+        cast_attributes(dry_good_type.send(:new, attrs))
+      end
+
+      def cast_attributes(dry_good)
+        columns_hash.find_all { |_, hash| hash.type.to_s == "datetime" }
+          .map(&:first)
+          .each do |attr|
+          if (value = dry_good.send(attr)) && value.is_a?(String)
+            dry_good.send("#{attr}=", Time.parse(value))
+          end
+        end
+        dry_good
+      end
+
+      def store(id, skip_deserialization: false)
+        cached = multi_store(
+          where(id: id).all.to_a,
+          skip_deserialization: skip_deserialization)
+        cached[id] unless skip_deserialization
+      end
+
+      def multi_store(objects, skip_deserialization: false)
+        return {} if objects.empty?
+
+        before_pantry_serialize(objects)
+        object_ids = []
+        to_cache = {}
+        objects.each do |obj|
+          object_ids << obj.id
+          to_cache[cache_key(obj.id)] = obj.send(:pantry_json)
+        end
+
+        Pantry.redis.pipelined do
+          Pantry.redis.mset(*to_cache.flatten)
+          object_ids.each do |id|
+            Pantry.redis.expire(cache_key(id), key_ttl_s)
+          end
+
+          # Add to "all" index key if necessary.
+          now = Time.now.to_i
+          if restock?
+            Pantry.redis.zadd(
+              all_index_cache_key,
+              object_ids.map { |id| [now + key_ttl_s, id] })
+          end
+        end
+
+        unless skip_deserialization
+          # HACK(lerebear): Incurring the JSON parsing cost here is really bad.
+          # Ideally we would just return `pantry_attributes` of every object. The
+          # problem is that the hash returned by `pantry_attributes` still
+          # contains unserialized types (e.g. Date, which gets serialized to a
+          # string when written to the cache and so emerges from the cache as a
+          # string). That creates problems in tests and, conceptually, this should
+          # return the same sort of object as `multi_fetch`, so the workaround is
+          # to just parse the JSON.
+          to_cache.values.reduce({}) do |memo, obj|
+            restored = restore_deserialized(JSON.parse(obj))
+            memo[restored.id] = restored
+            memo
+          end
+        end
+      end
+
+      def multi_store_by(attribute, values, skip_deserialization: false)
+        return {} if values.empty?
+
+        is_unique_index = secondary_indices[attribute.to_sym].try(:[], :unique)
+        block = secondary_indices[attribute.to_sym].try(:[], :block)
+
+        scope = where(attribute.to_sym => values)
+
+        if block
+          scope = scope.scoping { block.call }
+        end
+
+        objects_by_attribute_value ||= \
+          scope
+            .all
+            .group_by { |obj| obj.send(attribute) }
+
+        Pantry.redis.pipelined do
+          # Populate secondary indices.
+          objects_by_attribute_value.each do |value, objs|
+            Pantry.redis.sadd(
+              secondary_index_cache_key(attribute, value),
+              objs.map(&:id))
+          end
+        end
+        # Also populate primary index (since we have the objects handy).
+        multi_store(
+          objects_by_attribute_value.values.flatten.sort_by(&:id),
+          skip_deserialization: true)
+
+        unless skip_deserialization
+          # HACK(lerebear): Same hack as in `multi_store` method above.
+          values.reduce({}) do |memo, val|
+            objs = objects_by_attribute_value[val] || []
+            memo[val] = \
+              if is_unique_index
+                objs.first && restore_deserialized(
+                  JSON.parse(objs.first.send(:pantry_json)))
+              else
+                objs.map do |o|
+                  restore_deserialized(JSON.parse(o.send(:pantry_json)))
+                end
+              end
+            memo
+          end
+        end
+      end
+
+      def cache_key(id)
+        [
+          Pantry.configuration.global_key_prefix,
+          "v#{Pantry.configuration.global_key_version}",
+          local_key_prefix,
+          "v#{local_key_version}",
+          "##{id}"
+        ].join(":")
+      end
+
+      def secondary_index_cache_key(attribute, value)
+        [
+          Pantry.configuration.global_key_prefix,
+          "v#{Pantry.configuration.global_key_version}",
+          local_key_prefix,
+          "v#{local_key_version}",
+          "index",
+          attribute,
+          value.nil? ? "__pantry_nil__" : value
+        ].join(":")
+      end
+
+      def all_index_cache_key
+        secondary_index_cache_key(:id, "all")
+      end
+    end
+
+    # @return [Hash] Attributes to cache.
+    def pantry_attributes
+      attributes
+    end
+
+    private
+
+    def pantry_json
+      pantry_attributes.to_json
+    end
+  end
+end

data/lib/pantry/version.rb

@@ -0,0 +1,3 @@
+module Pantry
+  VERSION = "1.0.0"
+end

data/lib/pantry.rb

@@ -0,0 +1,46 @@
+require "active_record"
+require "hiredis"
+require "json"
+require "ostruct"
+require "redis"
+
+require "pantry/version"
+require "pantry/configuration_error"
+require "pantry/dry_good"
+require "pantry/stocked"
+
+module Pantry
+  class << self
+    # Returns the (mutable) configuration object for this module.
+    #
+    # The following keys are supported:
+    #   :redis_uri - The Redis instance to use as the cache. Defaults to nil,
+    #     which in turn allows the Redis library to connect to the default host.
+    #   :global_key_prefix - The portion of the cache key prefix that should be
+    #     used for all cache keys. Defaults to `pantry`.
+    #   :global_key_version - The key version to use for all cache keys.
+    #     Defaults to `1`.
+    #   :global_key_ttl_s - The default TTL (in seconds) to apply to all keys.
+    #     Defaults to 1 week.
+    #   :force_cache_misses - Whether or not to ignore the cache completely on
+    #     read. Defaults to false.
+    # @return [OpenStruct] Configuration object.
+    def configuration
+      @configuration ||= OpenStruct.new(
+        redis_uri: nil,
+        global_key_prefix: "pantry",
+        global_key_version: 1,
+        global_key_ttl_s: 60 * 60 * 24 * 7 * 2,
+        force_cache_misses: false)
+    end
+
+    # Returns the redis instance that this module is using as a cache.
+    #
+    # @return [Redis] Redis instance.
+    def redis
+      @redis ||= Redis.new(
+        url: Pantry.configuration.redis_uri,
+        driver: :hiredis)
+    end
+  end
+end

data/pantry.gemspec

@@ -0,0 +1,32 @@
+$LOAD_PATH.unshift(File.expand_path("../lib", __FILE__))
+
+require "pantry/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "the-pantry"
+  spec.version       = Pantry::VERSION
+  spec.authors       = ["sprig"]
+
+  spec.summary       = "Before you go to the store, check the pantry!"
+  spec.description   = "Simple ActiveRecord model caching using Redis."
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`
+                         .split("\x0")
+                         .reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "activerecord", "~> 4.2"
+  spec.add_runtime_dependency "hiredis", "~> 0.6"
+  spec.add_runtime_dependency "json", "~> 1.8"
+  spec.add_runtime_dependency "redis", "~> 3.2"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "database_cleaner", "~> 1.3"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.3"
+  spec.add_development_dependency "sqlite3", "~> 1.3"
+  spec.add_development_dependency "timecop", "~> 0.7"
+end

metadata

@@ -0,0 +1,200 @@
+--- !ruby/object:Gem::Specification
+name: the-pantry
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- sprig
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-03-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+- !ruby/object:Gem::Dependency
+  name: hiredis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: database_cleaner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+description: Simple ActiveRecord model caching using Redis.
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".ruby-version"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/pantry.rb
+- lib/pantry/configuration_error.rb
+- lib/pantry/dry_good.rb
+- lib/pantry/stocked.rb
+- lib/pantry/version.rb
+- pantry.gemspec
+homepage: 
+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.6.9
+signing_key: 
+specification_version: 4
+summary: Before you go to the store, check the pantry!
+test_files: []