activeitem 0.0.22 → 0.0.23

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a7d5990fc9c0532dc9a65f803bd9886c1769dc2b4c3071fd4748c079fa7559b3
-  data.tar.gz: 1c480246c6a898502eacedda1b456e003f54910a3f8562893cc5c070c06f168e
+  metadata.gz: 3391ecc77f10aaffc7953d95d84691bdf4791ea11163fe45ba7b3b5be3b8418f
+  data.tar.gz: 02ad5cbf59628300f250fa972729ad503a53e197824350f7990e7d8cefd4281f
 SHA512:
-  metadata.gz: db67b991fe6c8c9ed9ce18a362dc15dfd9f1b46c63ed20a49e8b1f82bf0bb2dfe3738b1e2f7d7b29a31396e61d40ee3e6d528393b01a93a92bf81c2e9d9f234b
-  data.tar.gz: dc5a3c76df184f02bf6fa4f0cd040e9a98e42729326f35243b198fc2d7c8ae4e4a86429bdc457be7f7e9198892ba93aaddf5a4d5650806afcba6cb528d6d54e7
+  metadata.gz: b60d3ec30ab2f3f5a593c320d6af5764e793574b03e4389661325942d9e31d8c7b40b25532816ac0e1a5b8cfd4c5b49650ea413673d2686dd05a3841aeb0ae56
+  data.tar.gz: 37398daa0b3af333ed40fb9dc2ad4571d9044df57ebaefe7f20fd21a5c714676cce31925e5b8d5a9a6a847768b15e0e53eca8138ed7b89b38fbf17d8cc71b665

data/CHANGELOG.md

@@ -1,5 +1,31 @@
 # Changelog
 
