cache_keeper 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a594d57869401830f847424c24851913039af6979f2e5f9665d77b96bb2c955e
+  data.tar.gz: c80f3edb0b84157a3e49ef8438347931c515ecffe2a55c9a08a630b2fca1c6c0
+SHA512:
+  metadata.gz: 46806eb4e857047be29c784b9c8455a2ce92ac79ebe19fac9bcec704fa9c29c48b63ebf546e78d615cf8d429044bc7557dbac7e94abc939b1288353f856729b3
+  data.tar.gz: b1902aa78ec63d686c7435924c412c997828c117cc498a6a474d0b00c3175c621542d5677a74bb97172523d0a24df38ee916ab8c0a0edafc42047a31dfa87a21

data/.github/workflows/ci.yml

@@ -0,0 +1,38 @@
+name: CI
+on: [push, pull_request]
+jobs:
+  tests:
+    strategy:
+      matrix:
+        ruby-version:
+          - "2.7"
+          - "3.0"
+        rails-version:
+          - "6.1"
+          - "7.0"
+          - "main"
+
+    env:
+      RAILS_VERSION: "${{ matrix.rails-version }}"
+
+    name: ${{ format('Tests (Ruby {0}, Rails {1})', matrix.ruby-version, matrix.rails-version) }}
+    runs-on: ubuntu-latest
+    continue-on-error: true
+
+    steps:
+      - uses: actions/checkout@v1
+
+      - name: Install Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby-version }}
+          bundler-cache: true
+
+      - name: Run tests
+        run: |
+          bin/test test/**/*_test.rb
+
+      - name: Fail when generated changes are not checked-in
+        run: |
+          git update-index --refresh
+          git diff-index --quiet HEAD --

data/.gitignore

@@ -0,0 +1,10 @@
+*.gem
+.byebug_history
+
+test/dummy/db/*.sqlite3
+test/dummy/db/*.sqlite3*
+test/dummy/log/*.log
+test/dummy/node_modules/
+test/dummy/yarn-error.log
+test/dummy/storage/
+test/dummy/tmp/

data/Gemfile

@@ -0,0 +1,8 @@
+source "https://rubygems.org"
+
+gemspec
+
+gem "rake"
+
+gem "rails", ">= 6.1"
+gem "sqlite3"

data/Gemfile.lock

@@ -0,0 +1,197 @@
+PATH
+  remote: .
+  specs:
+    cache_keeper (0.1.0)
+      rails (>= 6.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    actioncable (7.1.1)
+      actionpack (= 7.1.1)
+      activesupport (= 7.1.1)
+      nio4r (~> 2.0)
+      websocket-driver (>= 0.6.1)
+      zeitwerk (~> 2.6)
+    actionmailbox (7.1.1)
+      actionpack (= 7.1.1)
+      activejob (= 7.1.1)
+      activerecord (= 7.1.1)
+      activestorage (= 7.1.1)
+      activesupport (= 7.1.1)
+      mail (>= 2.7.1)
+      net-imap
+      net-pop
+      net-smtp
+    actionmailer (7.1.1)
+      actionpack (= 7.1.1)
+      actionview (= 7.1.1)
+      activejob (= 7.1.1)
+      activesupport (= 7.1.1)
+      mail (~> 2.5, >= 2.5.4)
+      net-imap
+      net-pop
+      net-smtp
+      rails-dom-testing (~> 2.2)
+    actionpack (7.1.1)
+      actionview (= 7.1.1)
+      activesupport (= 7.1.1)
+      nokogiri (>= 1.8.5)
+      rack (>= 2.2.4)
+      rack-session (>= 1.0.1)
+      rack-test (>= 0.6.3)
+      rails-dom-testing (~> 2.2)
+      rails-html-sanitizer (~> 1.6)
+    actiontext (7.1.1)
+      actionpack (= 7.1.1)
+      activerecord (= 7.1.1)
+      activestorage (= 7.1.1)
+      activesupport (= 7.1.1)
+      globalid (>= 0.6.0)
+      nokogiri (>= 1.8.5)
+    actionview (7.1.1)
+      activesupport (= 7.1.1)
+      builder (~> 3.1)
+      erubi (~> 1.11)
+      rails-dom-testing (~> 2.2)
+      rails-html-sanitizer (~> 1.6)
+    activejob (7.1.1)
+      activesupport (= 7.1.1)
+      globalid (>= 0.3.6)
+    activemodel (7.1.1)
+      activesupport (= 7.1.1)
+    activerecord (7.1.1)
+      activemodel (= 7.1.1)
+      activesupport (= 7.1.1)
+      timeout (>= 0.4.0)
+    activestorage (7.1.1)
+      actionpack (= 7.1.1)
+      activejob (= 7.1.1)
+      activerecord (= 7.1.1)
+      activesupport (= 7.1.1)
+      marcel (~> 1.0)
+    activesupport (7.1.1)
+      base64
+      bigdecimal
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      connection_pool (>= 2.2.5)
+      drb
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      mutex_m
+      tzinfo (~> 2.0)
+    base64 (0.1.1)
+    bigdecimal (3.1.4)
+    builder (3.2.4)
+    concurrent-ruby (1.2.2)
+    connection_pool (2.4.1)
+    crass (1.0.6)
+    date (3.3.3)
+    drb (2.1.1)
+      ruby2_keywords
+    erubi (1.12.0)
+    globalid (1.2.1)
+      activesupport (>= 6.1)
+    i18n (1.14.1)
+      concurrent-ruby (~> 1.0)
+    io-console (0.6.0)
+    irb (1.8.3)
+      rdoc
+      reline (>= 0.3.8)
+    loofah (2.21.4)
+      crass (~> 1.0.2)
+      nokogiri (>= 1.12.0)
+    mail (2.8.1)
+      mini_mime (>= 0.1.1)
+      net-imap
+      net-pop
+      net-smtp
+    marcel (1.0.2)
+    mini_mime (1.1.5)
+    minitest (5.20.0)
+    mutex_m (0.1.2)
+    net-imap (0.4.2)
+      date
+      net-protocol
+    net-pop (0.1.2)
+      net-protocol
+    net-protocol (0.2.1)
+      timeout
+    net-smtp (0.4.0)
+      net-protocol
+    nio4r (2.5.9)
+    nokogiri (1.15.4-arm64-darwin)
+      racc (~> 1.4)
+    nokogiri (1.15.4-x86_64-linux)
+      racc (~> 1.4)
+    psych (5.1.1.1)
+      stringio
+    racc (1.7.1)
+    rack (3.0.8)
+    rack-session (2.0.0)
+      rack (>= 3.0.0)
+    rack-test (2.1.0)
+      rack (>= 1.3)
+    rackup (2.1.0)
+      rack (>= 3)
+      webrick (~> 1.8)
+    rails (7.1.1)
+      actioncable (= 7.1.1)
+      actionmailbox (= 7.1.1)
+      actionmailer (= 7.1.1)
+      actionpack (= 7.1.1)
+      actiontext (= 7.1.1)
+      actionview (= 7.1.1)
+      activejob (= 7.1.1)
+      activemodel (= 7.1.1)
+      activerecord (= 7.1.1)
+      activestorage (= 7.1.1)
+      activesupport (= 7.1.1)
+      bundler (>= 1.15.0)
+      railties (= 7.1.1)
+    rails-dom-testing (2.2.0)
+      activesupport (>= 5.0.0)
+      minitest
+      nokogiri (>= 1.6)
+    rails-html-sanitizer (1.6.0)
+      loofah (~> 2.21)
+      nokogiri (~> 1.14)
+    railties (7.1.1)
+      actionpack (= 7.1.1)
+      activesupport (= 7.1.1)
+      irb
+      rackup (>= 1.0.0)
+      rake (>= 12.2)
+      thor (~> 1.0, >= 1.2.2)
+      zeitwerk (~> 2.6)
+    rake (13.0.6)
+    rdoc (6.5.0)
+      psych (>= 4.0.0)
+    reline (0.3.9)
+      io-console (~> 0.5)
+    ruby2_keywords (0.0.5)
+    sqlite3 (1.6.7-arm64-darwin)
+    sqlite3 (1.6.7-x86_64-linux)
+    stringio (3.0.8)
+    thor (1.3.0)
+    timeout (0.4.0)
+    tzinfo (2.0.6)
+      concurrent-ruby (~> 1.0)
+    webrick (1.8.1)
+    websocket-driver (0.7.6)
+      websocket-extensions (>= 0.1.0)
+    websocket-extensions (0.1.5)
+    zeitwerk (2.6.12)
+
+PLATFORMS
+  arm64-darwin-22
+  x86_64-linux
+
+DEPENDENCIES
+  cache_keeper!
+  rails (>= 6.1)
+  rake
+  sqlite3
+
+BUNDLED WITH
+   2.4.19

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2017 David Heinemeier Hansson, Basecamp
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,69 @@
+<h1 align="center">
+  CacheKeeper
+  <br>
+</h1>
+
+<h3 align="center">Keep cached methods always fresh in your Rails application.</h3>
+
+<p align="center">
+  <img alt="Build" src="https://img.shields.io/github/actions/workflow/status/martinzamuner/cache_keeper/ci.yml?branch=main">
+  <img alt="Gem" src="https://img.shields.io/gem/v/cache_keeper">
+  <img alt="rails version" src="https://img.shields.io/badge/rails-%3E%3D%206.1.0-informational">
+  <img alt="License" src="https://img.shields.io/github/license/martinzamuner/cache_keeper">
+</p>
+
+CacheKeeper allows you to mark any method to be kept fresh in your Rails cache. It uses ActiveJob to refresh the cache in the background.
+
+
+## Installation
+
+Add CacheKeeper to your Gemfile:
+
+```sh
+bundle add cache_keeper
+```
+
+
+## Usage
+
+CacheKeeper provides a `caches` method that will cache the result of the methods you give it:
+
+```ruby
+caches :slow_method, :really_slow_method, expires_in: 1.hour
+caches :incredibly_slow_method, expires_in: 2.hours, must_revalidate: true
+```
+
+It is automatically available in your ActiveRecord models and in your controllers. You can also use it in any other class by including `CacheKeeper::Caching`.
+
+By default, it will immediately run the method call if it hasn't been cached before. The next time it is called, it will return the cached value if it hasn't expired yet. If it has expired, it will enqueue a job to refresh the cache in the background and return the stale value in the meantime. You can avoid returning stale values by setting `must_revalidate: true` in the options.
+
+
+## Configuration
+
+CacheKeeper can be configured in an initializer, in any environment file or in your `config/application.rb` file. The following options are available:
+
+```ruby
+Rails.application.configure do
+  # If a stale entry is requested, refresh immediately instead of enqueuing a refresh job.
+  # Default: false
+  config.cache_keeper.must_revalidate = true
+
+  # The queue to use for the refresh jobs.
+  # Default: nil (uses the default queue)
+  config.cache_keeper.queues.refresh = :low_priority
+end
+```
+
+
+## Development
+
+<details>
+  <summary>Running the tests</summary><br>
+
+  - You can run the whole suite with `./bin/test test/**/*_test.rb`
+</details>
+
+
+## License
+
+CacheKeeper is released under the [MIT License](https://opensource.org/licenses/MIT).

data/app/jobs/cache_keeper/base_job.rb

@@ -0,0 +1,16 @@
+class CacheKeeper::BaseJob < ActiveJob::Base
+  discard_on StandardError
+
+  private
+
+  # Monkey patch ActiveJob::Core#serialize_arguments to use CacheKeeper::WhateverSerializer
+  # in case there's no serializer for the argument. I'm doing it this way because I don't
+  # want to register the serializer as it would affect the whole application.
+  def serialize_arguments(arguments)
+    arguments.map do |argument|
+      ActiveJob::Arguments.send :serialize_argument, argument
+    rescue ActiveJob::SerializationError
+      CacheKeeper::WhateverSerializer.serialize argument
+    end
+  end
+end

data/app/jobs/cache_keeper/refresh_job.rb

@@ -0,0 +1,7 @@
+class CacheKeeper::RefreshJob < CacheKeeper::BaseJob
+  queue_as { CacheKeeper.configuration.queues[:refresh] }
+
+  def perform(cached_method, instance)
+    cached_method.refresh instance
+  end
+end

data/app/models/cache_keeper/cached_method/refreshable.rb

@@ -0,0 +1,11 @@
+module CacheKeeper::CachedMethod::Refreshable
+  def refresh(instance)
+    Rails.cache.fetch(cache_key, expires_in: expires_in) do
+      instance.send alias_for_original_method
+    end
+  end
+
+  def refresh_later(instance)
+    CacheKeeper::RefreshJob.perform_later self, instance
+  end
+end

data/app/models/cache_keeper/cached_method.rb

@@ -0,0 +1,49 @@
+class CacheKeeper::CachedMethod
+  include Refreshable
+
+  attr_accessor :klass, :method_name, :options
+
+  def initialize(klass, method_name, options = {})
+    self.klass = klass
+    self.method_name = method_name
+    self.options = options.with_indifferent_access
+  end
+
+  def alias_for_original_method
+    :"__#{method_name}__hooked__"
+  end
+
+  def call(instance)
+    if cache_entry.blank?
+      refresh instance
+    elsif cache_entry.expired?
+      if must_revalidate?
+        refresh instance
+      else
+        refresh_later instance
+
+        cache_entry.value
+      end
+    else
+      cache_entry.value
+    end
+  end
+
+  private
+
+  def cache_entry
+    Rails.cache.send :read_entry, Rails.cache.send(:normalize_key, cache_key)
+  end
+
+  def cache_key
+    ["CacheKeeper", klass, method_name]
+  end
+
+  def expires_in
+    options[:expires_in]
+  end
+
+  def must_revalidate?
+    options[:must_revalidate].nil? ? CacheKeeper.configuration.must_revalidate : options[:must_revalidate]
+  end
+end

data/app/serializers/cache_keeper/cached_method_serializer.rb

@@ -0,0 +1,17 @@
+class CacheKeeper::CachedMethodSerializer < ActiveJob::Serializers::ObjectSerializer
+  def serialize?(argument)
+    argument.is_a? CacheKeeper::CachedMethod
+  end
+
+  def serialize(cached_method)
+    super(
+      "klass" => cached_method.klass,
+      "method_name" => cached_method.method_name,
+      "options" => cached_method.options
+    )
+  end
+
+  def deserialize(hash)
+    CacheKeeper::CachedMethod.new hash["klass"], hash["method_name"], hash["options"]
+  end
+end

data/app/serializers/cache_keeper/whatever_serializer.rb

@@ -0,0 +1,15 @@
+class CacheKeeper::WhateverSerializer < ActiveJob::Serializers::ObjectSerializer
+  def serialize?(argument)
+    true
+  end
+
+  def serialize(whatever)
+    super(
+      "klass" => whatever.class.to_s
+    )
+  end
+
+  def deserialize(hash)
+    hash["klass"].constantize.new
+  end
+end

data/bin/rails

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+# This command will automatically be run when you run "rails" with Rails gems
+# installed from the root of your application.
+
+ENGINE_ROOT = File.expand_path('..', __dir__)
+APP_PATH = File.expand_path('../test/dummy/config/application', __dir__)
+
+# Set up gems listed in the Gemfile.
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../Gemfile', __dir__)
+require 'bundler/setup' if File.exist?(ENV['BUNDLE_GEMFILE'])
+
+require 'rails/all'
+require 'rails/engine/commands'

data/bin/release

@@ -0,0 +1,13 @@
+#!/usr/bin/env bash
+
+VERSION=$1
+
+printf "module CacheKeeper\n  VERSION = \"$VERSION\"\nend\n" > ./lib/cache_keeper/version.rb
+bundle
+git add Gemfile.lock lib/cache_keeper/version.rb
+git commit -m "Bump version for $VERSION"
+git push
+git tag v$VERSION
+git push --tags
+gem build cache_keeper.gemspec
+gem push "cache_keeper-$VERSION.gem" --host https://rubygems.org

data/bin/test

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+$: << File.expand_path("../test", __dir__)
+
+puts "Installing Ruby dependencies"
+`bundle install`
+
+puts "Preparing test database"
+`cd test/dummy; ./bin/rails db:test:prepare`
+
+require "bundler/setup"
+require "rails/plugin/test"

data/cache_keeper.gemspec

@@ -0,0 +1,18 @@
+require_relative "lib/cache_keeper/version"
+
+Gem::Specification.new do |s|
+  s.name     = "cache_keeper"
+  s.version  = CacheKeeper::VERSION
+  s.authors  = ["Martin Zamuner"]
+  s.email    = "martinzamuner@gmail.com"
+  s.summary  = "Keep a fresh copy of any method in your cache"
+  s.homepage = "https://github.com/martinzamuner/cache_keeper"
+  s.license  = "MIT"
+
+  s.required_ruby_version = ">= 2.5.0"
+
+  s.add_dependency "rails", ">= 6.1.0"
+
+  s.files      = `git ls-files`.split("\n")
+  s.test_files = `git ls-files -- test/*`.split("\n")
+end

data/lib/cache_keeper/caching.rb

@@ -0,0 +1,20 @@
+module CacheKeeper::Caching
+  extend ActiveSupport::Concern
+
+  included do
+    def self.caches(*method_names, **options)
+      method_names.each do |method_name|
+        CacheKeeper.manager.handle self, method_name, options
+
+        # If the method is already defined, we need to hook it
+        method_added method_name
+      end
+    end
+
+    def self.method_added(method_name)
+      super
+
+      CacheKeeper.manager.activate_if_handling self, method_name
+    end
+  end
+end

data/lib/cache_keeper/configuration.rb

@@ -0,0 +1,20 @@
+class CacheKeeper::Configuration
+  DEFAULT_MUST_REVALIDATE = false
+  DEFAULT_QUEUES = {}
+
+  def must_revalidate
+    return rails_config[:must_revalidate] unless rails_config[:must_revalidate].nil?
+
+    DEFAULT_MUST_REVALIDATE
+  end
+
+  def queues
+    rails_config[:queues] || DEFAULT_QUEUES
+  end
+
+  private
+
+  def rails_config
+    Rails.application.config.cache_keeper
+  end
+end

data/lib/cache_keeper/engine.rb

@@ -0,0 +1,22 @@
+class CacheKeeper::Engine < ::Rails::Engine
+  isolate_namespace CacheKeeper
+
+  config.cache_keeper = ActiveSupport::OrderedOptions.new
+  config.cache_keeper.queues = ActiveSupport::InheritableOptions.new
+
+  initializer "cache_keeper.active_job_serializer" do |app|
+    config.to_prepare do
+      Rails.application.config.active_job.custom_serializers << CacheKeeper::CachedMethodSerializer
+    end
+  end
+
+  initializer "cache_keeper.caching_methods" do |app|
+    ActiveSupport.on_load :action_controller do
+      ActionController::Base.send :include, CacheKeeper::Caching
+    end
+
+    ActiveSupport.on_load :active_record do
+      include CacheKeeper::Caching
+    end
+  end
+end

data/lib/cache_keeper/manager.rb

@@ -0,0 +1,42 @@
+class CacheKeeper::Manager
+  attr_accessor :cached_methods
+
+  def initialize
+    self.cached_methods = []
+  end
+
+  def find(klass, method_name)
+    cached_methods.find do |cached_method|
+      cached_method.klass == klass && cached_method.method_name == method_name
+    end
+  end
+
+  def handled?(klass, method_name)
+    find(klass, method_name).present?
+  end
+
+  def handle(klass, method_name, options)
+    CacheKeeper::CachedMethod.new(klass, method_name, options).tap do |cached_method|
+      cached_methods << cached_method
+    end
+  end
+
+  def activate_if_handling(klass, method_name)
+    cached_method = find(klass, method_name) or return
+
+    return unless requires_activation?(cached_method)
+
+    CacheKeeper::ReplaceMethod.replace(cached_method) do
+      cached_method.call(self)
+    end
+  end
+
+  private
+
+  def requires_activation?(cached_method)
+    return false if cached_method.klass.instance_methods.exclude?(cached_method.method_name) && cached_method.klass.private_instance_methods.exclude?(cached_method.method_name)
+    return false if cached_method.klass.private_instance_methods.include?(cached_method.alias_for_original_method)
+
+    true
+  end
+end