wxruby3-shapes 0.9.0.pre.beta.3

data/lib/wx/shapes/serializer/json.rb

@@ -0,0 +1,258 @@
+# Wx::SF::Serializer - shape serializer module
+# Copyright (c) M.J.N. Corino, The Netherlands
+
+require 'json'
+require 'json/add/core'
+require 'json/add/set'
+require 'json/add/ostruct'
+
+module Wx::SF
+
+  module Serializable
+
+    module JSON
+
+      # Derived Hash class to use for deserialized JSON object data which
+      # supports using Symbol keys.
+      class ObjectHash < ::Hash
+        # Returns the object associated with given key.
+        # @param [String,Symbol] key key value
+        # @return [Object] associated object
+        # @see ::Hash#[]
+        def [](key)
+          super(key.to_s)
+        end
+        # Returns true if the given key exists in self otherwise false.
+        # @param [String,Symbol] key key value
+        # @return [Boolean]
+        # @see ::Hash#include?
+        def include?(key)
+          super(key.to_s)
+        end
+        alias member? include?
+        alias has_key? include?
+        alias key? include?
+      end
+
+      # Mixin module to patch hash objects during JSON serialization.
+      # By default JSON will not consider hash keys for custom serialization
+      # but assumes any key should be serialized as it's string representation.
+      # This is restrictive but compatible with "pure" JSON object notation.
+      # JSON however also does not (correctly?) honour overriding Hash#to_json to
+      # customize serialization of Hash-es which seems too restrictive (stupid?)
+      # as using more complex custom keys for Hash-es instead of String/Symbol-s
+      # is not that uncommon.
+      # This mixin is used to "patch" Hash **instances** through #extend.
+      module HashInstancePatch
+        def patch_nested_hashes(obj)
+          case obj
+          when ::Hash
+            obj.extend(HashInstancePatch) unless obj.singleton_class.include?(HashInstancePatch)
+            obj.each_pair { |k, v| patch_nested_hashes(k); patch_nested_hashes(v) }
+          when ::Array
+            obj.each { |e| patch_nested_hashes(e) }
+          end
+          obj
+        end
+        private :patch_nested_hashes
+
+        # Returns JSON representation (String) of self.
+        # Hash data which is part of object properties/members being serialized
+        # (including any nested Hash-es) will be patched with HashInstancePatch.
+        # Patched Hash instances will be serialized as JSON-creatable objects
+        # (so provided with a JSON#create_id) with the hash contents represented
+        # as an array of key/value pairs (arrays).
+        # @param [Array<Object>] args any args passed by the JSON generator
+        # @return [String] JSON representation
+        def to_json(*args)
+          if self.has_key?(::JSON.create_id)
+            if self.has_key?('data')
+              if (data = self['data']).is_a?(::Hash)
+                data.each_value { |v| patch_nested_hashes(v) }
+              end
+            else # core class extensions use different data members for property serialization
+              self.each_value { |v| patch_nested_hashes(v) }
+            end
+            super
+          else
+            {
+              ::JSON.create_id => self.class.name,
+              'data' => patch_nested_hashes(to_a)
+            }.to_json(*args)
+          end
+        end
+      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
+        end
+      end
+
+      class ::Hash
+        include Wx::SF::Serializable::JSON::HashInstancePatch
+        class << self
+          include Wx::SF::Serializable::JSON::HashClassPatch
+        end
+      end
+
+      class << self
+        def serializables
+          ::Set.new [::NilClass, ::TrueClass, ::FalseClass, ::Integer, ::Float, ::String, ::Array, ::Hash,
+                     ::Date, ::DateTime, ::Exception, ::Range, ::Regexp, ::Struct, ::Symbol, ::Time, ::Set, ::OpenStruct]
+        end
+
+        TLS_SAFE_DESERIALIZE_KEY = :wx_sf_json_safe_deserialize.freeze
+        private_constant :TLS_SAFE_DESERIALIZE_KEY
+
+        TLS_PARSE_STACK_KEY = :wx_sf_json_parse_stack.freeze
+        private_constant :TLS_PARSE_STACK_KEY
+
+        def safe_deserialize
+          ::Thread.current[TLS_SAFE_DESERIALIZE_KEY] ||= []
+        end
+        private :safe_deserialize
+
+        def start_safe_deserialize
+          safe_deserialize.push(true)
+        end
+
+        def end_safe_deserialize
+          safe_deserialize.pop
+        end
+
+        def parse_stack
+          ::Thread.current[TLS_PARSE_STACK_KEY] ||= []
+        end
+        private :parse_stack
+
+        def start_parse
+          parse_stack.push(safe_deserialize.pop)
+        end
+
+        def end_parse
+          unless (val = parse_stack.pop).nil?
+            safe_deserialize.push(val)
+          end
+        end
+
+        def safe_parsing?
+          !!parse_stack.last
+        end
+      end
+
+      def self.dump(obj, io=nil, pretty: false)
+        obj.extend(HashInstancePatch) if obj.is_a?(::Hash)
+        if pretty
+          if io || io.respond_to?(:write)
+            io.write(::JSON.pretty_generate(obj))
+            io
+          else
+            ::JSON.pretty_generate(obj)
+          end
+        else
+          ::JSON.dump(obj, io)
+        end
+      end
+
+      def self.load(source)
+        begin
+          # initialize ID restoration map
+          Serializable::ID.init_restoration_map
+          # enable safe deserializing
+          self.start_safe_deserialize
+          ::JSON.parse!(source,
+                        **{create_additions: true,
+                           object_class: Serializable::JSON::ObjectHash})
+        ensure
+          # reset safe deserializing
+          self.end_safe_deserialize
+          # reset ID restoration map
+          Serializable::ID.clear_restoration_map
+        end
+      end
+
+    end
+
+    # extend serialization class methods
+    module SerializeClassMethods
+
+      def json_create(object)
+        create_for_deserialize(data = object['data'])
+          .__send__(:from_serialized, data)
+      end
+
+    end
+
+    # extend instance serialization methods
+    module SerializeInstanceMethods
+
+      def to_json(*args)
+        {
+          ::JSON.create_id => self.class.name,
+          'data' => for_serialize(Hash.new)
+        }.to_json(*args)
+      end
+
+    end
+
+    class ID
+
+      def self.json_create(object)
+        create_for_deserialize(data = object['data'])
+      end
+
+      def to_json(*args)
+        {
+          ::JSON.create_id => self.class.name,
+          'data' => for_serialize(Hash.new)
+        }.to_json(*args)
+      end
+
+    end
+
+    register(Serializable.default_format, JSON)
+
+  end
+
+end
+
+module ::JSON
+  class << self
+
+    alias :pre_wxsf_parse! :parse!
+    def parse!(*args, **kwargs)
+      begin
+        # setup parsing stack for safe or normal deserializing
+        # the double bracketing provided from Wx::SF::Serializable::JSON#load and here
+        # makes sure to support both nested Wx::SF deserializing as well as nested
+        # hybrid deserializing (Wx::SF -> common JSON -> ...)
+        Wx::SF::Serializable::JSON.start_parse
+        pre_wxsf_parse!(*args, **kwargs)
+      ensure
+        # reset parsing stack
+        Wx::SF::Serializable::JSON.end_parse
+      end
+    end
+
+  end
+end
+
+class ::Class
+
+  # override this to be able to do safe deserializing
+  def json_creatable?
+    if Wx::SF::Serializable::JSON.safe_parsing?
+      return false unless Wx::SF::Serializable::JSON.serializables.include?(self) ||
+                          Wx::SF::Serializable.serializables.include?(self) ||
+                          ::Struct > self
+    end
+    respond_to?(:json_create)
+  end
+
+end

data/lib/wx/shapes/serializer/yaml.rb

@@ -0,0 +1,125 @@
+# Wx::SF::Serializer - shape serializer module
+# Copyright (c) M.J.N. Corino, The Netherlands
+
+require 'yaml'
+require 'set'
+require 'ostruct'
+
+module Wx::SF
+
+  module Serializable
+
+    module YAML
+
+      class << self
+        def serializables
+          [Date, DateTime, Exception, Range, Regexp, Struct, Symbol, Time, Set, OpenStruct]
+        end
+      end
+
+      module YamlSerializePatch
+
+        ALLOWED_ALIASES = [Serializable::ID, Wx::Pen, Wx::Colour, Wx::Brush, Wx::Enum, Wx::Rect, Wx::Point, Wx::RealPoint, Wx::Size]
+
+        if ::RUBY_VERSION >= '3.1.0'
+          def revive(klass, node)
+            if Wx::SF::Serializable > klass
+              s = register(node, klass.create_for_deserialize(data = revive_hash({}, node, true)))
+              init_with(s, data, node)
+            else
+              super
+            end
+          end
+        else
+          def revive(klass, node)
+            if Wx::SF::Serializable > klass
+              s = register(node, klass.create_for_deserialize(data = revive_hash({}, node)))
+              init_with(s, data, node)
+            else
+              super
+            end
+          end
+        end
+        def visit_Psych_Nodes_Alias o
+          rc = @st.fetch(o.anchor) { raise ::YAML::AnchorNotDefined, o.anchor }
+          # only allow Serializable::ID aliases
+          raise ::YAML::AliasesNotEnabled unless ALLOWED_ALIASES.any? { |klass| klass === rc }
+          rc
+        end
+      end
+
+      class RestrictedRelaxed < ::YAML::ClassLoader
+        def initialize(classes)
+          @classes = classes
+          @allow_struct = @classes.include?('Struct')
+          super()
+        end
+
+        private
+
+        def find(klassname)
+          if @classes.include?(klassname)
+            super
+          elsif @allow_struct && ::Struct > super
+            @cache[klassname]
+          else
+            raise ::YAML::DisallowedClass.new('load', klassname)
+          end
+        end
+      end
+
+      def self.dump(obj, io=nil, pretty: false)
+        ::YAML.dump(obj, io)
+      end
+
+      def self.load(source)
+        result = ::YAML.parse(source, filename: nil)
+        return nil unless result
+        begin
+          # initialize ID restoration map
+          Serializable::ID.init_restoration_map
+          allowed_classes =(YAML.serializables + Serializable.serializables.to_a).map(&:to_s)
+          class_loader = RestrictedRelaxed.new(allowed_classes)
+          scanner      = ::YAML::ScalarScanner.new(class_loader)
+          visitor = ::YAML::Visitors::NoAliasRuby.new(scanner, class_loader)
+          visitor.extend(YamlSerializePatch)
+          result = visitor.accept result
+        ensure
+          # reset ID restoration map
+          Serializable::ID.clear_restoration_map
+        end
+        result
+      end
+
+    end
+
+    # extend instance serialization methods
+    module SerializeInstanceMethods
+
+      def encode_with(coder)
+        for_serialize(coder)
+      end
+
+      def init_with(coder)
+        from_serialized(coder.map)
+      end
+
+    end
+
+    class ID
+
+      def encode_with(coder)
+        for_serialize(coder)
+      end
+
+      def init_with(_coder)
+        # noop
+      end
+
+    end
+
+    register(:yaml, YAML)
+
+  end
+
+end