firm 0.9.7 → 0.9.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8a4a4e31a319e92f4e5efb708562832f1072602084f5c0b4907c88d1e28d2c1b
-  data.tar.gz: 0e9e64b8fb301c3f895fe0b76978d6794389d0ca651339fd132396866d05eefa
+  metadata.gz: 70fc573f0deb51e97747caf3a36ccfabb8e93a0ff8cb72f0de16e877eeb9713b
+  data.tar.gz: 66811b4933baeaa1e555223fa554292339534a5de8d4de66bbd2fe4d26db1633
 SHA512:
-  metadata.gz: 6144308bc7ba7bba7cac24c173a8fbabcac75e3074d29205593c64173696c7b9c41b47c5747b1265ad680f437d87abbce400e9ea0f311b8417403be4faeb55a8
-  data.tar.gz: 32353706f381e81dcacb705bbe144464fef1233df920dcb45d21e3386fca873bbd6ae52b7a1825cff84fec88d43a68935c89ad7577e9fa8f31f1e618c6cba8c4
+  metadata.gz: a37bb0eb3d1aaffed3531979640070f7048e899c93206c61f2e9377bf256f923b4c70f19d1cd8bedc486a94b124803e6f7cd2b42419a65c2746e8f19ca1db432
+  data.tar.gz: 8fe43c7d9828632f27c0e12271250c85b06662ffd9969d3feefb4c9e78f653fc993c42361fcb38dc8e719c2c75601e9da603b26c8ee83736b9d3d991750ef963

data/README.md

@@ -50,7 +50,7 @@ resolve Class objects from these names if really needed.
 FIRM also supports a simple scheme to provide (de-)serialization support for user defined classes. 
 
 FIRM provides object aliasing support for JSON and XML in a similar fashion as the standard support provided
-by YAML. All user defined serializable class as well as **named** `Struct`-derived classes support aliasing.
+by YAML.
 
 FIRM also automatically recognizes and handles cyclic references of aliasable objects.
 

data/lib/firm/serializer/json.rb

@@ -44,15 +44,64 @@ module FIRM
         alias key? include?
       end
 
-      # Mixin module to patch singleton_clas of the Hash class to make Hash-es
-      # JSON creatable (#json_creatable? returns true).
-      module HashClassPatch
-        # Create a new Hash instance from deserialized JSON data.
-        # @param [Hash] object deserialized JSON object
-        # @return [Hash] restored Hash instance
-        def json_create(object)
-          object['data'].to_h
+      module ContainerPatch
+
+        def self.included(base)
+          class << base
+            def json_new(object, &block)
+              # deserializing (anchor) object or alias
+              if object.has_key?('*id')
+                if FIRM::Serializable::Aliasing.restored?(self, object['*id'])
+                  # resolving an already restored anchor for this alias
+                  FIRM::Serializable::Aliasing.resolve_anchor(self, object['*id'])
+                else
+                  # in case of cyclic references JSON will restore aliases before the anchors
+                  # so in this case we instantiate an instance here and register it as
+                  # the anchor; when the anchor is restored it will replace the contents of this
+                  # instance with the restored elements
+                  FIRM::Serializable::Aliasing.restore_anchor(object['*id'], self.new)
+                end
+              else
+                instance = if object.has_key?('&id')
+                             anchor_id = object['&id'] # extract anchor id
+                             if FIRM::Serializable::Aliasing.restored?(self, anchor_id)
+                               # in case of cyclic references an alias will already have restored the anchor instance
+                               # (default constructed); retrieve that instance here for deserialization of properties
+                               FIRM::Serializable::Aliasing.resolve_anchor(self, anchor_id)
+                             else
+                               # restore the anchor here with a newly instantiated instance
+                               FIRM::Serializable::Aliasing.restore_anchor(anchor_id, self.new)
+                             end
+                           else
+                             self.new
+                           end
+                block.call(instance)
+                instance
+              end
+            end
+            private :json_new
+          end
         end
+
+        def build_json(&block)
+          json_data = {
+            ::JSON.create_id => self.class.name
+          }
+          if (anchor = FIRM::Serializable::Aliasing.get_anchor(self))
+            anchor_data = FIRM::Serializable::Aliasing.get_anchor_data(self)
+            # retroactively insert the anchor in the anchored instance's serialization data
+            anchor_data['&id'] = anchor unless anchor_data.has_key?('&id')
+            json_data['*id'] = anchor
+          else
+            # register anchor object **before** serializing properties to properly handle cycling (bidirectional
+            # references)
+            FIRM::Serializable::Aliasing.register_anchor_object(self, json_data)
+            block.call(json_data)
+          end
+          json_data
+        end
+        private :build_json
+
       end
 
       class << self
@@ -131,8 +180,8 @@ module FIRM
           # enable safe deserializing
           self.start_safe_deserialize
           ::JSON.parse!(source,
-                        **{create_additions: true,
-                           object_class: Serializable::JSON::ObjectHash})
+                        create_additions: true,
+                        object_class: Serializable::JSON::ObjectHash)
         ensure
           # reset safe deserializing
           self.end_safe_deserialize
@@ -279,100 +328,101 @@ class ::Class
 end
 
 class ::Array
+  include FIRM::Serializable::JSON::ContainerPatch
+
+  class << self
+    # Create a new Array instance from deserialized JSON data.
+    # @param [Hash] object deserialized JSON object
+    # @return [Array] restored Array instance
+    def json_create(object)
+      json_new(object) { |instance| instance.replace(object['data']) }
+    end
+  end
+
   def as_json(*)
-    collect { |e| e.respond_to?(:as_json) ? e.as_json : e }
+    build_json do |json_data|
+      json_data['data'] = collect { |e| e.respond_to?(:as_json) ? e.as_json : e }
+    end
   end
 end
 
 class ::Hash
+  include FIRM::Serializable::JSON::ContainerPatch
+
   class << self
-    include FIRM::Serializable::JSON::HashClassPatch
+    # Create a new Hash instance from deserialized JSON data.
+    # @param [Hash] object deserialized JSON object
+    # @return [Hash] restored Hash instance
+    def json_create(object)
+      json_new(object) { |instance| instance.replace(object['data'].to_h) }
+    end
   end
+
   def as_json(*)
-    {
-      ::JSON.create_id => self.class.name,
-      'data' => collect { |k,v| [k.respond_to?(:as_json) ? k.as_json : k, v.respond_to?(:as_json) ? v.as_json : v] }
-    }
+    build_json do |json_data|
+      json_data['data'] = collect { |k,v| [k.respond_to?(:as_json) ? k.as_json : k, v.respond_to?(:as_json) ? v.as_json : v] }
+    end
   end
 end
 
 class ::Set
+  include FIRM::Serializable::JSON::ContainerPatch
+
+  class << self
+    # Create a new Set instance from deserialized JSON data.
+    # @param [Hash] object deserialized JSON object
+    # @return [Set] restored Set instance
+    def json_create(object)
+      json_new(object) { |instance| instance.replace(object['a']) }
+    end
+  end
+
   def as_json(*)
-    {
-      JSON.create_id => self.class.name,
-      'a'            => to_a.as_json,
-    }
+    build_json do |json_data|
+      json_data['a'] = to_a.collect { |e| e.respond_to?(:as_json) ? e.as_json : e }
+    end
   end
 end
 
 class ::Struct
+  include FIRM::Serializable::JSON::ContainerPatch
+
   class << self
+    # Create a new Struct instance from deserialized JSON data.
+    # @param [Hash] object deserialized JSON object
+    # @return [Struct] restored Set instance
     def json_create(object)
-      # deserializing (anchor) object or alias
-      if object.has_key?('*id')
-        if FIRM::Serializable::Aliasing.restored?(self, object['*id'])
-          # resolving an already restored anchor for this alias
-          FIRM::Serializable::Aliasing.resolve_anchor(self, object['*id'])
-        else
-          # in case of cyclic references JSON will restore aliases before the anchors
-          # so in this case we allocate an instance here and register it as
-          # the anchor; when the anchor is restored it will re-use this instance to restore
-          # the properties
-          FIRM::Serializable::Aliasing.restore_anchor(object['*id'], self.allocate)
-        end
-      else
-        if object.has_key?('&id')
-          anchor_id = object['&id'] # extract anchor id
-          instance = if FIRM::Serializable::Aliasing.restored?(self, anchor_id)
-                       # in case of cyclic references an alias will already have restored the anchor instance
-                       # (default constructed); retrieve that instance here for deserialization of properties
-                       FIRM::Serializable::Aliasing.resolve_anchor(self, anchor_id)
-                     else
-                       # restore the anchor here with a newly instantiated instance
-                       FIRM::Serializable::Aliasing.restore_anchor(anchor_id, self.allocate)
-                     end
-          instance.__send__(:initialize, *object['v'])
-          instance
-        else
-          self.new(*object['v'])
+        json_new(object) do |instance|
+          values = object['v']
+          instance.members.each_with_index { |n, i| instance[n] = values[i] }
         end
-      end
     end
   end
 
   def as_json(*)
-    klass = self.class.name
-    klass.to_s.empty? and raise JSON::JSONError, "Only named structs are supported!"
-    # {
-    #   JSON.create_id => klass,
-    #   'v'            => values.as_json,
-    # }
-    json_data = {
-      ::JSON.create_id => klass
-    }
-    if (anchor = FIRM::Serializable::Aliasing.get_anchor(self))
-      anchor_data = FIRM::Serializable::Aliasing.get_anchor_data(self)
-      # retroactively insert the anchor in the anchored instance's serialization data
-      anchor_data['&id'] = anchor unless anchor_data.has_key?('&id')
-      json_data['*id'] = anchor
-    else
-      # register anchor object **before** serializing properties to properly handle cycling (bidirectional
-      # references)
-      FIRM::Serializable::Aliasing.register_anchor_object(self, json_data)
-      json_data['v'] = values.as_json
+    self.class.name.to_s.empty? and raise JSON::JSONError, "Only named structs are supported!"
+    build_json do |json_data|
+      json_data['v'] = values.collect { |e| e.respond_to?(:as_json) ? e.as_json : e }
     end
-    json_data
   end
 end
 
 class ::OpenStruct
+  include FIRM::Serializable::JSON::ContainerPatch
+
+  class << self
+    # Create a new OpenStruct instance from deserialized JSON data.
+    # @param [Hash] object deserialized JSON object
+    # @return [OpenStruct] restored OpenStruct instance
+    def json_create(object)
+        json_new(object) { |instance| object['t'].each { |k,v| instance[k] = v } }
+    end
+  end
+
   def as_json(*)
-    klass = self.class.name
-    klass.to_s.empty? and raise JSON::JSONError, "Only named structs are supported!"
-    {
-      JSON.create_id => klass,
-      't'            => table.as_json,
-    }
+    build_json do |json_data|
+      json_data['t'] = table.collect { |k,v| [k.respond_to?(:as_json) ? k.as_json : k, v.respond_to?(:as_json) ? v.as_json : v] }
+    end
   end
 end
 

data/lib/firm/serializer/xml.rb

@@ -56,6 +56,7 @@ module FIRM
             def create_type_node(xml)
               xml.add_child(Nokogiri::XML::Node.new(tag.to_s, xml.document))
             end
+            private :create_type_node
             def to_xml(_, _)
               raise Serializable::Exception, "Missing serialization method for #{klass} XML handler"
             end
@@ -65,6 +66,42 @@ module FIRM
           end
           private_constant :HandlerMethods
 
+          module AliasableHandler
+            def build_xml(xml, value, &block)
+              node = create_type_node(xml)
+              node['class'] = value.class.name
+              if (anchor = Serializable::Aliasing.get_anchor(value))
+                anchor_data = Serializable::Aliasing.get_anchor_data(value)
+                # retroactively insert the anchor in the anchored instance's serialization data
+                anchor_data['anchor'] = anchor unless anchor_data.has_attribute?('anchor')
+                node['alias'] = "#{anchor}"
+              else
+                # register anchor object **before** serializing properties to properly handle cycling (bidirectional
+                # references)
+                Serializable::Aliasing.register_anchor_object(value, node)
+                block.call(node)
+              end
+              xml
+            end
+            private :build_xml
+            def create_from_xml(xml, &block)
+              klass = ::Object.const_get(xml['class'])
+              if xml.has_attribute?('alias')
+                # deserializing alias
+                Serializable::Aliasing.resolve_anchor(klass, xml['alias'].to_i)
+              else
+                instance = klass.new
+                # in case this is an anchor restore the anchor instance before restoring the member values
+                # and afterwards initialize the instance with the restored member values
+                Serializable::Aliasing.restore_anchor(xml['anchor'].to_i, instance) if xml.has_attribute?('anchor')
+                block.call(instance)
+                instance
+              end
+            end
+            private :create_from_xml
+          end
+          private_constant :AliasableHandler
+
           def xml_handlers
             @xml_handlers ||= {}
           end
@@ -86,9 +123,10 @@ module FIRM
           end
           private :get_xml_handler
 
-          def define_xml_handler(klass, tag=nil, &block)
+          def define_xml_handler(klass, tag=nil, aliasable: false, &block)
             hnd_klass = Class.new
             hnd_klass.singleton_class.include(HandlerMethods)
+            hnd_klass.singleton_class.include(AliasableHandler) if aliasable
             tag_code = if tag
                          ::Symbol === tag ? ":#{tag}" : "'#{tag.to_s}'"
                        else
@@ -179,16 +217,14 @@ module FIRM
           end
         end
 
-        define_xml_handler(::Array) do
+        define_xml_handler(::Array, aliasable: true) do
           def to_xml(xml, value)
-            node = create_type_node(xml)
-            value.each do |v|
-              Serializable::XML.to_xml(node, v)
-            end
-            xml
+            build_xml(xml, value) { |node| value.each { |v| Serializable::XML.to_xml(node, v) } }
           end
           def from_xml(xml)
-            xml.elements.collect { |child| Serializable::XML.from_xml(child) }
+            create_from_xml(xml) do |instance|
+              instance.replace(xml.elements.collect { |child| Serializable::XML.from_xml(child) })
+            end
           end
         end
 
@@ -243,56 +279,35 @@ module FIRM
           end
         end
 
-        define_xml_handler(::Hash) do
+        define_xml_handler(::Hash, aliasable: true) do
           def to_xml(xml, value)
-            node = create_type_node(xml)
-            value.each_pair do |k,v|
-              pair = node.add_child(Nokogiri::XML::Node.new('P', node.document))
-              Serializable::XML.to_xml(pair, k)
-              Serializable::XML.to_xml(pair, v)
+            build_xml(xml, value) do |node|
+              value.each_pair do |k,v|
+                pair = node.add_child(Nokogiri::XML::Node.new('P', node.document))
+                Serializable::XML.to_xml(pair, k)
+                Serializable::XML.to_xml(pair, v)
+              end
             end
-            xml
           end
           def from_xml(xml)
-            xml.elements.inject({}) do |hash, pair|
-              k, v = pair.elements
-              hash[Serializable::XML.from_xml(k)] = Serializable::XML.from_xml(v)
-              hash
+            create_from_xml(xml) do |instance|
+              xml.elements.inject(instance) do |hash, pair|
+                k, v = pair.elements
+                instance[Serializable::XML.from_xml(k)] = Serializable::XML.from_xml(v)
+                instance
+              end
             end
           end
         end
 
-        define_xml_handler(::Struct) do
+        define_xml_handler(::Struct, aliasable: true) do
           def to_xml(xml, value)
-            node = create_type_node(xml)
-            node['class'] = value.class.name
-            if (anchor = Serializable::Aliasing.get_anchor(value))
-              anchor_data = Serializable::Aliasing.get_anchor_data(value)
-              # retroactively insert the anchor in the anchored instance's serialization data
-              anchor_data['anchor'] = anchor unless anchor_data.has_attribute?('anchor')
-              node['alias'] = "#{anchor}"
-            else
-              # register anchor object **before** serializing properties to properly handle cycling (bidirectional
-              # references)
-              Serializable::Aliasing.register_anchor_object(value, node)
-              value.each do |v|
-                Serializable::XML.to_xml(node, v)
-              end
-            end
-            xml
+            build_xml(xml, value) { |node| value.each { |v| Serializable::XML.to_xml(node, v) } }
           end
           def from_xml(xml)
-            # deserializing alias
-            klass = ::Object.const_get(xml['class'])
-            if xml.has_attribute?('alias')
-              Serializable::Aliasing.resolve_anchor(klass, xml['alias'].to_i)
-            else
-              instance = klass.allocate
-              # in case this is an anchor restore the anchor instance before restoring the member values
-              # and afterwards initialize the instance with the restored member values
-              Serializable::Aliasing.restore_anchor(xml['anchor'].to_i, instance) if xml.has_attribute?('anchor')
-              instance.__send__(:initialize, *xml.elements.collect { |child| Serializable::XML.from_xml(child) })
-              instance
+            create_from_xml(xml) do |instance|
+              elems = xml.elements
+              instance.members.each_with_index { |n, i| instance[n] = Serializable::XML.from_xml(elems[i]) }
             end
           end
         end
@@ -408,34 +423,34 @@ module FIRM
           end
         end
 
-        define_xml_handler(::Set) do
+        define_xml_handler(::Set, aliasable: true) do
           def to_xml(xml, value)
-            node = create_type_node(xml)
-            value.each do |v|
-              Serializable::XML.to_xml(node, v)
-            end
-            xml
+            build_xml(xml, value) { |node| value.each { |v| Serializable::XML.to_xml(node, v) } }
           end
           def from_xml(xml)
-            ::Set.new(xml.elements.collect { |child| Serializable::XML.from_xml(child) })
+            create_from_xml(xml) do |instance|
+              instance.replace(xml.elements.collect { |child| Serializable::XML.from_xml(child) })
+            end
           end
         end
 
-        define_xml_handler(::OpenStruct) do
+        define_xml_handler(::OpenStruct, aliasable: true) do
           def to_xml(xml, value)
-            node = create_type_node(xml)
-            value.each_pair do |k,v|
-              pair = node.add_child(Nokogiri::XML::Node.new('P', node.document))
-              Serializable::XML.to_xml(pair, k)
-              Serializable::XML.to_xml(pair, v)
+            build_xml(xml, value) do |node|
+              value.each_pair do |k,v|
+                pair = node.add_child(Nokogiri::XML::Node.new('P', node.document))
+                Serializable::XML.to_xml(pair, k)
+                Serializable::XML.to_xml(pair, v)
+              end
             end
-            xml
           end
           def from_xml(xml)
-            xml.elements.inject(::OpenStruct.new) do |hash, pair|
-              k, v = pair.elements
-              hash[Serializable::XML.from_xml(k)] = Serializable::XML.from_xml(v)
-              hash
+            create_from_xml(xml) do |instance|
+              xml.elements.inject(::OpenStruct.new) do |hash, pair|
+                k, v = pair.elements
+                instance[Serializable::XML.from_xml(k)] = Serializable::XML.from_xml(v)
+                instance
+              end
             end
           end
         end

data/lib/firm/version.rb

@@ -4,6 +4,6 @@
 module FIRM
 
   # FIRM version
-  VERSION = "0.9.7"
+  VERSION = "0.9.8"
 
 end

data/tests/serializer_tests.rb

@@ -770,12 +770,56 @@ module SerializerTestMixin
     struct = CyclicTest.new
     struct.list = [struct]
     obj_serial = struct.serialize
-    struct_new = nil
-    assert_nothing_raised { struct_new = FIRM.deserialize(obj_serial) }
+    struct_new = assert_nothing_raised { FIRM.deserialize(obj_serial) }
     assert_instance_of(CyclicTest, struct_new)
     assert_equal(struct_new.object_id, struct_new.list[0].object_id)
   end
 
+  def test_cyclic_core_containers
+
+    array = [1, 2, 3]
+    array << array
+    obj_serial = array.serialize
+    arr_new = assert_nothing_raised { FIRM.deserialize(obj_serial) }
+    assert_instance_of(::Array, arr_new)
+    assert_instance_of(::Array, arr_new.last)
+    assert_equal(arr_new.size, arr_new.last.size)
+    assert_equal(arr_new.object_id, arr_new.last.object_id)
+
+    hash = { one: 1, two: 2 }
+    hash[:self] = hash
+    obj_serial = hash.serialize
+    hash_new = assert_nothing_raised { FIRM.deserialize(obj_serial) }
+    assert_instance_of(::Hash, hash_new)
+    assert_instance_of(::Hash, hash_new[:self])
+    assert_equal(hash_new.size, hash_new[:self].size)
+    assert_equal(hash_new.object_id, hash_new[:self].object_id)
+
+    # the JRuby Psych implementation has a bug preventing cyclic reference support
+    # for Set objects (https://github.com/jruby/jruby/issues/8352)
+    unless defined? JRUBY_VERSION
+      set = ::Set.new([[1,2], {one: 1}])
+      set << set
+      obj_serial = set.serialize(pretty: true)
+      set_new = assert_nothing_raised { FIRM.deserialize(obj_serial) }
+      assert_instance_of(::Set, set_new)
+      assert_true(set_new.any? { |e| ::Array === e })
+      assert_true(set_new.any? { |e| ::Hash === e })
+      assert_true(set_new.any? { |e| ::Set === e && set_new.object_id == e.object_id })
+    end
+
+    ostruct = ::OpenStruct.new(one: 1, two: 2)
+    ostruct.me = ostruct
+    obj_serial = ostruct.serialize
+    ostruct_new = assert_nothing_raised { FIRM.deserialize(obj_serial) }
+    assert_instance_of(::OpenStruct, ostruct_new)
+    assert_equal(1, ostruct_new.one)
+    assert_equal(2, ostruct_new.two)
+    assert_instance_of(::OpenStruct, ostruct_new.me)
+    assert_equal(ostruct_new.object_id, ostruct_new.me.object_id)
+
+  end
+
   def test_nested_hash_with_complex_keys
     id_obj = Identifiable.new(:one)
     id_obj2 = Identifiable.new(:two)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: firm
 version: !ruby/object:Gem::Version
-  version: 0.9.7
+  version: 0.9.8
 platform: ruby
 authors:
 - Martin Corino
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-09-22 00:00:00.000000000 Z
+date: 2024-09-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake