coaster 1.4.37 → 1.4.38

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bba62b6d537a978d276cce15b24fbadc212264a4f76c2b79957c2db624c82123
-  data.tar.gz: 11824cc9943176d3cc97cee10976ffe753a532dc72235bd69dacf86af6a9d1fc
+  metadata.gz: d69bb86707fa932dcc3782453f4a1eaf5a0f6affb00ae4ad7cb512af8ee5502b
+  data.tar.gz: afdd5fee8f322409b3ab0a67c735172d7afadeb243831d5ecc7e759b6381f1f6
 SHA512:
-  metadata.gz: c36188aa4545dc5e96d1d30ff2feb8b8324c458ec620dd3de54380eee427d9d2914d07f2b1d03d892790d76f2531f340f237c84765f152a3f95a5a7e5f8503d5
-  data.tar.gz: 2de119abb062d89d8a5ce7998f19c83c1cae7059f8ae6fc14959e55832662dd8d060fb6591a662cc70ae16729ed26d9b9424a282fa5e583dc59153d1c4320158
+  metadata.gz: 57bde1aabfa65503fbdfbc57e9c6c36d673fcd99838dcf914717ce5e09b70be5c4620ee9e3bdc0bb707f02b236cfc0e5cbade535d776bdf3aebab53bddae3ac9
+  data.tar.gz: 01da4d3b757a1cba48acdeda80bd3cd6adf0cb0b5f65f5f7592db9fde8b0465680f461467928d69b4870ecc4e780c8174f374598ace29dbe96cd52a441540d16

data/lib/coaster/serialized_properties.rb

@@ -17,6 +17,67 @@ module Coaster
         def sprop_previous_change(key) = sprop_previous_changes[key.to_s] 
         def sprop_previously_changed?(key) = sprop_previous_change(key).present?
         def sprop_previously_was(key) = (ch = sprop_previous_change(key)).present? ? ch[0] : nil
+
+        if defined?(ActiveRecord::Base) && base < ActiveRecord::Base
+          # Internal method to write serialized property value
+          # @param key [String, Symbol] property key
+          # @param value [Object] value to write
+          # @param apply_setter [Boolean] whether to apply setter proc
+          def _write_sprop_value(key, value, apply_setter: true)
+            setting = self.class.serialized_property_setting(key)
+            return unless setting
+            col = setting[:column]
+            send("#{col}_will_change!")
+            hsh = send(col)
+            if value.nil?
+              hsh.delete(key.to_s)
+            else
+              value = setting[:setter].call(value) if apply_setter && setting[:setter]
+              hsh[key.to_s] = value
+            end
+            value
+          end
+
+          def write_attribute(attr_name, value)
+            if self.class.serialized_property_setting(attr_name)
+              _write_sprop_value(attr_name, value, apply_setter: false)
+            else
+              super
+            end
+          end
+
+          def read_attribute(attr_name)
+            if (setting = self.class.serialized_property_setting(attr_name))
+              col = setting[:column]
+              hsh = super(col) || {}
+              val = hsh[attr_name.to_s]
+              val = setting[:getter].call(val) if setting[:getter]
+              val
+            else
+              super
+            end
+          end
+
+          def [](attr_name)
+            if (setting = self.class.serialized_property_setting(attr_name))
+              col = setting[:column]
+              hsh = super(col) || {}
+              val = hsh[attr_name.to_s]
+              val = setting[:getter].call(val) if setting[:getter]
+              val
+            else
+              super
+            end
+          end
+
+          def []=(attr_name, value)
+            if self.class.serialized_property_setting(attr_name)
+              _write_sprop_value(attr_name, value, apply_setter: false)
+            else
+              super
+            end
+          end
+        end
       end
     end
 
@@ -30,14 +91,40 @@ module Coaster
       end
     end
 
+    def own_serialized_property_settings
+      @own_serialized_property_settings ||= {}
+    end
+
     def serialized_property_settings
-      @serialized_property_settings ||= {}
+      @serialized_property_settings ||= if superclass.respond_to?(:serialized_property_settings)
+        superclass.serialized_property_settings.dup
+      else
+        {}
+      end
     end
 
     def serialized_property_setting(key)
       serialized_property_settings[key.to_sym]
     end
 
+    def set_serialized_property_setting(key, setting)
+      own_serialized_property_settings[key.to_sym] = setting
+      serialized_property_settings[key.to_sym] = setting
+    end
+
+    def delete_serialized_property_setting(key)
+    own_serialized_property_settings.delete(key.to_sym)
+      serialized_property_settings.delete(key.to_sym)
+    end
+
+    def rename_serialized_property_setting(from_key, to_key)
+      setting = own_serialized_property_settings.delete(from_key.to_sym)
+      own_serialized_property_settings[to_key.to_sym] = setting
+      serialized_property_settings.delete(from_key.to_sym)
+      serialized_property_settings[to_key.to_sym] = setting
+      setting
+    end
+
     def serialized_column(serialize_column)
       define_method serialize_column.to_sym do
         return read_attribute(serialize_column.to_sym) if read_attribute(serialize_column.to_sym)
@@ -53,8 +140,8 @@ module Coaster
     end
 
     def serialized_property(serialize_column, key, type: nil, comment: nil, getter: nil, setter: nil, setter_callback: nil, default: nil, rescuer: nil)
-      raise DuplicatedProperty, "#{self.name}##{key} duplicated\n#{caller[0..5].join("\n")}" if serialized_property_settings[key.to_sym]
-      serialized_property_settings[key.to_sym] = {column: serialize_column.to_sym, type: type, comment: comment, getter: getter, setter: setter, setter_callback: setter_callback, default: default, rescuer: rescuer}
+      raise DuplicatedProperty, "#{self.name}##{key} duplicated\n#{caller[0..5].join("\n")}" if own_serialized_property_settings[key.to_sym]
+      set_serialized_property_setting(key, {column: serialize_column.to_sym, type: type, comment: comment, getter: getter, setter: setter, setter_callback: setter_callback, default: default, rescuer: rescuer})
       _typed_serialized_property(serialize_column, key, type: type, getter: getter, setter: setter, setter_callback: setter_callback, default: default, rescuer: rescuer)
     end
 
@@ -98,7 +185,7 @@ module Coaster
                 end
               end
               if type
-                serialized_property_setting(key.to_sym)[:type] = type
+                serialized_property_setting(key)[:type] = type
                 _typed_serialized_property serialize_column, key, type: type, getter: getter, setter: setter, setter_callback: setter_callback, default: default
               end
             end
@@ -145,7 +232,7 @@ module Coaster
           elsif type.respond_to?(:serialized_property_serializer) && (serializer = type.serialized_property_serializer)
             _define_serialized_property(serialize_column, key, getter: serializer[:getter], setter: serializer[:setter], setter_callback: serializer[:setter_callback], default: default)
           elsif (type.is_a?(Symbol) && (t = type.to_s.constantize rescue nil)) || (type.is_a?(Class) && type < ActiveRecord::Base && (t = type))
-            serialized_property_settings["#{key}_id".to_sym] = serialized_property_settings.delete(key.to_sym) # rename key from setting
+            rename_serialized_property_setting(key, "#{key}_id")
             _define_serialized_property serialize_column, "#{key}_id", default: default
 
             define_method key.to_sym do
@@ -189,17 +276,22 @@ module Coaster
     end
 
     def _define_serialized_property(serialize_column, key, getter: nil, setter: nil, setter_callback: nil, default: nil)
+      is_active_record = defined?(ActiveRecord::Base) && self < ActiveRecord::Base
       if default
         if getter
           define_method key.to_sym do
             hsh = send(serialize_column.to_sym)
-            hsh[key.to_s] ||= default.dup
+            if hsh[key.to_s].nil?
+              hsh[key.to_s] = default.dup
+            end
             getter.call(hsh[key.to_s])
           end
         else
           define_method key.to_sym do
             hsh = send(serialize_column.to_sym)
-            hsh[key.to_s] ||= default.dup
+            if hsh[key.to_s].nil?
+              hsh[key.to_s] = default.dup
+            end
             hsh[key.to_s]
           end
         end
@@ -217,20 +309,25 @@ module Coaster
         end
       end
 
-      if setter
+      if is_active_record
         define_method "#{key}_without_callback=".to_sym do |val|
+          col = serialize_column
+          send("#{col}_will_change!")
+          hsh = send(col)
           if val.nil?
-            send(serialize_column.to_sym).delete(key.to_s)
+            hsh.delete(key.to_s)
           else
             val = setter.call(val) if setter
-            send(serialize_column.to_sym)[key.to_s] = val
+            hsh[key.to_s] = val
           end
+          val
         end
       else
         define_method "#{key}_without_callback=".to_sym do |val|
           if val.nil?
             send(serialize_column.to_sym).delete(key.to_s)
           else
+            val = setter.call(val) if setter
             send(serialize_column.to_sym)[key.to_s] = val
           end
         end

data/lib/coaster/version.rb

@@ -1,3 +1,3 @@
 module Coaster
-  VERSION = '1.4.37'
+  VERSION = '1.4.38'
 end

data/test/support/models.rb

@@ -6,6 +6,7 @@ class User < ActiveRecord::Base
   extend Coaster::SerializedProperties
   serialized_column :data
   serialized_property :data, :appendix, default: {}
+  serialized_property :data, :simple
   serialized_property :data, :father, type: :User
   serialized_property :data, :mother, type: self
 
@@ -14,3 +15,29 @@ class User < ActiveRecord::Base
     appendix['test_key2'] ||= 0
   end
 end
+
+class Student < User
+  serialized_property :data, :grade
+  serialized_property :data, :scores, default: {}
+
+  # Property with getter (transforms on read)
+  serialized_property :data, :score_percentage,
+    getter: ->(val) { val.nil? ? nil : "#{val}%" }
+
+  # Property with setter (transforms on write)
+  serialized_property :data, :uppercase_name,
+    setter: ->(val) { val.to_s.upcase }
+
+  # Property with both getter and setter
+  serialized_property :data, :encrypted_value,
+    getter: ->(val) { val.nil? ? nil : Base64.decode64(val) },
+    setter: ->(val) { Base64.strict_encode64(val.to_s) }
+
+  # Property with type: Time (uses ISO8601 string internally)
+  serialized_property :data, :enrolled_at, type: Time
+
+  # Property with type: :unix_epoch (uses integer timestamp internally)
+  serialized_property :data, :graduated_at, type: :unix_epoch
+
+  serialized_property :data, :teacher, type: 'User'
+end

data/test/support/schema.rb

@@ -1,5 +1,6 @@
 ActiveRecord::Schema.define do
   create_table :users do |t|
+    t.string :type
     t.string :key
     t.string :name
     t.integer :age

data/test/test_helper.rb

@@ -10,11 +10,17 @@ require 'bundler/setup'
 require 'coaster'
 require 'logger'
 
+require 'rails'
 require 'active_record'
+
+class TestApp < Rails::Application
+  config.eager_load = false
+end
+Rails.application.initialize!
+
 ActiveRecord::Base.establish_connection adapter: 'sqlite3', database: ":memory:"
 load File.expand_path('../support/schema.rb', __FILE__)
 load File.expand_path('../support/models.rb', __FILE__)
-require 'rails'
 
 class Raven
   def self.capture_exception(*args)

data/test/test_serialized_property.rb

@@ -11,7 +11,7 @@ module Coaster
 
     def test_serialized
       user = User.create(name: 'abc')
-      assert_equal([:appendix, :father_id, :mother_id], User.serialized_property_settings.keys)
+      assert_equal([:appendix, :simple, :father_id, :mother_id], User.serialized_property_settings.keys)
       user.init_appendix
       assert_equal 0, user.appendix['test_key1']
       assert_equal 0, user.appendix['test_key2']
@@ -24,7 +24,7 @@ module Coaster
       assert_equal mother, user.mother
       assert_equal mother.id, user.mother_id
       assert_equal({"appendix"=>{"test_key1"=>0, "test_key2"=>0}, "father_id"=>father.id, "mother_id"=>mother.id}, user.data)
-      assert_equal({"appendix" => [nil, {"test_key1" => 0, "test_key2" => 0}], "father_id" => [nil, 2], "mother_id" => [nil, 3]}, user.sprop_changes)
+      assert_equal({"appendix" => [nil, {"test_key1" => 0, "test_key2" => 0}], "father_id" => [nil, father.id], "mother_id" => [nil, mother.id]}, user.sprop_changes)
       assert_equal(true, user.mother_id_changed?)
       assert_equal(nil, user.mother_id_was)
       user.save!
