memcacheable 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0260c3ba7467a592bc787a2fb66355703ef1d31f
+  data.tar.gz: 093f304c2591ff664e671f03f6972f2cf0c9b4f2
+SHA512:
+  metadata.gz: 3dbd55c9b08ad60a26a148c2659c2052cd00806b6d3d9d4e5214922b728418616ae73b7e1e803946b9a457b1c3b1ee230b1f79048d53f5e02260767be6b16ea7
+  data.tar.gz: 6cfeed9c6dd105f8aafe8c2b5d30e1b461f27ca35ba84d753350bf65952bb535774be1226b9d4b36c6104730d2dd755c9bb56f584bc34bb690e45cab0a596a2c

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+bundler_stubs/
+.ruby-version

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Scott McCormack
+
+MIT License
+
+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,151 @@
+# Memcacheable [![Build Status](https://travis-ci.org/flintinatux/memcacheable.png)](https://travis-ci.org/flintinatux/memcacheable) [![Dependency Status](https://gemnasium.com/flintinatux/memcacheable.png)](https://gemnasium.com/flintinatux/memcacheable) [![Code Climate](https://codeclimate.com/github/flintinatux/memcacheable.png)](https://codeclimate.com/github/flintinatux/memcacheable)
+
+A Rails concern to make caching ActiveRecord objects as dead-simple as possible. Uses the built-in Rails.cache mechanism, and implements the new finder methods available in Rails 4.0 to ensure maximum future compatibility.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'memcacheable'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install memcacheable
+
+## Usage
+
+Let's do some caching!
+
+```ruby
+class Person < ActiveRecord::Base
+  include Memcacheable
+end
+```
+
+Boom!  Now you can `fetch` a person by their id, like below.  When the person gets updated or touched, it will flush the cache, and the person will be reloaded on the next `fetch`.
+
+```ruby
+person = Person.fetch id  # caches the person
+person.touch              # flushes the cache
+person = Person.fetch id  # the cache misses, and the person is reloaded
+```
+
+### Cache by criteria
+
+That's easy-sauce.  Time to step up our caching game!  _"I want to cache queries by criteria, not just id's!"_  No probs:
+
+```ruby
+class Person < ActiveRecord::Base
+  include Memcacheable
+  cache_index :name
+  cache_index :height, :weight
+end
+```
+
+Powerhouse time!  `cache_index` adds these index combinations to the list of cacheable things, so we can fetch single records with `fetch_by`, like this:
+
+```ruby
+person = Person.fetch_by name: 'Scott'    # caches an awesome dude
+person.update_attributes name: 'Scottie'  # flushes the cache
+person = Person.fetch_by name: 'Scott'    # => nil (he's got a new identity!)
+
+# You can also do multiple criteria, and order doesn't matter.
+person = Person.fetch_by weight: 175, height: 72
+person.update_attributes height: 71               # he shrunk? oh well, cache flushed
+person = Person.fetch_by weight: 175, height: 71  # fetched and cached with new height
+```
+
+Like noise in your life?  Try `fetch_by!` (hard to say: "fetch-by-_bang!_").
+
+```ruby
+person = Person.fetch_by! name: 'Mork'  # => ActiveRecord::RecordNotFound
+```
+
+While `fetch_by` just pulls back just one record, you can fetch a collection with `fetch_where`:
+
+```ruby
+people = Person.fetch_where weight: 42, height: 120  # => an array of tall, skinny people
+people.first.update_attributes weight: 43            # one guy gained a little weight --> cache flushed
+people = Person.fetch_where weight: 42, height: 120  # => an array of everyone but that first guy
+```
+
+Trying to `fetch_by` or `fetch_where` by criteria that you didn't specify with `cache_index` will raise an error, because Memcacheable won't know how to bust the cache when things get changed.  For example:
+
+```ruby
+Person.fetch_by name: 'Scott'           # good
+Person.fetch_by favorite_color: 'red'   # shame on you! this wasn't cache_index'd!
+```
+
+**Caveat:** hash-style criteria is currently **required** for `fetch_by` and `fetch_where`.  Something like `person.fetch_where 'height < ?', 71` will raise an error.
+
+Btw, don't do something stupid like trying to call scope methods on the result of a `fetch_where`.  It returns an `Array`, not an `ActiveRecord::Relation`.  That means this will blow up on you:
+
+```ruby
+Person.fetch_where(height: 60).limit(5)
+```
+
+I may fix this later, though, because I like scopes.
+
+### Cache associations
+
+If you love Rails, then you know you love ActiveRecord associations.  Memcacheable loves them too.  Check this out:
+
+```ruby
+class Person < ActiveRecord::Base
+  has_one  :dog
+  has_many :kittens
+  
+  include Memcacheable
+  cache_has_one  :dog
+  cache_has_many :kittens
+end
+
+class Dog < ActiveRecord::Base
+  belongs_to :person, touch: true
+  
+  include Memcacheable
+  cache_belongs_to :person
+end
+
+class Kitten < ActiveRecord::Base
+  belongs_to :person, touch: true
+  
+  include Memcacheable
+  cache_index :person_id
+end
+```
+
+**Notice** the `touch: true` above.  That's important to bust the parent cache when a child record is updated!
+
+So what do we get with all of this caching magic?  Why a bunch of dynamic association fetch methods of course! Observe:
+
+```ruby
+dog = person.fetch_dog              # his name's Bruiser, btw
+dog.update_attributes name: 'Fido'  # flushes the cached association on the person
+dog = person.fetch_dog              # finds and caches Fido with his new name
+dog.fetch_person                    # gets the cached owner
+```
+
+For a slight optimization, specify a `cache_index` on the foreign key of the association, like in the `Kitten` example above.  Memcacheable will then do a `fetch_by` or `fetch_where` as appropriate.  The cost: two copies in the cache.  The gain: when the parent changes but the children don't, the children can be reloaded from the cache.  Like this:
+
+```ruby
+person.fetch_kittens  # caches the kittens both by criteria and as an association
+person.touch          # association cache is flushed, but not the fetch_where
+person.fetch_kittens  # reloads the kittens from the cache, and caches as an association
+```
+
+## Inspiration
+
+None of the caching options out there really satisfied my needs, so I wrote this gem.  But I was not without inspiration.  I learned the basics of Rails caching from the [RailsCasts](http://railscasts.com/) episode on [Model Caching](http://railscasts.com/episodes/115-model-caching-revised), and I borrowed a lot of syntax from the very popular [IdentityCache gem](https://github.com/Shopify/identity_cache) from our friends at [Shopify](http://www.shopify.com/).
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

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

data/lib/memcacheable.rb

@@ -0,0 +1,71 @@
+require 'memcacheable/version'
+
+module Memcacheable
+  extend ActiveSupport::Autoload
+  extend ActiveSupport::Concern
+
+  autoload :FetchAssociation
+  autoload :FetchBelongsTo
+  autoload :FetchBy
+  autoload :FetchByCriteria
+  autoload :FetchHasMany
+  autoload :FetchHasOne
+  autoload :FetchOne
+  autoload :FetchWhere
+  autoload :Fetcher
+  autoload :Flusher
+
+  included do
+    cattr_accessor :cached_indexes do []; end
+    after_commit :flush_cache
+  end
+
+  def flush_cache
+    Flusher.new(self).flush
+  end
+
+  def touch
+    super
+    flush_cache
+  end
+
+  module ClassMethods
+    def cache_belongs_to(association)
+      define_method "fetch_#{association}" do
+        FetchBelongsTo.new(self, association).fetch
+      end
+    end
+
+    def cache_has_one(association)
+      define_method "fetch_#{association}" do
+        FetchHasOne.new(self, association).fetch
+      end
+    end
+
+    def cache_has_many(association)
+      define_method "fetch_#{association}" do
+        FetchHasMany.new(self, association).fetch
+      end
+    end
+
+    def cache_index(*fields)
+      self.cached_indexes << fields.map(&:to_sym).sort
+    end
+
+    def fetch(id)
+      FetchOne.new(self, id).fetch
+    end
+
+    def fetch_by(*args)
+      FetchBy.new(self, *args).fetch
+    end
+
+    def fetch_by!(*args)
+      fetch_by(*args) || raise(ActiveRecord::RecordNotFound)
+    end
+
+    def fetch_where(*args)
+      FetchWhere.new(self, *args).fetch
+    end
+  end
+end

data/lib/memcacheable/fetch_association.rb

@@ -0,0 +1,22 @@
+module Memcacheable
+  class FetchAssociation < Fetcher
+    attr_accessor :object, :association
+
+    def initialize(object, association)
+      self.object = object
+      self.association = association  
+    end
+
+    def cache_key
+      [object, association]
+    end
+    
+    def class_name
+      object.class.name.downcase
+    end
+
+    def description
+      "#{association} for #{class_name} #{object.id}"
+    end
+  end
+end

data/lib/memcacheable/fetch_belongs_to.rb

@@ -0,0 +1,11 @@
+module Memcacheable
+  class FetchBelongsTo < FetchAssociation
+
+    def find_on_cache_miss
+      klass = association.to_s.camelize.constantize
+      id = object.send "#{association}_id"
+      klass.respond_to?(:fetch) ? klass.fetch(id) : klass.find(id) rescue nil
+    end
+    
+  end
+end

data/lib/memcacheable/fetch_by.rb

@@ -0,0 +1,15 @@
+module Memcacheable
+  class FetchBy < FetchByCriteria
+    def cache_key
+      {what: klass.name.downcase}.merge criteria
+    end
+
+    def description
+      "#{klass.name.downcase} with #{criteria.inspect}"
+    end
+
+    def find_on_cache_miss
+      klass.find_by criteria
+    end
+  end
+end

data/lib/memcacheable/fetch_by_criteria.rb

@@ -0,0 +1,16 @@
+module Memcacheable
+  class FetchByCriteria < Fetcher
+    attr_accessor :klass, :criteria
+
+    def criteria_cacheable?
+      klass.cached_indexes.include? criteria.keys.map(&:to_sym).sort
+    end
+
+    def initialize(klass, *args)
+      self.klass = klass
+      self.criteria = args.extract_options!
+      raise "Only hash-style args accepted! Illegal args: #{args.inspect}" if args.any?
+      raise "No cache_index found in #{klass.name} matching fields #{criteria.keys.inspect}!" unless criteria_cacheable? 
+    end
+  end
+end

data/lib/memcacheable/fetch_has_many.rb

@@ -0,0 +1,16 @@
+module Memcacheable
+  class FetchHasMany < FetchAssociation
+    def fetchable?
+      klass.respond_to?(:fetch_where) && klass.cached_indexes.include?(["#{class_name}_id".to_sym])
+    end
+
+    def find_on_cache_miss
+      criteria = { "#{class_name}_id" => object.id }
+      fetchable? ? klass.fetch_where(criteria) : klass.where(criteria).to_a
+    end
+
+    def klass
+      @klass ||= association.to_s.classify.constantize
+    end
+  end
+end

data/lib/memcacheable/fetch_has_one.rb

@@ -0,0 +1,16 @@
+module Memcacheable
+  class FetchHasOne < FetchAssociation
+    def fetchable?
+      klass.respond_to?(:fetch_by) && klass.cached_indexes.include?(["#{class_name}_id".to_sym])
+    end
+
+    def find_on_cache_miss
+      criteria = { "#{class_name}_id" => object.id }
+      fetchable? ? klass.fetch_by(criteria) : klass.find_by(criteria)
+    end
+
+    def klass
+      @klass ||= association.to_s.camelize.constantize
+    end
+  end
+end

data/lib/memcacheable/fetch_one.rb

@@ -0,0 +1,22 @@
+module Memcacheable
+  class FetchOne < Fetcher
+    attr_accessor :klass, :id
+
+    def initialize(klass, id)
+      self.klass = klass
+      self.id = id  
+    end
+
+    def cache_key
+      [klass.name.downcase, id]
+    end
+
+    def description
+      "#{klass.name.downcase} #{id}"
+    end
+
+    def find_on_cache_miss
+      klass.find id
+    end
+  end
+end

data/lib/memcacheable/fetch_where.rb

@@ -0,0 +1,15 @@
+module Memcacheable
+  class FetchWhere < FetchByCriteria
+    def cache_key
+      {what: klass.name.tableize}.merge criteria
+    end
+
+    def description
+      "#{klass.name.tableize} with #{criteria.inspect}"
+    end
+
+    def find_on_cache_miss
+      klass.where(criteria).to_a
+    end
+  end
+end

data/lib/memcacheable/fetcher.rb

@@ -0,0 +1,19 @@
+module Memcacheable
+  class Fetcher
+    def debug(action)
+      Rails.logger.debug "[memcacheable] #{action} #{description}"
+    end
+
+    def fetch
+      debug :read
+      Rails.cache.fetch cache_key do
+        debug :write
+        find_on_cache_miss
+      end
+    end
+
+    def flush
+      Rails.cache.delete cache_key
+    end
+  end
+end

data/lib/memcacheable/flusher.rb

@@ -0,0 +1,30 @@
+module Memcacheable
+  class Flusher
+    attr_accessor :object
+
+    OLD_VAL = 0
+    NEW_VAL = 1
+
+    def initialize(object)
+      self.object = object
+    end
+
+    def changed_criteria_for(which, fields)
+      fields.inject({}) do |hash, field|
+        value = object.previous_changes[field][which] rescue object.send(field)
+        hash.merge! field => value
+      end
+    end
+
+    def flush
+      FetchOne.new(object.class, object.id).flush
+      object.cached_indexes.each do |fields|
+        [OLD_VAL,NEW_VAL].each do |which|
+          criteria = changed_criteria_for which, fields
+          FetchBy.new(object.class, criteria).flush
+          FetchWhere.new(object.class, criteria).flush
+        end
+      end
+    end
+  end
+end

data/lib/memcacheable/version.rb

@@ -0,0 +1,3 @@
+module Memcacheable
+  VERSION = "0.0.1"
+end

data/memcacheable.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'memcacheable/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'memcacheable'
+  spec.version       = Memcacheable::VERSION
+  spec.authors       = ['Scott McCormack']
+  spec.email         = ['flintinatux@gmail.com']
+  spec.description   = %q{A Rails concern to make caching ActiveRecord objects as dead-simple as possible. Uses the built-in Rails.cache mechanism, and implements the new finder methods available in Rails 4.0 to ensure maximum future compatibility.}
+  spec.summary       = spec.description
+  spec.homepage      = 'https://github.com/flintinatux/memcacheable'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'activerecord',  '>= 4.0.0'
+  spec.add_dependency 'activesupport', '>= 4.0.0'
+
+  spec.add_development_dependency 'activemodel', '>= 4.0.0'
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec', '~> 2.13'
+end

data/spec/lib/memcacheable_spec.rb

@@ -0,0 +1,272 @@
+require 'spec_helper'
+
+class Person < FakeModel
+  define_attribute :color, :number, :dog_id
+
+  include Memcacheable
+  cache_index :number
+  cache_index :color, :number
+  cache_has_one  :dog
+  cache_has_many :kittens
+end
+
+class Dog < FakeModel
+  define_attribute :person_id
+  include Memcacheable
+end
+
+class Kitten < FakeModel
+  define_attribute :person_id
+  include Memcacheable
+  cache_index :person_id
+  cache_belongs_to :person
+end
+
+describe Memcacheable do
+  let(:id)     { 123 }
+  let(:person) { Person.new id: id, color: 'red', number: 42 }
+
+  before :all do
+    unless defined?(Rails)
+      class Rails; cattr_accessor :cache, :logger; end
+      Rails.cache  = ActiveSupport::Cache::MemoryStore.new
+      Rails.logger = ActiveSupport::Logger.new(STDOUT)
+      Rails.logger.level = 3
+    end
+  end
+
+  after { Rails.cache.clear }
+  
+  describe '::fetch' do
+    before do
+      Person.stub(:find).with(id).and_return person
+    end
+
+    it "finds the correct record" do
+      Person.fetch(id).should eq person
+    end
+
+    it "only queries once and then caches" do
+      Person.should_receive(:find).once
+      Person.fetch id
+      Person.fetch id
+    end
+  end
+
+  describe '#touch' do
+    before do
+      Person.stub(:find).with(id).and_return person
+    end
+
+    it "flushes the cache" do
+      Person.fetch(id).touch
+      Person.should_receive(:find).once
+      Person.fetch id
+    end
+  end
+
+  describe '::fetch_by' do
+    let(:good_criteria) {{ number: 42, color: 'red' }}
+
+    before do
+      Person.stub(:find_by) do |criteria|
+        criteria.all?{ |k,v| person.send(k) == v } ? person : nil
+      end
+    end
+
+    it "finds the correct record" do
+      Person.fetch_by(good_criteria).should eq person
+    end
+
+    it "only queries once and then caches" do
+      Person.should_receive(:find_by).once
+      Person.fetch_by good_criteria
+      Person.fetch_by good_criteria
+    end
+
+    it "raises on non-hash style args" do
+      expect { Person.fetch_by 'color = ?', 'red' }.to raise_error
+    end
+
+    it "raises on non-cached indexes" do
+      expect { Person.fetch_by color: 'red' }.to raise_error
+    end
+
+    it "flushes when model updated" do
+      person = Person.fetch_by good_criteria
+      person.update_attributes number: 7
+      Person.should_receive(:find_by).once
+      Person.fetch_by good_criteria
+    end
+  end
+
+  describe '::fetch_by!' do
+    before do
+      Person.stub(:find_by).and_return nil
+    end
+
+    it "raises error on nil result" do
+      expect { Person.fetch_by!(number: 42) }.to raise_error(ActiveRecord::RecordNotFound)
+    end
+  end
+
+  describe 'flushing cached_indexes' do
+    let(:old_num) {{ number: 42 }}
+    let(:new_num) {{ number: 21 }}
+    let(:old_person) {{ person_id: id }}
+    let(:new_person) {{ person_id: 345 }}
+    let(:kittens) { 3.times.map { Kitten.new person_id: id} }
+
+    before do
+      Person.stub(:find_by) do |criteria|
+        criteria.all?{ |k,v| person.send(k) == v } ? person : nil
+      end
+      Kitten.stub(:where) do |criteria|
+        kittens.select do |kitten|
+          criteria.all? { |k,v| kitten.send(k) == v }
+        end
+      end
+    end
+
+    it "flushes old and new values for cached_indexes" do
+      Person.fetch_by(old_num).should eq person
+      Person.fetch_by(new_num).should eq nil
+      person.update_attributes new_num
+      Person.fetch_by(old_num).should eq nil
+      Person.fetch_by(new_num).should eq person
+
+      Kitten.fetch_where(old_person).should eq kittens
+      Kitten.fetch_where(new_person).should eq []
+      kittens.each { |k| k.update_attributes new_person }
+      Kitten.fetch_where(old_person).should eq []
+      Kitten.fetch_where(new_person).should eq kittens
+    end
+  end
+
+  describe '::cache_belongs_to' do
+    let(:kitten) { Kitten.new person_id: id }
+    before do
+      Person.stub(:find).and_return nil
+      Person.stub(:find).with(id).and_return person 
+    end
+
+    it "defines a new fetch method" do
+      kitten.should.respond_to? :fetch_person
+    end
+
+    it "fetches the correct object" do
+      kitten.fetch_person.should eq person
+    end
+
+    it "only queries once and then caches" do
+      Person.should_receive(:fetch).once
+      kitten.fetch_person
+      kitten.fetch_person
+    end
+
+    it "flushes when touched by association" do
+      kitten.fetch_person
+      kitten.touch
+      Person.should_receive(:fetch).once
+      kitten.fetch_person
+    end
+  end
+
+  describe '::cache_has_one' do
+    let(:dog) { Dog.new person_id: id }
+    before do
+      Dog.stub(:find_by) do |criteria|
+        criteria.all?{ |k,v| dog.send(k) == v } ? dog : nil
+      end  
+    end
+
+    it "defines a new fetch method" do
+      person.should.respond_to? :fetch_dog
+    end
+
+    it "fetches the correct object" do
+      person.fetch_dog.should eq dog
+    end
+
+    it "only queries once and then caches" do
+      Dog.should_receive(:find_by).once
+      person.fetch_dog
+      person.fetch_dog
+    end
+
+    it "flushes when touched by association" do
+      person.fetch_dog
+      person.touch
+      Dog.should_receive(:find_by).once
+      person.fetch_dog
+    end
+  end
+
+  describe '::fetch_where' do
+    let(:kittens) { 3.times.map { Kitten.new person_id: id} }
+    before do
+      Kitten.stub(:where) do |criteria|
+        kittens.select do |kitten|
+          criteria.all? { |k,v| kitten.send(k) == v }
+        end
+      end
+    end
+
+    it "fetches the correct objects" do
+      Kitten.fetch_where(person_id: id).should eq kittens
+    end
+
+    it "only queries once and then caches" do
+      Kitten.should_receive(:where).once
+      Kitten.fetch_where person_id: id
+      Kitten.fetch_where person_id: id
+    end
+
+    it "raises on non-hash style args" do
+      expect { Kitten.fetch_where 'color = ?', 'red' }.to raise_error
+    end
+
+    it "raises on non-cached indexes" do
+      expect { Kitten.fetch_where id: 123 }.to raise_error
+    end
+
+    it "flushes when model updated" do
+      kittens = Kitten.fetch_where person_id: id
+      kittens.first.update_attributes person_id: 345
+      Kitten.should_receive(:where).once
+      Kitten.fetch_where person_id: id
+    end
+  end
+
+  describe '::cache_has_many' do
+    let(:kittens) { 3.times.map { Kitten.new person_id: id} }
+    before do
+      Kitten.stub(:where) do |criteria|
+        kittens.select do |kitten|
+          criteria.all? { |k,v| kitten.send(k) == v }
+        end
+      end
+    end
+
+    it "defines a new fetch method" do
+      person.should.respond_to? :fetch_kittens
+    end
+
+    it "fetches the correct collection" do
+      person.fetch_kittens.should eq kittens
+    end
+
+    it "only queries once and then caches" do
+      Kitten.should_receive(:fetch_where).once
+      person.fetch_kittens
+      person.fetch_kittens
+    end
+
+    it "flushes when touched by association" do
+      person.fetch_kittens
+      person.touch
+      Kitten.should_receive(:fetch_where).once
+      person.fetch_kittens
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require 'active_model'
+require 'active_record'
+require 'active_support'
+require 'memcacheable'
+
+# Requires supporting ruby files with custom matchers and macros, etc,
+# in spec/support/ and its subdirectories.
+Dir[File.join File.dirname(__FILE__), 'support/**/*.rb'].each {|f| require f}

data/spec/support/fake_model.rb

@@ -0,0 +1,60 @@
+class FakeModel
+  include ActiveModel::Dirty
+  extend  ActiveModel::Callbacks
+
+  define_model_callbacks :commit
+
+  def self.define_attribute(*attrs)
+    attrs.each do |attr_name|
+      define_attribute_method attr_name
+      attr_reader attr_name
+      define_method "#{attr_name}=" do |value|
+        send "#{attr_name}_will_change!" unless value == send(attr_name)
+        instance_variable_set "@#{attr_name}", value
+      end
+    end
+  end
+
+  define_attribute :id, :updated_at
+
+  def initialize(new_attributes={})
+    assign_attributes new_attributes
+    self.updated_at = 0
+    save # to clear all "changes"
+  end
+
+  def cache_key
+    "#{self.class.name.tableize}/#{id}-#{updated_at.to_i}"
+  end
+
+  def commit
+    run_callbacks :commit
+  end
+
+  def save
+    if changes.any?
+      @previously_changed = changes
+      @changed_attributes.clear
+      commit
+      return true
+    end
+    false
+  end
+
+  def touch
+    self.updated_at += 1
+  end
+
+  def update_attributes(new_attributes={})
+    assign_attributes new_attributes
+    save 
+  end
+
+  private
+
+    def assign_attributes(new_attributes={})
+      new_attributes.each do |field, value|
+        send "#{field}=", value
+      end
+    end
+end

metadata

@@ -0,0 +1,157 @@
+--- !ruby/object:Gem::Specification
+name: memcacheable
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Scott McCormack
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-06-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.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+- !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: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.13'
+description: A Rails concern to make caching ActiveRecord objects as dead-simple as
+  possible. Uses the built-in Rails.cache mechanism, and implements the new finder
+  methods available in Rails 4.0 to ensure maximum future compatibility.
+email:
+- flintinatux@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/memcacheable.rb
+- lib/memcacheable/fetch_association.rb
+- lib/memcacheable/fetch_belongs_to.rb
+- lib/memcacheable/fetch_by.rb
+- lib/memcacheable/fetch_by_criteria.rb
+- lib/memcacheable/fetch_has_many.rb
+- lib/memcacheable/fetch_has_one.rb
+- lib/memcacheable/fetch_one.rb
+- lib/memcacheable/fetch_where.rb
+- lib/memcacheable/fetcher.rb
+- lib/memcacheable/flusher.rb
+- lib/memcacheable/version.rb
+- memcacheable.gemspec
+- spec/lib/memcacheable_spec.rb
+- spec/spec_helper.rb
+- spec/support/fake_model.rb
+homepage: https://github.com/flintinatux/memcacheable
+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.0.0.rc.2
+signing_key: 
+specification_version: 4
+summary: A Rails concern to make caching ActiveRecord objects as dead-simple as possible.
+  Uses the built-in Rails.cache mechanism, and implements the new finder methods available
+  in Rails 4.0 to ensure maximum future compatibility.
+test_files:
+- spec/lib/memcacheable_spec.rb
+- spec/spec_helper.rb
+- spec/support/fake_model.rb