thermos 0.5.2 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 69d08a67a8ad98400b2b0eda1e63af9b22cb127e82d72117c6dbb8fecb71a808
-  data.tar.gz: 8a8369af0507aae7ef1c81ddf0bc7833adea0bd5941708c183c8c011b3e7db22
+  metadata.gz: f3979389850e8fc2f1d7ffede3e023a8e9f81e5d1239f403fa79c1df49dd8f3e
+  data.tar.gz: 89806ca4b6ae5a81d121ae42adb784585852dd1af385d2f8067631b9cdd330a1
 SHA512:
-  metadata.gz: 0c9f06c52aa92a34a3beacd1384b8f4de92318484a536d657a1a8c3b5a5017ec09d42f6b99b95966b8e3572fdaf57d8c01dd2a0c8ec6b9eb99490ac413e1ca88
-  data.tar.gz: 3215b079c3890c74045ff902bcf259dc83d1d40e4ff5ee0c69be0833a959aa4e25dd7e92fbe9738fd18352223a6c050810d2065a9ab4bf25d45e0d87003d2889
+  metadata.gz: 9ceaaf4c53a3b06e012d66f1f60476c0278d973543a3d8dfb050e9637338dbe789cbb2b206d87d3e5b0f0cf60a130d85bc2119ec059f21bfffce7e1eef16eeb7
+  data.tar.gz: 1f5fc62f26e008e76059775cf273fcf05ea8b1be930acf5b25af3d3a0b36a11f9beae3f7a9b9083cb5869efb45105bb98e3cb1d22b443f61910934fed26c9315

data/Rakefile

@@ -27,6 +27,10 @@ Rake::TestTask.new(:test) do |t|
   t.verbose = false
 end
 
+task(:format) do
+  system('bundle exec rbprettier --write {lib,test}/**/*.rb')
+end
+
 task(:default) do
   Dir.chdir('test/dummy')
   system('rake db:migrate')

data/lib/thermos/beverage.rb

@@ -2,33 +2,44 @@
 
 module Thermos
   class Beverage
-    attr_reader :key, :model, :deps, :action, :lookup_key, :filter
+    attr_reader :key, :model, :deps, :action, :lookup_key, :filter, :queue
 
-    def initialize(key:, model:, deps:, action:, lookup_key: nil, filter: nil)
+    def initialize(
+      key:,
+      model:,
+      deps:,
+      action:,
+      lookup_key: nil,
+      filter: nil,
+      queue: nil
+    )
       @key = key
       @model = model
       @lookup_key = lookup_key || :id
       @filter = filter || nil
       @deps = generate_deps(model, deps)
       @action = action
+      @queue = queue || ActiveJob::Base.default_queue_name
 
       set_observers
     end
 
     def lookup_keys_for_dep_model(dep_model)
-      @deps.select do |dep|
-        dep.klass == dep_model.class
-      end.flat_map do |dep|
-        lookup_keys = []
+      @deps
+        .select { |dep| dep.klass == dep_model.class }
+        .flat_map do |dep|
+          lookup_keys = []
 
-        @model.joins(dep.path)
-              .where(dep.table => { id: dep_model.id })
-              .find_each do |model|
-                lookup_keys << model.send(@lookup_key) if should_fill?(model)
-              end
+          @model
+            .joins(dep.path)
+            .where(dep.table => { id: dep_model.id })
+            .find_each do |model|
+              lookup_keys << model.send(@lookup_key) if should_fill?(model)
+            end
 
-        lookup_keys
-      end.uniq
+          lookup_keys
+        end
+        .uniq
     end
 
     def should_fill?(model)
@@ -49,25 +60,26 @@ module Thermos
     def generate_deps(model, deps, root = nil, path = nil)
       deps.reduce([]) do |acc, dep|
         if dep.is_a? Symbol