@@ -35,6 +35,342 @@ module Coaster
       assert_equal({"appendix"=>{"test_key1"=>0, "test_key2"=>0}, "father_id"=>father.id, "mother_id"=>mother.id}, user.data)
       assert_equal mother, user.mother
       assert_equal father, user.father
+      user.write_attribute(:simple, 100)
+      assert_equal(100, user.read_attribute(:simple))
+    end
+
+    def test_active_record_attribute_methods
+      user = User.create(name: 'test_ar')
+
+      # Test write_attribute / read_attribute
+      user.write_attribute(:simple, 'test_value')
+      assert_equal 'test_value', user.read_attribute(:simple)
+      assert_equal 'test_value', user.simple
+
+      # Test [] / []= accessors
+      user[:simple] = 'bracket_value'
+      assert_equal 'bracket_value', user[:simple]
+      assert_equal 'bracket_value', user.simple
+
+      # Verify it's stored in the serialized column
+      assert_equal 'bracket_value', user.data['simple']
+
+      # Test that changes are persisted
+      user.save!
+      user.reload
+      assert_equal 'bracket_value', user.simple
+      assert_equal 'bracket_value', user.read_attribute(:simple)
+      assert_equal 'bracket_value', user[:simple]
+    end
+
+    def test_dirty_tracking_with_will_change
+      user = User.create(name: 'test_dirty')
+
+      # Initially no changes
+      assert_equal false, user.simple_changed?
+
+      # After setting value, should be marked as changed
+      user.simple = 'new_value'
+      assert_equal true, user.simple_changed?
+      assert_equal [nil, 'new_value'], user.simple_change
+
+      # Save and verify previous change tracking
+      user.save!
+      assert_equal false, user.simple_changed?
+      assert_equal true, user.simple_previously_changed?
+      assert_equal [nil, 'new_value'], user.simple_previous_change
+
+      # Update again
+      user.simple = 'updated_value'
+      assert_equal true, user.simple_changed?
+      assert_equal 'new_value', user.simple_was
+      user.save!
+      assert_equal 'new_value', user.simple_previously_was
+    end
+
+    def test_default_value_persistence
+      user = User.create(name: 'test_default')
+
+      # appendix has default: {}
+      # Modifying the returned hash should persist to data
+      user.appendix['key1'] = 'value1'
+      assert_equal 'value1', user.appendix['key1']
+      assert_equal({'key1' => 'value1'}, user.data['appendix'])
+
+      # Verify persistence after save
+      user.save!
+      user.reload
+      assert_equal 'value1', user.appendix['key1']
+    end
+
+    def test_inherited_model_serialized_properties
+      # Student inherits from User and has its own serialized properties
+      student = Student.create(name: 'test_student')
+
+      # Should have access to parent's serialized properties
+      student.simple = 'inherited_value'
+      assert_equal 'inherited_value', student.simple
+
+      # Should have access to parent's default property
+      student.appendix['parent_key'] = 'parent_value'
+      assert_equal 'parent_value', student.appendix['parent_key']
+
+      # Should have access to own serialized properties
+      student.grade = 'A'
+      assert_equal 'A', student.grade
+
+      # Should have access to own default property
+      student.scores['math'] = 95
+      student.scores['english'] = 88
+      assert_equal 95, student.scores['math']
+      assert_equal 88, student.scores['english']
+
+      # Verify data structure
+      assert_equal 'inherited_value', student.data['simple']
+      assert_equal 'A', student.data['grade']
+      assert_equal({'parent_key' => 'parent_value'}, student.data['appendix'])
+      assert_equal({'math' => 95, 'english' => 88}, student.data['scores'])
+
+      # Verify persistence
+      student.save!
+      student.reload
+      assert_equal 'inherited_value', student.simple
+      assert_equal 'A', student.grade
+      assert_equal 'parent_value', student.appendix['parent_key']
+      assert_equal 95, student.scores['math']
+    end
+
+    def test_inherited_model_attribute_methods
+      student = Student.create(name: 'test_student_ar')
+
+      # Test write_attribute / read_attribute for inherited property
+      student.write_attribute(:simple, 'write_test')
+      assert_equal 'write_test', student.read_attribute(:simple)
+
+      # Test write_attribute / read_attribute for own property
+      student.write_attribute(:grade, 'B+')
+      assert_equal 'B+', student.read_attribute(:grade)
+
+      # Test [] / []= for inherited property
+      student[:simple] = 'bracket_inherited'
+      assert_equal 'bracket_inherited', student[:simple]
+
+      # Test [] / []= for own property
+      student[:grade] = 'A-'
+      assert_equal 'A-', student[:grade]
+    end
+
+    def test_inherited_model_dirty_tracking
+      student = Student.create(name: 'test_student_dirty')
+
+      # Test dirty tracking for inherited property
+      student.simple = 'new_simple'
+      assert_equal true, student.simple_changed?
+
+      # Test dirty tracking for own property
+      student.grade = 'A'
+      assert_equal true, student.grade_changed?
+
+      student.save!
+      assert_equal false, student.simple_changed?
+      assert_equal false, student.grade_changed?
+      assert_equal true, student.simple_previously_changed?
+      assert_equal true, student.grade_previously_changed?
+    end
+
+    def test_inherited_model_settings
+      # Student should have both parent's and own property settings via serialized_property_setting
+      assert Student.serialized_property_setting(:appendix), 'should access parent appendix'
+      assert Student.serialized_property_setting(:simple), 'should access parent simple'
+      assert Student.serialized_property_setting(:grade), 'should access own grade'
+      assert Student.serialized_property_setting(:scores), 'should access own scores'
+
+      # serialized_property_settings should include both parent and own settings
+      all_settings = Student.serialized_property_settings
+      assert all_settings[:appendix], 'should include parent appendix'
+      assert all_settings[:simple], 'should include parent simple'
+      assert all_settings[:grade], 'should include own grade'
+      assert all_settings[:scores], 'should include own scores'
+
+      # own_serialized_property_settings should only include own settings
+      own_settings = Student.own_serialized_property_settings
+      assert_nil own_settings[:appendix], 'should not include parent appendix'
+      assert_nil own_settings[:simple], 'should not include parent simple'
+      assert own_settings[:grade], 'should include own grade'
+      assert own_settings[:scores], 'should include own scores'
+    end
+
+    def test_getter_transforms_on_read
+      student = Student.create(name: 'test_getter')
+
+      # Set raw value via write_attribute (bypasses setter)
+      student.write_attribute(:score_percentage, 85)
+      assert_equal '85%', student.score_percentage
+
+      # Verify raw value in data
+      assert_equal 85, student.data['score_percentage']
+
+      # Persistence
+      student.save!
+      student.reload
+      assert_equal '85%', student.score_percentage
+    end
+
+    def test_setter_transforms_on_write
+      student = Student.create(name: 'test_setter')
+
+      # Set via setter - should transform to uppercase
+      student.uppercase_name = 'john doe'
+      assert_equal 'JOHN DOE', student.uppercase_name
+      assert_equal 'JOHN DOE', student.data['uppercase_name']
+
+      # Persistence
+      student.save!
+      student.reload
+      assert_equal 'JOHN DOE', student.uppercase_name
+    end
+
+    def test_write_attribute_bypasses_setter
+      student = Student.create(name: 'test_write_attr')
+
+      # write_attribute should NOT apply setter transformation
+      student.write_attribute(:uppercase_name, 'lowercase')
+      assert_equal 'lowercase', student.uppercase_name
+      assert_equal 'lowercase', student.data['uppercase_name']
+
+      # But setter should apply transformation
+      student.uppercase_name = 'another value'
+      assert_equal 'ANOTHER VALUE', student.uppercase_name
+    end
+
+    def test_getter_and_setter_together
+      student = Student.create(name: 'test_both')
+
+      # Set value - setter encodes to Base64
+      student.encrypted_value = 'secret data'
+
+      # Raw value should be Base64 encoded
+      raw_value = student.data['encrypted_value']
+      assert_equal 'c2VjcmV0IGRhdGE=', raw_value
+
+      # Getter should decode
+      assert_equal 'secret data', student.encrypted_value
+
+      # Persistence
+      student.save!
+      student.reload
+      assert_equal 'secret data', student.encrypted_value
+      assert_equal 'c2VjcmV0IGRhdGE=', student.data['encrypted_value']
+    end
+
+    def test_time_type_property
+      Time.zone = 'UTC'
+      student = Student.create(name: 'test_time')
+      time = Time.zone.parse('2024-06-15 10:30:00 UTC')
+
+      # Use the _without_callback= method which applies setter via _define_serialized_property
+      student.enrolled_at_without_callback = time
+
+      # Raw value should be ISO8601 string (setter transforms Time to string)
+      raw_value = student.data['enrolled_at']
+      assert raw_value.is_a?(String), "Expected String but got #{raw_value.class}"
+      assert raw_value.include?('2024-06-15')
+
+      # getter transforms string back to Time
+      assert_equal time.to_i, student.enrolled_at.to_i
+
+      # Persistence
+      student.save!
+      student.reload
+      assert_equal time.to_i, student.enrolled_at.to_i
+    end
+
+    def test_unix_epoch_type_property
+      Time.zone = 'UTC'
+      student = Student.create(name: 'test_unix')
+      time = Time.zone.parse('2024-06-15 10:30:00 UTC')
+
+      # Use the _without_callback= method which applies setter
+      student.graduated_at = time
+
+      # Raw value should be integer timestamp (setter transforms Time to integer)
+      raw_value = student.data['graduated_at']
+      assert raw_value.is_a?(Integer), "Expected Integer but got #{raw_value.class}"
+      assert_equal time.to_i, raw_value
+
+      # getter transforms integer back to Time
+      assert_equal time.to_i, student.graduated_at.to_i
+
+      # Persistence
+      student.save!
+      student.reload
+      assert_equal time.to_i, student.graduated_at.to_i
+    end
+
+    def test_time_type_with_direct_data_assignment
+      Time.zone = 'UTC'
+      student = Student.create(name: 'test_time_direct')
+
+      student.enrolled_at = Time.parse('2024-01-01T00:00:00.000000Z')
+      assert '2024-01-01T00:00:00.000000Z', student.data['enrolled_at']
+      student.graduated_at = Time.parse('2028-01-01T00:00:00.000000Z')
+      assert Time.parse('2028-01-01T00:00:00.000000Z').to_i, student.data['graduated_at']
+
+      # getter transforms string to Time
+      assert student.enrolled_at.is_a?(ActiveSupport::TimeWithZone)
+      assert_equal 2024, student.enrolled_at.year
+
+      teacher = User.create(name: 'Dr john')
+      student.teacher = teacher
+      student.save
+      student = User.find(student.id)
+      assert teacher.id, student.data['teacher_id']
+      assert User, student.teacher.class
+      assert teacher.id, student.teacher.id
+    end
+
+    def test_read_attribute_applies_getter
+      student = Student.create(name: 'test_read_getter')
+
+      # Set raw value directly in data
+      student.data['score_percentage'] = 85
+
+      # read_attribute should apply getter (adds %)
+      assert_equal '85%', student.read_attribute(:score_percentage)
+
+      # Same with [] accessor
+      assert_equal '85%', student[:score_percentage]
+    end
+
+    def test_read_attribute_with_time_type
+      Time.zone = 'UTC'
+      student = Student.create(name: 'test_read_time')
+
+      # Set ISO8601 string directly
+      student.data['enrolled_at'] = '2024-06-15T10:30:00.000000Z'
+
+      # Note: type: Time creates getter in _define_serialized_property,
+      # but it's not stored in settings, so read_attribute returns raw value
+      # The property accessor (enrolled_at) applies the getter
+      result = student.read_attribute(:enrolled_at)
+      assert result.is_a?(String), "read_attribute returns raw value for type: Time"
+
+      # Property accessor applies getter
+      result2 = student.enrolled_at
+      assert result2.is_a?(ActiveSupport::TimeWithZone)
+      assert_equal 2024, result2.year
+    end
+
+    def test_nil_value_with_getter_setter
+      student = Student.create(name: 'test_nil')
+
+      # Set then clear
+      student.encrypted_value = 'some value'
+      assert_equal 'some value', student.encrypted_value
+
+      student.encrypted_value = nil
+      assert_nil student.encrypted_value
+      assert_nil student.data['encrypted_value']
     end
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: coaster
 version: !ruby/object:Gem::Version
-  version: 1.4.37
+  version: 1.4.38
 platform: ruby
 authors:
 - buzz jung
 bindir: bin
 cert_chain: []
-date: 2025-11-20 00:00:00.000000000 Z
+date: 2025-12-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: oj
@@ -257,7 +257,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 3.6.7
 specification_version: 4
 summary: A little convenient feature for standard library
 test_files: