rename from_allocate to _after_decode and add _before_encode

Author: Asmod4n

README.md

@@ -15,7 +15,7 @@
 | **Float Precision** | Float16/32/64 with subnormals, Inf, and NaN |
 | **Shared References** | Tags 28/29 for deduplication, including cyclic structures |
 | **Zero-Copy Decoding** | Both eager and lazy decoding operate directly on the input buffer without copying |
-| **Lazy Decoding** | `CBOR::Lazy` for on-demand nested access with result caching |
+| **Lazy Decoding** | `CBOR::Lazy` for on-demand nested access with key and result caching |
 | **Streaming** | `CBOR.stream` for CBOR sequence reading |
 | **Performance** | ~30% faster than msgpack; 1.3–3× faster than simdjson for selective access |
 
@@ -62,7 +62,7 @@ lazy["missing"]              # => KeyError (raises)
 lazy.dig("missing", "text")  # => nil (safe)
 ```
 
-**Performance:** Access is O(n) only in skipped elements, not the full document. Results are cached for O(1) repeated access.
+**Performance:** Access is O(n) only in skipped elements, not the full document. Keys and Results are cached for O(1) repeated access.
 ```ruby
 # Repeated access uses cache
 inner = lazy["outer"]["inner"].value
@@ -116,11 +116,18 @@ class Person
   native_ext_type :@name, CBOR::Type::String
   native_ext_type :@age, CBOR::Type::Integer
 
-  # Called after allocation during decode
-  def from_allocate
+  # Called after decoding (optional)
+  def _after_decode
     puts "Person #{@name} loaded"
     self
   end
+
+  # Called before encoding (optional)
+  # Must return self or a modified object
+  def _before_encode
+    @age += 1 if @age < 18  # Example transformation
+    self
+  end
 end
 
 # Register with a tag number (user-defined: 1000+)
@@ -131,7 +138,7 @@ person.name = "Alice"
 person.age = 30
 
 encoded = CBOR.encode(person)
-decoded = CBOR.decode(encoded)  # => Person object
+decoded = CBOR.decode(encoded)  # => Person object, after_decode called
 ```
 
 **Available Types:**

src/mrb_cbor.c

@@ -1178,7 +1178,6 @@ encode_simple(CborWriter* w, mrb_value obj)
     default: {
       mrb_state *mrb = w->mrb;
       mrb_raise(mrb, E_TYPE_ERROR, "unexpected simple value");
-      b = 0;
     } break;
   }
   cbor_writer_write(w, &b, 1);
@@ -1560,6 +1559,10 @@ encode_registered_tag(CborWriter *w, mrb_value obj, mrb_int tag_num)
 {
   mrb_state *mrb = w->mrb;
 
+  if (mrb_respond_to(mrb, obj, MRB_SYM(_before_encode))) {
+    obj = mrb_funcall_argv(mrb, obj, MRB_SYM(_before_encode), 0, NULL);
+  }
+
   encode_len(w, 6, (uint64_t)tag_num);
 
   mrb_value schema = mrb_net_schema(mrb, mrb_class(mrb, obj));
@@ -1572,7 +1575,7 @@ encode_registered_tag(CborWriter *w, mrb_value obj, mrb_int tag_num)
     mrb_hash_foreach(mrb, mrb_hash_ptr(schema),
                     encode_registered_tag_foreach, &ctx);
   } else {
-    mrb_raise(mrb, E_RUNTIME_ERROR, "registered class has no ned schema");
+    mrb_raise(mrb, E_RUNTIME_ERROR, "registered class has no net schema");
   }
 }
 
@@ -1671,8 +1674,8 @@ decode_registered_tag(mrb_state *mrb, Reader *r, mrb_value src,
       mrb_hash_foreach(mrb, mrb_hash_ptr(schema),
                       decode_registered_tag_foreach, &ctx);
 
-      if (mrb_respond_to(mrb, obj, MRB_SYM(from_allocate))) {
-        return mrb_funcall_argv(mrb, obj, MRB_SYM(from_allocate), 0, NULL);
+      if (mrb_respond_to(mrb, obj, MRB_SYM(_after_decode))) {
+        return mrb_funcall_argv(mrb, obj, MRB_SYM(_after_decode), 0, NULL);
       } else {
         return obj;
       }

test/test.rb

@@ -368,7 +368,11 @@ def initialize(x, y)
       @y = y
     end
 
-    def from_allocate
+    def _after_decode
+      self
+    end
+
+    def _before_encode
       self
     end
 
@@ -1566,3 +1570,252 @@ def from_allocate
   # dig on non-container should raise
   assert_raise(TypeError) { lazy.dig("key") }
 end
+
+# ============================================================================
+# Registered tag hooks: _before_encode and _after_decode
+# ============================================================================
+
+assert('CBOR registered tag: _after_decode hook called') do
+  class Person
+    attr_accessor :name, :age
+    native_ext_type :@name, CBOR::Type::String
+    native_ext_type :@age, CBOR::Type::Integer
+
+    def initialize
+      @loaded = false
+    end
+
+    def _after_decode
+      @loaded = true
+      self
+    end
+
+    def loaded?
+      @loaded
+    end
+  end
+
+  CBOR.register_tag(1000, Person)
+
+  person = Person.new
+  person.name = "Alice"
+  person.age = 30
+
+  encoded = CBOR.encode(person)
+  decoded = CBOR.decode(encoded)
+
+  assert_true decoded.is_a?(Person)
+  assert_equal "Alice", decoded.name
+  assert_equal 30, decoded.age
+  assert_true decoded.loaded?
+end
+
+assert('CBOR registered tag: _before_encode hook called') do
+  class Item
+    attr_accessor :value
+    native_ext_type :@value, CBOR::Type::Integer
+
+    def initialize(val)
+      @value = val
+    end
+
+    def _before_encode
+      @value = @value * 2  # Double before encoding
+      self
+    end
+  end
+
+  CBOR.register_tag(1001, Item)
+
+  item = Item.new(5)
+  encoded = CBOR.encode(item)
+  decoded = CBOR.decode(encoded)
+
+  assert_equal 10, decoded.value
+end
+
+assert('CBOR registered tag: both hooks in sequence') do
+  class Counter
+    attr_accessor :count
+    native_ext_type :@count, CBOR::Type::Integer
+
+    def initialize(n)
+      @count = n
+      @before_encode_called = false
+      @after_decode_called = false
+    end
+
+    def _before_encode
+      @before_encode_called = true
+      @count = @count + 1
+      self
+    end
+
+    def _after_decode
+      @after_decode_called = true
+      @count = @count + 1
+      self
+    end
+
+    def before_encode_called?
+      @before_encode_called
+    end
+
+    def after_decode_called?
+      @after_decode_called
+    end
+  end
+
+  CBOR.register_tag(1002, Counter)
+
+  counter = Counter.new(10)
+
+  encoded = CBOR.encode(counter)
+  assert_true counter.before_encode_called?  # _before_encode was called during encode
+  decoded = CBOR.decode(encoded)
+
+  assert_equal 12, decoded.count  # 10 + 1 (before_encode) + 1 (after_decode)
+  assert_true decoded.after_decode_called?
+end
+
+assert('CBOR registered tag: _before_encode without _after_decode') do
+  class Price
+    attr_accessor :amount
+    native_ext_type :@amount, CBOR::Type::Integer
+
+    def initialize(val)
+      @amount = val
+    end
+
+    def _before_encode
+      @amount = (@amount * 100).to_i  # Convert to cents
+      self
+    end
+  end
+
+  CBOR.register_tag(1003, Price)
+
+  price = Price.new(5)
+  encoded = CBOR.encode(price)
+  decoded = CBOR.decode(encoded)
+
+  assert_equal 500, decoded.amount
+  assert_true decoded.is_a?(Price)
+end
+
+assert('CBOR registered tag: _after_decode without _before_encode') do
+  class Config
+    attr_accessor :timeout
+    native_ext_type :@timeout, CBOR::Type::Integer
+
+    def initialize(val)
+      @timeout = val
+      @validated = false
+    end
+
+    def _after_decode
+      @timeout = @timeout.abs
+      @validated = true
+      self
+    end
+
+    def validated?
+      @validated
+    end
+  end
+
+  CBOR.register_tag(1004, Config)
+
+  config = Config.new(30)
+  encoded = CBOR.encode(config)
+  decoded = CBOR.decode(encoded)
+
+  assert_equal 30, decoded.timeout
+  assert_true decoded.validated?
+end
+
+assert('CBOR registered tag: hook exception propagates') do
+  class Strict
+    attr_accessor :value
+    native_ext_type :@value, CBOR::Type::Integer
+
+    def initialize(val)
+      @value = val
+    end
+
+    def _before_encode
+      raise "encode forbidden"
+    end
+  end
+
+  CBOR.register_tag(1005, Strict)
+
+  strict = Strict.new(42)
+  assert_raise(RuntimeError) { CBOR.encode(strict) }
+end
+
+assert('CBOR registered tag: hook modifies multiple fields') do
+  class User
+    attr_accessor :username, :email
+    native_ext_type :@username, CBOR::Type::String
+    native_ext_type :@email, CBOR::Type::String
+
+    def initialize
+      @username = ""
+      @email = ""
+    end
+
+    def _after_decode
+      @username = @username.downcase
+      @email = @email.downcase
+      self
+    end
+  end
+
+  CBOR.register_tag(1006, User)
+
+  user = User.new
+  user.username = "AlicE"
+  user.email = "Alice@Example.COM"
+
+  encoded = CBOR.encode(user)
+  decoded = CBOR.decode(encoded)
+
+  assert_equal "alice", decoded.username
+  assert_equal "alice@example.com", decoded.email
+end
+
+assert('CBOR registered tag: lazy decode with _after_decode') do
+  class Data
+    attr_accessor :value
+    native_ext_type :@value, CBOR::Type::Integer
+
+    def initialize(val)
+      @value = val
+      @materialized = false
+    end
+
+    def _after_decode
+      @materialized = true
+      self
+    end
+
+    def materialized?
+      @materialized
+    end
+  end
+
+  CBOR.register_tag(1007, Data)
+
+  data = Data.new(99)
+  encoded = CBOR.encode(data)
+  lazy = CBOR.decode_lazy(encoded)
+
+  # Lazy hasn't materialized yet
+  assert_false data.materialized?
+
+  # Calling .value triggers decode and _after_decode
+  materialized = lazy.value
+  assert_true materialized.materialized?
+  assert_equal 99, materialized.value
+end