support_table_cache 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6c7814572a411ad62d5077cf255ff24059d2ab9292be81ded041de7ecff8a6ac
+  data.tar.gz: 015ea25fb5083ce1a80579a143486bf44a091fa375bf0d122b0889763321852c
+SHA512:
+  metadata.gz: c4a1f00fa0873f0e28501119c5b588a6df166f5f9bcee84fcaf3dc4ffe0985251a6d6e6ee24f00d2ee740bd02b1dfe74db425a7a8170d8d5ddd98fbed0c8ecde
+  data.tar.gz: 81de8cda7452731a341e82752f3a25ab793c1b15e518c41c78118348841b41f5f8c56af13304e2565e9bfeffc00210764bf0351e4920d56af0e4e49704fdfde7

data/CHANGELOG.md

@@ -0,0 +1,10 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## 1.0.0
+
+### Added
+- Add SupportTableCache concern to enable automatic caching on models when calling `find_by` with unique key parameters.

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2022 Brian Durand
+
+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,102 @@
+# Support Table Cache
+
+[![Continuous Integration](https://github.com/bdurand/support_table_cache/actions/workflows/continuous_integration.yml/badge.svg)](https://github.com/bdurand/support_table_cache/actions/workflows/continuous_integration.yml)
+[![Ruby Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://github.com/testdouble/standard)
+
+This gem adds caching for ActiveRecord support table models. These are models which have a unique key (i.e. a unique `name` attribute, etc.) and which have a limited number of entries (a few hundred at most). These are often models added do normalize the data structure.
+
+Rows from these kinds of tables are rarely inserted, updated, or deleted, but are queried very frequently. To take advantage of this behavior, this gem adds automatic caching for records when using the `find_by` method. This is most useful in situations where you have a unique key but need to get the database row for that key.
+
+For instance, suppose you have a model `Status` that has a unique name attribute and you need to process a bunch of records from a data source that includes the status name. In order to do anything, you'll need to lookup each status by name to get the database id:
+
+```ruby
+params.each do |data|
+  status = Status.find_by(name: data[:status]
+  Things.where(id: data[:id]).update!(status_id: status.id)
+end
+```
+
+With this gem, you can avoid the database query for the `find_by` call. You don't need to alter your code in any way other than to include `SupportTableCache` in your model and tell it which attributes comprise a unique key that can be used for caching.
+
+## Usage
+
+To use the gem, you need to include it in you models and then specify which attributes can be used for caching with the `cache_by` method. A caching attribute must be a unique key on the model. For a composite key, you can specify an array of attributes. If any of the attributes are case insensitive strings, you need to specify that as well.
+
+```ruby
+  class MyModel < ApplicationRecord
+    include SupportTableCache
+
+    cache_by :id
+    cache_by [:group, :name], case_sensitive: false
+  end
+
+  # Uses cache
+  MyModel.find_by(id: 1)
+
+  # Uses cache on a composite key
+  MyModel.find_by(group: "first", name: "One")
+
+  # Does not use cache since value is not defined as a cacheable key
+  MyModel.find_by(value: 1)
+
+  # Does not use caching since not using find_by
+  MyModel.where(id: 1).first
+```
+
+By default, records will be cleaned up from the cache only when they are modified. However, you can set a time to live on the model after which records will be removed from the cache.
+
+```ruby
+  class MyModel < ApplicationRecord
+    include SupportTableCache
+
+    self.support_table_cache_ttl = 5.minutes
+  end
+```
+
+If you are in a Rails application, the `Rails.cache` will be used by default to cache records. Otherwise, you need to set the `ActiveSupport::Cache::CacheStore`` to use.
+
+```ruby
+SupportTableCache.cache = ActiveSupport::Cache::MemoryStore.new
+```
+
+You can also disable caching behavior entirely if you want or just within a block. You may want to disable it entirely in test mode if it interferes with your tests.
+
+```ruby
+# Disable the cache globally
+SupportTableCache.disable
+
+SupportTableCache.enable do
+  # Re-enable the cache for the block
+  SupportTableCache.disable do
+    # Disable it again
+  end
+end
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "support_table_cache"
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install support_table_cache
+```
+
+## Contributing
+
+Open a pull request on [GitHub](https://github.com/bdurand/support_table_cache).
+
+Please use the [standardrb](https://github.com/testdouble/standard) syntax and lint your code with `standardrb --fix` before submitting.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/lib/support_table_cache.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+# This concern can be added to a model for a support table to add the ability to lookup
+# entries in these table using Rails.cache when calling find_by rather than hitting the
+# database every time.
+module SupportTableCache
+  extend ActiveSupport::Concern
+
+  included do
+    class_attribute :support_table_cache_by_attributes, instance_accessor: false
+    class_attribute :support_table_cache_ttl, instance_accessor: false
+
+    class << self
+      prepend FindByOverride unless include?(FindByOverride)
+      private :support_table_cache_by_attributes=
+    end
+
+    after_commit :support_table_clear_cache_entries
+  end
+
+  class_methods do
+    protected
+
+    # Specify which attributes can be used for looking up records in the cache. Each value must
+    # define a unique key, Multiple unique keys can be specified.
+    # If multiple attributes are used to make up a unique key, then they should be passed in as an array.
+    # @param attributes [String, Symbol, Array<String, Symbol>] Attributes that make up a unique key.
+    # @param case_sensitive [Boolean] Indicate if strings should treated as case insensitive in the key.
+    def cache_by(attributes, case_sensitive: true)
+      attributes = Array(attributes).map(&:to_s).sort.freeze
+      self.support_table_cache_by_attributes = (support_table_cache_by_attributes || []) + [[attributes, case_sensitive]]
+    end
+  end
+
+  class << self
+    # Disable the caching behavior. If a block is specified, then caching is only
+    # disabled for that block. If no block is specified, then caching is disabled
+    # globally.
+    # @param disabled [Boolean] Caching will be disabled if this is true, enabled if false.
+    def disable(disabled = true, &block)
+      if block
+        save_val = Thread.current[:support_table_cache_disabled]
+        begin
+          Thread.current[:support_table_cache_disabled] = !!disabled
+        ensure
+          Thread.current[:support_table_cache_disabled] = save_val
+        end
+      else
+        @disabled = !!disabled
+      end
+    end
+
+    def enable(&block)
+      disable(false, &block)
+    end
+
+    # Return true if caching has been disabled.
+    # @return [Boolean]
+    def disabled?
+      block_value = Thread.current[:support_table_cache_disabled]
+      if block_value.nil?
+        !!(defined?(@disabled) && @disabled)
+      else
+        block_value
+      end
+    end
+
+    attr_writer :cache
+
+    def cache
+      if defined?(@cache)
+        @cache
+      elsif defined?(Rails.cache)
+        Rails.cache
+      end
+    end
+
+    # Generate a consistent cache key for a set of attributes. Returns nil if the attributes
+    # are not cacheable.
+    # @param klass [Class] The class to
+    # @api private
+    def cache_key(klass, attributes, key_attribute_names, case_sensitive)
+      return nil if attributes.blank? || key_attribute_names.blank?
+
+      sorted_names = attributes.keys.map(&:to_s).sort
+      return nil unless sorted_names == key_attribute_names
+
+      sorted_attributes = {}
+      sorted_names.each do |attribute_name|
+        value = (attributes[attribute_name] || attributes[attribute_name.to_sym])
+        if !case_sensitive && (value.is_a?(String) || value.is_a?(Symbol))
+          value = value.to_s.downcase
+        end
+        sorted_attributes[attribute_name] = value
+      end
+
+      [klass.name, sorted_attributes]
+    end
+  end
+
+  module FindByOverride
+    # Override for the find_by method that looks in the cache first.
+    def find_by(*args)
+      return super if SupportTableCache.cache.nil? || SupportTableCache.disabled?
+
+      cache_key = nil
+      attributes = args.first if args.size == 1 && args.first.is_a?(Hash)
+      if attributes
+        support_table_cache_by_attributes.each do |attribute_names, case_sensitive|
+          cache_key = SupportTableCache.cache_key(self, attributes, attribute_names, case_sensitive)
+          break if cache_key
+        end
+      end
+
+      if cache_key
+        SupportTableCache.cache.fetch(cache_key, expires_in: support_table_cache_ttl) { super }
+      else
+        super
+      end
+    end
+  end
+
+  # Remove the cache entry for this record.
+  # @return [void]
+  def uncache
+    cache_by_attributes = self.class.support_table_cache_by_attributes
+    return if cache_by_attributes.blank? || SupportTableCache.cache.nil?
+
+    cache_by_attributes.each do |attribute_names, case_sensitive|
+      attributes = {}
+      attribute_names.each do |name|
+        attributes[name] = self[name]
+      end
+      cache_key = SupportTableCache.cache_key(self.class, attributes, attribute_names, case_sensitive)
+      SupportTableCache.cache.delete(cache_key)
+    end
+  end
+
+  private
+
+  # Clear all combinations of the cacheable attributes whenever any attribute changes.
+  # We have to make sure to clear the keys with the attribute values both before
+  # and after the change.
+  def support_table_clear_cache_entries
+    cache_by_attributes = self.class.support_table_cache_by_attributes
+    return if cache_by_attributes.blank? || SupportTableCache.cache.nil?
+
+    cache_by_attributes.each do |attribute_names, case_sensitive|
+      attributes_before = {} if saved_change_to_id.blank? || saved_change_to_id.first.present?
+      attributes_after = {} if saved_change_to_id.blank? || saved_change_to_id.last.present?
+      attribute_names.each do |name|
+        if attributes_before
+          attributes_before[name] = (saved_changes.include?(name) ? saved_changes[name].first : self[name])
+        end
+        if attributes_after
+          attributes_after[name] = self[name]
+        end
+      end
+      [attributes_before, attributes_after].compact.uniq.each do |attributes|
+        cache_key = SupportTableCache.cache_key(self.class, attributes, attribute_names, case_sensitive)
+        SupportTableCache.cache.delete(cache_key)
+      end
+    end
+  end
+end

data/support_table_cache.gemspec

@@ -0,0 +1,33 @@
+Gem::Specification.new do |spec|
+  spec.name = "support_table_cache"
+  spec.version = File.read(File.expand_path("../VERSION", __FILE__)).strip
+  spec.authors = ["Brian Durand"]
+  spec.email = ["bbdurand@gmail.com"]
+
+  spec.summary = "Automatic ActiveRecord caching for small support tables."
+
+  spec.homepage = "https://github.com/bdurand/support_table_cache"
+  spec.license = "MIT"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  ignore_files = %w[
+    .
+    Appraisals
+    Gemfile
+    Gemfile.lock
+    Rakefile
+    bin/
+    gemfiles/
+    spec/
+  ]
+  spec.files = Dir.chdir(File.expand_path("..", __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| ignore_files.any? { |path| f.start_with?(path) } }
+  end
+
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activerecord"
+
+  spec.add_development_dependency "bundler"
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: support_table_cache
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Brian Durand
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2022-05-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- bbdurand@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- MIT-LICENSE
+- README.md
+- VERSION
+- lib/support_table_cache.rb
+- support_table_cache.gemspec
+homepage: https://github.com/bdurand/support_table_cache
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Automatic ActiveRecord caching for small support tables.
+test_files: []