firm 0.9.7 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8a4a4e31a319e92f4e5efb708562832f1072602084f5c0b4907c88d1e28d2c1b
-  data.tar.gz: 0e9e64b8fb301c3f895fe0b76978d6794389d0ca651339fd132396866d05eefa
+  metadata.gz: 0ebb1f6594b3ecc4e56863a0f04ce3eb44fc5bfad0218a183298b44e56e9cf8e
+  data.tar.gz: 4e2349b45ae0479c968406fcd2eafb7ac4e76c8317cbbeeea20ecb784e998115
 SHA512:
-  metadata.gz: 6144308bc7ba7bba7cac24c173a8fbabcac75e3074d29205593c64173696c7b9c41b47c5747b1265ad680f437d87abbce400e9ea0f311b8417403be4faeb55a8
-  data.tar.gz: 32353706f381e81dcacb705bbe144464fef1233df920dcb45d21e3386fca873bbd6ae52b7a1825cff84fec88d43a68935c89ad7577e9fa8f31f1e618c6cba8c4
+  metadata.gz: 247ca7e7c9eb24fc5ca31c8cfb3f06ec9e4c3779627f3e35722d2c51a630c255cc4d182d434d35da7207f112b0905635a5717fd767f3c904a251b7ab84873cbd
+  data.tar.gz: 2953c510c88ed9078f777a0c8e23399f48339ef5f6c85fcf264fe025de795ecc187407d7d7bddf77b89dbb182eb158123e62aad909c91fbfffc04f613cf8280f

data/README.md

@@ -8,11 +8,11 @@
 
 ## Introduction
 
-FIRM is a pure Ruby library that works across different Ruby implementations like MRI Ruby and JRuby providing output 
-format independent object (de-)serialization support.
+FIRM is a pure Ruby library that works across different Ruby implementations like MRI Ruby and JRuby providing format 
+independent object (de-)serialization support.
 
 FIRM is explicitly **NOT** intended as a non-discriminative marshaling library (dumping any object's attributes)
-but rather as structured and safe serialization library requiring users to think about what state they want
+but rather as a structured and safe serialization library requiring users to think about what state they want
 persisted (and possibly in what form) and what not.
 Straightforward attribute serialization is simple with minimal intrusion on user code.
 In addition various customization options are available to tweak (de-)serialization for a perfect fit if needed. 
@@ -39,20 +39,21 @@ FIRM supports (de-)serializing many core Ruby objects out of the box including:
 - `Time`
 - `Struct`
 - `Set`
-- `OpenStruct`
+- `OpenStruct` (optional starting from Ruby 3.5 which removes this class from the standard library)
 - `Date`
 - `DateTime`
 
-For security reasons FIRM does **not** support direct (de-)serializing of `Class` objects but will rather
+For simplicity and security reasons FIRM does **not** support direct (de-)serializing of `Class` objects but will rather
 serialize (and deserialize) these as their scoped string names. Customized property setters can be used to
 resolve Class objects from these names if really needed.
 
-FIRM also supports a simple scheme to provide (de-)serialization support for user defined classes. 
+Serialization support for user defined classes is available through a simple DSL scheme.
 
 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.<br>
+In addition FIRM automatically recognizes and handles cyclic references of aliasable objects.
 
-FIRM also automatically recognizes and handles cyclic references of aliasable objects.
+FIRM serialization is also thread safe and supports re-entrancy (i.e. nested serialization).
 
 ## Installing FIRM
 

data/lib/firm/serialize/core.rb

@@ -32,12 +32,20 @@ module FIRM
 end
 
 require 'set'
-require 'ostruct'
+# from Ruby 3.5.0 OpenStruct will not be available by default anymore
+begin
+  require 'ostruct'
+rescue LoadError
+end
 
-[::Array, ::Hash, ::Struct, ::Range, ::Rational, ::Complex, ::Regexp, ::Set, ::OpenStruct, ::Time, ::Date, ::DateTime].each do |c|
+[::Array, ::Hash, ::Struct, ::Range, ::Rational, ::Complex, ::Regexp, ::Set, ::Time, ::Date, ::DateTime].each do |c|
   c.include FIRM::Serializable::CoreExt
 end
 
+if ::Object.const_defined?(:OpenStruct)
+  ::OpenStruct.include FIRM::Serializable::CoreExt
+end
+
 if ::Object.const_defined?(:BigDecimal)
   ::BigDecimal.include FIRM::Serializable::CoreExt
 end

data/lib/firm/serializer/json.rb

@@ -14,7 +14,12 @@ require 'json/add/bigdecimal' if ::Object.const_defined?(:BigDecimal)
 require 'json/add/rational'
 require 'json/add/complex'
 require 'json/add/set'
-require 'json/add/ostruct'
+# from Ruby 3.5.0 OpenStruct will not be available by default anymore
+begin
+  require 'ostruct'
+  require 'json/add/ostruct'
+rescue LoadError
+end
 
 module FIRM
 
@@ -22,6 +27,8 @@ module FIRM
 
     module JSON
 
+      CREATE_ID = 'rbklass'.freeze
+
       # Derived Hash class to use for deserialized JSON object data which
       # supports using Symbol keys.
       class ObjectHash < ::Hash
@@ -44,21 +51,71 @@ 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
         def serializables
           set = ::Set.new( [::NilClass, ::TrueClass, ::FalseClass, ::Integer, ::Float, ::String, ::Array, ::Hash,
-                     ::Date, ::DateTime, ::Range, ::Rational, ::Complex, ::Regexp, ::Struct, ::Symbol, ::Time, ::Set, ::OpenStruct])
+                     ::Date, ::DateTime, ::Range, ::Rational, ::Complex, ::Regexp, ::Struct, ::Symbol, ::Time, ::Set])
+          set << ::OpenStruct if ::Object.const_defined?(:OpenStruct)
           set << ::BigDecimal if ::Object.const_defined?(:BigDecimal)
           set
         end
@@ -107,6 +164,8 @@ module FIRM
         begin
           # initialize anchor registry
           Serializable::Aliasing.start_anchor_object_registry
+          # set custom (more compact) create_id
+          ::JSON.create_id = Serializable::JSON::CREATE_ID
           for_json = obj.respond_to?(:as_json) ? obj.as_json : obj
           if pretty
             if io || io.respond_to?(:write)
@@ -130,9 +189,11 @@ module FIRM
           Serializable::Aliasing.start_anchor_references
           # enable safe deserializing
           self.start_safe_deserialize
+          # set custom (more compact) create_id
+          ::JSON.create_id = Serializable::JSON::CREATE_ID
           ::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 +340,103 @@ 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)
+        json_new(object) do |instance|
+          values = object['v']
+          instance.members.each_with_index { |n, i| instance[n] = values[i] }
         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'])
-        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
-  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,
-    }
+if ::Object.const_defined?(:OpenStruct)
+  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(*)
+      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
 end
 

data/lib/firm/serializer/xml.rb

@@ -3,7 +3,11 @@
 
 
 require 'set'
-require 'ostruct'
+# from Ruby 3.5.0 OpenStruct will not be available by default anymore
+begin
+  require 'ostruct'
+rescue LoadError
+end
 require 'date'
 
 module FIRM
@@ -56,15 +60,52 @@ 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
-            def from_xml(xml)
+            def from_xml(_xml)
               raise Serializable::Exception, "Missing serialization method for #{klass} XML handler"
             end
           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 +127,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
@@ -143,7 +185,7 @@ module FIRM
             create_type_node(xml).add_child(Nokogiri::XML::CDATA.new(xml.document, value.name))
             xml
           end
-          def from_xml(xml)
+          def from_xml(_xml)
             # should never be called
             raise Serializable::Exception, 'Unsupported Class deserialization'
           end
