microsoft_kiota_serialization_json 0.25.1 → 0.25.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bc53abc9b62b335f774180b3ba73406a9cc4397f7b0c24f64c53ac5099f3c85a
-  data.tar.gz: 4adf9b1c7bf9cc85f352a2fccdb24325b6d9bbca3e3f1a63d9bd013992f511e2
+  metadata.gz: dbf09cb43c152fe34b14248939ea8fff9bbc8006a35cceda4eee7d0692e5db8a
+  data.tar.gz: 68d268bd347d202193fb12278ec6e8e6e70bd9846b9e8dd60a64076dc3c4e01d
 SHA512:
-  metadata.gz: a0b7147ac4e3eb37e848245a76a2e0eab689682ca8271e26c02dcd3a2047d10f8c8f824db357a69f1bc5335f48f63cb7b2f17e1ce5f7716ba704c2ccc16d72f5
-  data.tar.gz: aa223417edd43f3e84beb877d5faa085eeb55dff6517d1349292d89a1e20ac5eb94c0b90470508fca63d55d7968b6c064d3a1ee932fa61dfd7088ace5a4c5dad
+  metadata.gz: 03ccf61996e27134c2029e60cfc691b5fdfa0ad6aab9293ddc788e5d46965089a6c9c7af734cb906094e52fd601b238efe1190ace07e5837b2c7481f49e62e89
+  data.tar.gz: 50028e6d47369aebadb04e15393778ff5d26b7e39dbca9f2c7c53abba8efcb64511eb817793b5ef644aaf252d5da47747adbb0f3290d4e9cb4d383c8267e4b73

data/lib/microsoft_kiota_serialization_json/json_parse_node_factory.rb

@@ -12,12 +12,9 @@ module MicrosoftKiotaSerializationJson
     end
 
     def get_parse_node(content_type, content)
-      if !content_type
-        raise StandardError, 'content type cannot be undefined or empty'
-      elsif get_valid_content_type != content_type
-        raise StandardError, `expected a #{get_valid_content_type} content type`
-      end
-      raise StandardError, 'content cannot be undefined or empty' unless content
+      raise ArgumentError, 'content type cannot be undefined or empty' if content_type.nil? || content_type.empty?
+      raise ArgumentError, "expected a #{get_valid_content_type} content type" unless get_valid_content_type.casecmp?(content_type)
+      raise ArgumentError, 'content cannot be undefined or empty' if content.nil?
 
       JsonParseNode.new(JSON.parse(content))
     end

data/lib/microsoft_kiota_serialization_json/json_serialization_writer.rb

@@ -23,7 +23,6 @@ module MicrosoftKiotaSerializationJson
     def set_root_value(value)
       @root_value = value
       @has_root_value = true
-      value
     end
 
     def root_value?
@@ -32,98 +31,84 @@ module MicrosoftKiotaSerializationJson
 
     def write_string_value(key, value)
       raise StandardError, 'no key or value included in write_string_value(key, value)' if key.nil? && value.nil?
-      return set_root_value(value) if key.nil?
       return if value.nil?
 
-      @writer[key] = value
+      write_value(key, value)
     end
 
     def write_boolean_value(key, value)
       raise StandardError, 'no key or value included in write_boolean_value(key, value)' if key.nil? && value.nil?
-      return set_root_value(value) if key.nil?
       return if value.nil?
 
-      @writer[key] = value
+      write_value(key, value)
     end
 
     def write_number_value(key, value)
       raise StandardError, 'no key or value included in write_number_value(key, value)' if key.nil? && value.nil?
-      return set_root_value(value) if key.nil?
       return if value.nil?
 
-      @writer[key] = value
+      write_value(key, value)
     end
 
     def write_float_value(key, value)
       raise StandardError, 'no key or value included in write_float_value(key, value)' if key.nil? && value.nil?
-      return set_root_value(value) if key.nil?
       return if value.nil?
 
