accepts_nested_attributes_for_public_id 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0c66a87c5663498998b2263ec28d9f1f1bafde4101e93190b1d3e336c2c12605
+  data.tar.gz: bed9e7a6048e6d2f9761acc39156f2bc359e2ba5bac144505061d592792faaa5
+SHA512:
+  metadata.gz: 45592a78a5438ef544dd687dbf52624efaf8e194d31a083736ace28dba20eb254670bb584e71d72bc2c141a078cbf7127d5909c8feb19f88d03feb85147b5868
+  data.tar.gz: a14e83ac5d39575dde70a0c0ec4ab5b0833ca681efc8b64a198d2417528cd03903c7f2818996f75cc56d1531c5011d00e26705600d63ecca1f092956a0512612

data/CHANGELOG.md

@@ -0,0 +1,8 @@
+# CHANGELOG
+
+- **Unreleased**
+  * [View Diff](https://github.com/westonganger/accepts_nested_attributes_for_public_id/compare/v1.0.0...master)
+  * Nothing yet
+
+- **v1.0.0**
+  * Initial gem release

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023 Weston Ganger
+
+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,83 @@
+# AcceptsNestedAttributesForPublicId
+
+<a href="https://badge.fury.io/rb/accepts_nested_attributes_for_public_id" target="_blank"><img height="21" style='border:0px;height:21px;' border='0' src="https://badge.fury.io/rb/accepts_nested_attributes_for_public_id.svg" alt="Gem Version"></a>
+<a href='https://github.com/westonganger/accepts_nested_attributes_for_public_id/actions' target='_blank'><img src="https://github.com/westonganger/accepts_nested_attributes_for_public_id/workflows/Tests/badge.svg" style="max-width:100%;" height='21' style='border:0px;height:21px;' border='0' alt="CI Status"></a>
+<a href='https://rubygems.org/gems/accepts_nested_attributes_for_public_id' target='_blank'><img height='21' style='border:0px;height:21px;' src='https://img.shields.io/gem/dt/accepts_nested_attributes_for_public_id?color=brightgreen&label=Rubygems%20Downloads' border='0' alt='RubyGems Downloads' /></a>
+
+A patch for Rails to support using a public ID column instead of ID for use with `accepts_nested_attributes_for`
+
+Supports Rails 5, 6, 7+
+
+Why:
+
+- By default ActiveRecord and `accepts_nested_attributes_for` does not respect `to_param` or provide any ability to utilize a public ID column. This results in your DB primary keys being exposed in your forms.
+- This was [extracted from a PR to Rails core](https://github.com/rails/rails/pull/48390) until this functionality is otherwise achievable in Rails core proper.
+
+# Installation
+
+```ruby
+gem 'accepts_nested_attributes_for_public_id'
+```
+
+# Usage
+
+You now have access to the following options:
+
+### Option A: Define a accepts_nested_attributes_for_public_id_column method on your class
+
+```ruby
+class Post < ApplicationRecord
+  has_many :comments
+  accepts_nested_attributes_for :comments
+end
+
+class Comment < ApplicationRecord
+  belongs_to :post
+
+  def self.accepts_nested_attributes_for_public_id_column
+    :my_public_id_db_column
+  end
+end
+```
+
+### Option B: Use the :public_id_column option on accepts_nested_attributes_for
+
+```ruby
+class Post < ApplicationRecord
+  has_many :comments
+  accepts_nested_attributes_for :comments, public_id_column: :my_public_id_db_column
+end
+
+class Comment < ApplicationRecord
+  belongs_to :post
+end
+```
+
+# How is this safe
+
+The code for Nested Attributes in Rails core has not changed since around Rails 4 (Rails 7.0 is the current release at the time of writing this)
+
+Because this patch requires changes in the very middle of some larger sized methods we are unable to use `super` in the patches. This can make it fragile if new changes were introduced to Rails core.
+
+We have taken steps to ensure that no issues are caused by any future Rails changes by adding [runtime contracts](./lib/accepts_nested_attributes_for_public_id/method_contracts.rb) that ensure the original method source matches our saved contract of the current sources of these methods. If a new Rails version were to change the original method source then you would receive a runtime error stating that we are unable to apply the patch until the gem has been made compatible with any changed code.
+
+# Testing
+
+```
+RAILS_ENV=test bundle exec rake db:create
+RAILS_ENV=test bundle exec rake db:migrate
+bundle exec rspec
+```
+
+We can locally test different versions of Rails using `ENV['RAILS_VERSION']` and different database gems using `ENV['DB_GEM']`
+
+```
+export RAILS_VERSION=7.0
+export DB_GEM=sqlite3
+bundle install
+bundle exec rspec
+```
+
+# Credits
+
+Created & Maintained by [Weston Ganger](https://westonganger.com) - [@westonganger](https://github.com/westonganger)

data/Rakefile

@@ -0,0 +1,13 @@
+require File.expand_path(File.dirname(__FILE__) + '/lib/accepts_nested_attributes_for_public_id/version.rb')
+require "bundler/gem_tasks"
+
+### Allow to use dummy app rake/rails commands from gem base folder
+APP_RAKEFILE = File.expand_path("spec/dummy_app/Rakefile", __dir__)
+load 'rails/tasks/engine.rake'
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+
+task test: [:spec]
+
+task default: [:spec]

data/lib/accepts_nested_attributes_for_public_id/method_contracts.rb

@@ -0,0 +1,205 @@
+module AcceptsNestedAttributesForPublicId
+  def verify_method_contract!(method, contract)
+    if method.source.strip.gsub(/^\s*/, "") != contract.strip.gsub(/^\s*/, "")
+      raise RuntimeError.new("Method definition contract violated for '#{self.class.name}##{method.name}', cannot apply patch for accepts_nested_attribute_for_public_id")
+    end
+  end
+  module_function :verify_method_contract!
+end
+
+ActiveSupport.on_load(:action_view) do
+  AcceptsNestedAttributesForPublicId.verify_method_contract!(
+    ActionView::Helpers::FormBuilder.instance_method(:fields_for_with_nested_attributes),
+    <<-'CODE'
+      def fields_for_with_nested_attributes(association_name, association, options, block)
+        name = "#{object_name}[#{association_name}_attributes]"
+        association = convert_to_model(association)
+
+        if association.respond_to?(:persisted?)
+          association = [association] if @object.public_send(association_name).respond_to?(:to_ary)
+        elsif !association.respond_to?(:to_ary)
+          association = @object.public_send(association_name)
+        end
+
+        if association.respond_to?(:to_ary)
+          explicit_child_index = options[:child_index]
+          output = ActiveSupport::SafeBuffer.new
+          association.each do |child|
+            if explicit_child_index
+              options[:child_index] = explicit_child_index.call if explicit_child_index.respond_to?(:call)
+            else
+              options[:child_index] = nested_child_index(name)
+            end
+            if content = fields_for_nested_model("#{name}[#{options[:child_index]}]", child, options, block)
+              output << content
+            end
+          end
+          output
+        elsif association
+          fields_for_nested_model(name, association, options, block)
+        end
+      end
+    CODE
+  )
+
+  AcceptsNestedAttributesForPublicId.verify_method_contract!(
+    ActionView::Helpers::FormBuilder.instance_method(:fields_for_nested_model),
+    <<-'CODE'
+      def fields_for_nested_model(name, object, fields_options, block)
+        object = convert_to_model(object)
+        emit_hidden_id = object.persisted? && fields_options.fetch(:include_id) {
+          options.fetch(:include_id, true)
+        }
+
+        @template.fields_for(name, object, fields_options) do |f|
+          output = @template.capture(f, &block)
+          output.concat f.hidden_field(:id) if output && emit_hidden_id && !f.emitted_hidden_id?
+          output
+        end
+      end
+    CODE
+  )
+end
+
+ActiveSupport.on_load(:active_record) do
+  AcceptsNestedAttributesForPublicId.verify_method_contract!(
+    ActiveRecord::NestedAttributes::ClassMethods.instance_method(:accepts_nested_attributes_for),
+    <<-'CODE'
+      def accepts_nested_attributes_for(*attr_names)
+        options = { allow_destroy: false, update_only: false }
+        options.update(attr_names.extract_options!)
+        options.assert_valid_keys(:allow_destroy, :reject_if, :limit, :update_only)
+        options[:reject_if] = REJECT_ALL_BLANK_PROC if options[:reject_if] == :all_blank
+
+        attr_names.each do |association_name|
+          if reflection = _reflect_on_association(association_name)
+            reflection.autosave = true
+            define_autosave_validation_callbacks(reflection)
+
+            nested_attributes_options = self.nested_attributes_options.dup
+            nested_attributes_options[association_name.to_sym] = options
+            self.nested_attributes_options = nested_attributes_options
+
+            type = (reflection.collection? ? :collection : :one_to_one)
+            generate_association_writer(association_name, type)
+          else
+            raise ArgumentError, "No association found for name `#{association_name}'. Has it been defined yet?"
+          end
+        end
+      end
+    CODE
+  )
+
+  AcceptsNestedAttributesForPublicId.verify_method_contract!(
+    ActiveRecord::NestedAttributes.instance_method(:assign_nested_attributes_for_one_to_one_association),
+    <<-'CODE'
+      def assign_nested_attributes_for_one_to_one_association(association_name, attributes)
+        options = nested_attributes_options[association_name]
+        if attributes.respond_to?(:permitted?)
+          attributes = attributes.to_h
+        end
+        attributes = attributes.with_indifferent_access
+        existing_record = send(association_name)
+
+        if (options[:update_only] || !attributes["id"].blank?) && existing_record &&
+          (options[:update_only] || existing_record.id.to_s == attributes["id"].to_s)
+          assign_to_or_mark_for_destruction(existing_record, attributes, options[:allow_destroy]) unless call_reject_if(association_name, attributes)
+
+        elsif attributes["id"].present?
+          raise_nested_attributes_record_not_found!(association_name, attributes["id"])
+
+        elsif !reject_new_record?(association_name, attributes)
+          assignable_attributes = attributes.except(*UNASSIGNABLE_KEYS)
+
+          if existing_record && existing_record.new_record?
+            existing_record.assign_attributes(assignable_attributes)
+            association(association_name).initialize_attributes(existing_record)
+          else
+            method = :"build_#{association_name}"
+            if respond_to?(method)
+              send(method, assignable_attributes)
+            else
+              raise ArgumentError, "Cannot build association `#{association_name}'. Are you trying to build a polymorphic one-to-one association?"
+            end
+          end
+        end
+      end
+    CODE
+  )
+
+  AcceptsNestedAttributesForPublicId.verify_method_contract!(
+    ActiveRecord::NestedAttributes.instance_method(:assign_nested_attributes_for_collection_association),
+    <<-'CODE'
+      def assign_nested_attributes_for_collection_association(association_name, attributes_collection)
+        options = nested_attributes_options[association_name]
+        if attributes_collection.respond_to?(:permitted?)
+          attributes_collection = attributes_collection.to_h
+        end
+
+        unless attributes_collection.is_a?(Hash) || attributes_collection.is_a?(Array)
+          raise ArgumentError, "Hash or Array expected for attribute `#{association_name}`, got #{attributes_collection.class.name} (#{attributes_collection.inspect})"
+        end
+
+        check_record_limit!(options[:limit], attributes_collection)
+
+        if attributes_collection.is_a? Hash
+          keys = attributes_collection.keys
+          attributes_collection = if keys.include?("id") || keys.include?(:id)
+            [attributes_collection]
+          else
+            attributes_collection.values
+          end
+        end
+
+        association = association(association_name)
+
+        existing_records = if association.loaded?
+          association.target
+        else
+          attribute_ids = attributes_collection.filter_map { |a| a["id"] || a[:id] }
+          attribute_ids.empty? ? [] : association.scope.where(association.klass.primary_key => attribute_ids)
+        end
+
+        attributes_collection.each do |attributes|
+          if attributes.respond_to?(:permitted?)
+            attributes = attributes.to_h
+          end
+          attributes = attributes.with_indifferent_access
+
+          if attributes["id"].blank?
+            unless reject_new_record?(association_name, attributes)
+              association.reader.build(attributes.except(*UNASSIGNABLE_KEYS))
+            end
+          elsif existing_record = existing_records.detect { |record| record.id.to_s == attributes["id"].to_s }
+            unless call_reject_if(association_name, attributes)
+              # Make sure we are operating on the actual object which is in the association's
+              # proxy_target array (either by finding it, or adding it if not found)
+              # Take into account that the proxy_target may have changed due to callbacks
+              target_record = association.target.detect { |record| record.id.to_s == attributes["id"].to_s }
+              if target_record
+                existing_record = target_record
+              else
+                association.add_to_target(existing_record, skip_callbacks: true)
+              end
+
+              assign_to_or_mark_for_destruction(existing_record, attributes, options[:allow_destroy])
+            end
+          else
+            raise_nested_attributes_record_not_found!(association_name, attributes["id"])
+          end
+        end
+      end
+    CODE
+  )
+
+  AcceptsNestedAttributesForPublicId.verify_method_contract!(
+    ActiveRecord::NestedAttributes.instance_method(:raise_nested_attributes_record_not_found!),
+    <<-'CODE'
+      def raise_nested_attributes_record_not_found!(association_name, record_id)
+        model = self.class._reflect_on_association(association_name).klass.name
+        raise RecordNotFound.new("Couldn't find #{model} with ID=#{record_id} for #{self.class.name} with ID=#{id}",
+                                 model, "id", record_id)
+      end
+    CODE
+  )
+end

data/lib/accepts_nested_attributes_for_public_id/method_patches.rb

@@ -0,0 +1,261 @@
+ActiveSupport.on_load(:action_view) do
+  module ActionView
+    module Helpers
+      class FormBuilder
+        private
+
+        def fields_for_with_nested_attributes(association_name, association, options, block)
+          name = "#{object_name}[#{association_name}_attributes]"
+          association = convert_to_model(association)
+
+          if association.respond_to?(:persisted?)
+            association = [association] if @object.public_send(association_name).respond_to?(:to_ary)
+          elsif !association.respond_to?(:to_ary)
+            association = @object.public_send(association_name)
+          end
+
+          ### NEW
+          if @object.respond_to?(:nested_attributes_options)
+            options[:public_id_column] = @object.nested_attributes_options.dig(association_name.to_sym, :public_id_column)
+          end
+          ### END NEW
+
+          if association.respond_to?(:to_ary)
+            explicit_child_index = options[:child_index]
+            output = ActiveSupport::SafeBuffer.new
+            association.each do |child|
+              if explicit_child_index
+                options[:child_index] = explicit_child_index.call if explicit_child_index.respond_to?(:call)
+              else
+                options[:child_index] = nested_child_index(name)
+              end
+              if content = fields_for_nested_model("#{name}[#{options[:child_index]}]", child, options, block)
+                output << content
+              end
+            end
+            output
+          elsif association
+            fields_for_nested_model(name, association, options, block)
+          end
+        end
+
+        def fields_for_nested_model(name, object, fields_options, block)
+          object = convert_to_model(object)
+          emit_hidden_id = object.persisted? && fields_options.fetch(:include_id) {
+            options.fetch(:include_id, true)
+          }
+
+          @template.fields_for(name, object, fields_options) do |f|
+            output = @template.capture(f, &block)
+
+            ### ORIGINAL
+            # output.concat f.hidden_field(:id) if output && emit_hidden_id && !f.emitted_hidden_id?
+            ### NEW
+            if f.object.class.respond_to?(:accepts_nested_attributes_for_public_id_column)
+              public_id_column = f.object.class.accepts_nested_attributes_for_public_id_column
+              public_id_value = f.object.send(public_id_column)
+            elsif fields_options[:public_id_column]
+              public_id_value = f.object.send(fields_options[:public_id_column])
+              fields_options.delete(:public_id_column)
+            else
+              public_id_value = f.object.id
+            end
+            output.concat f.hidden_field(:id, value: public_id_value) if output && emit_hidden_id && !f.emitted_hidden_id?
+            ### END NEW
+
+            output
+          end
+        end
+      end
+    end
+  end
+end
+
+ActiveSupport.on_load(:active_record) do
+  module ActiveRecord
+    module NestedAttributes
+      module ClassMethods
+        def accepts_nested_attributes_for(*attr_names)
+          options = { allow_destroy: false, update_only: false }
+          options.update(attr_names.extract_options!)
+          ### ORIGINAL
+          # options.assert_valid_keys(:allow_destroy, :reject_if, :limit, :update_only)
+          ### NEW
+          options.assert_valid_keys(:allow_destroy, :reject_if, :limit, :update_only, :public_id_column)
+          ### END NEW
+          options[:reject_if] = REJECT_ALL_BLANK_PROC if options[:reject_if] == :all_blank
+
+          attr_names.each do |association_name|
+            if reflection = _reflect_on_association(association_name)
+              reflection.autosave = true
+              define_autosave_validation_callbacks(reflection)
+
+              nested_attributes_options = self.nested_attributes_options.dup
+              nested_attributes_options[association_name.to_sym] = options
+              self.nested_attributes_options = nested_attributes_options
+
+              type = (reflection.collection? ? :collection : :one_to_one)
+              generate_association_writer(association_name, type)
+            else
+              raise ArgumentError, "No association found for name `#{association_name}'. Has it been defined yet?"
+            end
+          end
+        end
+      end
+    end
+
+    module NestedAttributes
+      private
+
+      def assign_nested_attributes_for_one_to_one_association(association_name, attributes)
+        options = nested_attributes_options[association_name]
+        if attributes.respond_to?(:permitted?)
+          attributes = attributes.to_h
+        end
+        attributes = attributes.with_indifferent_access
+        existing_record = send(association_name)
+
+        ### ORIGINAL
+        # if (options[:update_only] || !attributes["id"].blank?) && existing_record &&
+        #   (options[:update_only] || existing_record.id.to_s == attributes["id"].to_s)
+        ### NEW
+        if self.class.reflect_on_association(association_name).klass.respond_to?(:accepts_nested_attributes_for_public_id_column)
+          public_id_column = self.class.reflect_on_association(association_name).klass.accepts_nested_attributes_for_public_id_column
+        elsif options[:public_id_column]
+          public_id_column = options[:public_id_column]
+        else
+          public_id_column = :id
+        end
+
+        if (options[:update_only] || !attributes["id"].blank?) && existing_record &&
+          (options[:update_only] || existing_record.send(public_id_column).to_s == attributes["id"].to_s)
+        ### END NEW
+          assign_to_or_mark_for_destruction(existing_record, attributes, options[:allow_destroy]) unless call_reject_if(association_name, attributes)
+
+        elsif attributes["id"].present?
+          raise_nested_attributes_record_not_found!(association_name, attributes["id"])
+
+        elsif !reject_new_record?(association_name, attributes)
+          assignable_attributes = attributes.except(*UNASSIGNABLE_KEYS)
+
+          if existing_record && existing_record.new_record?
+            existing_record.assign_attributes(assignable_attributes)
+            association(association_name).initialize_attributes(existing_record)
+          else
+            method = :"build_#{association_name}"
+            if respond_to?(method)
+              send(method, assignable_attributes)
+            else
+              raise ArgumentError, "Cannot build association `#{association_name}'. Are you trying to build a polymorphic one-to-one association?"
+            end
+          end
+        end
+      end
+
+      def assign_nested_attributes_for_collection_association(association_name, attributes_collection)
+        options = nested_attributes_options[association_name]
+        if attributes_collection.respond_to?(:permitted?)
+          attributes_collection = attributes_collection.to_h
+        end
+
+        unless attributes_collection.is_a?(Hash) || attributes_collection.is_a?(Array)
+          raise ArgumentError, "Hash or Array expected for attribute `#{association_name}`, got #{attributes_collection.class.name} (#{attributes_collection.inspect})"
+        end
+
+        check_record_limit!(options[:limit], attributes_collection)
+
+        if attributes_collection.is_a? Hash
+          keys = attributes_collection.keys
+          attributes_collection = if keys.include?("id") || keys.include?(:id)
+            [attributes_collection]
+          else
+            attributes_collection.values
+          end
+        end
+
+        association = association(association_name)
+
+        ### NEW
+        if association.klass.respond_to?(:accepts_nested_attributes_for_public_id_column)
+          public_id_column = association.klass.accepts_nested_attributes_for_public_id_column
+        elsif nested_attributes_options[association.reflection.name][:public_id_column]
+          public_id_column = nested_attributes_options[association.reflection.name][:public_id_column]
+        else
+          public_id_column = :id
+        end
+        ### END NEW
+
+        existing_records = if association.loaded?
+          association.target
+        else
+          attribute_ids = attributes_collection.filter_map { |a| a["id"] || a[:id] }
+          ### ORIGINAL
+          # attribute_ids.empty? ? [] : association.scope.where(association.klass.primary_key => attribute_ids)
+          ### NEW
+          attribute_ids.empty? ? [] : association.scope.where(public_id_column => attribute_ids)
+          ### END NEW
+        end
+
+        attributes_collection.each do |attributes|
+          if attributes.respond_to?(:permitted?)
+            attributes = attributes.to_h
+          end
+          attributes = attributes.with_indifferent_access
+
+          if attributes["id"].blank?
+            unless reject_new_record?(association_name, attributes)
+              association.reader.build(attributes.except(*UNASSIGNABLE_KEYS))
+            end
+          ### ORIGINAL
+          # elsif existing_record = existing_records.detect { |record| record.id.to_s == attributes["id"].to_s }
+          ### NEW
+          elsif existing_record = existing_records.detect { |record| record.send(public_id_column).to_s == attributes["id"].to_s }
+          ### END NEW
+            unless call_reject_if(association_name, attributes)
+              # Make sure we are operating on the actual object which is in the association's
+              # proxy_target array (either by finding it, or adding it if not found)
+              # Take into account that the proxy_target may have changed due to callbacks
+              ### ORIGINAL
+              # target_record = association.target.detect { |record| record.id.to_s == attributes["id"].to_s }
+              ### NEW
+              target_record = association.target.detect { |record| record.send(public_id_column).to_s == attributes["id"].to_s }
+              ### END NEW
+
+              if target_record
+                existing_record = target_record
+              else
+                association.add_to_target(existing_record, skip_callbacks: true)
+              end
+
+              assign_to_or_mark_for_destruction(existing_record, attributes, options[:allow_destroy])
+            end
+          else
+            raise_nested_attributes_record_not_found!(association_name, attributes["id"])
+          end
+        end
+      end
+
+      def raise_nested_attributes_record_not_found!(association_name, record_id)
+        model = self.class._reflect_on_association(association_name).klass.name
+        ### ORIGINAL
+        # raise RecordNotFound.new("Couldn't find #{model} with ID=#{record_id} for #{self.class.name} with ID=#{id}",
+        #                          model, "id", record_id)
+        ### NEW
+        if self.class._reflect_on_association(association_name).klass.respond_to?(:accepts_nested_attributes_for_public_id_column)
+          id_column = self.class._reflect_on_association(association_name).klass.accepts_nested_attributes_for_public_id_column
+        elsif nested_attributes_options[association_name][:public_id_column]
+          id_column = nested_attributes_options[association_name][:public_id_column].to_s
+        else
+          id_column = "id"
+        end
+        raise RecordNotFound.new(
+          "Couldn't find #{model} with ID=#{record_id} for #{self.class.name} with ID=#{id}",
+          model,
+          id_column,
+          record_id,
+        )
+        ### END NEW
+      end
+    end
+  end
+end

data/lib/accepts_nested_attributes_for_public_id/version.rb

@@ -0,0 +1,3 @@
+module AcceptsNestedAttributesForPublicId
+  VERSION = "1.0.0".freeze
+end

data/lib/accepts_nested_attributes_for_public_id.rb

@@ -0,0 +1,4 @@
+require 'active_support/lazy_load_hooks'
+require "accepts_nested_attributes_for_public_id/version"
+require "accepts_nested_attributes_for_public_id/method_contracts"
+require "accepts_nested_attributes_for_public_id/method_patches"

metadata

@@ -0,0 +1,181 @@
+--- !ruby/object:Gem::Specification
+name: accepts_nested_attributes_for_public_id
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Weston Ganger
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-08-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+- !ruby/object:Gem::Dependency
+  name: actionview
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  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-rails
+  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: database_cleaner
+  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: rails-controller-testing
+  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: rails
+  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: warning
+  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: pry-rails
+  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: A patch for Rails to support using a public ID column instead of ID for
+  use with accepts_nested_attributes_for
+email:
+- weston@westonganger.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- Rakefile
+- lib/accepts_nested_attributes_for_public_id.rb
+- lib/accepts_nested_attributes_for_public_id/method_contracts.rb
+- lib/accepts_nested_attributes_for_public_id/method_patches.rb
+- lib/accepts_nested_attributes_for_public_id/version.rb
+homepage: https://github.com/westonganger/accepts_nested_attributes_for_public_id
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/westonganger/accepts_nested_attributes_for_public_id
+  changelog_uri: https://github.com/westonganger/accepts_nested_attributes_for_public_id/blob/master/CHANGELOG.md
+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.4.6
+signing_key:
+specification_version: 4
+summary: A patch for Rails to support using a public ID column instead of ID for use
+  with accepts_nested_attributes_for
+test_files: []