-          acc << Dependency.new(
-            model: root || model, 
-            ref: model.reflect_on_association(dep), 
-            path: path || dep)
+          acc <<
+            Dependency.new(
+              model: root || model,
+              ref: model.reflect_on_association(dep),
+              path: path || dep,
+            )
         elsif dep.is_a? Array
-          dep.each do |d| 
-            acc << Dependency.new(
-              model: root || model, 
-              ref: model.reflect_on_association(d), 
-              path: path || d)
+          dep.each do |d|
+            acc <<
+              Dependency.new(
+                model: root || model,
+                ref: model.reflect_on_association(d),
+                path: path || d,
+              )
           end
         elsif dep.is_a? Hash
-          dep.each do |k,v|
+          dep.each do |k, v|
             ref = model.reflect_on_association(k)
-            acc << Dependency.new(
-              model: root || model, 
-              ref: ref, 
-              path: path || k
-            )
+            acc <<
+              Dependency.new(model: root || model, ref: ref, path: path || k)
             acc.concat(generate_deps(ref.class_name.constantize, v, model, dep))
           end
         end

data/lib/thermos/notifier.rb

@@ -4,9 +4,7 @@ module Thermos
   module Notifier
     extend ActiveSupport::Concern
 
-    included do
-      after_commit :notify_thermos, on: %i[create update]
-    end
+    included { after_commit :notify_thermos, on: %i[create update] }
 
     private
 

data/lib/thermos/refill_job.rb

@@ -10,16 +10,22 @@ module Thermos
     def refill_primary_caches(model)
       BeverageStorage.instance.beverages.each do |beverage|
         if beverage.model == model.class && beverage.should_fill?(model)
-          Thermos::RebuildCacheJob.perform_later(beverage.key, model.send(beverage.lookup_key))
+          Thermos::RebuildCacheJob
+            .set(queue: beverage.queue)
+            .perform_later(beverage.key, model.send(beverage.lookup_key))
         end
       end
     end
 
     def refill_dependency_caches(model)
       BeverageStorage.instance.beverages.each do |beverage|
-        beverage.lookup_keys_for_dep_model(model).each do |lookup_key|
-          Thermos::RebuildCacheJob.perform_later(beverage.key, lookup_key)
-        end
+        beverage
+          .lookup_keys_for_dep_model(model)
+          .each do |lookup_key|
+            Thermos::RebuildCacheJob
+              .set(queue: beverage.queue)
+              .perform_later(beverage.key, lookup_key)
+          end
       end
     end
   end

data/lib/thermos/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Thermos
-  VERSION = '0.5.2'
+  VERSION = '0.6.0'
 end

data/lib/thermos.rb

@@ -8,20 +8,38 @@ require 'thermos/refill_job'
 require 'thermos/rebuild_cache_job'
 
 module Thermos
-  def self.keep_warm(key:, model:, id:, deps: [], lookup_key: nil, filter: nil, &block)
-    fill(key: key, model: model, deps: deps, lookup_key: lookup_key, filter: filter, &block)
+  def self.keep_warm(key:, model:, id:, deps: [], lookup_key: nil, filter: nil, queue: nil, &block)
+    fill(
+      key: key, 
+      model: model, 
+      deps: deps, 
+      lookup_key: lookup_key, 
+      filter: filter, 
+      queue: queue, 
+      &block
+    )
     drink(key: key, id: id)
   end
 
-  def self.fill(key:, model:, deps: [], lookup_key: nil, filter: nil, &block)
+  def self.fill(key:, model:, deps: [], lookup_key: nil, filter: nil, queue: nil, &block)
     BeverageStorage.instance.add_beverage(
-      Beverage.new(key: key, model: model, deps: deps, action: block, lookup_key: lookup_key, filter: filter)
+      Beverage.new(
+        key: key, 
+        model: model, 
+        deps: deps, 
+        action: block, 
+        lookup_key: lookup_key, 
+        filter: filter, 
+        queue: queue
+      )
     )
   end
 
   def self.drink(key:, id:)
-    Rails.cache.fetch([key, id]) do
-      BeverageStorage.instance.get_beverage(key).action.call(id)
-    end
+    Rails
+      .cache
+      .fetch([key, id]) do
+        BeverageStorage.instance.get_beverage(key).action.call(id)
+      end
   end
 end

data/test/dependencies_test.rb

@@ -0,0 +1,307 @@
+require 'test_helper'
+
+class DependenciesTest < ActiveSupport::TestCase
+  self.use_transactional_tests = true
+  teardown :clear_cache
+
+  test 'rebuilds the cache on has_many model change' do
+    mock = Minitest::Mock.new
+    category = categories(:baseball)
+    category_item = category_items(:baseball_glove)
+
+    Thermos.fill(key: 'key', model: Category, deps: [:category_items]) do |id|
+      mock.call(id)
+    end
+
+    mock.expect(:call, 1, [category.id])
+    assert_equal 1, Thermos.drink(key: 'key', id: category.id)
+    mock.verify
+
+    mock.expect(:call, 2, [category.id])
+    category_item.update!(name: 'foo')
+    mock.verify
+
+    mock.expect(:call, 3, [category.id])
+    assert_equal 2, Thermos.drink(key: 'key', id: category.id)
+    assert_raises(MockExpectationError) { mock.verify }
+  end
+
+  test 'does not rebuild the cache for an unrelated has_many model change' do
+    mock = Minitest::Mock.new
+    category = categories(:baseball)
+    category_item = CategoryItem.create(category: nil)
+
+    Thermos.fill(key: 'key', model: Category, deps: [:category_items]) do |id|
+      mock.call(id)
+    end
+
+    mock.expect(:call, 1, [category.id])
+    assert_equal 1, Thermos.drink(key: 'key', id: category.id)
+    mock.verify
+
+    mock.expect(:call, 2, [category.id])
+    category_item.update!(name: 'foo')
+    assert_raises(MockExpectationError) { mock.verify }
+
+    mock.expect(:call, 3, [category.id])
+    assert_equal 1, Thermos.drink(key: 'key', id: category.id)
+    assert_raises(MockExpectationError) { mock.verify }
+  end
+
+  test 're-builds the cache for new has_many records' do
+    mock = Minitest::Mock.new
+    category = categories(:baseball)
+
+    Thermos.fill(key: 'key', model: Category, deps: [:category_items]) do |id|
+      mock.call(id)
+    end
+
+    mock.expect(:call, 1, [category.id])
+    CategoryItem.create!(category: category)
+    mock.verify
+
+    mock.expect(:call, 2, [category.id])
+    assert_equal 1, Thermos.drink(key: 'key', id: category.id)
+    assert_raises(MockExpectationError) { mock.verify }
+  end
+
+  test 're-builds the cache for has_many record changes when filter condition is met' do
+    mock = Minitest::Mock.new
+    category = categories(:baseball)
+    filter = ->(model) { model.ball? }
+
+    Thermos.fill(
+      key: 'key',
+      model: Category,
+      deps: [:category_items],
+      filter: filter,
+    ) { |id| mock.call(id) }
+
+    mock.expect(:call, 1, [category.id])
+    CategoryItem.create!(category: category)
+    mock.verify
+
+    category.update!(name: 'hockey')
+
+    mock.expect(:call, 1, [category.id])
+    CategoryItem.create!(category: category)
+    assert_raises(MockExpectationError) { mock.verify }
+  end
+
+  test 'rebuilds the cache on belongs_to model change' do
+    mock = Minitest::Mock.new
+    category = categories(:baseball)
+    store = stores(:sports)
+
+    Thermos.fill(key: 'key', model: Category, deps: [:store]) do |id|
+      mock.call(id)
+    end
+
+    mock.expect(:call, 1, [category.id])
+    assert_equal 1, Thermos.drink(key: 'key', id: category.id)
+    mock.verify
+
+    mock.expect(:call, 2, [category.id])
+    store.update!(name: 'foo')
+    mock.verify
+
+    mock.expect(:call, 3, [category.id])
+    assert_equal 2, Thermos.drink(key: 'key', id: category.id)
+    assert_raises(MockExpectationError) { mock.verify }
+  end
+
+  test 'does not rebuild the cache for an unrelated belongs_to model change' do
+    mock = Minitest::Mock.new
+    category = categories(:baseball)
+    store = Store.create!
+
+    Thermos.fill(key: 'key', model: Category, deps: [:store]) do |id|
+      mock.call(id)
+    end
+
+    mock.expect(:call, 1, [category.id])
+    assert_equal 1, Thermos.drink(key: 'key', id: category.id)
+    mock.verify
+
+    mock.expect(:call, 2, [category.id])
+    store.update!(name: 'foo')
+    assert_raises(MockExpectationError) { mock.verify }
+
+    mock.expect(:call, 3, [category.id])
+    assert_equal 1, Thermos.drink(key: 'key', id: category.id)
+    assert_raises(MockExpectationError) { mock.verify }
+  end
+
+  test 're-builds the cache for new belongs_to records' do
+    mock = Minitest::Mock.new
+    category = categories(:baseball)
+
+    Thermos.fill(key: 'key', model: Category, deps: [:store]) do |id|
+      mock.call(id)
+    end
+
+    mock.expect(:call, 1, [category.id])
+    mock.expect(:call, 1, [category.id])
+    Store.create!(name: 'foo', categories: [category])
+    mock.verify
+
+    mock.expect(:call, 2, [category.id])
+    assert_equal 1, Thermos.drink(key: 'key', id: category.id)
+    assert_raises(MockExpectationError) { mock.verify }
+  end
+
+  test 're-builds the cache for belongs_to record changes when filter condition is met' do
+    mock = Minitest::Mock.new
+    category = categories(:baseball)
+    filter = ->(model) { model.ball? }
+
+    Thermos.fill(
+      key: 'key',
+      model: Category,
+      deps: [:store],
+      filter: filter,
+    ) { |id| mock.call(id) }
+
+    mock.expect(:call, 1, [category.id])
+    mock.expect(:call, 1, [category.id])
+    Store.create!(name: 'foo', categories: [category])
+    mock.verify
+
+    category.update!(name: 'hockey')
+
+    mock.expect(:call, 2, [category.id])
+    Store.create!(name: 'bar', categories: [category])
+    assert_raises(MockExpectationError) { mock.verify }
+  end
+
+  test 'rebuilds the cache on has_many through model change' do
+    mock = Minitest::Mock.new
+    category = categories(:baseball)
+    product = products(:glove)
+
+    Thermos.fill(key: 'key', model: Category, deps: [:products]) do |id|
+      mock.call(id)
+    end
+
+    mock.expect(:call, 1, [category.id])
+    assert_equal 1, Thermos.drink(key: 'key', id: category.id)
+    mock.verify
+
+    mock.expect(:call, 2, [category.id])
+    product.update!(name: 'foo')
+    mock.verify
+
+    mock.expect(:call, 3, [category.id])
+    assert_equal 2, Thermos.drink(key: 'key', id: category.id)
+    assert_raises(MockExpectationError) { mock.verify }
+  end
+
+  test 'does not rebuild the cache for an unrelated has_many through model change' do
+    mock = Minitest::Mock.new
+    category = categories(:baseball)
+    product = Product.create!
+
+    Thermos.fill(key: 'key', model: Category, deps: [:products]) do |id|
+      mock.call(id)
+    end
+
+    mock.expect(:call, 1, [category.id])
+    assert_equal 1, Thermos.drink(key: 'key', id: category.id)
+    mock.verify
+
+    mock.expect(:call, 2, [category.id])
+    product.update!(name: 'foo')
+    assert_raises(MockExpectationError) { mock.verify }
+
+    mock.expect(:call, 3, [category.id])
+    assert_equal 1, Thermos.drink(key: 'key', id: category.id)
+    assert_raises(MockExpectationError) { mock.verify }
+  end
+
+  test 're-builds the cache for new has_many through records' do
+    mock = Minitest::Mock.new
+    category = categories(:baseball)
+
+    Thermos.fill(key: 'key', model: Category, deps: [:products]) do |id|
+      mock.call(id)
+    end
+
+    mock.expect(:call, 1, [category.id])
+    Product.create!(categories: [category])
+    mock.verify
+
+    mock.expect(:call, 2, [category.id])
+    assert_equal 1, Thermos.drink(key: 'key', id: category.id)
+    assert_raises(MockExpectationError) { mock.verify }
+  end
+
+  test 're-builds the cache for has_many through record changes when filter condition is met' do
+    mock = Minitest::Mock.new
+    category = categories(:baseball)
+    filter = ->(model) { model.ball? }
+
+    Thermos.fill(
+      key: 'key',
+      model: Category,
+      deps: [:products],
+      filter: filter,
+    ) { |id| mock.call(id) }
+
+    mock.expect(:call, 1, [category.id])
+    Product.create!(categories: [category])
+    mock.verify
+
+    category.update!(name: 'hockey')
+
+    mock.expect(:call, 2, [category.id])
+    Product.create!(categories: [category])
+    assert_raises(MockExpectationError) { mock.verify }
+  end
+
+  test 'handles indirect associations' do
+    mock = Minitest::Mock.new
+    category = categories(:baseball)
+    store = category.store
+
+    Thermos.fill(
+      key: 'key',
+      model: Store,
+      deps: [categories: [:products]],
+    ) { |id| mock.call(id) }
+
+    mock.expect(:call, 1, [store.id])
+    category.update!(name: 'foo')
+    mock.verify
+
+    mock.expect(:call, 2, [store.id])
+    assert_equal 1, Thermos.drink(key: 'key', id: store.id)
+    assert_raises(MockExpectationError) { mock.verify }
+    Product.create!(categories: [category])
+    mock.verify
+
+    mock.expect(:call, 3, [store.id])
+    assert_equal 2, Thermos.drink(key: 'key', id: store.id)
+    assert_raises(MockExpectationError) { mock.verify }
+  end
+
+  test 'only rebuilds cache for stated dependencies, even if another cache has an associated model of the primary' do
+    category_mock = Minitest::Mock.new
+    product_mock = Minitest::Mock.new
+    category = categories(:baseball)
+    product = products(:glove)
+
+    Thermos.fill(key: 'category_key', model: Category) do |id|
+      category_mock.call(id)
+    end
+
+    Thermos.fill(key: 'product_key', model: Product) do |id|
+      product_mock.call(id)
+    end
+
+    category_mock.expect(:call, 2, [category.id])
+    product_mock.expect(:call, 2, [product.id])
+    product.update!(name: 'foo')
+    assert_raises(MockExpectationError) { category_mock.verify }
+    product_mock.verify
+  end
+end

data/test/dummy/app/models/category.rb

@@ -4,19 +4,17 @@ class Category < ActiveRecord::Base
   belongs_to :store
 
   def ball?
-    name.match("ball")
+    name.match('ball')
   end
 
   def as_json(*args)
     {
       name: name,
       store_name: store.name,
-      category_items: category_items.map do |item|
-        {
-          name: item.name,
-          product_name: item.product.name
-        }
-      end
+      category_items:
+        category_items.map do |item|
+          { name: item.name, product_name: item.product.name }
+        end,
     }
   end
 end

data/test/dummy/config/application.rb

@@ -3,21 +3,18 @@ require File.expand_path('../boot', __FILE__)
 require 'rails/all'
 
 Bundler.require(*Rails.groups)
-require "thermos"
+require 'thermos'
 
 module Dummy
   class Application < Rails::Application
     # Settings in config/environments/* take precedence over those specified here.
     # Application configuration should go into files in config/initializers
     # -- all .rb files in that directory are automatically loaded.
-
     # Set Time.zone default to the specified zone and make Active Record auto-convert to this zone.
     # Run "rake -D time" for a list of tasks for finding time zone names. Default is UTC.
     # config.time_zone = 'Central Time (US & Canada)'
-
     # The default locale is :en and all translations from config/locales/*.rb,yml are auto loaded.
     # config.i18n.load_path += Dir[Rails.root.join('my', 'locales', '*.{rb,yml}').to_s]
     # config.i18n.default_locale = :de
   end
 end
-

data/test/dummy/config/environments/development.rb

@@ -10,7 +10,7 @@ Rails.application.configure do
   config.eager_load = false
 
   # Show full error reports and disable caching.
-  config.consider_all_requests_local       = true
+  config.consider_all_requests_local = true
   config.action_controller.perform_caching = false
 
   # Don't care if the mailer can't send.

data/test/dummy/config/environments/production.rb

@@ -11,7 +11,7 @@ Rails.application.configure do
   config.eager_load = true
 
   # Full error reports are disabled and caching is turned on.
-  config.consider_all_requests_local       = false
+  config.consider_all_requests_local = false
   config.action_controller.perform_caching = true
 
   # Enable Rack::Cache to put a simple HTTP cache in front of your application
@@ -26,6 +26,7 @@ Rails.application.configure do
 
   # Compress JavaScripts and CSS.
   config.assets.js_compressor = :uglifier
+
   # config.assets.css_compressor = :sass
 
   # Do not fallback to assets pipeline if a precompiled asset is missed.

data/test/dummy/config/environments/test.rb

@@ -13,11 +13,11 @@ Rails.application.configure do
   config.eager_load = false
 
   # Configure static file server for tests with Cache-Control for performance.
-  config.serve_static_files   = true
+  config.serve_static_files = true
   config.static_cache_control = 'public, max-age=3600'
 
   # Show full error reports and disable caching.
-  config.consider_all_requests_local       = true
+  config.consider_all_requests_local = true
   config.action_controller.perform_caching = false
 
   # Raise exceptions instead of rendering exception templates.

data/test/dummy/config/routes.rb

@@ -1,19 +1,14 @@
 Rails.application.routes.draw do
   # The priority is based upon order of creation: first created -> highest priority.
   # See how all your routes lay out with "rake routes".
-
   # You can have the root of your site routed with "root"
   # root 'welcome#index'
-
   # Example of regular route:
   #   get 'products/:id' => 'catalog#view'
-
   # Example of named route that can be invoked with purchase_url(id: product.id)
   #   get 'products/:id/purchase' => 'catalog#purchase', as: :purchase
-
   # Example resource route (maps HTTP verbs to controller actions automatically):
   #   resources :products
-
   # Example resource route with options:
   #   resources :products do
   #     member do
@@ -25,13 +20,11 @@ Rails.application.routes.draw do
   #       get 'sold'
   #     end
   #   end
-
   # Example resource route with sub-resources:
   #   resources :products do
   #     resources :comments, :sales
   #     resource :seller
   #   end
-
   # Example resource route with more complex sub-resources:
   #   resources :products do
   #     resources :comments
@@ -39,14 +32,12 @@ Rails.application.routes.draw do
   #       get 'recent', on: :collection
   #     end
   #   end
-
   # Example resource route with concerns:
   #   concern :toggleable do
   #     post 'toggle'
   #   end
   #   resources :posts, concerns: :toggleable
   #   resources :photos, concerns: :toggleable
-
   # Example resource route within a namespace:
   #   namespace :admin do
   #     # Directs /admin/products/* to Admin::ProductsController