Implemented cache! to cache expensive data

This is going to be optimized later to use a fetch multi algorithm and
strings instead of marshalling.

We aren't doing any marshalling here but cache implementations always do
that, like active support cache stores.

By using strings instead of objects we can achieve higher throughput.

The expected interface of the cache store is this:

    cache_store.fetch(key, options, &block)

As you can guess, this is the interface implemented by active support,
so it should be plug n play for rails.

For other cache interfaces, you can implement a driver that have this
interface and maps to your desired interface.

Author: sobrinho

lib/abstract_builder.rb

@@ -1,6 +1,13 @@
+require 'abstract_builder/null_cache'
+
 class AbstractBuilder
   @@format_key = nil
   @@ignore_value = nil
+  @@cache_store = NullCache.new
+
+  def self.cache_store!(cache_store)
+    @@cache_store = cache_store
+  end
 
   def self.format_key!(&block)
     @@format_key = block
@@ -11,9 +18,10 @@ def self.ignore_value!(&block)
   end
 
   def initialize
-    @stack = []
     @format_key = @@format_key
     @ignore_value = @@ignore_value
+    @cache_store = @@cache_store
+    @stack = []
   end
 
   def format_key!(&block)
@@ -24,6 +32,10 @@ def ignore_value!(&block)
     @ignore_value = block
   end
 
+  def cache_store!(cache_store)
+    @cache_store = cache_store
+  end
+
   def set!(key, value)
     @stack << [:set, key, value]
   end
@@ -58,6 +70,16 @@ def array!(key, collection, &block)
     set! key, values
   end
 
+  def cache!(key, options = nil, &block)
+    value = @cache_store.fetch([:abstract_builder, :v1, *key], options) do
+      builder = _inherit
+      block.call(builder)
+      builder.data!
+    end
+
+    merge! value
+  end
+
   def data!
     data = {}
 
@@ -112,6 +134,7 @@ def _inherit
     builder = self.class.new
     builder.format_key!(&@format_key)
     builder.ignore_value!(&@ignore_value)
+    builder.cache_store!(@cache_store)
     builder
   end
 

lib/abstract_builder/null_cache.rb

@@ -0,0 +1,7 @@
+class AbstractBuilder
+  class NullCache
+    def fetch(key, _options = nil, &block)
+      block.call
+    end
+  end
+end

spec/abstract_builder_spec.rb

@@ -44,6 +44,46 @@
     end
   end
 
+  describe "#cache_store!" do
+    let :cache_store do
+      AbstractBuilder::NullCache.new
+    end
+
+    it "caches using the given cache store" do
+      subject.cache_store! cache_store
+
+      expect(cache_store).to receive(:fetch).with([:abstract_builder, :v1, :cache_key], nil).and_call_original
+
+      subject.cache! :cache_key do |builder|
+        builder.cache "hit"
+      end
+    end
+
+    it "caches using the given options" do
+      subject.cache_store! cache_store
+
+      expect(cache_store).to receive(:fetch).with([:abstract_builder, :v1, :cache_key], option: true).and_call_original
+
+      subject.cache! :cache_key, option: true do |builder|
+        builder.cache "hit"
+      end
+    end
+
+    it "inherits the global ignore value by default" do
+      begin
+        AbstractBuilder.cache_store! cache_store
+
+        expect(cache_store).to receive(:fetch).with([:abstract_builder, :v1, :cache_key], nil).and_call_original
+
+        subject.cache! :cache_key do |builder|
+          builder.cache "hit"
+        end
+      ensure
+        AbstractBuilder.cache_store! AbstractBuilder::NullCache.new
+      end
+    end
+  end
+
   describe "#set!" do
     it "sets the key and value" do
       subject.set! :key, "value"
@@ -177,6 +217,68 @@
         )
       end
     end
+
+    context "using cache store" do
+      it "inherits the parent cache store" do
+        subject.cache_store! NaiveCache.new
+
+        subject.cache! :outside_cache_key do |builder|
+          builder.outside_cache "hit"
+        end
+
+        subject.cache! :outside_cache_key do |builder|
+          builder.outside_cache "miss"
+        end
+
+        subject.block! :meta do |meta|
+          meta.cache! :inside_cache_key do |builder|
+            builder.inside_cache "hit"
+          end
+
+          meta.cache! :inside_cache_key do |builder|
+            builder.inside_cache "miss"
+          end
+        end
+
+        expect(subject.data!).to eq(
+          outside_cache: "hit",
+          meta: {
+            inside_cache: "hit"
+          }
+        )
+      end
+
+      it "do not leaks the ignore value to the parent" do
+        subject.cache_store! AbstractBuilder::NullCache.new
+
+        subject.cache! :outside_cache_key do |builder|
+          builder.outside_cache "hit"
+        end
+
+        subject.cache! :outside_cache_key do |builder|
+          builder.outside_cache "miss"
+        end
+
+        subject.block! :meta do |meta|
+          meta.cache_store! NaiveCache.new
+
+          meta.cache! :inside_cache_key do |builder|
+            builder.inside_cache "hit"
+          end
+
+          meta.cache! :inside_cache_key do |builder|
+            builder.inside_cache "miss"
+          end
+        end
+
+        expect(subject.data!).to eq(
+          outside_cache: "miss",
+          meta: {
+            inside_cache: "hit"
+          }
+        )
+      end
+    end
   end
 
   describe "#array!" do
@@ -199,6 +301,22 @@
     end
   end
 
+  describe "#cache!" do
+    it "caches the given block" do
+      subject.cache_store! NaiveCache.new
+
+      subject.cache! :cache_key do |cache|
+        cache.cache "miss"
+      end
+
+      subject.cache! :cache_key do |cache|
+        cache.cache "hit"
+      end
+
+      expect(subject.data!).to eq(cache: "miss")
+    end
+  end
+
   describe "#method_missing" do
     it "sets the key and value" do
       subject.key "value"

spec/spec_helper.rb

@@ -34,3 +34,13 @@ def died
     "July 17, 1967"
   end
 end
+
+class NaiveCache
+  def initialize
+    @cache = {}
+  end
+
+  def fetch(key, _options = nil, &block)
+    @cache[key] ||= block.call
+  end
+end