zenaton 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f1385767c881e6ef34069a875ca988133b9904b28f1446ab14cf1104d928122a
-  data.tar.gz: 01f116af0dbd6ccfead4ccd2a5a02d8a059f2ae59702e370d88a2ca9ac635141
+  metadata.gz: db17bf2caf28d2e2c9f8c610e0c882f53543af959af846e63f25dc4b9cf71d88
+  data.tar.gz: 28ae921a4fcfd86ab11c726238db69350341190fae32e897dc1c518562baec64
 SHA512:
-  metadata.gz: b8510ccddad7b89fc23ffd13de253f1b40a1ba07b435adba23e3805f90518b42787bb73e832c34d449d43b81b92448c2c92ba48aaae766dec3f0997dffd60a9b
-  data.tar.gz: 759d4c154c3362e981f9665aa65da1d350bcea2d82742e0624d5180abd5d66ef876ec134c78fac9cca2b3c3ea6af34ac2714e39c31822b0f4e22f94fe203b39a
+  metadata.gz: 5974cd83124ff35a036dce13e4800095f2a3c37923a6c568b5315140f44fb62390858545403ed52873a29ff432b7e785ed20c80c29e5fe467b75274ae40745ac
+  data.tar.gz: 548fc102b9aa3861efa4cb538845589f02ab32baefabd7821201cdb2992b01cbb07b90a75294a04032c036a70db2d06477880bb7a6f579ec228574607d893abe

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    zenaton (0.1.1)
+    zenaton (0.2.0)
       activesupport
       httparty
       tzinfo-data

data/lib/zenaton/services/serializer.rb

@@ -28,14 +28,10 @@ module Zenaton
         @decoded = []
         value = {}
         raise ArgumentError, 'Procs cannot be serialized' if data.is_a?(Proc)
-        if data.is_a?(Array)
-          value[KEY_ARRAY] = encode_array(data)
-        elsif data.is_a?(Hash)
-          value[KEY_ARRAY] = encode_hash(data)
-        elsif basic_type?(data)
+        if basic_type?(data)
           value[KEY_DATA] = data
         else
-          value[KEY_OBJECT] = encode_object(data)
+          value[KEY_OBJECT] = encode_to_store(data)
         end
         value[KEY_STORE] = @encoded
         value.to_json
@@ -53,17 +49,13 @@ module Zenaton
           return decode_enumerable(parsed_json[KEY_ARRAY])
         when KEY_OBJECT
           id = parsed_json[KEY_OBJECT][ID_PREFIX.length..-1].to_i
-          return decode_object(id, @encoded[id])
+          return decode_from_store(id, @encoded[id])
         end
       end
       # rubocop:enable Metrics/MethodLength
 
       private
 
-      def array_type?(data)
-        data.is_a?(Array) || data.is_a?(Hash)
-      end
-
       def basic_type?(data)
         data.is_a?(String) \
           || data.is_a?(Integer) \
@@ -73,82 +65,144 @@ module Zenaton
           || data.nil?
       end
 
-      def encode_array(array)
-        array.map { |elem| encode_value(elem) }
-      end
-
-      def encode_hash(hash)
-        transform_values(hash) { |value| encode_value(value) }
-      end
-
       def encode_value(value)
         raise ArgumentError, 'Procs cannot be serialized' if value.is_a?(Proc)
-        if value.is_a?(Array)
-          encode_array(value)
-        elsif value.is_a?(Hash)
-          encode_hash(value)
-        elsif basic_type?(value)
+        if basic_type?(value)
           value
         else
-          encode_object(value)
+          encode_to_store(value)
         end
       end
 
-      def encode_object(object)
+      def encode_to_store(object)
         id = @decoded.index(object)
-        unless id
-          id = @decoded.length
-          @decoded[id] = object
-          @encoded[id] = {
-            KEY_OBJECT_NAME => object.class.name,
-            KEY_OBJECT_PROPERTIES => encode_hash(@properties.from(object))
-          }
-        end
+        return store_id(id) if id
+        store_and_encode(object)
+      end
+
+      def store_and_encode(object)
+        id = @decoded.length
+        @decoded[id] = object
+        @encoded[id] = encoded_object_by_type(object)
+        store_id(id)
+      end
+
+      def store_id(id)
         "#{ID_PREFIX}#{id}"
       end
 
-      def object_id?(string)
-        string.is_a?(String) \
-          && string.start_with?(ID_PREFIX) \
-          && string[ID_PREFIX.length..-1].to_i <= @encoded.length
+      def encoded_object_by_type(object)
+        case object
+        when Array
+          encode_array(object)
+        when Hash
+          encode_hash(object)
+        else
+          encode_object(object)
+        end
       end
 
-      def decode_enumerable(enumerable)
-        return decode_array(enumerable) if enumerable.is_a?(Array)
-        return decode_hash(enumerable) if enumerable.is_a?(Hash)
-        raise ArgumentError, 'Unknown type'
+      def encode_object(object)
+        {
+          KEY_OBJECT_NAME => object.class.name,
+          KEY_OBJECT_PROPERTIES => encode_legacy_hash(@properties.from(object))
+        }
+      end
+
+      def encode_array(array)
+        {
+          KEY_ARRAY => array.map(&method(:encode_value))
+        }
+      end
+
+      def encode_hash(hash)
+        {
+          KEY_ARRAY => transform_values(hash, &method(:encode_value))
+        }
       end
 
-      def decode_array(array)
-        array.map { |elem| decode_element(elem) }
+      def encode_legacy_hash(hash)
+        transform_values(hash, &method(:encode_value))
       end
 
-      def decode_hash(hash)
-        transform_values(hash) { |value| decode_element(value) }
+      def store_id?(string)
+        string.is_a?(String) \
+          && string.start_with?(ID_PREFIX) \
+          && string[ID_PREFIX.length..-1].to_i <= @encoded.length
       end
 
       # rubocop:disable Metrics/MethodLength
       def decode_element(value)
-        if object_id?(value)
+        if store_id?(value)
           id = value[ID_PREFIX.length..-1].to_i
           encoded = @encoded[id]
-          decode_object(id, encoded) if encoded.is_a?(Hash)
+          decode_from_store(id, encoded)
         elsif value.is_a?(Array)
-          decode_array(value)
+          decode_legacy_array(value)
         elsif value.is_a?(Hash)
-          decode_hash(value)
+          decode_legacy_hash(value)
         else
           value
         end
       end
       # rubocop:enable Metrics/MethodLength
 
-      def decode_object(id, encoded_object)
+      def decode_enumerable(enumerable)
+        return decode_legacy_array(enumerable) if enumerable.is_a?(Array)
+        return decode_legacy_hash(enumerable) if enumerable.is_a?(Hash)
+        raise ArgumentError, 'Unknown type'
+      end
+
+      def decode_legacy_array(array)
+        array.map(&method(:decode_element))
+      end
+
+      def decode_legacy_hash(hash)
+        transform_values(hash, &method(:decode_element))
+      end
+
+      def decode_array(id, array)
+        @decoded[id] = object = []
+        object.concat(array.map(&method(:decode_element)))
+      end
+
+      def decode_hash(id, hash)
+        @decoded[id] = {}
+        hash.each do |key, value|
+          @decoded[id][key] = decode_element(value)
+        end
+        @decoded[id]
+      end
+
+      def decode_from_store(id, encoded)
         decoded = @decoded[id]
         return decoded if decoded
+        case encoded[KEY_ARRAY]
+        when Array
+          decode_array(id, encoded[KEY_ARRAY])
+        when Hash
+          decode_hash(id, encoded[KEY_ARRAY])
+        else
+          decode_object(id, encoded)
+        end
+      end
+
+      def decoded_object_by_type(id, encoded)
+        enumerable = encoded[KEY_ARRAY]
+        case enumerable
+        when Array
+          decode_array(id, enumerable)
+        when Hash
+          decode_hash(id, enumerable)
+        else
+          decode_object(id, encoded)
+        end
+      end
+
+      def decode_object(id, encoded_object)
         object = @properties.blank_instance(encoded_object[KEY_OBJECT_NAME])
         @decoded[id] = object
-        properties = decode_hash(encoded_object[KEY_OBJECT_PROPERTIES])
+        properties = decode_legacy_hash(encoded_object[KEY_OBJECT_PROPERTIES])
         @properties.set(object, properties)
       end
 

data/lib/zenaton/version.rb

@@ -2,5 +2,5 @@
 
 module Zenaton
   # This gem's current version
-  VERSION = '0.1.1'
+  VERSION = '0.2.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: zenaton
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Zenaton
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-08-03 00:00:00.000000000 Z
+date: 2018-08-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport