activerecord-polytypes 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: de50052f2a84d18714886f41876bfe80b9d9b9b4e7fd426338c4029fad5b925b
+  data.tar.gz: d94bdc1f419a3f1aed49965f8c09fe36fabf833ffaf8dae2837a38d2cc760d2b
+SHA512:
+  metadata.gz: e3c518408bf522adf86567c0f4a6f9bc0696bcf385b89159c29678a51de2d9660494c4a69ace25049920a67bac957fee425396b53526df71bfe4458f36ada2d0
+  data.tar.gz: ce13ce16d5239f575a98b2acd29cdd50d69bf36001e481cef893a76fb96f01ba27b2e790095d0d2a2c4c6e991b19e1dc8dd59e0be599856bac6381f98ade7633

data/.rubocop.yml

@@ -0,0 +1,13 @@
+AllCops:
+  TargetRubyVersion: 3.0
+
+Style/StringLiterals:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Layout/LineLength:
+  Max: 120

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+## [0.1.0] - 2024-03-15
+
+- Initial release

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,84 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our community a harassment-free experience for everyone, regardless of age, body size, visible or invisible disability, ethnicity, sex characteristics, gender identity and expression, level of experience, education, socio-economic status, nationality, personal appearance, race, religion, or sexual identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming, diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes, and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or
+  advances of any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email
+  address, without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of acceptable behavior and will take appropriate and fair corrective action in response to any behavior that they deem inappropriate, threatening, offensive, or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, and will communicate reasons for moderation decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when an individual is officially representing the community in public spaces. Examples of representing our community include using an official e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported to the community leaders responsible for enforcement at wouter.coppieters@employmenthero.com. All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing clarity around the nature of the violation and an explanation of why the behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of actions.
+
+**Consequence**: A warning with consequences for continued behavior. No interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, for a specified period of time. This includes avoiding interactions in community spaces as well as external channels like social media. Violating these terms may lead to a temporary or permanent ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public communication with the community for a specified period of time. No public or private interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, is allowed during this period. Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community standards, including sustained inappropriate behavior,  harassment of an individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 2.0,
+available at https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
+
+Community Impact Guidelines were inspired by [Mozilla's code of conduct enforcement ladder](https://github.com/mozilla/diversity).
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see the FAQ at
+https://www.contributor-covenant.org/faq. Translations are available at https://www.contributor-covenant.org/translations.

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Wouter Coppieters
+
+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,175 @@
+# ActiveRecord Polytypes
+
+ActiveRecord Polytypes adds features to ActiveRecord to combinine the best of multiple inheritance, multi-table inheritance, and polymorphic relationships, without the need for schema changes. It supports PostgreSQL, MySQL and SQLite.
+
+## Features
+
+- Efficient Polymorphic Queries: Load a polymorphic list of subtypes with a single query, eliminating the need for multiple database hits.
+- Intuitive Query Capabilities: Leverage ordinary ActiveRecord queries to filter across supertype and subtype attributes in a single query.
+- Schema-Friendly: Integrates into existing ActiveRecord relationships without requiring schema changes.
+- Enjoy the benefits of STI, while avoiding wide, sparse tables
+- Enjoy the benefits of abstract classes, without giving up the ability to query subtypes in a single collection
+- Enjoy the benefits of delegated types, while supporting filtering, ordering and aggregating on subtype and supertype attributes simultaneously and without needing to infiltrate your data with typename strings.
+
+## Anti-goals
+
+- Creating wide tables with many nullable columns (Single Table Inheritance).
+- Performing separate queries for each subtype and aggregating or filtering in memory (Abstract Classes, Delegated Types).
+- Encoding type information into data, which can lead to data integrity issues (Delegated Types).
+- Repeating common column definitions and constraints across multiple tables (Abstract Classes).
+- Relying on database-specific features like Postgres' table inheritance.
+
+Install the gem and add to the application's Gemfile by executing:
+
+    $ bundle add activerecord-polytypes
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+    $ gem install activerecord-polytypes
+
+## Usage
+
+Imagine you have a simple Entity model that can be either a User or an Organisation, and it has associated legal documents and a billing plan.
+
+```ruby
+# An entity, is either a user or an organisation.
+# It is also a container for a collection of legal documents,
+# and it has an associated billing plan.
+class Entity
+  belongs_to :billing_plan
+  has_many :documents
+end
+
+class User < ApplicationRecord; end
+class Organisation < ApplicationRecord; end
+```
+
+At times you may wish to fetch all entities, and their associated documents and billing plans
+but then vary in behaviour or processing, based on the subtype of entity.
+
+What are our options?
+
+## 1. Use a wide table, with a 'type' column with many nullable columns to implement STI. Then add user and organisation specific columns to it. However:
+
+- With each new type, our table becomes more and more bloated.
+- We leak rigid, code-specific type strings into our database, making it more difficult to shuffle types in the future.
+- Because we use native Ruby inheritance, User and Organisation are strictly coupled to Entity. I.e. they can't also be a subtype of another class.
+
+## 2. Use separate tables for each subtype. Make Entity an abstract class.
+
+- We now have lean tables, but lose the ability to query across all entities in a single hit (e.g. useful for any operations where we would like to treat subtypes as part of a uniform collection)
+- Because we use native Ruby inheritance, User and Organisation are strictly coupled to Entity. I.e. they can't also be a subtype of another class.
+- We have to repeat common column definitions and constraints across multiple tables, because subtypes no longer share a supertype table.
+
+## 3. Use delegated types, so that we can store superclass specific info on the Entity class, and subclass specific info on the User and Organisation classes.
+
+- We can query across all entities in a single hit (and also preload subtypes to load these reasonably efficiently)
+- We can allow User and Organisation to be delegated to (i.e. act as subtype to) more than one class.
+- We have a logical home for common column and constraints, and separate homes for subtype specific columns and constraints.
+- But:
+- - We still have to perform separate queries to load subtype details when addressing a collection
+- - We still have to perform aggregations or filters on subtype attributes in memory.
+- - We leak rigid code-specific strings into our database, making it more difficult to shuffle types.
+
+# This is where ActiveRecordPolytypes provides an alternative mechanism.
+
+# With ActiveRecordPolytypes you can easily query across all subtypes like this:
+
+```ruby
+  Entity::Subtype.where("user_created_at > ? OR organisation_country IN (?)", 1.day.ago, %(US)).order(billing_plan_renewal_date: :desc)
+```
+
+To e.g. fetch all entities that are either users created in the last day, or organisations in the US.
+and order by a common attribute:
+
+```ruby
+  => [
+    #<Entity::User...
+    #<Entity::Organisation...
+    #<Entity::User...
+    #<Entity::User...
+    #<Entity::Organisation...
+```
+
+It constructs the needed joins so that you can query across all subtypes in a single hit, performing aggregations and filters on subtype attributes, directly in the database.
+The instantiated subtypes also provide an interface that combines supertype + subtype.
+E.g. in the above, for each:
+
+- _Entity::User_ object, you can access the full set of methods and attributes from both Entity and User.
+- _Entity::Organisation_ object, you can access the full set of methods and attributes from both Entity and User.
+
+You can also create or update supertype + subtype objects in a single hit.
+E.g.
+
+```ruby
+  Entity::User.create(
+    billing_plan_id: 3, # Entity attributes
+    user_name: # User attributes
+  )
+  Entity::User.find(1).update(
+    billing_plan_id: 3, # Entity attributes
+    user_name: # User attributes
+  )
+```
+
+You can also limit queries (which limit the joined tables) to specific subtypes when applicable.
+E.g.
+Limit to specific subtypes
+
+```ruby
+  Entity::User.where(user_name: "Bob")
+  Entity::Organisation.where(organisation_country: "US")
+```
+
+Vs query across all subtypes
+
+```ruby
+  Entity::Subtype.where(...)
+```
+
+All you need to do to install ActiveRecordPolytypes into an existing model, is make a call to `polymorphic_supertype_of` in the model, and pass in the names of the associations that you want to act as subtypes.
+It will work on any existing `belongs_to` or `has_one` association (respecting any non conventional foreign keys, class overrides etc.)
+
+```ruby
+  class Entity < ApplicationRecord
+    belongs_to :billing_plan
+    has_many :documents
+    belongs_to :user
+    belongs_to :organisation
+    polymorphic_supertype_of :user, :organisation
+  end
+```
+
+An entity can act as a subtype to any number of supertypes, so e.g. while Users and Organisations might act as Entities, within a billing context
+they might also act as SearchableItems within a search API. Inheriting from multiple supertypes is as easy as repeating the pattern above, per supertype.
+E.g.
+
+```ruby
+class Searchable < ApplicationRecord
+  validates :searchable_index_string, presence: true
+  belongs_to :user
+  belongs_to :post
+  belongs_to :category
+  polymorphic_supertype_of :user, :post, :category
+end
+
+Searchable::Subtype.all # => [#<Searchable::User..., #<Searchable::Post.., #<Searchable::Category.., #<Searchable::User..]
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/wouterken/activerecord-polytypes. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/wouterken/activerecord-polytypes/blob/master/CODE_OF_CONDUCT.md).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the Activerecord::Mti project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/wouterken/activerecord-polytypes/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/activerecord-polytypes/*test.rb"]
+end
+
+task default: :test

data/activerecord-polytypes.gemspec

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "lib/activerecord-polytypes/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "activerecord-polytypes"
+  spec.version = ActiveRecordPolytypes::VERSION
+  spec.authors = ["Wouter Coppieters"]
+  spec.email = ["wc@pico.net.nz"]
+
+  spec.summary = "Enable ActiveRecord models to act like Polymorphic supertypes."
+  spec.description = "This gem provides an extension to ActiveRecord, enabling efficient Multi-Table, Multiple-Inheritance for ActiveRecord models."
+  spec.homepage = "https://github.com/wouterken/activerecord-polytypes"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.0.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/wouterken/activerecord-polytypes"
+  spec.metadata["changelog_uri"] = "https://github.com/wouterken/activerecord-polytypes"
+
+  # 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.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) ||
+        f.start_with?(*%w[bin/ test/ spec/ features/ .git appveyor Gemfile])
+    end
+  end
+  spec.require_paths = ["lib"]
+  spec.add_dependency "activerecord", "~>7", ">7"
+  spec.add_development_dependency "minitest", "~>5.16"
+  spec.add_development_dependency "minitest-around", "0.4.1"
+  spec.add_development_dependency "minitest-reporters", "~> 1.1", ">= 1.1.0"
+  spec.add_development_dependency "mysql2", "~> 0.5"
+  spec.add_development_dependency "pg", "~> 1", "> 1.0"
+  spec.add_development_dependency "pry-byebug", "~> 3.0"
+  spec.add_development_dependency "sqlite3", "~> 1.3"
+end

data/lib/activerecord-polytypes/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ActiveRecordPolytypes
+  VERSION = "0.1.0"
+end

data/lib/activerecord-polytypes.rb

@@ -0,0 +1,298 @@
+# frozen_string_literal: true
+
+require_relative "activerecord-polytypes/version"
+
+# ActiveRecordPolytypes extends ActiveRecord models with the capability to efficiently fetch, query, and aggregate across collections of subtypes without the need for:
+# - Creating wide tables with many nullable columns (Single Table Inheritance).
+# - Performing separate queries for each subtype and aggregating or filtering in memory (Abstract Classes, Delegated Types).
+# - Encoding type information into data, which can lead to data integrity issues (Delegated Types).
+# - Repeating common column definitions and constraints across multiple tables (Abstract Classes).
+# - Relying on database-specific features like Postgres' table inheritance.
+#
+# Imagine you have a simple Entity model that can represent either a User or an Organisation, and it has associated legal documents and a billing plan.
+#
+#   # An entity, is either a user or an organisation.
+#   # It is also a container for a collection of legal documents,
+#   # and it has an associated billing plan.
+#   class Entity
+#     belongs_to :billing_plan
+#     has_many :documents
+#   end
+#
+#   class User < ApplicationRecord;end
+#   class Organisation < ApplicationRecord;end
+#
+# At times you may wish to fetch all entities, and their associated documents and billing plans
+# but then vary in behaviour or processing, based on the subtype of entity.
+#
+# What are our options?
+#
+# == Use a wide table, with a 'type' column with many nullable columns to implement STI. Then add user and organisation specific columns to it. However:
+# * With each new type, our table becomes more and more bloated.
+# * We leak rigid, code-specific type strings into our database, making it more difficult to shuffle types in the future.
+# * Because we use native Ruby inheritance, User and Organisation are strictly coupled to Entity. I.e. they can't also be a subtype of another class.
+#
+# == Use separate tables for each subtype. Make Entity an abstract class.
+# * We now have lean tables, but lose the ability to query across all entities in a single hit (e.g. useful for any operations where we would like to treat subtypes as part of a uniform collection)
+# * Because we use native Ruby inheritance, User and Organisation are strictly coupled to Entity. I.e. they can't also be a subtype of another class.
+# * We have to repeat common column definitions and constraints across multiple tables, because subtypes no longer share a supertype table.
+#
+# == Use delegated types, so that we can store superclass specific info on the Entity class, and subclass specific info on the User and Organisation classes.
+# * We can query across all entities in a single hit (and also preload subtypes to load these reasonably efficiently)
+# * We can allow User and Organisation to be delegated to (i.e. act as subtype to) more than one class.
+# * We have a logical home for common column and constraints, and separate homes for subtype specific columns and constraints.
+# * But:
+# * * We still have to perform separate queries to load subtype details when addressing a collection
+# * * We still have to perform aggregations or filters on subtype attributes in memory.
+# * * We leak rigid code-specific strings into our database, making it more difficult to shuffle types.
+#
+# This is where ActiveRecordPolytypes provides an alternative mechanism.
+# With ActiveRecordPolytypes you can easily query across all subtypes like this:
+#
+#   Entity::Subtype.where("user_created_at > ? OR organisation_country IN (?)", 1.day.ago, %(US)).order(billing_plan_renewal_date: :desc)
+# To e.g. fetch all entities that are either users created in the last day, or organisations in the US.
+# and order by a common attribute:
+#   => [
+#     #<Entity::User...
+#     #<Entity::Organisation...
+#     #<Entity::User...
+#     #<Entity::User...
+#     #<Entity::Organisation...
+#
+# It constructs the needed joins so that you can query across all subtypes in a single hit, performing aggregations and filters on subtype attributes, directly in the database.
+# The instantiated subtypes also provide an interface that combines the interface of joined supertype + subtype.
+# E.g. in the above, for each:
+# * *Entity::User* object, you can access the full set of methods and attributes from both Entity and User.
+# * *Entity::Organisation* object, you can access the full set of methods and attributes from both Entity and User.
+#
+# You can even create or update supertype + subtype objects in a single hit.
+# E.g.
+#
+#   Entity::User.create(
+#     billing_plan_id: 3, # Entity attributes
+#     user_name: # User attributes
+#   )
+#
+#   Entity::User.find(1).update(
+#     billing_plan_id: 3, # Entity attributes
+#     user_name: # User attributes
+#   )
+#
+# You can also limit queries to specific subtypes when applicable
+# E.g.
+#
+# Limit to specific subtypes
+#
+#   Entity::User.where(user_name: "Bob")
+#   Entity::Organisation.where(organisation_country: "US")
+#
+# Vs query across all subtypes
+#
+#   Entity::Subtype.where(...)
+#
+#
+# All you need to do to install ActiveRecordPolytypes into an existing model, is make a call to <tt>polymorphic_supertype_of</tt> in the model, and pass in the names of the associations that you want to act as subtypes.
+# It will work on any existing <tt>belongs_to</tt> or <tt>has_one</tt> association (respecting any non conventional foreign keys, class overrides etc.)
+#
+#   class Entity < ApplicationRecord
+#     belongs_to :billing_plan
+#     has_many :documents
+#     belongs_to :user
+#     belongs_to :organisation
+#     polymorphic_supertype_of :user, :organisation
+#   end
+#
+# An entity can act as a subtype to any number of supertypes, so e.g. while Users and Organisations might act as Entities, within a billing context
+# they might also act as SearchableItems within a search API. Inheriting from multiple supertypes is as easy as repeating the pattern above, per supertype.
+# E.g.
+#
+#  class Searchable < ApplicationRecord
+#     validates :searchable_index_string, presence: true
+#     belongs_to :user
+#     belongs_to :post
+#     belongs_to :category
+#     polymorphic_supertype_of :user, :post, :category
+#   end
+#
+#   Searchable::Subtype.all # => [#<Searchable::User..., #<Searchable::Post.., #<Searchable::Category.., #<Searchable::User..]
+#
+# @note This documentation and code example is illustrative of how ActiveRecordPolytypes can be integrated into an ActiveRecord model to leverage polymorphism efficiently.
+module ActiveRecordPolytypes
+  extend ActiveSupport::Concern
+
+
+  # @!method polymorphic_supertype_of(*associations)
+  #   Sets up the ActiveRecord model as a polymorphic supertype of the specified associations
+  #   @!scope class
+  #   @param associations [Array<Symbol>] the names of the associations that should act as subtypes.
+  #     These associations are expected to be either `:belongs_to` or `:has_one` associations.
+  #
+  #   @example Adding polymorphic supertype to an Entity model
+  #     class Entity < ApplicationRecord
+  #       belongs_to :billing_plan
+  #       has_many :documents
+  #       belongs_to :user
+  #       belongs_to :organisation
+  #       polymorphic_supertype_of :user, :organisation
+  #     end
+  class_methods do
+
+    def polymorphic_supertype_of(*associations)
+      associations = associations.map { |a| reflect_on_association(a) }.compact
+      return unless associations.any?
+
+      supertype_type = self
+      # Remove any previously defined constant to avoid constant redefinition warnings.
+      self.send(:remove_const, :Subtype) if self.constants.include?(:Subtype)
+
+      # Define a new class inherited from the current class acting as the subtype.
+      subtype_class = self.const_set(:Subtype, Class.new(self))
+      subtype_class.class_eval do
+
+        attribute :type
+
+        select_components_by_type = {}
+        case_components_by_type = {}
+        join_components_by_type = {}
+
+        # Prepare SQL components to construct a query that joins subtypes and selects their attributes and type.
+        associations.each do |association|
+          base_type = association.compute_class(association.class_name)
+
+          # Generate a class name for the subtype proxy.
+          subtype_class_name = "#{supertype_type.name}::#{base_type.name}"
+          # Dynamically create a proxy class for the multi-table inheritance.
+          build_mti_proxy_class!(association, base_type, supertype_type)
+
+          select_components_by_type[association.name] = base_type.columns.map do |column|
+            column_name = "#{association.name}_#{column.name}"
+            "#{association.table_name}.#{column.name} as #{column_name}"
+          end.join(",")
+
+          case_components_by_type[association.name] = "WHEN #{association.table_name}.#{association.join_primary_key} IS NOT NULL THEN '#{subtype_class_name}'"
+          join_components_by_type[association.name] = if association.belongs_to?
+            "LEFT JOIN #{association.table_name} ON #{table_name}.#{association.foreign_key} = #{association.table_name}.#{association.join_primary_key}"
+          else
+            "LEFT JOIN #{association.table_name} ON #{table_name}.#{association.association_primary_key} = #{association.table_name}.#{association.join_primary_key}"
+          end
+        end
+
+        # Define a scope `with_subtypes` that enriches the base query with subtype information.
+        scope :with_subtypes, ->(*typenames){
+          select_components, case_components, join_components = typenames.map do |typename|
+            [
+              select_components_by_type[typename],
+              case_components_by_type[typename],
+              join_components_by_type[typename]
+            ]
+          end.transpose
+          from(<<~SQL)
+            (
+              SELECT #{table_name}.*,#{select_components * ","}, CASE #{case_components * " "} ELSE '#{name}' END AS type
+              FROM #{table_name} #{join_components * " "}
+            ) #{table_name}
+          SQL
+        }
+
+        # Automatically apply `with_subtypes` scope to all queries if specified.
+        default_scope -> { with_subtypes(*associations.map(&:name)) }
+      end
+    end
+
+    # Dynamically builds a proxy class for a given association to handle multi-table inheritance.
+    def build_mti_proxy_class!(association, base_type, supertype_type)
+      # Remove any previously defined constant to avoid constant redefinition warnings.
+      supertype_type.send(:remove_const, base_type.name) if supertype_type.constants.include?(base_type.name.to_sym)
+
+      # Define a new class inherited from the current class acting as the subtype.
+      subtype_class = supertype_type.const_set(base_type.name, Class.new(self))
+      subtype_class.class_eval do
+        attr_reader :inner
+
+        # Only include records of this subtype in the default scope.
+        default_scope ->{ with_subtypes(association.name) }
+        # Define callbacks and methods for initializing and saving the inner object.
+        after_initialize :initialize_inner_object
+        before_save :save_inner_object_if_changed
+        after_save :reload, if: :previously_new_record?
+
+        # Define attributes and delegation methods for columns inherited from the base type.
+        base_type.columns.each do |column|
+          column_name = "#{association.name}_#{column.name}"
+          attribute column_name, column.type
+          delegate column.name, to: :@inner, allow_nil: true, prefix: association.name
+          define_method :"#{column_name}=" do |value|
+            case
+            when @inner then @inner.send(:"#{column.name}=", value)
+            else
+              (@assigned_attributes ||= {})[column.name] = value
+            end
+          end
+        end
+
+        # Provide a mechanism to handle methods not explicitly defined in the proxy class, delegating them to the @inner object if possible.
+        def method_missing(m, *args, &block)
+          if @inner.respond_to?(m)
+            @inner.send(m, *args, &block)
+          else
+            super
+          end
+        end
+
+        # Initialize the inner object based on the association's attributes or build a new association instance.
+        define_method :initialize_inner_object do
+          # Prepare attributes for instantiation.
+          @inner_attributes ||= base_type.columns.each_with_object({}) do |c, attrs|
+            attrs[c.name.to_s] = self["#{association.name}_#{c.name}"]
+          end
+          # Instantiate or build the inner object based on current record state.
+          if @assigned_attributes && @assigned_attributes[association.association_primary_key]
+            @inner = base_type.instantiate(association.association_primary_key => @assigned_attributes[association.association_primary_key])
+            self.send(:"#{association.name}=", @inner)
+            @inner.assign_attributes(@assigned_attributes)
+            @assigned_attributes.each do |name, attribute|
+              self["#{association.name}_#{name}"] = attribute
+            end
+          elsif !new_record?
+            @inner = base_type.instantiate(@inner_attributes)
+          else
+            @inner = self.association(association.name).build(@assigned_attributes)
+          end
+        end
+
+        # Override `as_json` to include attributes from both the outer and inner objects.
+        define_method :as_json do |options={}|
+          only = base_type.column_names + ["type"] + (options || {}).fetch(:only,[])
+          outer = super(**(options || {}), only: )
+          @inner.as_json(options).merge(outer)
+        end
+
+        # Save the inner object if it has changed before saving the outer object.
+        def save_inner_object_if_changed
+          @inner.save if @inner.changed?
+        end
+
+        # Check if an attribute exists in either the outer or inner object.
+        def _has_attribute?(attribute)
+          super || @inner._has_attribute?(attribute)
+        end
+
+        # Reload both the outer and inner objects to ensure consistency.
+        define_method :reload do
+          super()
+          @inner.reload
+          # Update attributes from the reloaded inner object.
+          base_type.columns.each_with_object({}) do |c, attrs|
+            self["#{association.name}_#{c.name}"] = @inner[c.name.to_s]
+          end
+          self
+        end
+      end
+    end
+  end
+end
+
+# Hook into ActiveSupport's on_load mechanism to automatically include this functionality into ActiveRecord.
+ActiveSupport.on_load(:active_record) do
+  include ActiveRecordPolytypes
+end

metadata

@@ -0,0 +1,186 @@
+--- !ruby/object:Gem::Specification
+name: activerecord-polytypes
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Wouter Coppieters
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-03-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7'
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7'
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '7'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.16'
+- !ruby/object:Gem::Dependency
+  name: minitest-around
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.4.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.4.1
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+- !ruby/object:Gem::Dependency
+  name: mysql2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+description: This gem provides an extension to ActiveRecord, enabling efficient Multi-Table,
+  Multiple-Inheritance for ActiveRecord models.
+email:
+- wc@pico.net.nz
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rubocop.yml"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- activerecord-polytypes.gemspec
+- lib/activerecord-polytypes.rb
+- lib/activerecord-polytypes/version.rb
+homepage: https://github.com/wouterken/activerecord-polytypes
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/wouterken/activerecord-polytypes
+  source_code_uri: https://github.com/wouterken/activerecord-polytypes
+  changelog_uri: https://github.com/wouterken/activerecord-polytypes
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.6
+signing_key:
+specification_version: 4
+summary: Enable ActiveRecord models to act like Polymorphic supertypes.
+test_files: []