memcacheable 0.0.2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8ada7260a91b22ee55210e38fced1ee123e23c2e
-  data.tar.gz: 86e4b7113bc21f837d3b17261b6bf00f589db6b0
+  metadata.gz: 83bbf521df93a4a60b8a30d553026ad529de5a4a
+  data.tar.gz: b4c06414324517d18d7baeb121340b190784d418
 SHA512:
-  metadata.gz: 64ab2b3303b5f27c66eef23cfe426ccc98d925995cdcc20ba631e4348d6bad53319aca7c8b311cc85a82b2fa60f76582f368579d08f2f2241e75a5a25538ea51
-  data.tar.gz: 15c657ebc23dc4b4807423d5e0c317709cf9005ad675c9030e601f0bd86e52d834eeaa37804c1fd4c158749d49b676366ca24833b14f0a82a012ae6e61e7fab7
+  metadata.gz: 70da4d0ccb557357110e24298fc01b41995b3da99ead6ebd23d85101ea45cecfdeb26e7476d303a2e2894d5154ca3fc1cd6ea0d5900b1e4cecc3aa6376a36bd6
+  data.tar.gz: 0365dced8c66ecd9f3a9e0577a187ef7e62d9de21dc88816c7f17737943be9f7a706c5678ace823b50ae9837b17bc60c4466c046ef811e3daff5d9750d7e314b

data/README.md

@@ -26,7 +26,7 @@ class Person < ActiveRecord::Base
 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`.
+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
@@ -62,7 +62,7 @@ person = Person.fetch_by weight: 175, height: 71  # fetched and cached with new
 Like noise in your life?  Try `fetch_by!` (hard to say: "fetch-by-bang!").
 
 ```ruby
-person = Person.fetch_by! name: 'Mork'  # => raises ActiveRecord::RecordNotFound
+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`:
@@ -88,7 +88,7 @@ Btw, don't do something stupid like trying to call scope methods on the result o
 Person.fetch_where(height: 60).limit(5)
 ```
 
-I may fix this later, though, because I like scopes.
+If you want something very similar to scopes, keep reading to learn about [caching methods](https://github.com/flintinatux/memcacheable#cache-methods).
 
 ### Cache associations
 
@@ -138,6 +138,31 @@ 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
 ```
 
+### Cache methods
+
+Does your model have a method that eats up lots of calculation time, or perhaps a scope-like method that requires a database query?  Cache that bad boy!
+
+```ruby
+class Person < ActiveRecord::Base
+  has_many :kittens
+  
+  include Memcacheable
+  cache_method :random_kitten
+  
+  def random_kitten(seed=Random.new_seed)
+    kittens.sample(Random.new seed)
+  end
+end
+```
+
+**Voila!** Now you get a nice fetch method to cache the results:
+
+```ruby
+person.fetch_random_kitten(12345)   # => gets your random kitty, and then caches it
+```
+
+Notice that the fetch method accepts the same args as the original.  **Caveat:** blocks are not accepted, unfortunately.  I love blocks, but they don't have a consistent identifier to include in a cache key.  So feel free to get creative with args, but not blocks.
+
 ## 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/).

data/lib/memcacheable.rb

@@ -10,6 +10,7 @@ module Memcacheable
   autoload :FetchByCriteria
   autoload :FetchHasMany
   autoload :FetchHasOne
+  autoload :FetchMethod
   autoload :FetchOne
   autoload :FetchWhere
   autoload :Fetcher
@@ -52,6 +53,14 @@ module Memcacheable
       self.cached_indexes << fields.map(&:to_sym).sort
     end
 
+    def cache_method(*methods)
+      methods.each do |method|
+        define_method "fetch_#{method}" do |*args|
+          FetchMethod.new(self, method, args).fetch
+        end
+      end
+    end
+
     def fetch(id)
       FetchOne.new(self, id).fetch
     end

data/lib/memcacheable/fetch_belongs_to.rb

@@ -1,11 +1,16 @@
 module Memcacheable
   class FetchBelongsTo < FetchAssociation
+    def fetchable?
+      klass.respond_to?(:fetch)
+    end
 
     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
+      fetchable? ? klass.fetch(id) : object.send(association) rescue nil
+    end
+
+    def klass
+      @klass ||= association.to_s.camelize.constantize
     end
-    
   end
 end

data/lib/memcacheable/fetch_has_many.rb

@@ -6,7 +6,7 @@ module Memcacheable
 
     def find_on_cache_miss
       criteria = { "#{class_name}_id" => object.id }
-      fetchable? ? klass.fetch_where(criteria) : klass.where(criteria).to_a
+      fetchable? ? klass.fetch_where(criteria) : object.send(association).to_a
     end
 
     def klass

data/lib/memcacheable/fetch_has_one.rb

@@ -6,7 +6,7 @@ module Memcacheable
 
     def find_on_cache_miss
       criteria = { "#{class_name}_id" => object.id }
-      fetchable? ? klass.fetch_by(criteria) : klass.find_by(criteria)
+      fetchable? ? klass.fetch_by(criteria) : object.send(association)
     end
 
     def klass

data/lib/memcacheable/fetch_method.rb

@@ -0,0 +1,23 @@
+module Memcacheable
+  class FetchMethod < Fetcher
+    attr_accessor :object, :method, :args
+
+    def initialize(object, method, args)
+      self.object = object
+      self.method = method
+      self.args = args
+    end
+
+    def cache_key
+      [object, method, args]
+    end
+
+    def description
+      "method #{cache_key.to_param}"
+    end
+
+    def find_on_cache_miss
+      object.send method, *args
+    end
+  end
+end

data/lib/memcacheable/version.rb

@@ -1,3 +1,3 @@
 module Memcacheable
-  VERSION = "0.0.2"
+  VERSION = "0.1.0"
 end

data/spec/lib/memcacheable_spec.rb

@@ -20,6 +20,11 @@ class Kitten < FakeModel
   include Memcacheable
   cache_index :person_id
   cache_belongs_to :person
+  cache_method :meow
+
+  def meow(how_many=1)
+    how_many.times.map{ 'meow' }.join ' '
+  end
 end
 
 describe Memcacheable do
@@ -175,6 +180,7 @@ describe Memcacheable do
   describe '::cache_has_one' do
     let(:dog) { Dog.new person_id: id }
     before do
+      person.stub(:dog).and_return dog
       Dog.stub(:find_by) do |criteria|
         criteria.all?{ |k,v| dog.send(k) == v } ? dog : nil
       end  
@@ -189,7 +195,7 @@ describe Memcacheable do
     end
 
     it "only queries once and then caches" do
-      Dog.should_receive(:find_by).once
+      person.should_receive(:dog).once
       person.fetch_dog
       person.fetch_dog
     end
@@ -197,7 +203,7 @@ describe Memcacheable do
     it "flushes when touched by association" do
       person.fetch_dog
       person.touch
-      Dog.should_receive(:find_by).once
+      person.should_receive(:dog).once
       person.fetch_dog
     end
   end
@@ -269,4 +275,29 @@ describe Memcacheable do
       person.fetch_kittens
     end
   end
+
+  describe '::cache_method' do
+    let(:kitten) { Kitten.new }
+
+    it "defines a new fetch method" do
+      kitten.should.respond_to?(:fetch_meow)
+    end
+
+    it "calls down to the method correctly on cache miss" do
+      kitten.fetch_meow(3) { |sound| sound.upcase }.should eq 'meow meow meow'
+    end
+
+    it "only queries once and then caches" do
+      kitten.should_receive(:meow).once
+      kitten.fetch_meow
+      kitten.fetch_meow
+    end
+
+    it "flushed when touched by an association" do
+      kitten.fetch_meow
+      kitten.touch
+      kitten.should_receive(:meow).once
+      kitten.fetch_meow
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: memcacheable
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
 platform: ruby
 authors:
 - Scott McCormack
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-30 00:00:00.000000000 Z
+date: 2013-07-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -116,6 +116,7 @@ files:
 - lib/memcacheable/fetch_by_criteria.rb
 - lib/memcacheable/fetch_has_many.rb
 - lib/memcacheable/fetch_has_one.rb
+- lib/memcacheable/fetch_method.rb
 - lib/memcacheable/fetch_one.rb
 - lib/memcacheable/fetch_where.rb
 - lib/memcacheable/fetcher.rb