support_table_data 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 93d64b82d63c76b8a0d51232bc39dacb319d5c5304aea0f97899d843fb32b21a
+  data.tar.gz: 8d07ea94b74ea7daf8dd5a863527cdd57c55a0bd301e347dfeb25ec5915208c9
+SHA512:
+  metadata.gz: 2032fa102c26ffd779b01a75d7cd7c1079b51b33e6afb3677a0b34f879864a60c6895fa6e4795c74f300b4cdd4786e2bb195a43f03c75749f88dec74fdf8b245
+  data.tar.gz: d3877f8a0d8abe36a293ad726471db5336ac0f555b3aa13f41ef1ffb06f457692674f726c4056aae300d97b236b8715bb5a79a19a5c55a601eb7088e4fb1d6be

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 SupportTableData concern to enable automatic syncing of data on support tables.

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,192 @@
+# Support Table Data
+
+[![Continuous Integration](https://github.com/bdurand/support_table_data/actions/workflows/continuous_integration.yml/badge.svg)](https://github.com/bdurand/support_table_data/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 provides a mixin for ActiveRecord support table models that allows you to load data from YAML, JSON, or CSV files and reference specific records more easily. It is intended to solve issues with support tables (also known as lookup tables) that contain a small set of canonical data that must exist for your application to work.
+
+These kinds of models blur the line between data and code. You'll often end up with constants and application logic based on specific values that need to exist in the table. By using this gem, you can easily define methods for loading and comparing specific instances. This can give you cleaner code that reads far more naturally. You can also avoid defining dozens of constants or referencing magic values (i.e. no more hard-coded strings or ids in the code to look up specific records).
+
+## Usage
+
+In the examples below, suppose we have a simple `Status` model in which each row has an id and a name, and the name can only have a handful of statuses: "Pending", "In Progress", and "Completed".
+
+Now, we may have code that needs to reference the status and make decisions based on it. This will require that the table have the exact same values in it in every environment. This gem lets you define these values in a YAML file:
+
+```yaml
+- id: 1
+  name: Pending
+
+- id: 2
+  name: In Progress
+
+- id: 3
+  name: Completed
+```
+
+You can then use this mixin to match that data with your model:
+
+```ruby
+class Status < ApplicationRecord
+  include SupportTableData
+
+  # Set the default location for data files. (This is the default value in a Rails application.)
+  self.support_table_data_directory = Rails.root + "db" + "support_tables"
+
+  # Add the data file to the model; you can also specify an absolute path and add multiple data files.
+  add_support_table_data "statuses.yml"
+end
+```
+
+### Specifying Data Files
+
+You use the `add_support_table_data` class method to add a data file path. This file must be a YAML, JSON, or CSV file that defines a list of attributes. YAML and JSON files should contain an array where each element is a hash of the attributes for each record. YAML and JSON file can also be defined as a hash when using named instances (see below). CSV files must use comma delimiters, double quotes for the quote character, and have a header row containing the attribute names.
+
+One of the attributes in your data files will be the key attribute. This attribute must uniquely identify each element. By default, the key attribute will be the table's primary key. You can change this by setting the `support_table_key_attribute` class attribute on the model.
+
+```ruby
+class Status < ApplicationRecord
+  include SupportTableData
+
+  self.support_table_key_attribute = :name
+ end
+```
+
+You cannot update the value of the key attribute in a record in the data file. If you do, a new record will be created and the existing record will be left unchanged.
+
+You can specify data files as relative paths. This can be done by setting the `SupportTableData.data_directory` value. You can override this value for a model by setting the `support_table_data_directory` attribute on its class. In a Rails application, `SupportTableData.data_directory` will be automatically set to `db/support_tables/`. Otherwise, relative file paths will be resolved from the current working directory. You must define the directory to load relative files from before loading your model classes.
+
+### Named Instances
+
+You can also automatically define helper methods to load instances and determine if they match specific values. This allows you to add more natural ways of referencing specific records.
+
+Named instances are defined if you supply a hash instead of an array in the data files. The hash keys must be valid Ruby method names. Keys that begin with an underscore will not be used to generate named instances. If you only want to create named instances on a few rows in a table, you can add them to an array under an underscored key.
+
+Here is an example data file using named instances:
+
+```yaml
+pending:
+  id: 1
+  name: Pending
+  icon: :clock:
+
+in_progress:
+  id: 2
+  name: In Progress
+  icon: :construction:
+
+completed:
+  id: 3
+  name: Completed
+  icon: :heavy_check_mark:
+
+_others:
+  - id: 4
+    name: Draft
+
+  - id: 5
+    name: Deleted
+```
+
+The hash keys will be used to define helper methods to load and test for specific instances. In this example, our model defines these methods that make it substantially more natural to reference specific instances.
+
+```ruby
+# These methods can be used to load specific instances.
+Status.pending      # Status.find_by!(id: 1)
+Status.in_progress  # Status.find_by!(id: 2)
+Status.completed    # Status.find_by!(id: 3)
+
+# These methods can be used to test for specific instances.
+status.pending?     # status.id == 1
+status.in_progress? # status.id == 2
+status.completed?   # status.id == 3
+```
+
+Helper methods will not override already defined methods on a model class. If a method is already defined, an `ArgumentError` will be raised.
+
+### Caching
+
+You can use the companion [support_table_cache gem](https://github.com/bdurand/support_table_cache) to add caching support to your models. That way your application won't need to constantly query the database for records that will never change.
+
+```
+class Status < ApplicationRecord
+  include SupportTableData
+  include SupportTableCache
+
+  add_support_table_data "statuses.yml"
+
+  # Cache lookups when finding by name or by id.
+  cache_by :name
+  cache_by :id
+
+  # Cache records in local memory instead of a shared cache for best performance.
+  self.support_table_cache = :memory
+end
+
+class Thing < ApplicationRecord
+  belongs_to :status
+
+  # Use caching to load the association rather than hitting the database every time.
+  cache_belongs_to :status
+end
+```
+
+### Loading Data
+
+Calling `sync_table_data!` on your model class will synchronize the data in the database table with the values from the data files.
+
+```ruby
+Status.sync_table_data!
+```
+
+This will add any missing records to the table and update existing records so that the attributes in the table match the values in the data files. Records that do not appear in the data files will not be touched. Any attributes not specified in the data files will not be changed.
+
+The number of records contained in data files should be fairly small (ideally fewer than 100). It is possible to load just a subset of rows in a large table because only the rows listed in the data files will be synced. You can use this feature if your table allows user-entered data, but has a few rows that must exist for the code to work.
+
+Loading data is done inside a database transaction. No changes will be persisted to the database unless all rows for a model can be synced.
+
+You can synchronize the data in all models by calling `SupportTableData.sync_all!`. This method will discover all ActiveRecord models that include `SupportTableData` and synchronize each of them. (Note that there can be issues discovering all support table models in a Rails application if eager loading is turned off.) The discovery mechanism will try to detect unloaded classes by looking at the file names in the support table data directory so it's best to stick to standard Rails naming conventions for your data files.
+
+You need to call `SupportTableData.sync_all!` when deploying your application. This gem includes a rake task `support_table_data:sync` that is suitable for hooking into deploy scripts. An easy way to hook it into a Rails application is by enhancing the `db:migrate` task so that the sync task runs immediately after database migrations are run. You can do this by adding code to a Rakefile in your application's `lib/tasks` directory:
+
+```ruby
+if Rake::Task.task_defined?("db:migrate")
+  Rake::Task["db:migrate"].enhance do
+    Rake::Task["support_table_data:sync"].invoke
+  end
+end
+```
+
+Enhancing the `db:migrate` task also ensures that local development environments will stay up to date.
+
+### Testing
+
+You must also call `SupportTableData.sync_all!` before running your test suite. This method should be called in the test suite setup code after any data in the test database has been purged and before any tests are run.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "support_table_data"
+```
+
+Then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install support_table_data
+```
+
+## Contributing
+
+Open a pull request on [GitHub](https://github.com/bdurand/support_table_data).
+
+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_data/railtie.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module SupportTableData
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      load File.expand_path("../tasks/support_table_data.rake", __dir__)
+    end
+  end
+end

data/lib/support_table_data.rb

@@ -0,0 +1,338 @@
+# frozen_string_literal: true
+
+# This concern can be mixed into models that represent static support tables. These are small tables
+# that have a limited number of rows, and have values that are often tied to the logic in the code.
+#
+# The values that should be in support tables can be defined in YAML, JSON, or CSV files. These
+# values can then be synced to the database and helper methods can be generated from them.
+module SupportTableData
+  extend ActiveSupport::Concern
+
+  module ClassMethods
+    # Synchronize the rows in the table with the values defined in the data files added with
+    # `add_support_table_data`. Note that rows will not be deleted if they are no longer in
+    # the data files.
+    #
+    # @return [Array<Hash>] List of saved changes for each record that was created or modified.
+    def sync_table_data!
+      return unless table_exists?
+
+      key_attribute = (support_table_key_attribute || primary_key).to_s
+      canonical_data = support_table_data.each_with_object({}) { |attributes, hash| hash[attributes[key_attribute].to_s] = attributes }
+      records = where(key_attribute => canonical_data.keys)
+      changes = []
+
+      ActiveSupport::Notifications.instrument("support_table_data.sync", class: self) do
+        transaction do
+          records.each do |record|
+            key = record[key_attribute].to_s
+            attributes = canonical_data.delete(key)
+            attributes&.each do |name, value|
+              record.send("#{name}=", value) if record.respond_to?("#{name}=", true)
+            end
+            if record.changed?
+              changes << record.changes
+              record.save!
+            end
+          end
+
+          canonical_data.each_value do |attributes|
+            record = new
+            attributes.each do |name, value|
+              record.send("#{name}=", value) if record.respond_to?("#{name}=", true)
+            end
+            changes << record.changes
+            record.save!
+          end
+        end
+      end
+
+      changes
+    end
+
+    # Add a data file that contains the support table data. This method can be called multiple times to
+    # load data from multiple files.
+    #
+    # @param data_file_path [String, Pathname] The path to a YAML, JSON, or CSV file containing data for this model. If
+    #   the path is a relative path, then it will be resolved from the either the default directory set for
+    #   this model or the global directory set with SupportTableData.data_directory.
+    # @return [void]
+    def add_support_table_data(data_file_path)
+      @support_table_data_files ||= []
+      root_dir = (support_table_data_directory || SupportTableData.data_directory || Dir.pwd)
+      @support_table_data_files << File.expand_path(data_file_path, root_dir)
+      define_support_table_named_instances
+    end
+
+    # Get the data for the support table from the data files.
+    #
+    # @return [Array<Hash>] List of attributes for all records in the data files.
+    def support_table_data
+      @support_table_data_files ||= []
+      data = {}
+      key_attribute = (support_table_key_attribute || primary_key).to_s
+
+      @support_table_data_files.each do |data_file_path|
+        file_data = support_table_parse_data_file(data_file_path)
+        file_data = file_data.values if file_data.is_a?(Hash)
+        file_data = Array(file_data).flatten
+        file_data.each do |attributes|
+          key_value = attributes[key_attribute].to_s
+          existing = data[key_value]
+          if existing
+            existing.merge!(attributes)
+          else
+            data[key_value] = attributes
+          end
+        end
+      end
+
+      data.values
+    end
+
+    # Get the names of all named instances.
+    #
+    # @return [Array<String>] List of all instance names.
+    def instance_names
+      @support_table_instance_names ||= Set.new
+      @support_table_instance_names.to_a
+    end
+
+    # Get the key values for all instances loaded from the data files.
+    #
+    # @return [Array] List of all the key attribute values.
+    def instance_keys
+      unless defined?(@support_table_instance_keys)
+        key_attribute = (support_table_key_attribute || primary_key).to_s
+        values = []
+        support_table_data.each do |attributes|
+          key_value = attributes[key_attribute]
+          instance = new
+          instance.send("#{key_attribute}=", key_value)
+          values << instance.send(key_attribute)
+        end
+        @support_table_instance_keys = values.uniq
+      end
+      @support_table_instance_keys
+    end
+
+    # Return true if the instance has data being managed from a data file.
+    #
+    # @return [Boolean]
+    def protected_instance?(instance)
+      key_attribute = (support_table_key_attribute || primary_key).to_s
+
+      unless defined?(@protected_keys)
+        keys = support_table_data.collect { |attributes| attributes[key_attribute].to_s }
+        @protected_keys = keys
+      end
+
+      @protected_keys.include?(instance[key_attribute].to_s)
+    end
+
+    private
+
+    def define_support_table_named_instances
+      @support_table_data_files ||= []
+      @support_table_instance_names ||= Set.new
+      key_attribute = (support_table_key_attribute || primary_key).to_s
+
+      @support_table_data_files.each do |file_path|
+        data = support_table_parse_data_file(file_path)
+        if data.is_a?(Hash)
+          data.each do |key, attributes|
+            method_name = key.to_s.freeze
+            next if method_name.start_with?("_")
+
+            unless attributes.is_a?(Hash)
+              raise ArgumentError.new("Cannot define named instance #{method_name} on #{name}; value must be a Hash")
+            end
+
+            unless method_name.match?(/\A[a-z][a-z0-9_]+\z/)
+              raise ArgumentError.new("Cannot define named instance #{method_name} on #{name}; name contains illegal characters")
+            end
+
+            unless @support_table_instance_names.include?(method_name)
+              @support_table_instance_names << method_name
+              key_value = attributes[key_attribute]
+              define_support_table_instance_helper(method_name, key_attribute, key_value)
+              define_support_table_predicates_helper("#{method_name}?", key_attribute, key_value)
+            end
+          end
+        end
+      end
+    end
+
+    def define_support_table_instance_helper(method_name, attribute_name, attribute_value)
+      if respond_to?(method_name, true)
+        raise ArgumentError.new("Could not define support table helper method #{name}.#{method_name} because it is already a defined method")
+      end
+
+      class_eval <<~RUBY, __FILE__, __LINE__ + 1
+        def self.#{method_name}
+          find_by!(#{attribute_name}: #{attribute_value.inspect})
+        end
+      RUBY
+    end
+
+    def define_support_table_predicates_helper(method_name, attribute_name, attribute_value)
+      if method_defined?(method_name) || private_method_defined?(method_name)
+        raise ArgumentError.new("Could not define support table helper method #{name}##{method_name} because it is already a defined method")
+      end
+
+      class_eval <<~RUBY, __FILE__, __LINE__ + 1
+        def #{method_name}
+          #{attribute_name} == #{attribute_value.inspect}
+        end
+      RUBY
+    end
+
+    def support_table_parse_data_file(file_path)
+      file_data = File.read(file_path)
+
+      extension = file_path.split(".").last&.downcase
+      data = []
+
+      case extension
+      when "json"
+        require "json" unless defined?(JSON)
+        data = JSON.parse(file_data)
+      when "csv"
+        require "csv" unless defined?(CSV)
+        CSV.new(file_data, headers: true).each do |row|
+          data << row.to_h
+        end
+      else
+        require "yaml" unless defined?(YAML)
+        data = YAML.safe_load(file_data)
+      end
+
+      data
+    end
+  end
+
+  included do
+    # Define the attribute used as the key of the hash in the data files.
+    # This should be a value that never changes. By default the key attribute will be the id.
+    class_attribute :support_table_key_attribute, instance_accessor: false
+
+    # Define the directory where data files should be loaded from. This value will override the global
+    # value set by SupportTableData.data_directory. This is only used if relative paths are passed
+    # in to add_support_table_data.
+    class_attribute :support_table_data_directory, instance_accessor: false
+  end
+
+  class << self
+    # Specify the default directory for data files.
+    attr_writer :data_directory
+
+    # The directory where data files live by default. If you are running in a Rails environment,
+    # then this will be `db/support_tables`. Otherwise, the current working directory will be used.
+    #
+    # @return [String]
+    def data_directory
+      if defined?(@data_directory)
+        @data_directory
+      elsif defined?(Rails.root)
+        Rails.root.join("db", "support_tables").to_s
+      end
+    end
+
+    # Sync all support table classes. Classes must already be loaded in order to be synced.
+    #
+    # You can pass in a list of classes that you want to ensure are synced. This feature
+    # can be used to force load classes that are only loaded at runtime. For instance, if
+    # eager loading is turned off for the test environment in a Rails application (which is
+    # the default), then there is a good chance that support table models won't be loaded
+    # when the test suite is initializing.
+    #
+    # @param extra_classes [Class] List of classes to force into the detected list of classes to sync.
+    # @return [Hash<Class, Array<Hash>] Hash of classes synced with a list of saved changes.
+    def sync_all!(*extra_classes)
+      changes = {}
+      support_table_classes(*extra_classes).each do |klass|
+        changes[klass] = klass.sync_table_data!
+      end
+      changes
+    end
+
+    # Return the list of all support table classes in the order they should be loaded.
+    # Note that this method relies on the classes already having been loaded by the application.
+    # It can return indeterminate results if eager loading is turned off (i.e. development
+    # or test mode in a Rails application).
+    #
+    # If any data files exist in the default data directory, any class name that matches
+    # the file name will attempt to be loaded (i.e. "task/statuses.yml" will attempt to
+    # load the `Task::Status` class if it exists).
+    #
+    # You can also pass in a list of classes that you explicitly want to include in the returned list.
+    #
+    # @param extra_classes [Class] List of extra classes to include in the return list.
+    # @return [Array<Class>] List of classes in the order they should be loaded.
+    # @api private
+    def support_table_classes(*extra_classes)
+      classes = []
+      extra_classes.flatten.each do |klass|
+        unless klass.is_a?(Class) && klass.include?(SupportTableData)
+          raise ArgumentError.new("#{klass} does not include SupportTableData")
+        end
+        classes << klass
+      end
+
+      # Eager load any classes defined in the default data directory by guessing class names
+      # from the file names.
+      if SupportTableData.data_directory && File.exist?(SupportTableData.data_directory) && File.directory?(SupportTableData.data_directory)
+        Dir.chdir(SupportTableData.data_directory) { Dir.glob(File.join("**", "*")) }.each do |file_name|
+          class_name = file_name.sub(/\.[^.]*/, "").singularize.camelize
+          class_name.safe_constantize
+        end
+      end
+
+      ActiveRecord::Base.descendants.sort_by(&:name).each do |klass|
+        next unless klass.include?(SupportTableData)
+        next if klass.abstract_class?
+        next if classes.include?(klass)
+        classes << klass
+      end
+
+      levels = [classes]
+      checked = Set.new
+      loop do
+        checked << classes
+        dependencies = classes.collect { |klass| support_table_dependencies(klass) }.flatten.uniq.sort_by(&:name)
+        break if dependencies.empty? || checked.include?(dependencies)
+        levels.unshift(dependencies)
+        classes = dependencies
+      end
+
+      levels.flatten.uniq
+    end
+
+    private
+
+    # Extract support table dependencies from the belongs to associations on a class.
+    #
+    # @return [Array<Class>]
+    def support_table_dependencies(klass)
+      dependencies = []
+      klass.reflections.values.select(&:belongs_to?).each do |reflection|
+        if reflection.klass.include?(SupportTableData) && !(reflection.klass <= klass)
+          dependencies << reflection.klass
+        end
+      end
+      dependencies
+    end
+  end
+
+  # Return true if this instance has data being managed from a data file. You can add validation
+  # logic using this information if you want to prevent the application from updating protected instances.
+  #
+  # @return [Boolean]
+  def protected_instance?
+    self.class.protected_instance?(self)
+  end
+end
+
+if defined?(Rails::Railtie)
+  require_relative "support_table_data/railtie"
+end

data/lib/tasks/support_table_data.rake

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+namespace :support_table_data do
+  desc "Syncronize data for all models that include SupportTableData."
+  task sync: :environment do
+    # Eager load models if we are in a Rails enviroment with eager loading turned off.
+    if defined?(Rails.application)
+      unless Rails.application.config.eager_load
+        if defined?(Rails.application.eager_load!)
+          Rails.application.eager_load!
+        elsif defined?(Rails.autoloaders.zeitwerk_enabled?) && Rails.autoloaders.zeitwerk_enabled?
+          Rails.autoloaders.each(&:eager_load)
+        else
+          warn "Could not eager load models; some support table data may not load"
+        end
+      end
+    end
+
+    logger_callback = lambda do |name, started, finished, unique_id, payload|
+      klass = payload[:class]
+      elapsed_time = finished - started
+      message = "Synchronized support table model #{klass.name} in #{(elapsed_time * 1000).round}ms"
+      if klass.logger
+        klass.logger.info(message)
+      else
+        puts message
+      end
+    end
+
+    ActiveSupport::Notifications.subscribed(logger_callback, "support_table_data.sync") do
+      SupportTableData.sync_all!
+    end
+  end
+end

data/support_table_data.gemspec

@@ -0,0 +1,33 @@
+Gem::Specification.new do |spec|
+  spec.name = "support_table_data"
+  spec.version = File.read(File.expand_path("../VERSION", __FILE__)).strip
+  spec.authors = ["Brian Durand"]
+  spec.email = ["bbdurand@gmail.com"]
+
+  spec.summary = "Extension for ActiveRecord models to manage synchronizing data in support/lookup tables across environments. Also provides the ability to directly reference and test for specific rows in these tables."
+
+  spec.homepage = "https://github.com/bdurand/support_table_data"
+  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,81 @@
+--- !ruby/object:Gem::Specification
+name: support_table_data
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Brian Durand
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2022-11-02 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_data.rb
+- lib/support_table_data/railtie.rb
+- lib/tasks/support_table_data.rake
+- support_table_data.gemspec
+homepage: https://github.com/bdurand/support_table_data
+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: Extension for ActiveRecord models to manage synchronizing data in support/lookup
+  tables across environments. Also provides the ability to directly reference and
+  test for specific rows in these tables.
+test_files: []