yasl 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ede09b21493ce4855f31b11dace169aeb8a218d2f524c86758ca5643fcfe29e5
+  data.tar.gz: 9c34b64eea2244ba1673a2d643872832d694f07c6b644a413824607c9be6469b
+SHA512:
+  metadata.gz: 6afd16380e645f3b972508747b3e41c1254058e25f2f55ab7a872140b4f06aa566a165687c162777c6dcae470d4a1b91aea25a5e82d321ae720644a4b927b353
+  data.tar.gz: f976082dea29c4b130bb6394cc7f1d7a6d71bbef708b9312d61bad265a62e6e6519c12159a6667dcf50618475fdd5474542d959cb415e0984e7ed14355d4946e

data/CHANGELOG.md

@@ -0,0 +1,23 @@
+# Change Log
+
+## 0.1.0
+
+- Serialize JSON basic data types
+- Serialize Ruby basic data types
+- Serialize instance variables as JSON
+- Serialize class variables as JSON
+- Serialize struct member values as JSON
+- Serialize top-level class/module as JSON
+- Serialize cycles by using object ID references
+- Support `include_classes` option on dump
+- Silently ignore non-serializable objects like `Proc`, `Binding`, and `IO`.
+- Deserialize instance variables from JSON
+- Deserialize Class occurence in variables from JSON
+- Deserialize Module occurence in variables from JSON
+- Deserialize class variables from JSON
+- Deserialize Struct members from JSON
+- Deserialize cycles with object ID references
+- Deserialize top-level class/module from JSON
+- Support `include_classes` option on load
+- Raise error for deserialization not finding a class mentioned in the data
+- Require passing `whitelist_classes` to `YASL#load` or else raise error for illegal classes

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2020 Andy Maleh
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,333 @@
+# YASL - Yet Another Serialization Library
+[![Gem Version](https://badge.fury.io/rb/yasl.svg)](http://badge.fury.io/rb/yasl)
+[![Ruby](https://github.com/AndyObtiva/yasl/workflows/Ruby/badge.svg)](https://github.com/AndyObtiva/yasl/actions?query=workflow%3ARuby)
+[![Coverage Status](https://coveralls.io/repos/github/AndyObtiva/yasl/badge.svg?branch=master)](https://coveralls.io/github/AndyObtiva/yasl?branch=master)
+[![Maintainability](https://api.codeclimate.com/v1/badges/e8d043b8c78c801f0aa3/maintainability)](https://codeclimate.com/github/AndyObtiva/yasl/maintainability)
+
+A pure Ruby serialization library that works across different Ruby implementations like Opal and JRuby as an alternative to YAML/Marshal.
+
+## Requirements
+
+- Portablity across different Ruby implementations, especially Opal and JRuby.
+- Zero configuration. Developers are too busy solving business domain problems to worry about low-level serialization details.
+- Silently ignore non-serializable objects like `Proc`, `Binding`, and `IO`.
+- Support serializing classes and modules, not just object instances.
+- JSON encoding is good enough. No need for premature optimization.
+
+## Usage Instructions
+
+Run:
+
+`gem install yasl`
+
+Or add to Gemfile:
+
+```ruby
+gem 'yasl', '~> 0.1.0'
+```
+
+And, run:
+
+`bundle`
+
+Finally, require in Ruby code:
+
+```ruby
+require 'yasl'
+```
+
+### Serialize
+
+To serialize, use the `YASL#dump(object)` method.
+
+Keep in mind that `YASL::UNSERIALIZABLE_DATA_TYPES` classes are unserializable, and will serialize as `nil` (feel free to add more classes that you would like filtered out):
+
+`Proc`, `Binding`, `IO`, `File::Stat`, `Dir`, `BasicSocket`, `MatchData`, `Method`, `UnboundMethod`, `Thread`, `ThreadGroup`, `Continuation`
+
+Example (from [samples/dump_basic.rb](samples/dump_basic.rb)):
+
+```ruby
+require 'yasl'
+require 'date'
+
+class Car
+  attr_accessor :make,
+                :model,
+                :year,
+                :registration_time,
+                :registration_date,
+                :registration_date_time,
+                :complex_number,
+                :complex_polar_number,
+                :rational_number
+end
+
+car = Car.new
+car.make = 'Mitsubishi'
+car.model = 'Eclipse'
+car.year = '2002'
+car.registration_time = Time.new(2003, 10, 19, 10, 39, 37.092, '-03:00')
+car.registration_date = Date.new(2003, 10, 19)
+car.registration_date_time = DateTime.new(2003, 10, 19, 10, 39, 37.092, '-03:00')
+car.complex_number = Complex(2,37)
+car.complex_polar_number = Complex.polar(-23,28)
+car.rational_number = Rational(22/7)
+
+dump = YASL.dump(car)
+
+puts dump.inspect
+
+# => "{\"_class\":\"Car\",\"_id\":1,\"_instance_variables\":{\"make\":\"Mitsubishi\",\"model\":\"Eclipse\",\"year\":\"2002\",\"registration_time\":{\"_class\":\"Time\",\"_data\":[0,2452932,49177,\"12644383719423828125/137438953472\",-10800,2299161.0]},\"registration_date\":{\"_class\":\"Date\",\"_data\":[0,2452932,0,0,0,2299161.0]},\"registration_date_time\":{\"_class\":\"DateTime\",\"_data\":[0,2452932,49177,92000000,-10800,2299161.0]},\"complex_number\":{\"_class\":\"Complex\",\"_data\":\"2+37i\"},\"complex_polar_number\":{\"_class\":\"Complex\",\"_data\":\"22.13993492521203-6.230833131080988i\"},\"rational_number\":{\"_class\":\"Rational\",\"_data\":\"3/1\"}}}"
+```
+
+#### Cycles
+
+YASL automatically detects cycles when serializing bidirectional object references.
+
+Example (from [samples/dump_cycle.rb](samples/dump_cycle.rb)):
+
+```ruby
+require 'yasl'
+require 'date'
+require 'set'
+
+class Car
+  attr_accessor :make,
+                :model,
+                :year,
+                :owner
+end
+
+class Person
+  class << self
+    def reset_count!
+      @count = 0
+    end
+    
+    def increment_count!
+      @count ||= 0
+      @count += 1
+    end
+    
+    def reset_class_count!
+      @@class_count = 0
+    end
+    
+    def increment_class_count!
+      @@class_count = 0 unless defined?(@@class_count)
+      @@class_count += 1
+    end
+  end
+  
+  attr_accessor :name, :dob, :cars
+  
+  def initialize
+    self.class.increment_count!
+    self.class.increment_class_count!
+  end
+end
+
+person = Person.new
+person.name = 'Sean Hux'
+person.dob = Time.new(2017, 10, 17, 10, 3, 4)
+
+car = Car.new
+car.make = 'Mitsubishi'
+car.model = 'Eclipse'
+car.year = '2002'
+
+car.owner = person
+person.cars = [car]
+
+dump = YASL.dump(car)
+
+puts dump.inspect
+
+# => "{\"_class\":\"Car\",\"_id\":1,\"_instance_variables\":{\"make\":\"Mitsubishi\",\"model\":\"Eclipse\",\"owner\":{\"_class\":\"Person\",\"_id\":1,\"_instance_variables\":{\"cars\":{\"_class\":\"Array\",\"_data\":[{\"_class\":\"Car\",\"_id\":1}]},\"dob\":{\"_class\":\"Time\",\"_data\":[0,2458044,50584,0,-14400,2299161.0]},\"name\":\"Sean Hux\"}},\"year\":\"2002\"}}"
+```
+
+### Deserialize
+
+To deserialize, use the `YASL#load(data, whitelist_classes: [])` method. The value of `whitelist_classes` must mention all classes expected to appear in the serialized data to load. This is required to ensure software security by not allowing arbitrary unexpected classes to be deserialized.
+
+By default, only `YASL::RUBY_BASIC_DATA_TYPES` classes are deserialized:
+
+`NilClass`, `String`, `Integer`, `Float`, `TrueClass`, `FalseClass`, `Time`, `Date`, `Complex`, `Rational`, `Regexp`, `Symbol`, `Set`, `Range`, `Array`, `Hash`
+
+Example (from [samples/load_basic.rb](samples/load_basic.rb)):
+
+```ruby
+require 'yasl'
+require 'date'
+
+class Car
+  attr_accessor :make,
+                :model,
+                :year,
+                :registration_time,
+                :registration_date,
+                :registration_date_time,
+                :complex_number,
+                :complex_polar_number,
+                :rational_number
+end
+
+car = Car.new
+car.make = 'Mitsubishi'
+car.model = 'Eclipse'
+car.year = '2002'
+car.registration_time = Time.new(2003, 10, 19, 10, 39, 37.092, '-03:00')
+car.registration_date = Date.new(2003, 10, 19)
+car.registration_date_time = DateTime.new(2003, 10, 19, 10, 39, 37.092, '-03:00')
+car.complex_number = Complex(2,37)
+car.complex_polar_number = Complex.polar(-23,28)
+car.rational_number = Rational(22/7)
+
+dump = YASL.dump(car)
+car2 = YASL.load(dump, whitelist_classes: [Car])
+
+puts car2.make
+# => Mitsubishi
+
+puts car2.model
+# => Eclipse
+
+puts car2.year
+# => 2002
+
+puts car2.registration_time
+# => 2003-10-19 10:39:37 -0300
+
+puts car2.registration_date
+# => 2003-10-19
+
+puts car2.registration_date_time
+# => 2003-10-19T10:39:37-03:00
+
+puts car2.complex_number
+# => 2+37i
+
+puts car2.complex_polar_number
+# => 22.13993492521203-6.230833131080988i
+
+puts car2.rational_number
+# => 3/1
+
+```
+
+#### Cycles
+
+YASL automatically restores cycles when deserializing bidirectional object references.
+
+Example (from [samples/load_cycle.rb](samples/load_cycle.rb)):
+
+```ruby
+require 'yasl'
+require 'date'
+require 'set'
+
+class Car
+  attr_accessor :make,
+                :model,
+                :year,
+                :owner
+end
+
+class Person
+  class << self
+    def reset_count!
+      @count = 0
+    end
+    
+    def increment_count!
+      @count ||= 0
+      @count += 1
+    end
+    
+    def reset_class_count!
+      @@class_count = 0
+    end
+    
+    def increment_class_count!
+      @@class_count = 0 unless defined?(@@class_count)
+      @@class_count += 1
+    end
+  end
+  
+  attr_accessor :name, :dob, :cars
+  
+  def initialize
+    self.class.increment_count!
+    self.class.increment_class_count!
+  end
+end
+
+person = Person.new
+person.name = 'Sean Hux'
+person.dob = Time.new(2017, 10, 17, 10, 3, 4)
+
+car = Car.new
+car.make = 'Mitsubishi'
+car.model = 'Eclipse'
+car.year = '2002'
+
+car.owner = person
+person.cars = [car]
+
+dump = YASL.dump(car)
+car2 = YASL.load(dump, whitelist_classes: [Car, Person])
+
+puts car2.make
+# => Mitsubishi
+
+puts car2.model
+# => Eclipse
+
+puts car2.year
+# => 2002
+
+puts car2.owner
+# => #<Person:0x00007ffdf008dc20>
+
+puts car2.owner.name
+# => Sean Hux
+
+puts car2.owner.dob
+# => 2017-10-17 10:03:04 -0400
+
+puts car2.owner.cars.inspect
+# => [#<Car:0x00007ffdf008e120 @make="Mitsubishi", @model="Eclipse", @year="2002", @owner=#<Person:0x00007ffdf008dc20 @name="Sean Hux", @dob=2017-10-17 10:03:04 -0400, @cars=[...]>>]
+
+puts car2.inspect
+# => #<Car:0x00007ffdf008e120 @make="Mitsubishi", @model="Eclipse", @year="2002", @owner=#<Person:0x00007ffdf008dc20 @name="Sean Hux", @dob=2017-10-17 10:03:04 -0400, @cars=[#<Car:0x00007ffdf008e120 ...>]>>
+```
+
+## Contributing
+
+-   Check out the latest master to make sure the feature hasn't been
+    implemented or the bug hasn't been fixed yet.
+-   Check out the issue tracker to make sure someone already hasn't
+    requested it and/or contributed it.
+-   Fork the project.
+-   Start a feature/bugfix branch.
+-   Commit and push until you are happy with your contribution.
+-   Make sure to add tests for it. This is important so I don't break it
+    in a future version unintentionally.
+-   Please try not to mess with the Rakefile, version, or history. If
+    you want to have your own version, or is otherwise necessary, that
+    is fine, but please isolate to its own commit so I can cherry-pick
+    around it.
+
+## TODO
+
+[TODO.md](TODO.md)
+
+## Change Log
+
+[CHANGELOG.md](CHANGELOG.md)
+
+## Copyright
+
+[MIT](LICENSE.txt)
+
+Copyright (c) 2020 Andy Maleh.

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/yasl.rb

@@ -0,0 +1,59 @@
+# Copyright (c) 2020 Andy Maleh
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+require 'json'
+
+require 'yasl/dumper'
+require 'yasl/loader'
+
+module YASL
+  JSON_BASIC_DATA_TYPES = ['NilClass', 'String', 'Integer', 'Float', 'TrueClass', 'FalseClass']
+  RUBY_ONLY_BASIC_DATA_TYPES = ['Time', 'Date', 'Complex', 'Rational', 'Regexp', 'Symbol', 'Set', 'Range', 'Array', 'Hash']
+  RUBY_BASIC_DATA_TYPES = RUBY_ONLY_BASIC_DATA_TYPES + JSON_BASIC_DATA_TYPES
+  UNSERIALIZABLE_DATA_TYPES = ['Proc', 'Binding', 'IO', 'File::Stat', 'Dir', 'BasicSocket', 'MatchData', 'Method', 'UnboundMethod', 'Thread', 'ThreadGroup', 'Continuation']
+  
+  class << self
+    def dump(object, include_classes: false)
+      JSON.dump(Dumper.new(object).dump(include_classes: include_classes))
+    end
+    
+    def load(data, include_classes: false, whitelist_classes: [])
+      Loader.new(JSON.load(data), whitelist_classes: whitelist_classes).load(include_classes: include_classes)
+    end
+    
+    def json_basic_data_type?(object)
+      type_in?(object, JSON_BASIC_DATA_TYPES)
+    end
+    
+    def ruby_basic_data_type?(object)
+      type_in?(object, RUBY_BASIC_DATA_TYPES)
+    end
+    
+    private
+    
+    def type_in?(object, types)
+      types.reduce(false) do |result, class_name|
+        result || object.class.ancestors.map(&:name).include?(class_name)
+      end
+    end
+    
+  end
+end

data/lib/yasl/dumper.rb

@@ -0,0 +1,193 @@
+# Copyright (c) 2020 Andy Maleh
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+module YASL
+  class Dumper
+    attr_reader :object, :classes, :class_objects
+    
+    def initialize(object)
+      @object = object
+      @classes = []
+      @class_objects = {}
+    end
+    
+    def dump(include_classes: false)
+      structure = dump_structure(object)
+      structure.merge!(dump_classes_structure) if include_classes && structure.is_a?(Hash)
+      structure
+    end
+    
+    def dump_structure(object, for_classes: false)
+      structure = {}
+      if top_level_class?(object, for_classes)
+        if object.name.nil?
+          return nil
+        else
+          structure[:_class] = object.name
+          add_to_classes(object)
+        end
+      elsif YASL.json_basic_data_type?(object)
+        structure = object
+      elsif YASL.ruby_basic_data_type?(object)
+        structure[:_class] = object.class.name
+        structure[:_data] = dump_ruby_basic_data_type_data(object)
+      else
+        structure.merge!(dump_non_basic_data_type_structure(object))
+      end
+      structure
+    end
+    
+    def dump_classes_structure
+      structure = {}
+      structure[:_classes] ||= []
+      @original_classes = []
+      while classes.size > @original_classes.size
+        diff = (classes - @original_classes)
+        @original_classes = classes.clone
+        diff.each { |klass| structure[:_classes] << dump_class_structure(klass) }
+      end
+      structure[:_classes] = structure[:_classes].compact
+      structure.delete(:_classes) if structure[:_classes].empty?
+      structure
+    end
+    
+    def dump_class_structure(klass)
+      dump_structure(klass, for_classes: true) unless klass.class_variables.empty? && klass.instance_variables.empty?
+    end
+    
+    def dump_ruby_basic_data_type_data(object)
+      case object
+      when Time
+        object.to_datetime.marshal_dump
+      when Date
+        object.marshal_dump
+      when Complex, Rational, Regexp, Symbol
+        object.to_s
+      when Set
+        object.to_a.uniq.map {|element| dump_structure(element) unless unserializable?(element)}
+      when Range
+        [object.begin, object.end, object.exclude_end?]
+      when Array
+        object.map {|element| dump_structure(element) unless unserializable?(element)}
+      when Hash
+        object.reject do |key, value|
+          [key, value].detect {|element| unserializable?(element)}
+        end.map do |pair|
+          pair.map {|element| dump_structure(element)}
+        end
+      end
+    end
+    
+    def dump_non_basic_data_type_structure(object)
+      structure = {}
+      klass = class_for(object)
+      add_to_classes(klass)
+      structure[:_class] = klass.name
+      the_class_object_id = class_object_id(object)
+      if the_class_object_id.nil?
+        structure.merge!(dump_new_non_basic_data_type_structure(object))
+      else
+        structure[:_id] = the_class_object_id
+      end
+      structure
+    end
+    
+    def dump_new_non_basic_data_type_structure(object)
+      structure = {}
+      structure[:_id] = add_to_class_array(object) unless object.is_a?(Class) || object.is_a?(Module)
+      structure.merge!(dump_class_variables(object))
+      structure.merge!(dump_instance_variables(object))
+      structure.merge!(dump_struct_member_values(object))
+      structure
+    end
+    
+    def dump_class_variables(object)
+      structure = {}
+      if object.respond_to?(:class_variables) && !object.class_variables.empty?
+        structure[:_class_variables] = object.class_variables.reduce({}) do |class_vars, var|
+          value = object.class_variable_get(var)
+          unserializable?(value) ? class_vars : class_vars.merge(var.to_s.sub('@@', '') => dump_structure(value))
+        end
+        structure.delete(:_class_variables) if structure[:_class_variables].empty?
+      end
+      structure
+    end
+    
+    def dump_instance_variables(object)
+      structure = {}
+      if !object.instance_variables.empty?
+        structure[:_instance_variables] = object.instance_variables.sort.reduce({}) do |instance_vars, var|
+          value = object.instance_variable_get(var)
+          unserializable?(value) ? instance_vars : instance_vars.merge(var.to_s.sub('@', '') => dump_structure(value))
+        end
+        structure.delete(:_instance_variables) if structure[:_instance_variables].empty?
+      end
+      structure
+    end
+        
+    def dump_struct_member_values(object)
+      structure = {}
+      if object.is_a?(Struct)
+        structure[:_struct_member_values] = object.members.reduce({}) do |member_values, member|
+          value = object[member]
+          value.nil? || unserializable?(value) ? member_values : member_values.merge(member => dump_structure(value))
+        end
+        structure.delete(:_struct_member_values) if structure[:_struct_member_values].empty?
+      end
+      structure
+    end
+    
+    def unserializable?(value)
+      result = UNSERIALIZABLE_DATA_TYPES.detect {|class_name| value.class.ancestors.map(&:name).include?(class_name)}
+      result = ((value.is_a?(Class) || value.is_a?(Module)) && value.name.nil?) if result.nil?
+      result
+    end
+        
+    private
+    
+    def top_level_class?(object, for_classes)
+      (object.is_a?(Class) || object.is_a?(Module)) && !for_classes
+    end
+    
+    def class_for(object)
+      object.is_a?(Class) || object.is_a?(Module) ? object : object.class
+    end
+    
+    def add_to_classes(object)
+      classes << object unless classes.include?(object)
+    end
+    
+    def class_object_id(object)
+      object_class_array = class_objects[class_for(object)]
+      object_class_array_index = object_class_array&.index(object)
+      (object_class_array_index + 1) unless object_class_array_index.nil?
+    end
+    
+    def add_to_class_array(object)
+      object_class = class_for(object)
+      class_objects[object_class] ||= []
+      class_objects[object_class] << object unless class_objects[object_class].include?(object)
+      class_objects[object_class].index(object) + 1
+    end
+        
+  end
+  
+end

data/lib/yasl/loader.rb

@@ -0,0 +1,156 @@
+# Copyright (c) 2020 Andy Maleh
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+module YASL
+  class Loader
+    attr_reader :structure, :whitelist_classes, :class_objects
+    
+    def initialize(structure, whitelist_classes: [])
+      @structure = structure
+      @whitelist_classes = whitelist_classes
+      @class_objects = {}
+    end
+  
+    def load(include_classes: false)
+      load_structure(structure).tap do
+        load_classes_structure if include_classes
+      end
+    end
+    
+    def load_classes_structure
+      structure['_classes'].to_a.each do |class_structure|
+        load_non_basic_data_type_object(class_structure, for_classes: true)
+      end
+    end
+    
+    def load_structure(structure, for_classes: false)
+      if top_level_class?(structure)
+        class_for(structure['_class'])
+      elsif YASL.json_basic_data_type?(structure) && !(structure.is_a?(String) && structure.start_with?('_'))
+        structure
+      elsif (structure['_class'] && (structure['_data'] || !structure.keys.detect {|key| key.start_with?('_') && key != '_class'} ))
+        load_ruby_basic_data_type_object(structure['_class'], structure['_data'])
+      elsif structure['_class'] && (structure['_id'] || structure['_instance_variables'] || structure['_class_variables'] || structure['_struct_member_values'])
+        load_non_basic_data_type_object(structure)
+      end
+    end
+    
+    private
+    
+    def load_non_basic_data_type_object(structure, for_classes: false)
+      class_name = structure['_class']
+      object_class = class_for(class_name)
+      object_class.alias_method(:initialize_without_yasl, :initialize)
+      object = object_for_id(object_class, structure['_id'])
+      if object.nil?
+        object = for_classes ? object_class : object_class.new
+        add_to_class_array(object, structure['_id']) if !object.is_a?(Class) && !object.is_a?(Module)
+      end
+      structure['_instance_variables'].to_a.each do |instance_var, value|
+        value = load_structure(value)
+        object.instance_variable_set("@#{instance_var}".to_sym, value)
+      end
+      structure['_struct_member_values'].to_a.each do |member, value|
+        value = load_structure(value)
+        object[member.to_sym] = value
+      end
+      structure['_class_variables'].to_a.each do |class_var, value|
+        value = load_structure(value)
+        object.class_variable_set("@@#{class_var}".to_sym, value)
+      end
+      object
+    ensure
+      object_class&.define_method(:initialize, object_class.instance_method(:initialize_without_yasl))
+    end
+    
+    def load_ruby_basic_data_type_object(class_name, data)
+      case class_name
+      when 'Time'
+        DateTime.new.marshal_load(data.map(&:to_r)).to_time
+      when 'Date'
+        Date.new.marshal_load(data.map(&:to_r))
+      when 'DateTime'
+        DateTime.new.marshal_load(data.map(&:to_r))
+      when 'Complex'
+        Complex(data)
+      when 'Rational'
+        Rational(data)
+      when 'Regexp'
+        Regexp.new(data)
+      when 'Symbol'
+        data.to_sym
+      when 'Set'
+        Set.new(data.map {|element| load_structure(element)})
+      when 'Range'
+        Range.new(*data)
+      when 'Array'
+        data.map {|element| load_structure(element)}
+      when 'Hash'
+        data.reduce({}) do |new_hash, pair|
+          new_hash.merge(load_structure(pair.first) => load_structure(pair.last))
+        end
+      end
+    end
+    
+    private
+    
+    def class_for(class_name)
+      class_name_components = class_name.to_s.split('::')
+      current_class = Object
+      object_class = class_name_components.reduce(Object) do |result_class, class_name|
+        result_class.const_get(class_name)
+      end
+      if !@whitelist_classes.include?(object_class)
+        raise "Class `#{class_name}` is not mentioned in `whitelist_classes` (e.g. `YASL.load(data, whitelist_classes: [#{class_name}])`)!"
+      end
+      object_class
+    rescue NameError
+      # TODO materialize a class matching the non-existing class
+      raise "Class `#{class_name}` does not exist! YASL expects the same classes used for serialization to exist during deserialization."
+    end
+    
+    def top_level_class?(structure)
+      structure && structure.is_a?(Hash) && structure['_class'] && structure['_id'].nil? && structure['_instance_variables'].nil? && structure['_class_variables'].nil? && structure['_struct_member_values'].nil? && structure['_data'].nil?
+    end
+    
+    def add_to_classes(object)
+      classes << object unless classes.include?(object)
+    end
+    
+    def class_objects_for(object_class)
+      class_objects[object_class] ||= {}
+    end
+    
+    def object_for_id(object_class, class_object_id)
+      return if class_object_id.nil?
+      return unless (object_class.is_a?(Class) || object_class.is_a?(Module))
+      class_objects_for(object_class)[class_object_id.to_i]
+    end
+    
+    def add_to_class_array(object, class_object_id)
+      return if class_object_id.nil?
+      object_class = object.class
+      found_object = object_for_id(object_class, class_object_id)
+      class_objects_for(object_class)[class_object_id.to_i] = object unless found_object
+    end
+            
+  end
+end

data/yasl.gemspec

@@ -0,0 +1,59 @@
+# Generated by juwelier
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Juwelier::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+# stub: yasl 0.1.0 ruby lib
+
+Gem::Specification.new do |s|
+  s.name = "yasl".freeze
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
+  s.require_paths = ["lib".freeze]
+  s.authors = ["Andy Maleh".freeze]
+  s.date = "2020-12-30"
+  s.description = "A pure Ruby serialization library that works across different Ruby implementations like Opal and JRuby as an alternative to YAML/Marshal.".freeze
+  s.email = "andy.am@gmail.com".freeze
+  s.extra_rdoc_files = [
+    "CHANGELOG.md",
+    "LICENSE.txt",
+    "README.md"
+  ]
+  s.files = [
+    "CHANGELOG.md",
+    "LICENSE.txt",
+    "README.md",
+    "VERSION",
+    "lib/yasl.rb",
+    "lib/yasl/dumper.rb",
+    "lib/yasl/loader.rb",
+    "yasl.gemspec"
+  ]
+  s.homepage = "http://github.com/AndyObtiva/yasl".freeze
+  s.licenses = ["MIT".freeze]
+  s.rubygems_version = "3.1.4".freeze
+  s.summary = "A pure Ruby serialization library that works across different Ruby implementations like Opal and JRuby as an alternative to YAML/Marshal.".freeze
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 4
+  end
+
+  if s.respond_to? :add_runtime_dependency then
+    s.add_development_dependency(%q<rspec>.freeze, ["~> 3.5.0"])
+    s.add_development_dependency(%q<bundler>.freeze, [">= 1.0"])
+    s.add_development_dependency(%q<juwelier>.freeze, ["~> 2.1.0"])
+    s.add_development_dependency(%q<simplecov>.freeze, ["~> 0.16.0"])
+    s.add_development_dependency(%q<coveralls>.freeze, [">= 0"])
+    s.add_development_dependency(%q<puts_debuggerer>.freeze, [">= 0"])
+    s.add_development_dependency(%q<equalizer>.freeze, [">= 0"])
+  else
+    s.add_dependency(%q<rspec>.freeze, ["~> 3.5.0"])
+    s.add_dependency(%q<bundler>.freeze, [">= 1.0"])
+    s.add_dependency(%q<juwelier>.freeze, ["~> 2.1.0"])
+    s.add_dependency(%q<simplecov>.freeze, ["~> 0.16.0"])
+    s.add_dependency(%q<coveralls>.freeze, [">= 0"])
+    s.add_dependency(%q<puts_debuggerer>.freeze, [">= 0"])
+    s.add_dependency(%q<equalizer>.freeze, [">= 0"])
+  end
+end
+

metadata

@@ -0,0 +1,153 @@
+--- !ruby/object:Gem::Specification
+name: yasl
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Andy Maleh
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2020-12-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.5.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.5.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: juwelier
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.16.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.16.0
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: puts_debuggerer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: equalizer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A pure Ruby serialization library that works across different Ruby implementations
+  like Opal and JRuby as an alternative to YAML/Marshal.
+email: andy.am@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- VERSION
+- lib/yasl.rb
+- lib/yasl/dumper.rb
+- lib/yasl/loader.rb
+- yasl.gemspec
+homepage: http://github.com/AndyObtiva/yasl
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.4
+signing_key:
+specification_version: 4
+summary: A pure Ruby serialization library that works across different Ruby implementations
+  like Opal and JRuby as an alternative to YAML/Marshal.
+test_files: []