fat_cache 0.0.5 → 0.0.6

data/VERSION

@@ -1 +1 @@
-0.0.5
+0.0.6

data/lib/fat_cache.rb

@@ -4,29 +4,22 @@ class FatCache
 
   class << self
     @initted = false
-    attr_accessor :fetchers, :fatcache, :indexed_fatcache
-
-    def store(*key_and_maybe_data, &fetcher)
-      init unless initted? # for first time store
-
-      if key_and_maybe_data.length == 2 && fetcher.nil?
-        key, data = key_and_maybe_data
-        fatcache[key] = data
-      elsif key_and_maybe_data.length == 1 && fetcher
-        key = key_and_maybe_data.first
-        fetchers[key] = fetcher
-        fatcache[key] = fetcher.call
-      else
-        argstr   = "#{key_and_maybe_data.length} arguments"
-        blockstr = (block_given?) ? 'a block' : 'no block'
-        raise "Got #{argstr} and #{blockstr}, expected (key, data) or (key) { fetcher block }"
-      end
+    attr_accessor :fatcache, :indexed_fatcache
+    attr_accessor :fetchers, :index_fetchers
+
+    # Simply store value as key
+    def set(key, &fetcher)
+      init unless initted? # for first time set
+
+      fetchers[key] = fetcher
     end
 
+    # Gets from cache or pays fetch cost if necessary to get, raises if none
+    # available
     def get(key)
       unless cached?(key)
         if fetchable?(key)
-          fatcache[key] = fetchers[key].call
+          fetch!(key)
         else
           raise "no data for #{key}" 
         end
@@ -39,23 +32,17 @@ class FatCache
       by      = [*options.delete(:by)]
       using   = [*options.delete(:using)]
       
-      # create index if it doesn't exist
-      index(key, by) unless indexed?(key, by)
-     
-      return indexed_fatcache[key][by][using]
+      fetch_index!(key, by) unless indexed?(key, by)
+
+      indexed_fatcache[key][by][using]
     end
 
     def index(key, on, &block)
-      # must have cache data to work with
-      ensure_cached(key)
-
-      # ensure we're dealing with an array, we're such a friendly API!
-      on = [*on]
+      on = [*on] # ensure we're dealing with an array, we're such a friendly API!
 
-      # init hash if we've never indexed for this key before
-      indexed_fatcache[key] = {} unless indexed_fatcache.has_key?(key)
+      ensure_fetchable(key)
 
-      raw_data = get(key)
+      index_fetchers[key] = {} unless index_fetchers.has_key?(key)
 
       if block
         # make the cache available to the passed block, and ensure that
@@ -65,14 +52,39 @@ class FatCache
 
         # pass each element of the raw data set into the block, which will
         # compute the key for us
-        indexed_fatcache[key][on] = raw_data.group_by(&wrapped_block)
+        index_fetchers[key][on] = lambda { |data| data.group_by(&wrapped_block) }
       else
         # call each method specified in the `on` array once on each element in
         # the raw dataset, and use the results of those calls to key this index
-        indexed_fatcache[key][on] = raw_data.group_by { |x| on.map { |b| x.send(b) } }
+        index_fetchers[key][on] = lambda { |data| data.group_by { |x| on.map { |b| x.send(b) } } }
       end
     end
 
+    def invalidate!(key)
+      return unless cached?(key)
+      
+      indexed_fatcache.delete(key)
+      fatcache.delete(key)
+    end
+
+    def fetch!(key)
+      ensure_fetchable(key)
+      fatcache[key] = fetchers[key].call(self)
+    end
+
+    def fetch_index!(key, on)
+      on = [*on]
+
+      index(key, on) unless index_defined?(key, on)
+
+      # init hash if we've never indexed for this key before
+      indexed_fatcache[key] = {} unless indexed_fatcache.has_key?(key)
+
+      raw_data = get(key)
+
+      indexed_fatcache[key][on] = index_fetchers[key][on].call(raw_data)
+    end
+
     def get_index(key, on)
       on = [*on]
 
@@ -82,14 +94,17 @@ class FatCache
     end
 
     def ensure_cached(key)
-      raise "no data for #{key}" unless cached?(key)
+      raise "no data in cache for #{key}" unless cached?(key)
     end
 
     def ensure_indexed(key, on)
-      ensure_cached(key)
       raise "no index for #{key} on #{on.inspect}" unless indexed?(key, on)
     end
 
+    def ensure_fetchable(key)
+      raise "cannot fetch for #{key}" unless fetchable?(key)
+    end
+
     def cached?(key)
       fatcache && fatcache.has_key?(key)
     end
@@ -103,15 +118,16 @@ class FatCache
     def fetchable?(key)
       fetchers && fetchers.has_key?(key)
     end
-
-    def invalidate(key)
-      init unless initted? 
-      
-      fatcache.delete(key)
+    
+    def index_defined?(key, on)
+      index_fetchers                   && 
+      index_fetchers.has_key?(key)     &&
+      index_fetchers[key].has_key?(on)
     end
 
     def reset!
       self.fetchers         = nil
+      self.index_fetchers   = nil
       self.fatcache         = nil
       self.indexed_fatcache = nil
       @initted              = nil
@@ -121,6 +137,7 @@ class FatCache
 
     def init
       self.fetchers         = {}
+      self.index_fetchers   = {}
       self.fatcache         = {}
       self.indexed_fatcache = {}
       @initted             = true

data/spec/fat_cache_spec.rb

@@ -5,63 +5,71 @@ describe FatCache do
   after  { FatCache.reset! }
 
   describe 'get(key)' do
-    it 'raises an exception if no data is stored for this key' do
+    it 'raises an exception if no data is set for this key' do
       lambda { 
         FatCache.get(:not_there) 
       }.should raise_error(/not_there/)
     end
 
-    describe 'when data has been invalidated for a key with a fetcher' do
-      it 'uses a fetcher to get new data' do
-        i = 0
-        FatCache.store(:increment) { i += 1 }
-        FatCache.invalidate(:increment)
-        FatCache.get(:increment).should == 2
-      end
+    it 'uses specified fetcher to get new data' do
+      needy = mock('needy')
+      needy.should_receive(:called).once
+      FatCache.set(:call_me) { needy.called }
+      FatCache.get(:call_me)
     end
-  end
 
-  describe 'store(key[, data])' do
-    describe 'when called with key and data arguments' do
-      it 'stores data for specified key' do
-        FatCache.store(:five_alive, 5)
-        FatCache.get(:five_alive).should == 5
-      end
+    it 'calls the block only once, caching the data returned' do
+      i = 0
+      FatCache.set(:increment) { i += 1 }
 
-      it 'properly stores nil for key if explicitly specified' do
-        FatCache.store(:empty_inside, nil)
-        FatCache.get(:empty_inside).should be_nil
-      end
+      first_result = FatCache.get(:increment)
+      second_result = FatCache.get(:increment)
+
+      first_result.should == 1
+      second_result.should == 1
     end
+  end
 
-    describe 'when called with key and fetcher block' do
-      it 'uses block as fetcher to retrieve data to store' do
-        FatCache.store(:fetched_from_block) { 'cheese sandwich' }
-        FatCache.get(:fetched_from_block).should == 'cheese sandwich'
-      end
+  describe 'set(key) { fetcher_block }' do
+    it 'does not evaluate fetcher_block' do
+      independent = mock('independent')
+      independent.should_not_receive(:called)
+      FatCache.set(:dont_need_you) { independent.called }
+    end
 
-      it 'calls the block only once, caching the data returned' do
-        i = 0
-        FatCache.store(:increment) { i += 1 }
+    it 'makes data available on get' do
+      FatCache.set(:fetched_from_block) { 'cheese sandwich' }
+      FatCache.get(:fetched_from_block).should == 'cheese sandwich'
+    end
+  end
 
-        first_result = FatCache.get(:increment)
-        second_result = FatCache.get(:increment)
+  describe 'fetch!(key)' do
+    it 'activates evaluation of a fetcher block' do
+      needy = mock('needy')
+      needy.should_receive(:called)
+      FatCache.set(:call_me) { needy.called }
+      FatCache.fetch!(:call_me)
+    end
 
-        first_result.should == 1
-        second_result.should == 1
-      end
+    it 'prevents evaluation fetcher block in future gets' do
+      fool_me_once = stub('fool_me_once')
+      fool_me_once.should_receive(:fooled!).once
+
+      FatCache.set(:dont_fool_me_twice) { fool_me_once.fooled! }
+      FatCache.fetch!(:dont_fool_me_twice)
+      FatCache.get(:dont_fool_me_twice)
     end
   end
 
   describe 'lookup(key, :by => [:method_names], :using => [:index_key])' do
-    it 'returns a records stored in the dataset specified by key, indexed by the specified methods, and with the following key to the index' do
-      FatCache.store(:a_set, [0,1,2,3,4,5])
+    it 'returns a records set in the dataset specified by key, indexed by the specified methods, and with the following key to the index' do
+      FatCache.set(:a_set) { [0,1,2,3,4,5] }
       result = FatCache.lookup(:a_set, :by => :odd?, :using => true)
       result.should == [1,3,5]
     end
 
     it 'works with multi-element index keys' do
-      FatCache.store(:a_set, [0,1,2,3,4,5])
+      FatCache.set(:a_set) { [0,1,2,3,4,5] }
       result = FatCache.lookup(:a_set, :by => [:even?, :zero?], :using => [true, true])
       result.should == [0]
     end
@@ -69,13 +77,14 @@ describe FatCache do
 
   describe 'get_index(key, on)' do
     it 'returns the given index for a key' do
-      FatCache.store(:numbers, [0,1,2,3,4])
+      FatCache.set(:numbers) { [0,1,2,3,4] }
       FatCache.index(:numbers, :odd?)
+      FatCache.fetch_index!(:numbers, :odd?)
       FatCache.get_index(:numbers, :odd?).should be_a Hash
     end
 
     it 'raises an error if no index exists for on specified key' do
-      FatCache.store(:indexed_one_way, [123])
+      FatCache.set(:indexed_one_way) { [123] }
       FatCache.index(:indexed_one_way, :zero?)
       lambda {
         FatCache.get_index(:indexed_one_way, :odd?)
@@ -91,9 +100,10 @@ describe FatCache do
     end
 
     it 'raises an error if the elements of the dataset do not respond to the index key methods' do
-      FatCache.store(:numbers, [1,2,3,4,5,6])
+      FatCache.set(:numbers) { [1,2,3,4,5,6] }
       lambda {
         FatCache.index(:numbers, :millionaire?)
+        FatCache.fetch_index!(:numbers, :millionaire?)
       }.should raise_error(/millionaire?/)
     end
     
@@ -104,11 +114,12 @@ describe FatCache do
           stub(:banana, :grams_of_awesome => 10),
           stub(:apple,  :grams_of_awesome => 3)
         ]
-        FatCache.store(:fruit, @fruit)
+        FatCache.set(:fruit) { @fruit }
       end
 
       it 'calls each method specified in `on` array and uses the results as the index key' do
         FatCache.index(:fruit, [:grams_of_awesome])
+        FatCache.fetch_index!(:fruit, [:grams_of_awesome])
         index = FatCache.get_index(:fruit, :grams_of_awesome)
         index.keys.should =~ [[3],[10]]
       end
@@ -134,33 +145,35 @@ describe FatCache do
         it 'passes each item into the block as the second argument' do
           FatCache.get(:fruit).each { |f| f.should_receive(:seen) }
           FatCache.index(:fruit, :grams_of_awesome) { |_, item| item.seen }
+          FatCache.fetch_index!(:fruit, :grams_of_awesome)
         end
       end
     end
 
   end
 
-  describe 'invalidate(key)' do
+  describe 'invalidate!(key)' do
     describe 'when no fetcher has been specified for key' do
       it 'returns the last value the cache had for the key' do
-        FatCache.store(:once_upon_a_time, 33)  
-        retval = FatCache.invalidate(:once_upon_a_time)
+        FatCache.set(:once_upon_a_time) { 33 }  
+        FatCache.get(:once_upon_a_time)
+        retval = FatCache.invalidate!(:once_upon_a_time)
         retval.should == 33
       end
 
-      it 'removes data stored for a given key' do
-        FatCache.store(:there_and_gone, 100)  
-        FatCache.invalidate(:there_and_gone)
-        lambda {
-          FatCache.get(:there_and_gone)
-        }.should raise_error(/there_and_gone/)
+      it 'causes data to be retreived from the fetcher again' do
+        i = 0
+        FatCache.set(:increment) { i += 1 }
+        FatCache.get(:increment).should == 1
+        FatCache.invalidate!(:increment)
+        FatCache.get(:increment).should == 2
       end
     end
 
     describe 'when a fetcher has been specified for a key' do
       it 'does not clear out the fetcher, which can be used in the next lookup' do
-        FatCache.store(:fetch_me) { "I've been fetched" }
-        FatCache.invalidate(:fetch_me)
+        FatCache.set(:fetch_me) { "I've been fetched" }
+        FatCache.invalidate!(:fetch_me)
         FatCache.get(:fetch_me).should == "I've been fetched" 
       end
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: fat_cache
 version: !ruby/object:Gem::Version 
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors: 
 - phinze
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-03 00:00:00 -06:00
+date: 2010-03-05 00:00:00 -06:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency