support_table 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e6446caaf1ed0561e4fc98214a72e30fae6fc70aa7ef868aa6e6a17f4dc4f621
+  data.tar.gz: 9f7739af82443b3279bf74cb1262370284fc0c3554f42a3dc1d5d254c176d4a5
+SHA512:
+  metadata.gz: ddb606d4d8674bb335dad19888ee531aafe2d8790396bbfde7ab6ea574fb20b3b01aa0d599ac2f43720d6ecca1709f0318c2ab42f4f9749c259f1b75462ae451
+  data.tar.gz: 22cfa034d8062e57d5e7eff49a532f97d293bb2a7847392f57388ebc7e40530df91dfd452be58131e45c3fd6798a39bcb3215a5d8775307e878e0fd19327ac05

data/CHANGELOG.md

@@ -0,0 +1,11 @@
+# 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
+
+- Initial release.

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2026 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,377 @@
+# Support Table
+
+[![Continuous Integration](https://github.com/bdurand/support_table/actions/workflows/continuous_integration.yml/badge.svg)](https://github.com/bdurand/support_table/actions/workflows/continuous_integration.yml)
+[![Ruby Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://github.com/testdouble/standard)
+[![Gem Version](https://badge.fury.io/rb/support_table.svg)](https://badge.fury.io/rb/support_table)
+
+This gem builds on top of the [support_table_data](https://github.com/bdurand/support_table_data) and [support_table_cache](https://github.com/bdurand/support_table_cache) gems to provide a pre-configured, drop-in solution for maintaining and using support tables in a Rails application.
+
+Support tables are small database tables that contain static data that rarely changes. They are often used to represent enumerations or lookup values in an application and values are often referenced directly from code.
+
+This gem provides a simple DSL for defining your Rails models as support tables. When a model is defined as a support table
+
+- the data for the table can be defined in a YAML file and distributed with the code
+- helper methods can be generated to allow code to reference specific rows from the table
+- lookups from the table will use caching to avoid querying the database repeatedly for data that rarely changes
+
+If you have more advanced needs, you can use the [support_table_data](https://github.com/bdurand/support_table_data) and [support_table_cache](https://github.com/bdurand/support_table_cache) gems directly or in combination with this gem.
+
+## Table of Contents
+
+- [Usage](#usage)
+  - [Defining Support Table Data](#defining-support-table-data)
+    - [Advanced Data Settings](#advanced-data-settings)
+      - [Key Attribute](#key-attribute)
+      - [Data File](#data-file)
+      - [Additional Helper Methods](#additional-helper-methods)
+      - [Documenting Helper Methods](#documenting-helper-methods)
+      - [More Data Options](#more-data-options)
+  - [Caching](#caching)
+    - [Specifying Additional Cache Keys](#specifying-additional-cache-keys)
+    - [Changing The Cache Implementation](#changing-the-cache-implementation)
+    - [Cache TTL](#cache-ttl)
+    - [Belongs To Caching](#belongs-to-caching)
+    - [More Cache Options](#more-cache-options)
+  - [Full Example](#full-example)
+- [Installation](#installation)
+- [Contributing](#contributing)
+- [License](#license)
+
+## Usage
+
+Start by including the `SupportTable` concern in your `ApplicationRecord` base model.
+
+```ruby
+class ApplicationRecord < ActiveRecord::Base
+  self.abstract_class = true
+
+  include SupportTable
+end
+```
+
+This will add DSL methods to your models for defining support tables and associations to them.
+
+```ruby
+class Status < ApplicationRecord
+  support_table
+end
+
+class Task < ApplicationRecord
+  belongs_to_support_table :status
+end
+```
+
+### Defining Support Table Data
+
+You can define the data for your support table in the `db/support_tables` directory in a YAML file. The file name should match the model name in plural form. For the `Status` model, the file would be `db/support_tables/statuses.yml`.
+
+> [!NOTE]
+> If the model is in a namespace, the directory structure should reflect that (e.g. `Status::Group` data would be defined in the `db/support_tables/status/groups.yml` file).
+
+```yaml
+draft:
+  id: 1
+  name: Draft
+
+pending:
+  id: 2
+  name: Pending
+
+in_progress:
+  id: 3
+  name: In Progress
+
+completed:
+  id: 4
+  name: Completed
+```
+
+The keys in the YAML file are named instances of the model. These will dynamically generate helper methods to load the instance and to test if a value is that instance.
+
+```ruby
+Status.draft         # returns the Status instance with name "Draft"
+
+task.status.draft?   # returns true if the task's status is "Draft"
+```
+
+Data will be automatically synced to the database whenever you run any of the following rake tasks:
+
+- `db:seed`
+- `db:seed:replant`
+- `db:prepare`
+- `db:test:prepare`
+- `db:fixtures:load`
+
+You can also manually trigger synchronization with the `support_table_data:sync` rake task.
+
+You **must** popululate the support table data in your test database during your deploy process or test suite setup to ensure that the data is present when your application code runs.
+
+> [!TIP]
+> You can also call `SupportTable.sync_all!` in from your application code to synchronize the data.
+
+#### Advanced Data Settings
+
+You can customize the behavior of the support table data syncing by passing options to the `support_table` method.
+
+##### Key Attribute
+
+One of the attributes on the table will be used as the unique identifier for each row in the YAML file. By default, this is will be the primary key on the table. You can set a different attribute by passing the `key_attribute` option.
+
+```ruby
+class Status < ApplicationRecord
+  support_table key_attribute: :name
+end
+```
+
+> [!TIP]
+> If you are starting from scratch, the primary key is the best choice for the key attribute. If all of the data in the table will be specified in the YAML file, you should turn off auto incrementing primary keys with `auto_increment: false` on the `create_table` statement.
+>
+> If you are adding support table behavior to an existing table, you may need to use an existing unique attribute instead especially if the primary key is not identical in the existing environments.
+>
+> Make sure that the attribute you choose has a unique index on it to ensure data integrity and that the values will never need to change. Using a display attribute can be problematic if it ever needs to change. It's best to add a new internal identifier attribute if needed (i.e. add a `code` attribute instead of using the `name` attribute if the `name` might ever change).
+
+#### Data File
+
+You can customize the location of the YAML data file by passing the `data_file` option to the `support_table` method.
+
+```ruby
+class Status < ApplicationRecord
+  support_table data_file: "custom/statuses.yml"
+end
+```
+
+You can also change the base directory for all support table data files by setting `SupportTable.data_directory` in your application configuration (e.g., in an initializer).
+
+```ruby
+# config/initializers/support_table.rb
+SupportTable.data_directory = Rails.root.join("db", "support_tables")
+```
+
+#### Additional Helper Methods
+
+You can add additional helper methods to your support table models by passing `attribute_helpers` to the `support_table` method.
+
+```ruby
+class Status < ApplicationRecord
+  support_table attribute_helpers: [:name]
+end
+```
+
+This will add class methods to the class to reference values directly from the YAML file. You automatically get helper methods for the key attribute defined for the table.
+
+```ruby
+Status.draft_name   # returns "Draft"
+Status.pending_name # returns "Pending"
+
+Status.draft_id    # returns 1
+Status.pending_id  # returns 2
+```
+
+These helper methods do not need to hit the database and so can be used in situations where the database is not available (i.e. during application initialization).
+
+> [!TIP]
+> You use these methods in lieu of hard coding values in the code or defining constants. This keeps all of the support table data defined in one place (the YAML file) and avoids duplication.
+
+#### Documenting Helper Methods
+
+You can generate YARD documentation for the dynamically generated helper methods by running the rake task `support_table_data:yard_docs:add`. This will add YARD comments to you support table models for the named instance helper methods (i.e. `Status.draft`, etc.). This exposes these methods in your source code for other developers and AI agents to see.
+
+You can also run the `support_table_data:yard_docs:verify` rake task in your CI pipeline to ensure that the documentation is up to date. This task will fail if the documentation is missing or out of date.
+
+#### More Data Options
+
+See the [support_table_data](https://github.com/bdurand/support_table_data) gem for more details on defining support table data.
+
+You can use any of the DSL methods defined in that gem to further customize how data is loaded.
+
+### Caching
+
+Support table data is often read frequently but changes rarely. To improve performance, lookups from support tables by the key attribute are cached by default. Any query that queries a record by the key attribute (i.e. `find_by(name: "Draft")` if `name` is the key attribute) will use the cache. The `id` column is also always cacheable so `find(1)` or `find_by(id: 1)` will also use the cache.
+
+You can use the `fetch_by` method to better express in your code that the lookup is using a cache. This method is an alias for `find_by` except that it will raise an error if the lookup is not using a cache on that attribute.
+
+```ruby
+# Uses the cache or raise an error if the model does not support caching by `name`.
+Status.fetch_by(name: "Draft")
+```
+
+#### Specifying Additional Cache Keys
+
+You can also manually specify the attributes that can be used for caching by passing the `cache_by` option to the `support_table` method.
+
+```ruby
+class Status < ApplicationRecord
+  support_table cache_by: :name # uses both id and name for caching
+end
+```
+
+You can even specify composite keys with the `cache_by` method.
+
+```ruby
+create_table :statuses do |t|
+  t.string :name, null: false
+  t.string :group, null: false
+  t.index [:name, :group], unique: true
+end
+
+class Status < ApplicationRecord
+  support_table
+  cache_by [:name, :group]
+end
+
+Status.fetch_by(name: "Draft", group: "Non-Live") # Uses the cache
+```
+
+#### Changing The Cache Implementation
+
+The default caching implementation uses an in memory cache that stores rows in local memory for the lifetime of the application process. This is the most efficient caching strategy for most use cases. If you need a different caching strategy, you can customize it by passing an implementation of `ActiveSupport::Cache::Store` to the `cache` option of the `support_table` method.
+
+```ruby
+class Status < ApplicationRecord
+  # Use the application cache for caching.
+  support_table cache: Rails.cache
+end
+```
+
+You can also disable caching entirely by passing `cache: false` or `cache: nil`.
+
+```ruby
+class Status < ApplicationRecord
+  # Disable caching.
+  support_table cache: false
+end
+```
+
+You can specify the value `:memory` to use an in memory cache. This is the default behavior.
+
+```ruby
+class Status < ApplicationRecord
+  # Use an in memory cache.
+  support_table cache: :memory
+end
+```
+
+#### Cache TTL
+
+By default, cached records are stored indefinitely (until the application process restarts or the cache is cleared). You can set a time-to-live (TTL) for cached records by passing the `ttl` option to the `support_table` method.
+
+```ruby
+class Status < ApplicationRecord
+  # Cache records for 1 hour.
+  support_table ttl: 1.hour
+end
+```
+
+The TTL value should be a number of seconds or an `ActiveSupport::Duration` object. When a cached record expires, it will be reloaded from the database on the next access.
+
+> [!TIP]
+> For most support tables, you don't need to set a TTL since the data rarely changes. An in-memory cache without a TTL is the most performant option. Only set a TTL if you need to ensure the data is refreshed periodically.
+
+#### Belongs To Caching
+
+When you have another model with a `belongs_to` association to a support table, you can use the `belongs_to_support_table` method to define the association. This will ensure that lookups for the associated support table record will use the cache.
+
+```ruby
+class Task < ApplicationRecord
+  belongs_to_support_table :status
+end
+```
+
+This method works exactly like the standard `belongs_to` method except that it ensures that lookups for the associated support table record will use the cache.
+
+#### More Cache Options
+
+See the [support_table_cache](https://github.com/bdurand/support_table_cache) gem for more details on caching support table data.
+
+You can use any of the DSL methods defined in that gem to further customize how models are cached.
+
+### Full Example
+
+For this example, we'll start with a simple application for managing a list of tasks. Each task will have a status.
+
+First, let's start with the table definitions.
+
+```ruby
+create_table :statuses do |t|
+  t.string :name, null: false, index: {unique: true}
+  t.timestamps
+end
+
+create_table :tasks do |t|
+  t.integer :status_id, null: false, index: true
+  t.string :description, null: false
+  t.timestamps
+end
+```
+
+First, you need to include the `SupportTable` concern in your `ApplicationRecord` so that all models have access to it.
+
+```ruby
+class ApplicationRecord < ActiveRecord::Base
+  self.abstract_class = true
+
+  include SupportTable
+end
+```
+
+This will add DSL methods to your models for defining support tables and associations to them.
+
+```ruby
+class Status < ApplicationRecord
+  support_table
+end
+
+class Task < ApplicationRecord
+  belongs_to_support_table :status
+end
+```
+
+Next add the YAML file at `db/support_tables/statuses.yml` to define the data that should be in the `statuses` table.
+
+```yaml
+draft:
+  id: 1
+  name: Draft
+
+pending:
+  id: 2
+  name: Pending
+
+in_progress:
+  id: 3
+  name: In Progress
+
+finished:
+  id: 4
+  name: Finished
+```
+
+That's it. Now the `Status` will load data from a YAML file and cache lookups automatically including from the `Task#status` association.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "support_table"
+```
+
+Then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install support_table
+```
+
+## Contributing
+
+Open a pull request on [GitHub](https://github.com/bdurand/support_table).
+
+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/belongs_to_support_table.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module SupportTable
+  # Module to add support for specifying `belongs_to` associations that
+  # reference support tables.
+  module BelongsToSupportTable
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      # Define a `belongs_to` association that references a support table. This method takes
+      # the same arguments as `belongs_to`. It will add a caching layer to the association
+      # to minimize database queries.
+      #
+      # @param name [Symbol] The name of the association.
+      # @param args [Array] Additional arguments to pass to `belongs_to`.
+      # @param kwargs [Hash] Additional keyword arguments to pass to `belongs_to`.
+      # @return [void]
+      def belongs_to_support_table(name, *args, **kwargs)
+        unless include?(SupportTableCache::Associations)
+          include SupportTableCache::Associations
+        end
+
+        retval = belongs_to name, *args, **kwargs
+        cache_belongs_to name
+        retval
+      end
+    end
+  end
+end

data/lib/support_table/definition.rb

@@ -0,0 +1,81 @@
+# frozen_string_leteral: true
+
+module SupportTable
+  # Class to define support table behavior on an ActiveRecord class.
+  #
+  # @api private
+  class Definition
+    attr_reader :klass
+
+    def initialize(klass)
+      @klass = klass
+    end
+
+    # Setup a class to be a support table.
+    #
+    # @param data_file [String, Array<String>, nil] Path to data files to load the table from.
+    # @param key_attribute [String, Symbol, nil] The name of the attribute in the data file that
+    #   uniquely identifies each row in the data.
+    # @param cache_by [String, Symbol, Array, nil] List of attributes that can be used to uniquely
+    #   identify a row that can be used for caching records.
+    # @param cache [ActiveSupport::Cache::Store, Symbol, Boolean, nil] The caching mechanism to use.
+    # @param ttl [Numeric, ActiveSupport::Duration, nil] The time-to-live (in seconds) for cached records.
+    # @return [void]
+    def support_table(data_file:, key_attribute:, attribute_helpers:, cache_by:, cache:, ttl:)
+      include_modules
+      set_key_attribute(key_attribute)
+      set_attribute_helpers(attribute_helpers)
+      set_data_file(data_file)
+      setup_caching(cache_by, cache, ttl)
+    end
+
+    private
+
+    def include_modules
+      klass.include SupportTableData unless klass.include?(SupportTableData)
+      klass.include SupportTableCache unless klass.include?(SupportTableCache)
+    end
+
+    def set_key_attribute(key_attribute)
+      klass.support_table_key_attribute = key_attribute if key_attribute
+    end
+
+    def set_attribute_helpers(attribute_helpers)
+      helpers = [klass.support_table_key_attribute]
+      helpers.concat(Array(attribute_helpers)) if attribute_helpers
+      klass.named_instance_attribute_helpers(*helpers.uniq.compact)
+    end
+
+    def set_data_file(data_file)
+      if data_file
+        Array(data_file).each do |file|
+          klass.add_support_table_data(file)
+        end
+      elsif data_file.nil?
+        data_root_dir = klass.support_table_data_directory || SupportTableData.data_directory || Dir.pwd
+        default_data_file = File.join(data_root_dir, "#{klass.name.pluralize.underscore}.yml")
+        if File.exist?(default_data_file)
+          klass.add_support_table_data(default_data_file)
+        end
+      end
+    end
+
+    def setup_caching(cache_by, cache, ttl)
+      if cache == false
+        klass.send(:cache_by, false)
+        return
+      end
+
+      cache_keys = [klass.support_table_key_attribute, "id"]
+      cache_keys.concat(Array(cache_by)) if cache_by
+      cache_keys.uniq! { |key| Array(key).collect(&:to_s) }
+
+      cache_keys.each do |key|
+        klass.send(:cache_by, key)
+      end
+
+      klass.support_table_cache = cache
+      klass.support_table_cache_ttl = ttl
+    end
+  end
+end

data/lib/support_table.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require "support_table_cache"
+require "support_table_data"
+
+# Include this module to add the ability to define support tables in ActiveRecord models.
+# This will add the `support_table` and `belongs_to_support_table` class methods to the model.
+#
+# A support table is a table that contains a fixed set of data that is used to support
+# the application. This data is typically loaded from a data file (YAML, JSON, or CSV)
+# and is intended to be read-only. Support tables are also usually small and can be
+# cached in memory for fast access.
+#
+# You would normally just include this module in your `ApplicationRecord` class. However,
+# you can also include it in individual models.
+#
+# @example Define a support table
+#
+#   class ApplicationRecord < ActiveRecord::Base
+#     self.abstract_class = true
+#
+#     include SupportTable
+#   end
+#
+#   class Status < ApplicationRecord
+#     support_table
+#   end
+#
+#   class Task < ApplicationRecord
+#     belongs_to_support_table :status
+#   end
+module SupportTable
+  extend ActiveSupport::Concern
+
+  VERSION = File.read(File.join(__dir__, "../VERSION")).strip
+
+  included do
+    include BelongsToSupportTable unless include?(BelongsToSupportTable)
+  end
+
+  module ClassMethods
+    # Define details about the support table. You only need to call this method if
+    # you need to override any of the defaults. See SupportTableData and SupportTableCache
+    # for more details.
+    #
+    # @param data_file [String, Array<String>, nil] Path to the data file to use to load the table. This
+    #   should be a YAML, JSON, or CSV file that defines the records that should always exist in
+    #   the table. If no value is specified, then a YAML file in the data directory with the
+    #   same name as the underscored, pluralized name of the class will be used. For example,
+    #   if the class name is `Task::Status`, then it will look for the file `task/statuses.yml`
+    #   in the `db/support_tables` directory.
+    #
+    # @param key_attribute [String, Symbol, nil] The name of the attribute in the data file that
+    #   uniquely identifies each row in the data. By default this will be the primary key
+    #   attribute of the table (usually `id`).
+    #
+    # @param attribute_helpers [String, Symbol, Array<String, Symbol>, nil] List of attributes
+    #   which should have helper methods created for them. This generates methods for each named instance
+    #   to get that attribute directly from the YAML data. For example, adding a helper for `:name`
+    #   will create a class method `*_name` for each named instance (i.e. Status.draft_name).
+    #
+    # @param cache_by [String, Symbol, Array, nil] List of attributes that can be used to uniquely
+    #   identify a row that can be used for caching records. If a unique key is made up of
+    #   multiple columns, then you will need to set it up with a call to `SupportTableCache.cache_by`
+    #
+    # @param cache [ActiveSupport::Cache::Store, Symbol, Boolean, nil] The caching mechanism to use.
+    #   This can be either an instance of `ActiveSupport::Cache::Store` like `Rails.cache`, or
+    #   the value `:memory` to use an in-memory cache, or `false` to disable caching.
+    #
+    #
+    # @param ttl [Numeric, ActiveSupport::Duration, nil] The time-to-live (in seconds) for cached records. If not specified,
+    # @return [void]
+    def support_table(data_file: nil, key_attribute: nil, attribute_helpers: nil, cache_by: nil, cache: :memory, ttl: nil)
+      SupportTable::Definition.new(self).support_table(
+        data_file: data_file,
+        key_attribute: key_attribute,
+        attribute_helpers: attribute_helpers,
+        cache_by: cache_by,
+        cache: cache,
+        ttl: ttl
+      )
+    end
+  end
+
+  class << self
+    # Set the directory where data files are stored. See SupportTableData for details.
+    # This is an alias for `SupportTableData.data_directory=`.
+    #
+    # @param dir [String] Path to the directory where data files are stored.
+    # @return [void]
+    def data_directory=(dir)
+      SupportTableData.data_directory = dir
+    end
+
+    # Sync all support tables. See SupportTableData for details. This is an alias for
+    # `SupportTableData.sync_all!`.
+    #
+    # @param classes [Array<Class>] List of support table classes to sync. If no classes
+    #   are specified, then all support tables will be synced.
+    # @return [void]
+    def sync_all!(*classes)
+      SupportTableData.sync_all!(*classes)
+    end
+
+    # Set the cache used on support tables. See SupportTableCache for details. This is an
+    # alias for `SupportTableCache.cache=`.
+    #
+    # @param cache_impl [ActiveSupport::Cache::Store] The cache implementation to use.
+    # @return [void]
+    def cache=(cache_impl)
+      SupportTableCache.cache = cache_impl
+    end
+  end
+end
+
+require_relative "support_table/belongs_to_support_table"
+require_relative "support_table/definition"

data/support_table.gemspec

@@ -0,0 +1,42 @@
+Gem::Specification.new do |spec|
+  spec.name = "support_table"
+  spec.version = File.read(File.expand_path("../VERSION", __FILE__)).strip
+  spec.authors = ["Brian Durand"]
+  spec.email = ["bbdurand@gmail.com"]
+
+  spec.summary = "Support tables for ActiveRecord models with YAML-backed data, helper methods, and automatic caching for small tables."
+
+  spec.homepage = "https://github.com/bdurand/support_table"
+  spec.license = "MIT"
+
+  spec.metadata = {
+    "homepage_uri" => spec.homepage,
+    "source_code_uri" => spec.homepage,
+    "changelog_uri" => "#{spec.homepage}/blob/main/CHANGELOG.md"
+  }
+
+  # 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[
+    .
+    AGENTS.md
+    Appraisals
+    Gemfile
+    Gemfile.lock
+    Rakefile
+    bin/
+    gemfiles/
+    spec/
+    test_app/
+  ]
+  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 "support_table_cache", "~> 1.1", ">= 1.1.5"
+  spec.add_dependency "support_table_data", "~> 1.5", ">= 1.5.0"
+
+  spec.add_development_dependency "bundler"
+end

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification
+name: support_table
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Brian Durand
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: support_table_cache
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.5
+- !ruby/object:Gem::Dependency
+  name: support_table_data
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.5.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.5.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'
+email:
+- bbdurand@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- MIT-LICENSE
+- README.md
+- VERSION
+- lib/support_table.rb
+- lib/support_table/belongs_to_support_table.rb
+- lib/support_table/definition.rb
+- support_table.gemspec
+homepage: https://github.com/bdurand/support_table
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/bdurand/support_table
+  source_code_uri: https://github.com/bdurand/support_table
+  changelog_uri: https://github.com/bdurand/support_table/blob/main/CHANGELOG.md
+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: 4.0.3
+specification_version: 4
+summary: Support tables for ActiveRecord models with YAML-backed data, helper methods,
+  and automatic caching for small tables.
+test_files: []