@@ -179,16 +221,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 +283,34 @@ 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.each do |pair|
+                k, v = pair.elements
+                instance[Serializable::XML.from_xml(k)] = Serializable::XML.from_xml(v)
+              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 +426,35 @@ 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
-          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)
+        if ::Object.const_defined?(:OpenStruct)
+          define_xml_handler(::OpenStruct, aliasable: true) do
+            def to_xml(xml, value)
+              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
             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
+            def from_xml(xml)
+              create_from_xml(xml) do |instance|
+                xml.elements.each do |pair|
+                  k, v = pair.elements
+                  instance[Serializable::XML.from_xml(k)] = Serializable::XML.from_xml(v)
+                end
+              end
             end
           end
         end

data/lib/firm/serializer/yaml.rb

@@ -5,7 +5,11 @@
 require 'yaml'
 require 'date'
 require 'set'
-require 'ostruct'
+# from Ruby 3.5.0 OpenStruct will not be available by default anymore
+begin
+  require 'ostruct'
+rescue LoadError
+end
 
 module FIRM
 
@@ -15,7 +19,8 @@ module FIRM
 
       class << self
         def serializables
-          list = [::Date, ::DateTime, ::Range, ::Rational, ::Complex, ::Regexp, ::Struct, ::Symbol, ::Time, ::Set, ::OpenStruct]
+          list = [::Date, ::DateTime, ::Range, ::Rational, ::Complex, ::Regexp, ::Struct, ::Symbol, ::Time, ::Set]
+          list.push(::OpenStruct) if ::Object.const_defined?(:OpenStruct)
           list.push(::BigDecimal) if ::Object.const_defined?(:BigDecimal)
           list
         end

data/lib/firm/version.rb

@@ -4,6 +4,6 @@
 module FIRM
 
   # FIRM version
-  VERSION = "0.9.7"
+  VERSION = "1.0.0"
 
 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)
@@ -1040,4 +1084,62 @@ module SerializerTestMixin
     assert_equal(obj.symbol, obj_new.symbol)
   end
 
+  def run_test_threads
+    data = { list: ::Array.new(5, [ PropTest.new, Point.new(0, 0), Point.new(10, 10), Point.new(100, 400), Rect.new(20, 20, 40, 40) ]) }
+    results = []
+    threads = ::Array.new(10) do
+      Thread.new do
+        results << run_test_fibers(data)
+      end
+    end
+    threads.each { |t| t.join }
+    results
+  end
+
+  def run_test_fibers(data)
+    fibers = ::Array.new(100) do |_|
+      Fiber.new do
+        s = assert_nothing_raised { data.serialize }
+        Fiber.yield nil
+        new_data = assert_nothing_raised { FIRM.deserialize(s) }
+        Fiber.yield nil
+        assert_instance_of(::Hash, new_data)
+        assert_instance_of(::Array, new_data[:list])
+        assert_equal(5, new_data[:list].size)
+        assert_true(new_data[:list].all? { |e| e.is_a?(::Array) && e.size == 5 })
+        5.times { |i| assert_equal(data[:list].first[i], new_data[:list].first[i]) }
+        4.times do |n|
+          5.times { |i| assert_equal(new_data[:list].first[i].object_id, new_data[:list][n+1][i].object_id) }
+        end
+        new_data
+      end
+    end
+    results = []
+    begin
+      fibers = fibers.select do |fiber|
+        if (rc = fiber.resume)
+          results << rc
+          false
+        else
+          true
+        end
+      end
+    end until fibers.empty?
+    results
+  end
+
+  def test_threading
+
+    results = run_test_threads
+
+    set = results.inject(::Set.new) do |set, fiber_results|
+      fiber_results.inject(set) { |set_, fiber_result| set_.merge(fiber_result[:list][1].collect { |o| o.object_id }) }
+    end
+
+    # although we started with a single unique dataset, distributing that through 10 threads * 100 fibers
+    # to serialize and deserialize should result in 1000 distinct datasets with each 5 distinct data instances
+    assert_equal(5000, set.size)
+
+  end
+
 end

metadata

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