belongs_to_one_of 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 98bf15abb668273f22d84ff9bf834806e66994533eb2393ae07929f2dd675789
+  data.tar.gz: d53da88da80da202fb3cc65f041f8dbeffb2a388017dc667694452ef8182d6b8
+SHA512:
+  metadata.gz: 8b06bcea6fa1f26f0791829451d3eedf8f82737e7710502a0222ca3bb94a97ed6402aef8fd935165bb664a45602a5c1e4a7bc529ff650bbf9d48e7e548010276
+  data.tar.gz: b1b2a1fbf7b60889cad46f9a97b61cbfb0dde782f1a11ff90b1efd189e225d2bfe94a01fbb186e99d2ce7ea31d9d2236b1b438bca23c55ff5875326ed5e35151

data/.circleci/config.yml

@@ -0,0 +1,53 @@
+version: 2.1
+
+jobs:
+  test:
+    parameters:
+      ruby-version:
+        type: string
+      rails-version:
+        type: string
+
+    docker:
+      - image: ruby:<<parameters.ruby-version>>
+        environment:
+          - RAILS_VERSION=<<parameters.rails-version>>
+    steps:
+      - checkout
+
+      - run: gem install bundler
+      - run: bundle install
+
+      - run: |
+          bundle exec rspec --profile 10 \
+                            --format RspecJunitFormatter \
+                            --out /tmp/test-results/rspec.xml \
+                            --format progress \
+                            spec
+      - store_test_results:
+          path: /tmp/test-results
+
+  rubocop:
+    docker:
+      - image: ruby:2.7
+    steps:
+      - checkout
+      - run: gem install bundler -v 2.1.4
+      - run: bundle install
+      - run:
+          name: Rubocop
+          command: bundle exec rubocop --parallel --extra-details --display-style-guide
+
+workflows:
+  version: 2
+  tests:
+    jobs:
+      - test:
+          matrix:
+            parameters:
+              ruby-version: ["2.6", "2.7", "3.0"]
+              rails-version: ["5.2", "6.0", "6.1"]
+            exclude:
+              - ruby-version: "3.0"
+                rails-version: "5.2"
+      - rubocop

data/.dependabot/config.yml

@@ -0,0 +1,6 @@
+---
+version: 1
+update_configs:
+  - package_manager: "ruby:bundler"
+    directory: "/"
+    update_schedule: "weekly"

data/.gitignore

@@ -0,0 +1 @@
+Gemfile.lock

data/.rubocop.yml

@@ -0,0 +1,10 @@
+inherit_from: .rubocop_todo.yml
+
+inherit_gem:
+  gc_ruboconfig: rubocop.yml
+
+AllCops:
+  TargetRubyVersion: 2.6
+
+Style/CaseLikeIf:
+  Enabled: false

data/.rubocop_todo.yml

@@ -0,0 +1,16 @@
+# This configuration was generated by
+# `rubocop --auto-gen-config`
+# on 2020-04-17 14:28:59 +0100 using RuboCop version 0.80.1.
+# The point is for the user to remove these configuration records
+# one by one as the offenses are removed from the code base.
+# Note that changes in the inspected code, or installation of new
+# versions of RuboCop, may require this file to be generated again.
+
+# Offense count: 2
+Metrics/AbcSize:
+  Max: 22
+
+# Offense count: 3
+# Configuration parameters: CountComments, ExcludedMethods.
+Metrics/MethodLength:
+  Max: 37

data/.ruby-version

@@ -0,0 +1 @@
+2.7.1

data/Gemfile

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gemspec
+
+gem "activerecord", "~> #{ENV['RAILS_VERSION']}" if ENV["RAILS_VERSION"]

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2021 GoCardless
+
+MIT License
+
+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,178 @@
+# belongs_to_one_of
+Gem to support activemodel relations where one model can be a child of one of many models.
+In our examples, we will be targeting a class `Competitor` which can either belong to a `School` or a `College`.
+We will consider this more general concept an `organisation`.
+
+The gem provides a simple method to declare this relationship, some validators to enforce the relationships,
+and some helper functions to safely set and get the associated model.
+
+## What about rails polymorphic relations?
+
+Unlike rails polymorphic relations, this supports having a separate `id` column for each parent 
+model type (e.g. `school_id` and `college_id` instead of just `organisation_id`). This is desirable
+(in some cases) to enable the database to use foreign keys.
+
+The gem will also error if you try to set a resource which isn't one of the specified classes, unlike
+a rails polymorphic relation which will accept any model class.
+
+
+## Installation
+
+Install the package from Rubygems:
+```shell script
+gem install belongs_to_one_of
+```
+
+Or add it to your gemfile
+```
+gem 'belongs_to_one_of'
+```
+
+For our policy on compatibility with Ruby versions, see [COMPATIBILITY.md](docs/COMPATIBILITY.md).
+
+## Quick Start
+
+Our code will say:
+
+> This model belongs to an organisation, which might be a School or might be a College
+
+This allows us to store the association in the columns `school_id` and `college_id`, which can use foreign keys,
+but for the 99% of your code which doesn't care which is which, they can just call a method `organisation` or 
+`organisation_id` to access the resource.
+
+The library adds a new association to `ActiveRecord` called `belongs_to_one_of :organisation, `. To use it, simply call this
+hook in your `ActiveRecord` class:
+
+```ruby
+class Competitor < ActiveRecord::Base
+  belongs_to_one_of :organisation, %i[school college]
+end
+
+class School < ActiveRecord::Base
+  has_many :competitors
+end 
+
+class College < ActiveRecord::Base
+  has_many :competitors
+end 
+
+school = School.new
+
+my_competitor = Competitor.create(name: 'jack', organisation: school)
+
+my_competitor.organisation
+# => school
+
+my_competitor.organisation_id == school.id
+# => true 
+```
+
+Note that this helper calls `belongs_to :school, optional:true` and `belongs_to :college, optional:true`, so you don't have to.
+
+## Available methods
+
+The hook defines a few methods on your class. The names are dynamic, we will use 'organisation' as our example
+(as per above):
+
+### Validators
+
+#### `belongs_to_exactly_one_[organisation]`
+A validator that can be used to check that a model belongs to exactly one organisation
+
+#### `belongs_to_at_most_one_[organisation]`
+A validator that can be used to check that a model belongs to either no organisations or one organisation
+
+#### `[organisation_type]_matches_[organisation]`
+A validator that can be used to check that the type of model matches the model. Only relevant when 
+`include_type_column` is true
+
+### Getters & Setters
+
+#### `[organisation]=`
+Allows you to create a new instance of the model with the interface:
+
+```ruby
+Competitor.new(
+  organisation: my_school,
+  name: "Joe Bloggs"
+)
+```
+
+This will raise a `ModelNotFound` exception if the organisation is not one of the permitted model types
+
+#### `[organisation]`
+Allows you to get the linked resource via `.organisation` e.g.:
+```ruby
+my_competitor.organisation
+```
+#### `[organisation]_id`
+Allows you to get the linked resource's id via `.organisation_id` e.g.:
+```ruby
+my_competitor.organisation_id
+``` 
+
+#### `[organisation]_type`
+This is only set when the associations are configured with `include_type_column` (see below). This allows you to access the resource type via
+`.organisation_type` e.g.:
+```ruby
+my_competitor.organisation_type
+# => 'School'
+``` 
+
+## Configuration Options
+
+### `include_type_column`
+
+By default, the library assumes that the underlying table looks like:
+
+`id` | `name` | `school_id` | `college_id`
+----|----|---|---
+1 | Aaron J Aaronson | | COL123
+2 | Betty F Parker | SCH456 | 
+
+however you can set `include_type_column: true` to explicitly store what type of model is connected, e.g.:
+
+```ruby
+  belongs_to_one_of :organisation, %i[school college], include_type_column: true
+```
+
+`id` | `name` | `organisation_type` | `school_id` | `college_id`
+----|----|---|---|---
+1 | Aaron J Aaronson | College | | COL123
+2 | Betty F Parker | School | SCH456 | 
+
+if the column is not called `[organisation]_type`, you can specify the column name e.g.
+
+```ruby
+  belongs_to_one_of :organisation, %i[school college], include_type_column: :type_of_organisation
+```
+
+`id` | `name` | `type_of_organisation` | `school_id` | `college_id`
+----|----|---|---|---
+1 | Aaron J Aaronson | College | | COL123
+2 | Betty F Parker | School | SCH456 | 
+
+
+### `type_column_value`
+
+If you have `include_type_column: true` set, by default we assume you want to store the classname in the db.
+However, there may be some logic that you want to apply. If you pass a Proc to `type_column_value` 
+you can add your own logic to determine what goes into the db.
+
+```ruby
+  belongs_to_one_of :organisation,  %i[school college], include_type_column: true,
+                                                       type_column_value: ->(resource) { resource.class.downcase }
+```
+
+`id` | `name` | `organisation_type` | `school_id` | `college_id`
+----|----|---|---|---
+1 | Aaron J Aaronson | college | | COL123
+2 | Betty F Parker | school | SCH456 | 
+
+
+## License & Contributing
+
+* BelongsToOneOf is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+* Bug reports and pull requests are welcome on GitHub at https://github.com/gocardless/belongs-to-one-of.
+
+GoCardless ♥ open source. If you do too, come [join us](https://gocardless.com/about/careers/).

data/belongs_to_one_of.gemspec

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require "belongs_to_one_of/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "belongs_to_one_of"
+  spec.version       = BelongsToOneOf::VERSION
+  spec.authors       = ["GoCardless Engineering"]
+  spec.email         = ["engineering@gocardless.com"]
+
+  spec.summary       = "A small library that helps with models which can have " \
+                       "multiple parent model types"
+  spec.homepage      = "https://github.com/gocardless/belongs-to-one-of"
+  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.
+  spec.files         = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.require_paths = ["lib"]
+
+  spec.required_ruby_version = ">= 2.6"
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "gc_ruboconfig", "~> 2.25.0"
+  spec.add_development_dependency "pry-byebug"
+  spec.add_development_dependency "rspec", "~> 3.9"
+  spec.add_development_dependency "rspec_junit_formatter", "~> 0.4"
+
+  # For integration testing
+  spec.add_development_dependency "sqlite3", "~> 1.4.1"
+
+  spec.add_dependency "activerecord", ">= 5.2", "< 6.2"
+  spec.add_dependency "activesupport", ">= 5.2", "< 6.2"
+end

data/docs/COMPATABILITY.md

@@ -0,0 +1,26 @@
+# Compatibility
+
+Our goal as maintainers is for the library to be compatible with all supported
+versions of Ruby.
+
+Specifically, any CRuby/MRI version that has not received an End of Life notice
+([e.g. this notice for Ruby 2.1](https://www.ruby-lang.org/en/news/2017/04/01/support-of-ruby-2-1-has-ended/))
+is supported.
+
+To that end, [our build matrix](../.circleci/config.yml) includes all these versions.
+
+Any time BelongsToOneOf doesn't work on a supported version of Ruby, it's a bug, and can be
+reported [here](https://github.com/gocardless/belongs-to-one-of/issues).
+
+# Deprecation
+
+Whenever a version of Ruby falls out of support, we will mirror that change in BelongsToOneOf
+by updating the build matrix and releasing a new major version.
+
+At that point, we will close any issues that only affect the unsupported version, and may
+choose to remove any workarounds from the code that are only necessary for the unsupported
+version.
+
+We will then bump the major version of BelongsToOneOf, to indicate the break in compatibility.
+Even if the new version of BelongsToOneOf happens to work on the unsupported version of Ruby, we
+consider compatibility to be broken at this point.

data/lib/belongs_to_one_of.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "active_record"
+require "active_record/associations"
+require_relative "belongs_to_one_of/belongs_to_one_of_model"
+
+# We assume that the connected model is called a 'resource',
+# for the purposes of naming variables in this file
+
+module ActiveRecord
+  module Associations
+    module ClassMethods
+      include BelongsToOneOf
+
+      def belongs_to_one_of(
+        resource_key,
+        raw_possible_resource_types,
+        include_type_column: false
+      )
+        resource_type_field = "#{resource_key}_type"
+        unless [true, false].include?(include_type_column)
+          resource_type_field =
+            include_type_column
+        end
+
+        config_model = BelongsToOneOfModel.new(
+          resource_key,
+          raw_possible_resource_types,
+          include_type_column,
+          resource_type_field,
+          self,
+        )
+
+        # validators
+        define_method "belongs_to_exactly_one_#{resource_key}" do
+          config_model.validate_exactly_one_resource(self)
+        end
+
+        define_method "belongs_to_at_most_one_#{resource_key}" do
+          config_model.validate_at_most_one_resource(self)
+        end
+
+        if include_type_column
+          define_method "#{resource_type_field}_matches_#{resource_key}" do
+            config_model.validate_correct_resource_type(self)
+          end
+        end
+
+        # setters
+        define_method "#{resource_key}=" do |resource|
+          config_model.resource_setter(resource, self)
+        end
+
+        # getters
+        define_method resource_key do
+          config_model.resource_getter(self)
+        end
+
+        define_method "#{resource_key}_id" do
+          config_model.resource_id_getter(self)
+        end
+
+        unless include_type_column
+          define_method "#{resource_key}_type" do
+            config_model.resource_type_getter(self)
+          end
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+    end
+  end
+end

data/lib/belongs_to_one_of/belongs_to_one_of_model.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+module BelongsToOneOf
+  class BelongsToOneOfModel
+    class InvalidParamsException < ArgumentError; end
+
+    def initialize(
+      resource_key,
+      raw_possible_resource_types,
+      include_type_column,
+      resource_type_field,
+      model_class
+    )
+      @resource_key = resource_key
+      @possible_resource_types = normalise_resource_types(raw_possible_resource_types)
+      @include_type_column = include_type_column
+      @resource_type_field = resource_type_field
+      @model_class = model_class
+      validate_config
+      initialize_associations
+    end
+
+    attr_reader :resource_key, :possible_resource_types, :include_type_column,
+                :resource_type_field, :model_class
+
+    # TODO: I18n the error messages (provide translations??)
+    def validate_exactly_one_resource(model)
+      return if number_of_resources(model) == 1
+
+      model.errors.add(:base, "model must belong to exactly one #{resource_key}")
+    end
+
+    def validate_at_most_one_resource(model)
+      return unless number_of_resources(model) > 1
+
+      model.errors.add(:base, "model must belong to at most one #{resource_key}")
+    end
+
+    def validate_correct_resource_type(model)
+      resource = model.send(resource_key)
+      return unless resource
+
+      actual_resource_type = resource_type_getter(model)
+      specified_resource_type = model.send(resource_type_field)
+
+      unless actual_resource_type == specified_resource_type
+        model.errors.add(
+          resource_type_field,
+          "#{resource_type_field} must match the type of #{resource_key}",
+        )
+      end
+    end
+
+    def resource_setter(resource, model)
+      return if resource.nil?
+
+      possible_resource_types.each_key do |resource_type|
+        model.public_send("#{resource_type}=", nil)
+      end
+
+      model.instance_variable_set("@#{resource_key}", resource)
+      resource_type_accessor = find_resource_accessor(resource, model)
+
+      unless resource_type_accessor
+        message = "one of #{possible_resource_types.keys.join(', ')} expected, "\
+              "got #{resource.inspect} which is an instance of "\
+"#{resource.class}(##{resource.class.object_id})"
+        raise ActiveRecord::AssociationTypeMismatch, message
+      end
+
+      resource_setter_method = "#{resource_type_accessor}="
+      model.public_send(resource_setter_method, resource)
+
+      if include_type_column
+        resource_type_setter_method = "#{resource_type_field}="
+        resource_type_to_store = find_resource_type(resource, model)
+        model.public_send(resource_type_setter_method, resource_type_to_store)
+      end
+    end
+
+    def resource_getter(model)
+      possible_resource_types.keys.detect do |resource_type|
+        return model.send(resource_type) if model.send(resource_type)
+      end
+    end
+
+    def resource_id_getter(model)
+      possible_resource_types.values.detect do |id_column|
+        return model.send(id_column) if model.send(id_column)
+      end
+    end
+
+    def resource_type_getter(model)
+      resource = model.send(resource_key)
+      return unless resource
+
+      possible_resource_types.keys.detect do |resource_type_accessor|
+        reflection = model.class.reflect_on_association(resource_type_accessor)
+        return reflection.class_name if resource.is_a?(reflection.klass)
+      end
+    end
+
+    private
+
+    def validate_config
+      unless resource_key.is_a?(Symbol)
+        raise InvalidParamsException,
+              "expected resource_key to be a symbol, received #{resource_key.class}"
+      end
+    end
+
+    def initialize_associations
+      possible_resource_types.each do |resource_type_accessor, resource_id_column|
+        opts = { optional: true }
+
+        # Only set :foreign_key for a complex relation. Simple relations can be safely
+        # "inflected" (i.e. Rails knows these objects are the same...)
+        #   foo = Foo.find(1)
+        #   foo.bar.foo == foo
+        if resource_id_column.to_s.gsub!(/_id$/, "") != resource_type_accessor.to_s
+          opts[:foreign_key] = resource_id_column
+        end
+
+        model_class.belongs_to(resource_type_accessor, **opts)
+      end
+    end
+
+    def normalise_resource_types(raw_possible_resource_types)
+      if raw_possible_resource_types.is_a?(Array)
+        raw_possible_resource_types.each_with_object({}) do |classname, hash|
+          unless classname.is_a?(Symbol)
+            raise InvalidParamsException, "expected a symbol, received #{classname}"
+          end
+
+          hash[classname] = "#{classname.to_s.underscore}_id".to_sym
+        end
+      elsif raw_possible_resource_types.is_a?(Hash)
+        raw_possible_resource_types
+      else
+        raise InvalidParamsException,
+              "possible_resource_types must be an Array or a Hash, " \
+          "received #{raw_possible_resource_types.class}"
+      end
+    end
+
+    def number_of_resources(model)
+      possible_resource_types.keys.count do |resource_type_accessor|
+        model.send(resource_type_accessor)
+      end
+    end
+
+    def find_resource_accessor(resource, model)
+      possible_resource_types.keys.detect do |resource_type_accessor|
+        reflection = model.class.reflect_on_association(resource_type_accessor)
+        return resource_type_accessor if resource.is_a?(reflection.klass)
+      end
+    end
+
+    def find_resource_type(resource, model)
+      possible_resource_types.keys.detect do |resource_type_accessor|
+        reflection = model.class.reflect_on_association(resource_type_accessor)
+        return reflection.class_name if resource.is_a?(reflection.klass)
+      end
+    end
+  end
+end

data/lib/belongs_to_one_of/version.rb

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

metadata

@@ -0,0 +1,182 @@
+--- !ruby/object:Gem::Specification
+name: belongs_to_one_of
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- GoCardless Engineering
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-06-11 00:00:00.000000000 Z
+dependencies:
+- !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'
+- !ruby/object:Gem::Dependency
+  name: gc_ruboconfig
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.25.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.25.0
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  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'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+- !ruby/object:Gem::Dependency
+  name: rspec_junit_formatter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.4.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.4.1
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6.2'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6.2'
+description:
+email:
+- engineering@gocardless.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".circleci/config.yml"
+- ".dependabot/config.yml"
+- ".gitignore"
+- ".rubocop.yml"
+- ".rubocop_todo.yml"
+- ".ruby-version"
+- Gemfile
+- LICENSE.txt
+- README.md
+- belongs_to_one_of.gemspec
+- docs/COMPATABILITY.md
+- lib/belongs_to_one_of.rb
+- lib/belongs_to_one_of/belongs_to_one_of_model.rb
+- lib/belongs_to_one_of/version.rb
+homepage: https://github.com/gocardless/belongs-to-one-of
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.6'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.3
+signing_key:
+specification_version: 4
+summary: A small library that helps with models which can have multiple parent model
+  types
+test_files: []