stackone_client 0.7.1 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 36f6cd376a3333cd2a97fbd3af65c81bae0e0b284a122944313fdda7f94c2a52
-  data.tar.gz: 1b754e36b768e3a645f9b90c11b6a54964a27ba9808e5d48ecb9cbcc3de28a7b
+  metadata.gz: a24c3c36630e3fc4726010e1d32ba74ed6fe68d38a1dc8a3023d32edcb1d7a4a
+  data.tar.gz: e0ef51e23fa194652b5818bcc3075deb2430187516f0247f575e8bca00d1a358
 SHA512:
-  metadata.gz: 6f07d5b77c1f76371ac6c082f761cde9f98d93ff767b105e47e128c897dd66ec3192ec7bdb3316c384f4bf1d99ab710163621096a63c1465401ca211a2506fe8
-  data.tar.gz: 35f06617b8981457b2153b8216888d243213fa62521867a09b0aac8a717c7a925b8777bf9971f5a754846bd558dd7ae46aae238ba69aed1c6518b874f3e98ec5
+  metadata.gz: 1cf485a55f0cb1bbbd080700055a03b2a8cc3d34e84ce5062bd622a7e55343241ae3b1e2cde415224b5747aa3fd56230e5cf72df442169b15dcbb856749eb939
+  data.tar.gz: 1e1fad3a695cda51b1d77f62673521f22349c234b79b1012c39f31667c94ea360c5efd95e06aea404a5596935b18a4190b7e18b15ad60f4e0ea26e9ecef1fe9d

data/lib/crystalline/metadata_fields.rb

@@ -38,7 +38,7 @@ module Crystalline
       end
 
       def unmarshal_single(field_type, value, decoder = nil)
-        if field_type.instance_of?(Class) && field_type < ::Crystalline::FieldAugmented
+        if field_type.instance_of?(Class) && field_type.include?(::Crystalline::MetadataFields)
           unmarshalled = field_type.from_dict(value)
           return unmarshalled
         elsif field_type.to_s == 'Object'
@@ -57,7 +57,7 @@ module Crystalline
         end
       end
 
-      sig { params(json_obj: T.any(String, T::Hash[Symbol, String])).returns(::Crystalline::FieldAugmented) }
+      sig { params(json_obj: T.any(String, T::Hash[Symbol, String])).returns(Object) }
       def from_json(json_obj)
         begin
           d = JSON.parse(json_obj)
@@ -67,7 +67,7 @@ module Crystalline
         from_dict(d)
       end
 
-      sig { params(d: T::Hash[Symbol, String]).returns(::Crystalline::FieldAugmented) }
+      sig { params(d: T::Hash[Symbol, String]).returns(Object) }
       def from_dict(d)
         to_build = new
 
@@ -80,6 +80,10 @@ module Crystalline
           key = "#{field.name}="
           lookup = field.metadata.fetch(:format_json, {}).fetch(:letter_case, nil).call
           value = d[lookup]
+          
+          # If field is not nilable, and the value is not in the dict, raise a KeyError
+          raise KeyError, "key #{lookup} not found in hash" if value.nil? && !T.nilable?(field.type)
+          # If field is nilable, and the value is not in the dict, just move to the next field
           next if value.nil?
 
           if T.arr? field_type
@@ -93,12 +97,41 @@ module Crystalline
             unmarshalled_hash = value.map { |k, v| [k, unmarshal_single(val_type, v)] }.to_h
             # rubocop:enable Style/HashTransformValues
             to_build.send(key, unmarshalled_hash)
+          elsif T.union? field_type
+            discriminator = field.metadata.fetch(:discriminator, nil)
+            if !discriminator.nil?
+              type_to_deserialize = value.fetch(discriminator)
+              type_to_deserialize = T.get_union_types(field_type).find { |t| t.name.split('::').last == type_to_deserialize }              
+              unmarshalled_val = Crystalline.unmarshal_json(value, type_to_deserialize)
+              to_build.send(key, unmarshalled_val)
+            else
+              union_types = T.get_union_types(field_type)
+              union_types = union_types.sort_by { |klass| Crystalline.non_nilable_attr_count(klass) }
+
+              union_types.each do |union_type|
+                begin
+                  unmarshalled_val = Crystalline.unmarshal_json(value, union_type)
+                  to_build.send(key, unmarshalled_val)
+                rescue TypeError
+                  next
+                rescue NoMethodError
+                  next
+                rescue KeyError
+                  next
+                end
+                break
+              end
+            end
+          elsif field_type.instance_of?(Class) && field_type.include?(::Crystalline::MetadataFields)
+            unmarshalled = Crystalline.unmarshal_json(value, field_type)
+            to_build.send(key, unmarshalled)
           else
             decoder = field.metadata.fetch(:format_json, {}).fetch(:decoder, nil)
             final_value = unmarshal_single(field_type, value, decoder)
             to_build.send(key, final_value)
           end
         end
+
         to_build
       end
     end
@@ -124,7 +157,7 @@ module Crystalline
     end
 
     def marshal_single(field)
-      if field.is_a? ::Crystalline::FieldAugmented
+      if field.class.include? ::Crystalline::MetadataFields
         field.to_dict
       else
         ::Crystalline.val_to_string(field, primitives: false)

data/lib/crystalline/t.rb

@@ -27,11 +27,17 @@ module T
   end
 
   def self.nilable?(t)
-    t.respond_to? :unwrap_nilable
+    # in sorbet all `T.any` types provide unwrap_nilable for some reason
+    # So, in order to make this check more robust, we check if the type responds to the `types` method, and if so, whether
+    # one of those types is NilClass.  For non-nilable unions, `types` will return a valid list that does not include NilClass
+    return false unless t.respond_to?(:unwrap_nilable)
+    return true unless t.respond_to?(:types)
+    t.types.map { |tt| simplify_type(tt) }.include?(NilClass)
   end
 
   def self.nilable_of(t)
-    if t.respond_to? :unwrap_nilable
+    
+    if nilable t
       return simplify_type t.unwrap_nilable
     end
     nil
@@ -48,6 +54,19 @@ module T
     t
   end
 
+    
+  def self.union?(t)
+    return false unless t.respond_to? :types
+    return false if t.types.any? { |tt| get_raw_type(tt) == TrueClass }
+    return false if t.types.length == 2 && t.types.any? { |tt| get_raw_type(tt) == NilClass }
+    t.types.length > 1
+  end
+
+  def self.get_union_types(t)
+    t.types.map { |tt| get_raw_type(tt) }
+  end
+
+
   def self.get_raw_type(t)
     if t.respond_to? :raw_type
       return t.raw_type

data/lib/crystalline/utils.rb

@@ -8,30 +8,21 @@ require 'sorbet-runtime'
 module Crystalline
   extend T::Sig
 
-  class FieldAugmented
-    include MetadataFields
-  end
-
   sig { params(complex: Object).returns(Object) }
-  def self.marshal_dict_complex(complex)
+  def self.to_dict(complex)
     if complex.is_a? Array
-      complex.map { |v| Crystalline.marshal_dict_complex(v) }
+      complex.map { |v| Crystalline.to_dict(v) }
     elsif complex.is_a? Hash
-      complex.transform_values { |v| Crystalline.marshal_dict_complex(v) }
-    elsif complex.is_a? Crystalline::FieldAugmented
+      complex.transform_values { |v| Crystalline.to_dict(v) }
+    elsif complex.respond_to?(:class) && complex.class.include?(::Crystalline::MetadataFields)
       complex.to_dict
     else
-      complex
+      val_to_string complex, primitives: false
     end
   end
 
-  def self.marshal_json_complex(complex)
-    JSON.dump(marshal_dict_complex(complex))
-  end
-
-  sig { params(data: Object, type: Object).returns(Object) }
-  def self.unmarshal_complex(data, type)
-    unmarshal_json(data, type)
+  def self.to_json(complex)
+    JSON.dump(to_dict(complex))
   end
 
   sig { params(data: Object, type: Object).returns(Object) }
@@ -39,12 +30,12 @@ module Crystalline
     if T.simplifiable? type
       type = T.simplify_type type
     end
-    if type.instance_of?(Class) && type < ::Crystalline::FieldAugmented
+    if type.instance_of?(Class) && type.include?(::Crystalline::MetadataFields)
       type.from_dict(data)
     elsif T.arr? type
-      data.map { |v| Crystalline.unmarshal_complex(v, T.arr_of(type)) }
+      data.map { |v| Crystalline.unmarshal_json(v, T.arr_of(type)) }
     elsif T.hash? type
-      data.transform_values { |v| Crystalline.unmarshal_complex(v, T.hash_of(type)) }
+      data.transform_values { |v| Crystalline.unmarshal_json(v, T.hash_of(type)) }
     else
       data
     end
@@ -62,4 +53,25 @@ module Crystalline
       val
     end
   end
+
+  sig { params(klass: T.any(Class, T::Types::TypedArray, T::Types::TypedHash)).returns(Integer) }
+  def self.non_nilable_attr_count(klass)
+    # somewhat sane sort ordering for Union deserialization.
+    # All Crystalline objects return the number of non-nilable fields
+    # All non-string primitives return 2
+    # All arrays and hashes return 1
+    # Strings return 0 (since any data can deserialize to a string, it should be our last attempt)
+    if klass.respond_to? :fields
+      return -1 * klass.fields.count do |field|
+        !T.nilable? field.type
+      end
+    else
+      if klass == String
+        return 0
+      elsif klass.is_a?(T::Types::TypedArray) || klass.is_a?(T::Types::TypedHash)
+        return 1
+      end
+      return 2
+    end
+  end
 end