-      @writer[key] = value
+      write_value(key, value)
     end
 
     def write_guid_value(key, value)
       raise StandardError, 'no key or value included in write_guid_value(key, value)' if !key && !value
-      return set_root_value(value.to_s) unless key
       return if value.nil?
 
-      @writer[key] = value.to_s
+      write_value(key, value.to_s)
     end
 
     def write_date_value(key, value)
       raise StandardError, 'no key or value included in write_date_value(key, value)' if !key && !value
-      return set_root_value(value.strftime('%Y-%m-%d')) unless key
       return if value.nil?
 
-      @writer[key] = value.strftime('%Y-%m-%d')
+      write_value(key, value.strftime('%Y-%m-%d'))
     end
 
     def write_time_value(key, value)
       raise StandardError, 'no key or value included in write_time_value(key, value)' if !key && !value
-      return set_root_value(value.strftime('%H:%M:%S%Z')) unless key
       return if value.nil?
 
-      @writer[key] = value.strftime('%H:%M:%S%Z')
+      write_value(key, value.strftime('%H:%M:%S%Z'))
     end
 
     def write_date_time_value(key, value)
       raise StandardError, 'no key or value included in write_date_time_value(key, value)' if !key && !value
-      return set_root_value(value.strftime('%Y-%m-%dT%H:%M:%S%Z')) unless key
       return if value.nil?
 
-      @writer[key] = value.strftime('%Y-%m-%dT%H:%M:%S%Z')
+      write_value(key, value.strftime('%Y-%m-%dT%H:%M:%S%Z'))
     end
 
     def write_duration_value(key, value)
       raise StandardError, 'no key or value included in write_duration_value(key, value)' if !key && !value
-      return set_root_value(value.string) unless key
       return if value.nil?
 
-      @writer[key] = value.string
+      write_value(key, value.string)
     end
 
     def write_byte_array_value(key, value)
       raise StandardError, 'no key or value included in write_byte_array_value(key, value)' if key.nil? && value.nil?
-      return set_root_value([value].pack('m0')) if key.nil?
       return if value.nil?
 
-      @writer[key] = [value].pack('m0')
+      write_value(key, [value].pack('m0'))
     end
 
     def write_collection_of_primitive_values(key, values)
       return unless values
-      return set_root_value(values.map { |v| serialized_scalar(v) }) unless key
 
-      @writer[key] = values.map do |v|
-        write_any_value(key, v)
-      end
+      write_value(key, values.map { |v| serialized_scalar(v) })
     end
 
     def write_collection_of_object_values(key, values)
       return unless values
-      return set_root_value(values.map { |v| object_value_hash(v) }) unless key
 
-      @writer[key] = values.map { |v| object_value_hash(v) }
+      write_value(key, values.map { |v| object_value_hash(v) })
     end
 
     def write_object_value(key, value, *additional_values_to_merge)
@@ -138,18 +123,13 @@ module MicrosoftKiotaSerializationJson
     end
 
     def write_null_value(key)
-      return set_root_value(nil) if key.nil?
-
-      @writer[key] = nil
+      write_value(key, nil)
     end
 
     def write_collection_of_enum_values(key, values)
       return unless values
 
-      serialized = values.compact.map(&:to_s)
-      return set_root_value(serialized) unless key
-
-      @writer[key] = serialized
+      write_value(key, values.compact.map(&:to_s))
     end
 
     def write_enum_value(key, values)
@@ -173,6 +153,16 @@ module MicrosoftKiotaSerializationJson
 
     private
 
+    # a nil key writes the document root, which a composed type wrapper of a scalar uses
+    def write_value(key, value)
+      if key.nil?
+        set_root_value(value)
+      else
+        @writer[key] = value
+      end
+      nil
+    end
+
     def object_value_hash(value, *additional_values_to_merge)
       temp = child_writer
       serialize_object(value, temp)
@@ -198,46 +188,43 @@ module MicrosoftKiotaSerializationJson
       end
     end
 
+    def write_hash_value(key, value)
+      write_value(key, value.transform_values { |v| serialized_scalar(v) })
+    end
+
+    # a composed type wrapper writes its scalar as the root value, which a nested object hash would drop
+    def write_parsable_value(key, value)
+      if key
+        write_value(key, serialized_scalar(value))
+      else
+        write_object_value(nil, value)
+      end
+    end
+
     public
 
     def serialized_scalar(value)
-      return value if value.nil? || value == true || value == false
-
-      temp = JsonSerializationWriter.new
-      result = temp.write_any_value(nil, value)
-      temp.root_value? ? temp.root_value : result
+      temp = child_writer
+      temp.write_any_value(nil, value)
+      temp.root_value? ? temp.root_value : temp.writer
     end
 
     def write_any_value(key, value)
-      if value
-        if !value.nil? == value
-          value
-        elsif value.instance_of? String
-          write_string_value(key, value)
-        elsif value.instance_of? Integer
-          write_number_value(key, value)
-        elsif value.instance_of? Float
-          write_float_value(key, value)
-        elsif value.instance_of? DateTime
-          write_date_time_value(key, value)
-        elsif value.instance_of? Time
-          write_time_value(key, value)
-        elsif value.instance_of? Date
-          write_date_value(key, value)
-        elsif value.instance_of? MicrosoftKiotaAbstractions::ISODuration
-          write_duration_value(key, value)
-        elsif value.instance_of? Array
-          write_collection_of_primitive_values(key, value)
-        elsif value.is_a? Object
-          value.to_s
-        else
-          raise StandardError, "encountered unknown value type during serialization #{value}"
-        end
-      else
-        raise StandardError, 'no key included when writing json property' unless key
-
-        @writer[key] = nil
-
+      case value
+      when nil then write_null_value(key)
+      when true, false then write_boolean_value(key, value)
+      when String, Symbol then write_string_value(key, value.to_s)
+      when Integer then write_number_value(key, value)
+      when Float then write_float_value(key, value)
+      when DateTime then write_date_time_value(key, value)
+      when Time then write_time_value(key, value)
+      when Date then write_date_value(key, value)
+      when MicrosoftKiotaAbstractions::ISODuration then write_duration_value(key, value)
+      when UUIDTools::UUID then write_guid_value(key, value)
+      when Array then write_collection_of_primitive_values(key, value)
+      when Hash then write_hash_value(key, value)
+      when MicrosoftKiotaAbstractions::Parsable then write_parsable_value(key, value)
+      else raise StandardError, "Encountered an unknown type during serialization #{value.class} with key #{key}"
       end
     end
   end

data/lib/microsoft_kiota_serialization_json/json_serialization_writer_factory.rb

@@ -11,11 +11,8 @@ module MicrosoftKiotaSerializationJson
     end
 
     def get_serialization_writer(content_type)
-      if !content_type
-        raise StandardError, 'content type cannot be undefined or empty'
-      elsif get_valid_content_type != content_type
-        raise StandardError, `expected a #{get_valid_content_type} content type`
-      end
+      raise ArgumentError, 'content type cannot be undefined or empty' if content_type.nil? || content_type.empty?
+      raise ArgumentError, "expected a #{get_valid_content_type} content type" unless get_valid_content_type.casecmp?(content_type)
 
       JsonSerializationWriter.new
     end

data/lib/microsoft_kiota_serialization_json/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MicrosoftKiotaSerializationJson
-  VERSION = '0.25.1' # x-release-please-version
+  VERSION = '0.25.3' # x-release-please-version
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: microsoft_kiota_serialization_json
 version: !ruby/object:Gem::Version
-  version: 0.25.1
+  version: 0.25.3
 platform: ruby
 authors:
 - Microsoft Corporation
@@ -35,14 +35,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.25.1
+        version: 0.25.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.25.1
+        version: 0.25.3
 - !ruby/object:Gem::Dependency
   name: uuidtools
   requirement: !ruby/object:Gem::Requirement