Preserve enum methods when using becomes! on STI subclasses #55074
Conversation
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Yuhi-Sato
changed the title
zzak
reviewed
May 20, 2025
Yuhi-Sato
force-pushed
the
fix-becomes-enum-sti
branch
3 times, most recently
from
b2de3b6 to
522cf6a
Compare
- Fix rails#55001 The `becomes!` method fails to preserve enum-related behavior when converting between STI (Single Table Inheritance) subclasses that define different `enum` values for the same attribute. In Active Record, `enum` dynamically defines instance methods—such as predicate methods (`#published?`) and mutator methods (`#published!`)— at the time the `enum` macro is invoked. These method definitions are specific to the class where the enum is declared, and the underlying attribute uses a class-specific `EnumType` for validation and serialization. However, when calling `becomes!`, the internal attribute set (`@attributes`) is copied to the new instance **without rebinding the types** to the destination class. As a result: - The enum continues to use the original class’s mapping. - Dynamically defined methods from the destination class exist, but internally operate on the *wrong enum mapping*. - This leads to unexpected behavior such as `nil` values or `ArgumentError` exceptions when calling enum methods. This breaks expectations in STI scenarios, where subclasses often define their own `enum` values on shared columns. ```ruby class Foo < ActiveRecord::Base end class Bar < Foo enum(:state, { draft: 'draft' }) end class Baz < Foo enum(:state, { published: 'published' }) end bar = Bar.create!(state: 'draft') baz = bar.becomes!(Baz) baz.published! # => raises ArgumentError ``` This fails with `ArgumentError`, because the value is not valid under the destination class's enum mapping checked by `EnumType#assert_valid_value`: ```ruby def assert_valid_value(value) return unless @_raise_on_invalid_values unless value.blank? || mapping.has_key?(value) || mapping.has_value?(value) raise ArgumentError, "'#{value}' is not a valid #{name}" end end ``` The problem arises because the enum type mapping from the original class (`Bar`) is preserved in the internal attribute state even after calling `becomes!`, making the new class's enum invalid. When performing `becomes!`, ensure that each attribute is rebound to the new class’s attribute type using `with_type`, so that enum accessors function correctly in the destination class.
Yuhi-Sato
force-pushed
the
fix-becomes-enum-sti
branch
from
522cf6a to
c88d31f
Compare
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
Motivation / Background
Fixes rails#55001
The
becomes!method fails to preserve enum-based behavior when converting between STI (Single Table Inheritance) subclasses that define differentenumvalues for the same attribute.This is particularly problematic because
enumdefines predicate (#published?) and mutator (#published!) methods specific to each class. When switching classes viabecomes!, the internal type mapping (EnumType) from the original class is retained, leading to incorrect validation and method behavior.Detail
This change ensures that when performing
becomes!, each attribute is rebound to the destination class’s attribute type usingwith_type. This guarantees that enum accessors work correctly in the destination class context.A test case using
LiveParrotandDeadParrotsubclasses ofParrot(each declaring their own enum:breed) demonstrates that the fix allows safe conversion between STI subclasses while maintaining proper enum behavior.Before this change:
This failed due to the original enum mapping from
LiveParrotbeing retained.Additional information
EnumType#assert_valid_valuewhen the new enum value is not recognized by the old enum mapping.(
ActiveRecord::Encryption::EncryptedAttributeType), such attributes areexplicitly skipped when rebinding types.
Checklist
Before submitting the PR make sure the following are checked:
[Fix #issue-number]