thermos 0.5.2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 69d08a67a8ad98400b2b0eda1e63af9b22cb127e82d72117c6dbb8fecb71a808
-  data.tar.gz: 8a8369af0507aae7ef1c81ddf0bc7833adea0bd5941708c183c8c011b3e7db22
+  metadata.gz: 8436d0765dee9eafadbbb9994cce8aaed1e5746d96bc735fccdf55a945dcb4a8
+  data.tar.gz: 19fd374d31d2885979d791ab9dc0bfe021c9c61053b97ed4f96a0a5d862afa75
 SHA512:
-  metadata.gz: 0c9f06c52aa92a34a3beacd1384b8f4de92318484a536d657a1a8c3b5a5017ec09d42f6b99b95966b8e3572fdaf57d8c01dd2a0c8ec6b9eb99490ac413e1ca88
-  data.tar.gz: 3215b079c3890c74045ff902bcf259dc83d1d40e4ff5ee0c69be0833a959aa4e25dd7e92fbe9738fd18352223a6c050810d2065a9ab4bf25d45e0d87003d2889
+  metadata.gz: dd71bd6038960d9c556b3d55b697a6126d14573bb12ddc131e52a592629e39cc15e054c54cb0ee44aaf90a7b9879a43fc72571a9920c3ceae7b3a0721fb09cc2
+  data.tar.gz: 6de309fc56d581825c7497cd137595769ca81eff2298f9ba791b5809511bf1281e9b7376feac34849592c660605c9f53b5304e751f3e53df55cea8d377bf5413

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)
@@ -50,23 +61,25 @@ module Thermos
       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)
+            model: root || model,
+            ref: model.reflect_on_association(dep),
+            path: path || dep,
+          )
         elsif dep.is_a? Array
-          dep.each do |d| 
+          dep.each do |d|
             acc << Dependency.new(
-              model: root || model, 
-              ref: model.reflect_on_association(d), 
-              path: path || d)
+              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
+              model: root || model,
+              ref: ref,
+              path: path || k,
             )
             acc.concat(generate_deps(ref.class_name.constantize, v, model, dep))
           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,24 @@ 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 = "1.0.0"
 end

data/lib/thermos.rb

@@ -1,27 +1,62 @@
 # frozen_string_literal: true
 
-require 'thermos/beverage'
-require 'thermos/beverage_storage'
-require 'thermos/dependency'
-require 'thermos/notifier'
-require 'thermos/refill_job'
-require 'thermos/rebuild_cache_job'
+require "thermos/beverage"
+require "thermos/beverage_storage"
+require "thermos/dependency"
+require "thermos/notifier"
+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

@@ -11,12 +11,10 @@ class Category < ActiveRecord::Base
     {
       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

@@ -1,6 +1,6 @@
-require File.expand_path('../boot', __FILE__)
+require File.expand_path("../boot", __FILE__)
 
-require 'rails/all'
+require "rails/all"
 
 Bundler.require(*Rails.groups)
 require "thermos"
@@ -10,14 +10,11 @@ module Dummy
     # 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/boot.rb

@@ -1,5 +1,5 @@
 # Set up gems listed in the Gemfile.
-ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../../../Gemfile', __FILE__)
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../../../Gemfile", __FILE__)
 
-require 'bundler/setup' if File.exist?(ENV['BUNDLE_GEMFILE'])
-$LOAD_PATH.unshift File.expand_path('../../../../lib', __FILE__)
+require "bundler/setup" if File.exist?(ENV["BUNDLE_GEMFILE"])
+$LOAD_PATH.unshift File.expand_path("../../../../lib", __FILE__)

data/test/dummy/config/environment.rb

@@ -1,5 +1,5 @@
 # Load the Rails application.
-require File.expand_path('../application', __FILE__)
+require File.expand_path("../application", __FILE__)
 
 # Initialize the Rails application.
 Rails.application.initialize!

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.
@@ -25,16 +25,16 @@ Rails.application.configure do
   # Debug mode disables concatenation and preprocessing of assets.
   # This option may cause significant delays in view rendering with a large
   # number of complex assets.
-  config.assets.debug = true
+  # config.assets.debug = true
 
   # Asset digests allow you to set far-future HTTP expiration dates on all assets,
   # yet still be able to expire them through the digest params.
-  config.assets.digest = true
+  # config.assets.digest = true
 
   # Adds additional error checking when serving assets at runtime.
   # Checks for improperly declared sprockets dependencies.
   # Raises helpful error messages.
-  config.assets.raise_runtime_errors = true
+  # config.assets.raise_runtime_errors = true
 
   # Raises error for missing translations
   # config.action_view.raise_on_missing_translations = true

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
@@ -22,18 +22,19 @@ Rails.application.configure do
 
   # Disable serving static files from the `/public` folder by default since
   # Apache or NGINX already handles this.
-  config.serve_static_files = ENV['RAILS_SERVE_STATIC_FILES'].present?
+  config.serve_static_files = ENV["RAILS_SERVE_STATIC_FILES"].present?
 
   # Compress JavaScripts and CSS.
-  config.assets.js_compressor = :uglifier
+  # config.assets.js_compressor = :uglifier
+
   # config.assets.css_compressor = :sass
 
   # Do not fallback to assets pipeline if a precompiled asset is missed.
-  config.assets.compile = false
+  # config.assets.compile = false
 
   # Asset digests allow you to set far-future HTTP expiration dates on all assets,
   # yet still be able to expire them through the digest params.
-  config.assets.digest = true
+  # config.assets.digest = true
 
   # `config.assets.precompile` and `config.assets.version` have moved to config/initializers/assets.rb