activerecord-changesets 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2f8304362b500e3a957f2e4ec977fa975b29d924143a2ef07a0e15890226c65a
+  data.tar.gz: 7011898666788a431744395c17db50188aed98bd82ef313909fdd6ac8fe4811c
+SHA512:
+  metadata.gz: 74ebdc8406de80a84d3c166ea2886e7dd19a28856e033fda8f0e959acda8cb822cadcfd7717e117a312fa27f380788206b50ad2032b4c8a06920d34bee92d0d7
+  data.tar.gz: 87fc9ddd42de7c8a2548863bfed928e5d9d8aac9dae053d0cfdd5b64e10548f49589f70f6b0e42cbe38b7baaa5df81294e991d749e0367728e607a1b577d9f05

data/CHANGELOG.md

@@ -0,0 +1,2 @@
+## 1.0.0 [Unreleased]
+- Initial release

data/LICENSE.md

@@ -0,0 +1,22 @@
+Copyright (c) 2025 Simon J.
+
+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,379 @@
+# ActiveRecord Changesets
+
+Make your model updates explicit and predictable.
+
+Instead of scattering validations, strong parameters, and business rules across controllers and models, changesets give you one clear pipeline for handling data before it touches the database.
+
+* 🔍 Make model operations clear and intentional
+* 🔒 Scope attribute filtering and validation per operation
+* ✨ Reduce coupling between controllers and models
+
+## Quick start
+
+Install the gem:
+
+```shell
+bundle add activerecord-changesets
+```
+
+Use it in your model:
+
+```ruby
+class User < ApplicationRecord
+  # Or include it in your ApplicationRecord class
+  include ActiveRecordChangesets
+  
+  changeset :create_user do
+    # Only allow the email and password fields to be changed
+    expect :email, :password
+    
+    # Run validation rules specifically for this changeset
+    validates :email, presence: true, uniqueness: true, format: {with: URI::MailTo::EMAIL_REGEXP}
+    validate :must_have_secure_password
+  end
+end
+
+User.create_user(email: "bob@example.com", password: "password1234")
+```
+
+## Why use changesets?
+
+### Reduce boilerplate and business logic in controllers
+
+Validations are defined in our models, but we still need to use strong parameters in our controllers to filter incoming parameters. This approach leads to extra boilerplate and a tighter coupling between controllers and models. If you make a change to the model, you need to update the controller.
+
+Changesets solve this problem by moving the behaviour of strong parameters to the model: each changeset defines which parameters are allowed to change. This means that controllers no longer need to know anything about model attributes - they can just focus on the HTTP request.
+
+<details>
+<summary>Show code example</summary>
+
+```ruby
+# Model
+class User < ApplicationRecord
+    changeset :create_user do
+        expect :name
+        validates :name, presence: true
+    end
+end
+
+# Controller
+class UsersController < ApplicationController
+    def new
+        render :new, locals: { changeset: User.create_user }
+    end
+    
+    def create
+        # Notice how the controller doesn't need to know about the model's attributes
+        changeset = User.create_user(params)
+        
+        if changeset.save
+            redirect_to changeset
+        else
+            render :new, locals: { changeset: changeset }, status: :unprocessable_content
+        end
+    end
+end
+
+# View
+<%= form_with changeset do |f| %>
+    <%= f.text_field :name %>
+    <%= f.submit %>
+<% end %>
+```
+</details>
+
+
+### Prevent validation changes from causing unintended consequences
+
+If you ever need to change the validation logic in your model, you may end up with unintended consequences for your existing data. For example, if you start validating that all users have a phone number, if you're not careful, an existing record without a phone number may be marked invalid when they go to change their password.
+
+Changesets let you define validations that are specific to each operation, so you can be sure that your validation logic is only applied when it makes sense.
+
+Although this is possible using contexts in vanilla Rails, it can be difficult to see which validations apply to which operations.
+
+<details>
+<summary>Show code example</summary>
+
+```ruby
+# Model
+class User < ApplicationRecord
+    changeset :edit_name do
+        expect :name
+        
+        validates_name
+    end
+    
+    changeset :edit_phone do
+        expect :phone_number
+        
+        validates_phone_number
+    end
+    
+    def self.validates_name
+        validates :name, presence: true
+    end
+    
+    def self.validates_phone_number
+        validates :phone_number, presence: true
+    end
+end
+```
+
+Because the validations are scoped to the changeset, you won't get an unexpected phone number error when you try to change your name.
+</details>
+
+### Simplify nested attributes
+
+Nested attributes are a common pattern in Rails, but it can be tricky to permit the right parameters using strong parameters. Nested changesets let you define a changeset for each association so that the changeset controls which parameters are allowed.
+
+<details>
+<summary>Show code example</summary>
+
+```ruby
+class User < ApplicationRecord
+    has_many :accounts
+    
+    changeset :edit_user do
+        expect :email
+        validates :email, presence: true
+        
+        nested_changeset :accounts, :edit_account
+    end
+end
+
+class Account < ApplicationRecord
+    belongs_to :user
+    
+    changeset :edit_account do
+        expect :name
+        validates :name, presence: true
+    end
+end
+
+def update
+    changeset = @user.edit_user(params)
+    changeset.save!
+end
+```
+</details>
+
+## Getting started
+
+Install `activerecord-changesets` in your Rails project:
+
+```ruby
+# Gemfile
+gem "activerecord-changesets"
+```
+
+Or using bundler:
+
+```shell
+bundle add activerecord-changesets
+```
+
+## Usage
+
+To start using changesets, add it to your model:
+
+```ruby
+class ApplicationRecord < ActiveRecord::Base
+  include ActiveRecordChangesets
+end
+```
+
+### Defining Changesets
+
+Use the class-level `changeset` method to define a changeset:
+
+```ruby
+class User < ApplicationRecord
+  # Changeset for user creation
+  changeset :create_user do
+    # Required parameters
+    expect :first_name, :last_name, :email, :password
+
+    # Validations specific to this changeset
+    validates :first_name, presence: true
+    validates :last_name, presence: true
+    validates :email, presence: true, uniqueness: true, format: {with: URI::MailTo::EMAIL_REGEXP}
+    validate :must_have_secure_password
+  end
+
+  # Changeset for updating user's name
+  changeset :edit_name do
+    # Optional parameter
+    permit :first_name
+    # Required parameter
+    expect :last_name
+
+    # Validations specific to this changeset
+    validates :first_name, presence: true
+    validates :last_name, presence: true
+  end
+
+  # Changeset for updating user's email
+  changeset :edit_email do
+    expect :email
+
+    validates :email, presence: true, uniqueness: true, format: {with: URI::MailTo::EMAIL_REGEXP}
+  end
+
+  private
+
+  def must_have_secure_password
+    errors.add(:password, "can't be blank") unless self.password.present? && self.password.is_a?(String)
+    errors.add(:password, "must be at least 10 characters") unless self.password.is_a?(String) && self.password.length >= 10
+  end
+end
+```
+
+### Using Changesets
+
+#### Creating a new record with a changeset
+
+```ruby
+# Class-level method
+changeset = User.create_user({
+  first_name: "Bob", 
+  last_name: "Ross", 
+  email: "bob@example.com", 
+  password: "password1234"
+})
+
+# Save the changeset to create the record
+changeset.save!
+```
+
+#### Updating an existing record with a changeset
+
+```ruby
+user = User.find(params[:id])
+
+# Instance-level method
+changeset = user.edit_name({
+  first_name: "Rob", 
+  last_name: "Boss"
+})
+
+# Save the changeset to update the record
+changeset.save!
+```
+
+#### Automatical parameter unwrapping
+
+If parameters are wrapped under the model parameter key (e.g., { user: { ... } }), they will be unwrapped automatically. The following two calls are equivalent:
+
+```ruby
+user.edit_email({user: {email: "..."}})
+user.edit_email(email: "...")
+```
+
+#### Working with Rails Strong Parameters
+
+Changesets work seamlessly with Rails' strong parameters:
+
+```ruby
+# In a controller
+def create
+  changeset = User.create_user(params)
+
+  if changeset.save
+    redirect_to user_path(changeset)
+  else
+    render :new
+  end
+end
+```
+
+### API Reference
+
+#### Changeset Definition
+
+```ruby
+changeset :name do
+  # Changeset configuration
+end
+```
+
+#### Parameter Control
+
+- `expect :param1, :param2, ...` - Define required parameters
+- `permit :param1, :param2, ...` - Define optional parameters
+
+#### Nested Changesets
+
+For associations, you can define nested changesets:
+
+```ruby
+changeset :create_post do
+  expect :title, :content
+
+  # Define a nested changeset for the comments association
+  # This will use the Comment model's :create_comment changeset
+  nested_changeset :comments, :create_comment, optional: true
+end
+```
+
+Note: `nested_changeset` forwards any additional options to ActiveRecord's `accepts_nested_attributes_for` (e.g., `:allow_destroy`, `:limit`, `:update_only`, `:reject_if`). The `:optional` flag controls whether `[association]_attributes` is expected (required) or merely permitted for this changeset.
+
+#### Configuration
+
+These global settings can be overridden in a Rails initializer:
+
+```ruby
+# Whether to raise an error if unexpected parameters are passed to a changeset
+# Defaults to true
+ActiveRecordChangesets.strict_mode = false
+
+# Parameter keys that are ignored when strict mode is enabled
+# Defaults to [:authenticity_token, :_method]
+ActiveRecordChangesets.ignored_attributes = [:authenticity_token, :_method, :utf8]
+```
+
+These options can also be overridden on a per-changeset basis:
+
+```ruby
+class User < ApplicationRecord
+  include ActiveRecordChangesets
+
+  changeset :register, strict: false, ignore: [:utf8, :commit] do
+    expect :email, :password
+    permit :name
+  end
+end
+```
+
+#### Error Handling
+
+If required parameters are missing, an ActiveRecordChangesets::MissingParametersError will be raised:
+
+```ruby
+begin
+  User.create_user({}) # Missing all required parameters
+rescue ActiveRecordChangesets::MissingParametersError => e
+  puts e.message
+  # => "User::Changesets::CreateUser: Expected parameters were missing: first_name, last_name, email, password"
+end
+```
+
+If unexpected parameters are provided while strict mode is enabled (globally or for a specific changeset), an ActiveRecordChangesets::StrictParametersError will be raised:
+
+```ruby
+begin
+  User.register(email: "a@b.com", password: "secret", extra: "nope")
+rescue ActiveRecordChangesets::StrictParametersError => e
+  puts e.message
+  # => "User::Changesets::Register: Unexpected parameters passed to changeset: extra"
+end
+```
+
+If you reference a changeset that hasn't been defined, an ActiveRecordChangesets::UnknownChangeset will be raised:
+
+```ruby
+begin
+  User.changeset_class(:does_not_exist)
+rescue ActiveRecordChangesets::UnknownChangeset => e
+  puts e.message
+end
+```

data/lib/active_record_changesets.rb

@@ -0,0 +1,311 @@
+require "active_support/core_ext/module/attribute_accessors"
+
+# ActiveRecordChangesets provides a lightweight DSL to build parameter-scoped
+# "changeset" subclasses of your ActiveRecord models. These changeset classes
+# restrict mass assignment to a declared set of attributes and can operate in a
+# strict mode that rejects unexpected parameters. Changesets are built lazily
+# and named under Model::Changesets::<Name> for clearer backtraces.
+#
+# Typical usage:
+#   class User < ApplicationRecord
+#     include ActiveRecordChangesets
+#
+#     changeset :register, strict: true do
+#       expect :email, :password
+#       permit :name
+#     end
+#
+#     changeset :update_profile do
+#       permit :name, :bio
+#       nested_changeset :profile, :update, optional: true
+#     end
+#   end
+#
+#   user = User.register(email: "a@b.com", password: "secret")
+#   user.save
+module ActiveRecordChangesets
+  # Base error for all gem-specific exceptions
+  class Error < StandardError; end
+  
+  # Raised when required parameters are missing while building/assigning a changeset
+  class MissingParametersError < Error; end
+  
+  # Raised when strict mode is enabled and unexpected parameters are provided
+  class StrictParametersError < Error; end
+  
+  # Raised when requesting an undefined changeset
+  class UnknownChangeset < Error; end
+
+  # Global list of attribute keys that will be ignored when checking for extra
+  # attributes in strict mode. Defaults to Rails form helpers params.
+  # @return [Array<Symbol>]
+  mattr_accessor :ignored_attributes, default: [:authenticity_token, :_method]
+  
+  # Global default for strict mode. If true, changesets will reject any
+  # parameters not explicitly expected/permitted. Can be overridden per changeset.
+  # @return [Boolean]
+  mattr_accessor :strict_mode, default: true
+
+  # Hook invoked when the module is included into an ActiveRecord model.
+  # It installs internal state used to register and build changesets and defines
+  # the Model::Changesets namespace for named anonymous classes.
+  # @param base [Class] the including model class
+  def self.included(base)
+    base.extend(ClassMethods)
+
+    base.class_attribute :_changesets, default: {}
+    base.private_class_method :_changesets, :_changesets=
+
+    base.class_attribute :_changeset_mutex, instance_accessor: false, default: Mutex.new
+    base.private_class_method :_changeset_mutex, :_changeset_mutex=
+
+    base.const_set(:Changesets, Module.new)
+  end
+
+  module ClassMethods
+    # @!group Changeset DSL (class-level)
+
+    # @!scope class
+    # @!method nested_changeset(association, changeset, optional: false, **options)
+    #   Declare a nested changeset for an association and wire up nested attributes handling.
+    #   This makes "<association>_attributes" permitted or expected depending on `optional`,
+    #   and configures `accepts_nested_attributes_for` on the association.
+    #   @param association [Symbol, String] The association name (e.g., :profile)
+    #   @param changeset [Symbol, String] The changeset name on the associated model (e.g., :update_profile)
+    #   @param optional [Boolean] If true, parameters are optional; otherwise required
+    #   @param options [Hash] Options forwarded to `accepts_nested_attributes_for`
+    #   @option options [Boolean] :allow_destroy Whether to allow destroying nested records
+    #   @option options [Integer] :limit Max number of associated records
+    #   @option options [Boolean] :update_only Only update existing records
+    #   @option options [Proc,Symbol] :reject_if A Proc or a Symbol pointing to a method that checks whether a record should be built for a certain attribute hash
+    #   @see ActiveRecord::NestedAttributes::ClassMethods#accepts_nested_attributes_for
+
+    # @!scope class
+    # @!method expect(*parameter_keys)
+    #   Declare required parameters for a changeset. If any are missing, building/assigning
+    #   will raise an error describing the missing keys.
+    #   @param parameter_keys [Array<Symbol>] Keys that must be present in changeset parameters
+
+    # @!scope class
+    # @!method permit(*parameter_keys)
+    #   Declare optional parameters for this changeset. These are allowed but not required.
+    #   @param parameter_keys [Array<Symbol>] Keys that may be present in changeset parameters
+
+    # @!endgroup
+
+    # Define a changeset for this model.
+    #
+    # Registers a lazily-built anonymous subclass that filters mass-assignment to
+    # declared parameters. Also defines:
+    # - an instance method with the same name that returns a changeset instance
+    #   seeded from the model and optionally assigned with params
+    # - a class method with the same name that instantiates a new model and
+    #   returns its changeset
+    #
+    # @param name [Symbol, String] The changeset name (e.g., :register)
+    # @param options [Hash] Options controlling behavior
+    # @option options [Boolean] :strict Whether to enable strict parameter checking (defaults to ActiveRecordChangesets.strict_mode)
+    # @option options [Array<Symbol>] :ignore Attribute keys to ignore when checking for extra params (defaults to ActiveRecordChangesets.ignored_attributes)
+    # @yield DSL to declare expected/permitted attributes and nested changesets
+    # @yieldparam self [Class] the generated changeset class
+    # @return [void]
+    # @example
+    #   changeset :register, strict: true do
+    #     expect :email, :password
+    #     permit :name
+    #   end
+    def changeset(name, **options, &block)
+      key = name.to_sym
+
+      options.with_defaults!(strict: ActiveRecordChangesets.strict_mode, ignore: ActiveRecordChangesets.ignored_attributes)
+
+      # Defer building the class until methods in the parent model are available
+      _changesets[key] = {dsl_proc: block, options:}
+
+      # Define an instance method to convert an existing model into the changeset
+      #
+      # === Example
+      #
+      #   user = User.find(params[:id])
+      #   changeset = user.change_email
+      define_method(key) do |params = nil|
+        changeset = self.class.changeset_class(key).new
+        changeset.instance_variable_set(:@attributes, @attributes.deep_dup)
+        changeset.instance_variable_set(:@mutations_from_database, @mutations_from_database ||= nil)
+        changeset.instance_variable_set(:@new_record, new_record?)
+        changeset.instance_variable_set(:@destroyed, destroyed?)
+
+        changeset.assign_attributes(params) unless params.nil?
+        changeset.instance_variable_set(:@parent_model, self)
+
+        changeset
+      end
+
+      # Define a class-level convenience for the changeset
+      #
+      # === Example
+      #
+      #   changeset = User.register_user
+      singleton_class.define_method(name) do |params = nil|
+        new.send(name, params)
+      end
+    end
+
+    
+    # Resolve or build the concrete changeset class for the given name.
+    # The class is built lazily and cached. Thread-safe via a mutex.
+    # @param name [Symbol, String]
+    # @return [Class] the generated changeset subclass
+    # @raise [UnknownChangeset] if the name was never registered via `changeset`
+    def changeset_class(name)
+      raise UnknownChangeset, "Unknown changeset for #{self.name}: #{name}" unless _changesets.has_key?(name)
+
+      return _changesets[name][:class] if _changesets[name][:class].present?
+
+      _changeset_mutex.synchronize do
+        # Prevent race condition where two threads call changeset_class at the same time, both
+        # observing a Proc and building two distinct classes
+        return _changesets[name][:class] if _changesets[name][:class].present?
+
+        _changesets[name][:class] = build_changeset_class(name)
+      end
+    end
+
+    # Build the anonymous changeset subclass and evaluate its DSL.
+    # Gives the class a stable constant under Model::Changesets for better backtraces.
+    # @api private
+    # @param name [Symbol]
+    # @return [Class]
+    private def build_changeset_class(name)
+      changeset_class = Class.new(self) do
+        class_attribute :nested_changesets, instance_accessor: false, default: {}
+        private_class_method :nested_changesets=
+
+        class_attribute :permitted_attributes, instance_accessor: false, default: {}
+        private_class_method :permitted_attributes=
+
+        class_attribute :changeset_options, instance_accessor: false, default: {}
+
+        class << self
+          delegate :model_name, to: :superclass
+
+          # Declare required parameter keys for this changeset.
+          # @param keys [Array<Symbol,String>]
+          # @return [void]
+          def expect(*keys)
+            keys.each do |key|
+              permitted_attributes[key.to_sym] = {optional: false}
+            end
+          end
+
+          # Declare optional parameter keys for this changeset.
+          # @param keys [Array<Symbol,String>]
+          # @return [void]
+          def permit(*keys)
+            keys.each do |key|
+              permitted_attributes[key.to_sym] = {optional: true}
+            end
+          end
+
+          # Declare a nested changeset for an association. Also wires up
+          # accepts_nested_attributes_for and adds "<association>_attributes"
+          # to permitted or expected parameters based on `optional`.
+          # @param association [Symbol,String]
+          # @param changeset [Symbol,String]
+          # @param optional [Boolean]
+          # @param options [Hash] forwarded to accepts_nested_attributes_for
+          # @return [void]
+          def nested_changeset(association, changeset, optional: false, **options)
+            association_key = association.to_sym
+            changeset_key = changeset.to_sym
+
+            nested_changesets[association_key] = changeset
+            accepts_nested_attributes_for association_key, **options
+
+            if optional
+              permit :"#{association}_attributes"
+            else
+              expect :"#{association}_attributes"
+            end
+
+            # Change the association class to use the specified changeset class
+            reflection = _reflections[association_key]
+            changeset_class = reflection.klass.changeset_class(changeset_key)
+            reflection.instance_variable_set(:@klass, changeset_class)
+          end
+        end
+
+        # We overwrite assign_attributes to filter the attributes for all mass assignments
+        # Accepts both ActionController::Parameters and plain Hash. If params are wrapped
+        # under the model key (e.g., { user: {...} }), unwraps them. Applies strict/permit
+        # rules and raises helpful errors when something is wrong.
+        # @param new_attributes [Hash, ActionController::Parameters]
+        # @raise [ArgumentError] if new_attributes is not a hash-like object
+        # @raise [ActiveRecordChangesets::MissingParametersError] if required keys are missing
+        # @raise [ActiveRecordChangesets::StrictParametersError] if strict mode and unexpected keys
+        # @return [void]
+        def assign_attributes(new_attributes)
+          unless new_attributes.respond_to?(:each_pair)
+            raise ArgumentError, "When assigning attributes, you must pass a Hash as an argument, #{new_attributes.class} passed."
+          end
+
+          new_attributes = new_attributes.to_unsafe_h if new_attributes.respond_to?(:to_unsafe_h)
+          new_attributes = new_attributes.symbolize_keys if new_attributes.respond_to?(:symbolize_keys!)
+
+          # If the given Hash is wrapped in the model key, we extract it
+          model_key = model_name.param_key.to_sym
+          if new_attributes.has_key?(model_key) && new_attributes[model_key].respond_to?(:each_pair)
+            new_attributes = new_attributes[model_key]
+          end
+
+          _assign_attributes(filter_permitted_attributes(new_attributes))
+        end
+
+        # Internal helper to pick only expected/permitted attributes and validate presence
+        # of required keys. Optionally enforces strict mode rejecting unexpected keys.
+        # @param attributes [Hash]
+        # @return [Hash] a filtered attributes hash suitable for _assign_attributes
+        # @raise [MissingParametersError] when required keys are missing
+        # @raise [StrictParametersError] when extra keys are present in strict mode
+        def filter_permitted_attributes(attributes)
+          filtered_attributes = {}
+          missing_attributes = []
+
+          self.class.permitted_attributes.each do |key, config|
+            if attributes.has_key?(key)
+              filtered_attributes[key] = attributes[key]
+            elsif attributes.has_key?(key.to_s)
+              filtered_attributes[key] = attributes[key.to_s]
+            elsif !config[:optional]
+              missing_attributes << key
+            end
+          end
+
+          if missing_attributes.any?
+            raise ActiveRecordChangesets::MissingParametersError, "#{self.class.name}: Expected parameters were missing: #{missing_attributes.join(", ")}"
+          end
+
+          # If we have enabled strict mode, check for extra attributes. Perform a faster check
+          # using count first before comparing keys.
+          if self.class.changeset_options[:strict] && attributes.count > filtered_attributes.count
+            extra_attributes = attributes.keys - filtered_attributes.keys - self.class.changeset_options[:ignore]
+
+            if extra_attributes.any?
+              raise ActiveRecordChangesets::StrictParametersError, "#{self.class.name}: Unexpected parameters passed to changeset: #{extra_attributes.join(", ")}"
+            end
+          end
+
+          filtered_attributes
+        end
+      end
+      changeset_class.changeset_options = _changesets[name][:options]
+      changeset_class.class_eval(&_changesets[name][:dsl_proc])
+      _changesets[name].delete :dsl_proc
+
+      # Give the anonymous class a name for clearer backtraces (e.g. Model::Changesets::CreateModel)
+      const_get(:Changesets).const_set(name.to_s.camelcase, changeset_class)
+
+      changeset_class
+    end
+  end
+end

metadata

@@ -0,0 +1,178 @@
+--- !ruby/object:Gem::Specification
+name: activerecord-changesets
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Simon J
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-09-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '8.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '8.0'
+- !ruby/object:Gem::Dependency
+  name: temping
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: actionpack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '8.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '8.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: standard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.49'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.49'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.75'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.75'
+- !ruby/object:Gem::Dependency
+  name: benchmark-ips
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.14'
+description: Instead of scattering validations, strong parameters, and business rules
+  across controllers and models, changesets give you one clear pipeline for handling
+  data before it touches the database.
+email: 2857218+mwnciau@users.noreply.github.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.md
+- README.md
+- lib/active_record_changesets.rb
+homepage: https://rubygems.org/gems/dotkey
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/mwnciau/dotkey
+  changelog_uri: https://github.com/mwnciau/dotkey/blob/main/CHANGELOG.md
+  documentation_uri: https://github.com/mwnciau/dotkey
+  bug_tracker_uri: https://github.com/mwnciau/dotkey/issues
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.20
+signing_key:
+specification_version: 4
+summary: Make your model updates explicit and predictable using changesets
+test_files: []