yasl 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5c4491f82bad72b2981e4bbbf35001f30c95be844ebf4bc3c8f904e019d1e0cd
-  data.tar.gz: eb27247b7913c181fb409f8e07f8735d42bf1ac73e55fb6905ed9c931826449b
+  metadata.gz: ad1fc5f516869a322107b0bb86c96cf46ea789960e920a14fefbf4173294a52f
+  data.tar.gz: 1bacb014f802c4295ebaa4b4db5ca6a99120f1cd10ac4f469cf77da2457cfcaa
 SHA512:
-  metadata.gz: 199b1226c4a33b6bc4c1daa6ab04c34c7beecfc2c8eb82bdf27d7cc434b7c2537f1d0b806886f2f1dcd83df1a3a55d5af9be9a9b589d5cc7c06b39d508c01446
-  data.tar.gz: eb167b327b5041ff1087381d2f999c9d42f8942ff617ef850700a3be282732a017af0e9cdcfe04e0527979c531bfc9db31d250e64a82a8c46a91af5e9f5c36f6
+  metadata.gz: 97579e85d7bdd8e7d7feec52e0ce6567782c67466dffe103e95261d52628d1c0e3b4a1f40897d39401e5d05d2123ea22b7f4ff98f5134f76a46e32b5103a64a4
+  data.tar.gz: 5f7d04c0a0e821d88bf3cafdba3c497df92f1dd92d4f2e8c8222f5c903cbc866767666d10ee8b09d0fd84d05ad03105ba9fc7f0784e4521060a7aa671005bf77

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Change Log
 
+## 0.2.1
+
+- Make `YASL::UNSERIALIZABLE_DATA_TYPES` work with regular classes too
+- Make load `whitelist_classes` work with string class names
+- Make load `whitelist_classes` work with a single class or class name string
+- Support deserialization fallback of instance variables for Struct member values
+- Added missing hash method to optional pure Ruby Struct implementation
+- Fixed issue with requiring one arg minimum, using `select`, and using undefined `upcase?` in implementation of optional pure Ruby Struct
+
 ## 0.2.0
 
 - Support Boolean serialization in Opal (instead of TrueClass and FalseClass)

data/README.md

@@ -11,7 +11,7 @@ A pure Ruby serialization library that works across different Ruby implementatio
 ## Requirements
 
 - Portablity across different Ruby implementations, especially [Opal](https://opalrb.com/) in the web browser and [JRuby](https://www.jruby.org/).
-- Zero required configuration. Developers are too busy solving business domain problems to worry about low-level serialization details.
+- Zero required configuration. Developers are too busy solving business domain problems to worry about low-level serialization details (no mucking around `as_json` methods and serializer classes).
 - Silently ignore non-serializable objects (unlike Marshal), such as `Proc`, `Binding`, and `IO`.
 - No special performance requirements. No high throughput usage. Average Internet speeds.
 - Ensure system safety through secure deserialization.
@@ -26,7 +26,7 @@ Run:
 Or add to Gemfile:
 
 ```ruby
-gem 'yasl', '~> 0.2.0'
+gem 'yasl', '~> 0.2.1'
 ```
 
 And, run:
@@ -315,8 +315,6 @@ To avoid some JS and `keyword_init` issues with `Struct` in [Opal](https://opalr
 require 'yasl/ext/struct'
 ```
 
-This ensures successful serialization in YASL.
-
 ## Contributing
 
 -   Check out the latest master to make sure the feature hasn't been
@@ -333,6 +331,10 @@ This ensures successful serialization in YASL.
     is fine, but please isolate to its own commit so I can cherry-pick
     around it.
 
+## Software Process
+
+[Glimmer Process](https://github.com/AndyObtiva/glimmer/blob/master/PROCESS.md)
+
 ## TODO
 
 [TODO.md](TODO.md)

data/VERSION

@@ -1 +1 @@
-0.2.0
+0.2.1

data/lib/yasl/dumper.rb

@@ -36,14 +36,11 @@ module YASL
     end
     
     def dump_structure(object, for_classes: false)
+      return if unserializable?(object)
       structure = {}
       if top_level_class?(object, for_classes)
-        if object.name.nil?
-          return nil
-        else
-          structure[:_class] = object.name
-          add_to_classes(object)
-        end
+        structure[:_class] = object.name
+        add_to_classes(object)
       elsif YASL.json_basic_data_type?(object)
         structure = object
       elsif YASL.ruby_basic_data_type?(object)
@@ -73,22 +70,25 @@ module YASL
       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 class_ancestor_names_include?('Time')
-        object.to_datetime.marshal_dump
-      when class_ancestor_names_include?('Date')
-        object.marshal_dump
-      when class_ancestor_names_include?('Complex', 'Rational', 'Regexp', 'Symbol', 'BigDecimal')
-        object.to_s
-      when class_ancestor_names_include?('Set')
-        object.to_a.uniq.map {|element| dump_structure(element) unless unserializable?(element)}
-      when class_ancestor_names_include?('Range')
-        [object.begin, object.end, object.exclude_end?]
-      when class_ancestor_names_include?('Array')
-        object.map {|element| dump_structure(element) unless unserializable?(element)}
-      when class_ancestor_names_include?('Hash')
-        object.reject do |key, value|
+    def dump_ruby_basic_data_type_data(obj)
+      class_ancestors_names_include = lambda do |*class_names|
+        lambda { |obj| class_names.any? { |class_name| obj.class.ancestors.map(&:name).include?(class_name) } }
+      end
+      case obj
+      when class_ancestors_names_include['Time']
+        obj.to_datetime.marshal_dump
+      when class_ancestors_names_include['Date']
+        obj.marshal_dump
+      when class_ancestors_names_include['Complex', 'Rational', 'Regexp', 'Symbol', 'BigDecimal']
+        obj.to_s
+      when class_ancestors_names_include['Set']
+        obj.to_a.uniq.map {|element| dump_structure(element)}
+      when class_ancestors_names_include['Range']
+        [obj.begin, obj.end, obj.exclude_end?]
+      when class_ancestors_names_include['Array']
+        obj.map {|element| dump_structure(element)}
+      when class_ancestors_names_include['Hash']
+        obj.reject do |key, value|
           [key, value].detect {|element| unserializable?(element)}
         end.map do |pair|
           pair.map {|element| dump_structure(element)}
@@ -122,10 +122,7 @@ module YASL
     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[:_class_variables] = dump_class_variables_hash(object)
         structure.delete(:_class_variables) if structure[:_class_variables].empty?
       end
       structure
@@ -134,10 +131,7 @@ module YASL
     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[:_instance_variables] = dump_instance_variables_hash(object)
         structure.delete(:_instance_variables) if structure[:_instance_variables].empty?
       end
       structure
@@ -146,17 +140,14 @@ module YASL
     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[:_struct_member_values] = dump_struct_member_values_hash(object)
         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 = UNSERIALIZABLE_DATA_TYPES.detect {|class_name| value.class.ancestors.map(&:name).include?(class_name.to_s)}
       result = ((value.is_a?(Class) || value.is_a?(Module)) && value.name.nil?) if result.nil?
       result
     end
@@ -181,6 +172,27 @@ module YASL
       (object_class_array_index + 1) unless object_class_array_index.nil?
     end
     
+    def dump_class_variables_hash(object)
+      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
+    end
+    
+    def dump_instance_variables_hash(object)
+      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
+    end
+    
+    def dump_struct_member_values_hash(object)
+      object.members.reduce({}) do |member_values, member|
+        value = object[member]
+        value.nil? || unserializable?(value) ? member_values : member_values.merge(member => dump_structure(value))
+      end
+    end
+    
     def add_to_class_array(object)
       object_class = class_for(object)
       class_objects[object_class] ||= []
@@ -188,14 +200,6 @@ module YASL
       class_objects[object_class].index(object) + 1
     end
         
-    def class_ancestor_names_include?(*class_names)
-      lambda do |object|
-        class_names.reduce(false) do |result, class_name|
-          result || object.class.ancestors.map(&:name).include?(class_name)
-        end
-      end
-    end
-    
   end
   
 end

data/lib/yasl/ext/struct.rb

@@ -24,10 +24,8 @@ Object.send(:remove_const, :Struct) if Object.constants.include?(:Struct)
 # Optional re-implmentation of Struct in Pure Ruby (to get around JS issues in Opal Struct)
 class Struct
   class << self
-    def new(*class_name_and_or_attributes, keyword_init: false)
-      class_name = class_name_and_or_attributes.shift if class_name_and_or_attributes.first.to_s.chars.first.to_s.upcase?
-      attributes = class_name_and_or_attributes.compact.map(&:to_s).map(&:to_sym)
-      struct_class = Class.new do
+    CLASS_DEFINITION_FOR_ATTRIBUTES = lambda do |attributes, keyword_init|
+      lambda do |defined_class|
         members_array = attributes
         
         define_method(:members) do
@@ -72,16 +70,23 @@ class Struct
         end
         
         def select(&block)
-          @to_a.select(&block)
+          to_a.select(&block)
         end
         
         def eql?(other)
-          instance_of?(other.class) && members.all? { |key| __send__(key).public_send(:eql?, other.__send__(key)) }
+          instance_of?(other.class) &&
+            members.all? { |key| self[key].eql?(other[key]) }
         end
         
         def ==(other)
           other = coerce(other).first if respond_to?(:coerce, true)
-          other.kind_of?(self.class) && members.all? { |key| __send__(key).public_send(:==, other.__send__(key)) }
+          other.kind_of?(self.class) &&
+            members.all? { |key| self[key] == other[key] }
+        end
+        
+        def hash
+          self.class.hash +
+            to_a.each_with_index.map {|value, i| (i+1) * value.hash}.sum
         end
         
         if keyword_init
@@ -117,11 +122,27 @@ class Struct
           end
         end
       end
-      if class_name.nil?
-        struct_class
-      else
-        const_set(class_name, struct_class)
+    end
+    
+    ARG_VALIDATION = lambda do |class_name_or_attribute, *attributes|
+      class_name_or_attribute.nil? || attributes.any?(&:nil?)
+    end
+    
+    CLASS_NAME_EXTRACTION = lambda do |class_name_or_attribute|
+      if class_name_or_attribute.is_a?(String)
+        raise NameError, "identifier name needs to be constant" unless class_name_or_attribute.match(/^[A-Z]/)
+        class_name_or_attribute
       end
     end
+    
+    def new(class_name_or_attribute, *attributes, keyword_init: false)
+      raise 'Arguments cannot be nil' if ARG_VALIDATION[class_name_or_attribute, *attributes]
+      class_name = CLASS_NAME_EXTRACTION[class_name_or_attribute]
+      attributes.unshift(class_name_or_attribute) if class_name.nil?
+      attributes = attributes.map(&:to_sym)
+      struct_class = Class.new(&CLASS_DEFINITION_FOR_ATTRIBUTES[attributes, keyword_init])
+      class_name.nil? ? struct_class : const_set(class_name, struct_class)
+    end
+      
   end
 end

data/lib/yasl/loader.rb

@@ -46,15 +46,23 @@ module YASL
         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'} ))
+      elsif ruby_basic_data_type_structure?(structure)
         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'])
+      elsif load_non_basic_data_type_structure?(structure)
         load_non_basic_data_type_object(structure)
       end
     end
     
     private
     
+    def ruby_basic_data_type_structure?(structure)
+      (structure['_class'] && (structure['_data'] || !structure.keys.detect {|key| key.start_with?('_') && key != '_class'} ))
+    end
+    
+    def load_non_basic_data_type_structure?(structure)
+      structure['_class'] && (structure['_id'] || structure['_instance_variables'] || structure['_class_variables'] || structure['_struct_member_values'])
+    end
+    
     def load_non_basic_data_type_object(structure, for_classes: false)
       class_name = structure['_class']
       object_class = class_for(class_name)
@@ -62,20 +70,11 @@ module YASL
       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)
+        add_to_class_array(object, structure['_id'])
       end
+      structure['_class_variables'].to_a.each { |class_var, value| object.class_variable_set("@@#{class_var}".to_sym, load_structure(value)) }
+      structure['_instance_variables'].to_a.each { |instance_var, value| object.instance_variable_set("@#{instance_var}".to_sym, load_structure(value)) }
+      structure['_struct_member_values'].to_a.each { |member, value| load_struct_member_value(object, member, value) }
       object
     ensure
       object_class&.define_method(:initialize, object_class.instance_method(:initialize_without_yasl))
@@ -106,9 +105,7 @@ module YASL
       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
+        data.reduce({}) { |new_hash, pair| new_hash.merge(load_structure(pair.first) => load_structure(pair.last)) }
       end
     end
     
@@ -120,7 +117,7 @@ module YASL
       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)
+      if ![@whitelist_classes].compact.flatten.map(&:to_s).include?(object_class.to_s)
         raise "Class `#{class_name}` is not mentioned in `whitelist_classes` (e.g. `YASL.load(data, whitelist_classes: [#{class_name}])`)!"
       end
       object_class
@@ -133,10 +130,6 @@ module YASL
       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
@@ -148,11 +141,20 @@ module YASL
     end
     
     def add_to_class_array(object, class_object_id)
-      return if class_object_id.nil?
+      return if object.is_a?(Class) || object.is_a?(Module) || 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
             
+    def load_struct_member_value(object, member, value)
+      value = load_structure(value)
+      begin
+        object[member.to_sym] = value
+      rescue => e
+        puts "#{e.message}. Setting `@#{member}` instance variable instead."
+        object.instance_variable_set("@#{member}".to_sym, value)
+      end
+    end
   end
 end

data/yasl.gemspec

@@ -2,16 +2,16 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Juwelier::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
-# stub: yasl 0.2.0 ruby lib
+# stub: yasl 0.2.1 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "yasl".freeze
-  s.version = "0.2.0"
+  s.version = "0.2.1"
 
   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-31"
+  s.date = "2021-01-01"
   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 = [

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: yasl
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Andy Maleh
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-12-31 00:00:00.000000000 Z
+date: 2021-01-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec