chunky_cache 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 900e71f999ba2cf5a9996aad4a700b7c22df75e1a240a5fc9e4fc7b2df88e39e
-  data.tar.gz: 42e100f7f0aef3b9bc932dded4f7d3556bf007ed0057b28932cde7a902025f34
+  metadata.gz: c342e8e301ad9650d1b50e25e74b6b31995b6d0ee649aef74d473c4fe556404d
+  data.tar.gz: 3fb5c2e12003ca7687714366270c4850419784149647254b31a52182ec965727
 SHA512:
-  metadata.gz: cd58b7c0267f3a015a344e68354a83e4b6a74bac7774795d83cfc137331fb7ee750ad7b3732cf66095f8034636fc1959c7d7390ffb840ca5a484cd25cd0b68af
-  data.tar.gz: 4ce371b52d6d27a4b8aafd1cbaa0edcd2a2620574fa105dda0a7db3e0e9810df6e9dc8f0b27484dc5538648c7e6a2fe624f6f769624a270dd85f4d93b5f00be7
+  metadata.gz: dd96272d0a37bfa442df78dddda1227adac58c7c55456b941da1ffbfa919bca70e0fa1131b518f31424cf6a6f9d01333763f1d2815f4cd15c301ff45ec77def3
+  data.tar.gz: '0481cb78d6e06b35f807ec542f41bb823fb62a4a267d09c19a4f3c34a85c22b49c1b7476477964bd90989e182ea3cd0687b0063ff47d62f8817e418c7362bb28'

data/README.md

@@ -27,16 +27,16 @@ Or install it yourself as:
   <h1>Something not cached</h1>
 
   <p>
-    <%= cache_chunk(:important_message, current_user) %>
+    <%= cache_chunk(:important_message, current_user) do %>
       <strong>This is very important, <%= current_user.name %>!</strong>
     <% end %>
 
-    <%= cache_chunk(:the_actual_message) %>
+    <%= cache_chunk(:the_actual_message) do %>
       <oblique>No, really</oblique>
     <% end %>
   </p>
 
-  <%= cache_chunk(:footer) %>
+  <%= cache_chunk(:footer) do %>
     <p>Fin.</p>
   <% end %>
 <% end %>
@@ -44,7 +44,7 @@ Or install it yourself as:
 
 This will execute only one call to your cache store, using `Rails.cache.fetch_multi`.
 
-When using `cache_chunk` inside a block, use its ability to pass the key components to the block
+When using `cache_chunk` inside a loop, use its ability to pass the key components to the block
 to persist the context (i.e. it'll be super borked if you don't do this):
 
 ```slim
@@ -53,17 +53,28 @@ to persist the context (i.e. it'll be super borked if you don't do this):
       h1= article.title
 ```
 
+`cache_chunk` calls inside partials rendered inside the main `chunky_cache` call will also be picked up, this allows you to execute one network request for multiple chunks inside multiple view renders, e.g.
+
+```slim
+= chunky_cache(expires_in: 1.hour) do
+  = render partial: "foxes", collection: @foxes
+
+# Then inside _foxes.html.slim
+
+= chunky_cache(expires_in: 1.hour) do # this will defer to the parent call, and isn't necessary
+  = cache_chunk(fox) do |fox|
+    = "Hello #{fox}"
+```
+
 ## How does it work?
 
-The helpers use Rails' built-in helper `capture` to consume the contents of their blocks and turn them into strings. `chunky_cache` does this immediately, and returns the final output after mixing everything together. But `cache_chunk` instead doesn't execute its block, but stores it in an instance variable established by `chunky_cache`, and it then returns a cache key string. At this point the template is thus half-complete, with sections missing and only weird strings in their place.
+The helpers use Rails' built-in helper `capture` to consume the contents of their blocks and turn them into strings. `chunky_cache` does this immediately, and returns the final output after mixing everything together. But `cache_chunk` doesn't execute its block, instead storing it in an instance variable established by `chunky_cache`, and it then returns a cache key string. At this point the template is thus half-complete, with sections missing and only weird strings in their place.
 
 `chunky_cache` then performs a cache multi-fetch, passing in all the keys it knows about. For any missing keys, the block captured by `cache_chunk` is executed and returned to the cache. The mix of cached/non-cached chunks are then reinserted into the main block content, replacing the key placeholders. A final compiled string is then returned.
 
-## Development
-
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+## Why is this useful?
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+If you run `memcached` as your cache store on the same server as your Rails app, this gem is probably not very useful. Where it shines, however, is when network latency becomes more expensive than what you are caching. It allows you to cache lots of little chunks of markup, with different cache keys, and expend only one network request to fetch it. This allows you to start caching really trivial parts of templates that would never be worth caching normally; like caching individual navigation links in a menu, with active/inactive states, rather than caching the whole menu for each state. You can break up your larger caches into small sections with different keys, allowing parts of a cache to contain user-specific data but sharing generic data for everyone. This can be a useful cache storage size optimisation.
 
 ## Contributing
 

data/lib/chunky_cache/version.rb

@@ -1,3 +1,3 @@
 module ChunkyCache
-  VERSION = "0.1.2"
+  VERSION = "0.1.3"
 end

data/lib/chunky_cache/view_helpers.rb

@@ -14,8 +14,18 @@ module ChunkyCache
     # @param expires_in [ActiveSupport::Duration, Integer] expiry time will be passed to the underlying store
     # @return [ActiveSupport::SafeBuffer]
     def chunky_cache(**cache_options)
-      @chunky_key_blocks ||= {}
-      blocks = @chunky_key_blocks[template_root_key] = {}
+      # Return if the memory cache is already established, as an outer run of
+      # this method is in progress already
+      return capture { yield } if memory_cache.present?
+
+      # Set up the in-memory cache for this block
+      establish_memory_cache(cache_options)
+
+      # Exit out if caching isn't enabled
+      return capture { yield } unless memory_cache[:perform_caching]
+
+      blocks = memory_cache[:key_blocks]
+      output_buffer = ActiveSupport::SafeBuffer.new
 
       # Capture the block, storing its output in a string
       big_ol_strang = capture do
@@ -24,27 +34,26 @@ module ChunkyCache
 
       # This probably shouldn't happen
       return if big_ol_strang.nil?
-
+      
       # Now the cache blocks are populated and the placeholders in place,
       # we multi-fetch all the keys from the cache, or call the `cache_chunk` blocks
       # for missing values.
       chunks = Rails.cache.fetch_multi(*blocks.keys, **cache_options) do |missing_key|
-        logger.debug("Chunk cache miss: #{missing_key}")
-
         capture do
           block, context = *blocks[missing_key]
           block.call(*context)
         end
       end
 
-      # Then we replace the placeholders with our new compiled template data
       chunks.each do |key, chunk|
-        logger.debug("Chunk key replacement: #{key}")
-
-        big_ol_strang.gsub!(key, (chunk || ""))
+        pre, big_ol_strang = *big_ol_strang.split(key, 2)
+        output_buffer << pre.html_safe
+        output_buffer << chunk
       end
 
-      big_ol_strang.html_safe
+      reset_memory_cache
+
+      output_buffer
     end
 
     # Denote a cached chunk of markup. This captures the block
@@ -54,17 +63,38 @@ module ChunkyCache
     # @param context [*Object] one or multiple objects which respond to `#cache_key` or convert to strings
     # @return [String] the placeholder key
     def cache_chunk(*context, &block)
-      raise MissingChunkyCacheError if @chunky_key_blocks.nil?
+      return block.call(*context) if memory_cache.nil? || !memory_cache[:perform_caching]
 
       key = context.map { |k| k.try(:cache_key) || k.to_s }.unshift(template_root_key).join(":")
 
-      @chunky_key_blocks[template_root_key][key] = [block, context]
+      memory_cache[:key_blocks][key] = [block, context]
 
       return key
     end
 
     private
 
+    def establish_memory_cache(cache_options, perform_caching: true)
+      if conditional_if = cache_options.delete(:if)
+        perform_caching = (conditional_if.call == true)
+      elsif conditional_unless = cache_options.delete(:unless)
+        perform_caching = (conditional_unless.call == false)
+      end
+
+      @chunky_cache_store = {
+        key_blocks: {},
+        perform_caching: perform_caching
+      }
+    end
+
+    def memory_cache
+      @chunky_cache_store
+    end
+
+    def reset_memory_cache
+      @chunky_cache_store = nil
+    end
+
     # Returns the digest of the current template
     #
     # @return [String]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: chunky_cache
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Robert May
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-03-06 00:00:00.000000000 Z
+date: 2021-03-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -81,7 +81,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.4
 signing_key: 
 specification_version: 4
 summary: Rails cache multi-fetch inside a view