+## 0.0.23
+
+### Added
+
+- **`read_attribute` / `write_attribute`** — ActiveItem now exposes the same attribute primitives as ActiveRecord. `write_attribute(:name, value)` records the change for dirty tracking; `read_attribute(:name)` returns the current value. Custom readers/writers can route through these instead of touching the ivar directly.
+
+### Fixed
+
+- **Custom attribute writers now persist on update, Rails-style** — Overriding a generated writer to coerce or normalize a value no longer silently drops the change. Generated readers/writers are now defined in an included module (like Rails' `GeneratedAttributeMethods`), so a hand-written `def foo=` can call `super` and get dirty tracking for free. Previously, a custom writer that assigned `@foo` directly left the attribute out of the changeset — `save` returned `true` with no error, but the update wrote nothing. Both `super` and `write_attribute` are now supported.
+
+  ```ruby
+  class Article < ActiveItem::Base
+    attr_accessor :tags, :payload
+
+    # Coerce to an Array, Rails-style: override and call super.
+    def tags=(value)
+      super(Array(value))
+    end
+
+    # Or be explicit with write_attribute.
+    def payload=(value)
+      write_attribute(:payload, value.is_a?(String) ? value : JSON.generate(value))
+    end
+  end
+  ```
+
 ## 0.0.22
 
 ### Changed

data/README.md

@@ -114,6 +114,38 @@ class Customer < ActiveItem::Base
 end
 ```
 
+### Custom Attribute Writers
+
+Like ActiveRecord, you can override a generated writer to coerce or normalize a
+value on assignment. Just route the assignment back through the generated
+writer — call `super`, or use `write_attribute`. Both record the change for
+dirty tracking, so `save` (and `update`) persist it. Assigning `@ivar` directly
+bypasses dirty tracking and the change is silently dropped on update.
+
+```ruby
+class Article < ActiveItem::Base
+  attr_accessor :tags, :payload
+
+  # Coerce to an Array, Rails-style: override and call super.
+  def tags=(value)
+    super(Array(value))
+  end
+
+  # Or be explicit with write_attribute.
+  def payload=(value)
+    write_attribute(:payload, value.is_a?(String) ? value : JSON.generate(value))
+  end
+end
+```
+
+`read_attribute(:name)` is available too, for custom readers:
+
+```ruby
+def display_name
+  read_attribute(:name).to_s.strip
+end
+```
+
 ## License
 
 MIT

data/lib/active_item/base.rb

@@ -100,15 +100,33 @@ module ActiveItem
 
           define_attribute_methods attr_name
 
-          define_method(attr_name) do
-            instance_variable_get("@#{attr_name}")
+          # Define the generated reader/writer in a dedicated module that is
+          # included into the model, rather than directly on the class. This
+          # mirrors Rails' GeneratedAttributeMethods: a hand-written
+          # `def foo=` on the model sits *above* the generated writer in the
+          # ancestor chain, so a custom writer can call `super` (or
+          # `write_attribute`) to get dirty tracking for free.
+          generated_attribute_methods.module_eval do
+            define_method(attr_name) do
+              read_attribute(attr_name)
+            end
+
+            define_method("#{attr_name}=") do |value|
+              write_attribute(attr_name, value)
+            end
           end
+        end
+      end
 
-          define_method("#{attr_name}=") do |value|
-            old_value = instance_variable_get("@#{attr_name}")
-            send("#{attr_name}_will_change!") if (old_value != value) && !changed_attributes.key?(attr_name)
-            instance_variable_set("@#{attr_name}", value)
-          end
+      # Per-class module that holds the generated attribute reader/writer
+      # methods. Included once, ahead of ActiveModel in the ancestor chain but
+      # behind the model class itself, so user-defined setters can `super`.
+      def generated_attribute_methods
+        @generated_attribute_methods ||= begin
+          mod = Module.new
+          include mod
+
+          mod
         end
       end
 
@@ -490,6 +508,50 @@ module ActiveItem
       end
     end
 
+    # Read the current value of an attribute by name.
+    #
+    # This is the Rails-like primitive that generated readers delegate to.
+    # Custom readers can call it (or `super`) instead of poking at the ivar
+    # directly.
+    #
+    #   def display_name
+    #     read_attribute(:name).to_s.strip
+    #   end
+    #
+    # @param attr_name [String, Symbol] the attribute name
+    # @return the attribute's current value
+    def read_attribute(attr_name)
+      instance_variable_get("@#{attr_name}")
+    end
+
+    # Write an attribute value, recording it for dirty tracking so `save`
+    # actually persists it.
+    #
+    # This is the single place dirty tracking happens for attributes, mirroring
+    # Rails' `write_attribute`. Generated writers delegate here, which means a
+    # custom writer gets dirty tracking for free by going through either
+    # `super` or `write_attribute` directly:
+    #
+    #   # coerce/normalize on assignment, Rails-style
+    #   def tags=(value)
+    #     super(Array(value))            # -> generated writer -> write_attribute
+    #   end
+    #
+    #   # or be explicit
+    #   def payload=(value)
+    #     write_attribute(:payload, value.is_a?(String) ? value : JSON.generate(value))
+    #   end
+    #
+    # @param attr_name [String, Symbol] the attribute name
+    # @param value the value to assign
+    # @return the assigned value
+    def write_attribute(attr_name, value)
+      attr_name = attr_name.to_s
+      old_value = instance_variable_get("@#{attr_name}")
+      mark_attribute_will_change(attr_name, old_value, value)
+      instance_variable_set("@#{attr_name}", value)
+    end
+
     def attribute_changed?(attr_name)
       super(attr_name.to_s)
     end
@@ -511,6 +573,18 @@ module ActiveItem
 
     private
 
+    # Record a pending change for dirty tracking. Guarded with `respond_to?`
+    # so it degrades gracefully for attributes that weren't declared via
+    # `attr_accessor` (and under test harnesses that stub the ORM), and skips
+    # re-recording an original value that's already been captured.
+    def mark_attribute_will_change(attr_name, old_value, new_value)
+      return if old_value == new_value
+      return if changed_attributes.key?(attr_name)
+      return unless respond_to?("#{attr_name}_will_change!", true)
+
+      send("#{attr_name}_will_change!")
+    end
+
     # Enroll this record's save operation in the current transaction.
     # Called when save is invoked inside a transaction block.
     def enroll_in_transaction

data/lib/active_item/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveItem
-  VERSION = '0.0.22'
+  VERSION = '0.0.23'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activeitem
 version: !ruby/object:Gem::Version
-  version: 0.0.22
+  version: 0.0.23
 platform: ruby
 authors:
 - Andy Davis
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-09-07 00:00:00.000000000 Z
+date: 2026-09-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel