microsoft_kiota_abstractions 0.24.0 → 0.25.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ec82d13c67d7a99abb8072fc1bfb3e1b7926ae95462caca4f9260993e09583bb
-  data.tar.gz: 910a8c047e114d477144c8769f27efe623a56486800422811cb772b612680ffd
+  metadata.gz: 513206169119988b7f24a1bf7e7dea92ecfb179111e71145b8e3dc4bcd38da81
+  data.tar.gz: a4fa14ef64cb4c64feb606852dd542d37eb7fb4650579de10f13263379b1763e
 SHA512:
-  metadata.gz: ca47b5b57ae1e5df01a5921f36d85f231ca34d23365f91e0c7c785617e8b82017559e5e2f3bdae5558f19a8c428fe91b9b2e7c71c3e9c9b2a767d50f43d1516b
-  data.tar.gz: 2d3485190a43513db40db1e6f0022982076552d5eb2162a7580c9f6551314feecc532ab20a1cd0aeef35c918d7f539df3b64e7517518188508d4343c38630904
+  metadata.gz: a76b0d9d11fa0d77d740de87eb29574e8ba070c06770472a590e2fa4d25f5588f0b6d502e86f06460117c4b373d9acd658581798a0a02bacad12161a4aa63b0d
+  data.tar.gz: daced43e53c41e8194540a9704da0d6be3f66c61429c2d7a8555c1c06ea8d6fe255e581476cc6732a2e16fb78a494edf04de17b42f5ce545dbd7f67474b2f0ae

data/lib/microsoft_kiota_abstractions/api_client_builder.rb

@@ -4,6 +4,8 @@ require_relative 'serialization/parse_node_factory'
 require_relative 'serialization/parse_node_factory_registry'
 require_relative 'serialization/serialization_writer_factory'
 require_relative 'serialization/serialization_writer_factory_registry'
+require_relative 'store/backing_store_parse_node_factory'
+require_relative 'store/backing_store_serialization_writer_proxy_factory'
 
 module MicrosoftKiotaAbstractions
   class ApiClientBuilder
@@ -13,6 +15,41 @@ module MicrosoftKiotaAbstractions
         factory
     end
 
+    # wraps the factory, and every factory registered by default, so models write only their changed values
+    def self.enable_backing_store_for_serialization_writer_factory(original)
+      result = original
+      if original.is_a?(SerializationWriterFactoryRegistry)
+        enable_backing_store_for_registry(original, BackingStoreSerializationWriterProxyFactory)
+      elsif !original.is_a?(BackingStoreSerializationWriterProxyFactory)
+        result = BackingStoreSerializationWriterProxyFactory.new(original)
+      end
+      enable_backing_store_for_registry(SerializationWriterFactoryRegistry.default_instance,
+                                        BackingStoreSerializationWriterProxyFactory)
+      result
+    end
+
+    # wraps the factory, and every factory registered by default, so models start tracking changes once read
+    def self.enable_backing_store_for_parse_node_factory(original)
+      result = original
+      if original.is_a?(ParseNodeFactoryRegistry)
+        enable_backing_store_for_registry(original, BackingStoreParseNodeFactory)
+      elsif !original.is_a?(BackingStoreParseNodeFactory)
+        result = BackingStoreParseNodeFactory.new(original)
+      end
+      enable_backing_store_for_registry(ParseNodeFactoryRegistry.default_instance, BackingStoreParseNodeFactory)
+      result
+    end
+
+    def self.enable_backing_store_for_registry(registry, proxy_class)
+      factories = registry.content_type_associated_factories
+      factories.each do |content_type, factory|
+        next if factory.is_a?(proxy_class) || factory.is_a?(registry.class)
+
+        factories[content_type] = proxy_class.new(factory)
+      end
+    end
+    private_class_method :enable_backing_store_for_registry
+
     def self.register_default_deserializer(factory_class)
       factory = factory_class.new
       MicrosoftKiotaAbstractions::ParseNodeFactoryRegistry.default_instance.content_type_associated_factories[factory.get_valid_content_type] =

data/lib/microsoft_kiota_abstractions/authentication/allowed_hosts_validator.rb

@@ -8,14 +8,18 @@ module MicrosoftKiotaAbstractions
   class AllowedHostsValidator
     # creates a new AllocatedHostsValidator with provided values
     def initialize(allowed_hosts)
-      @allowed_hosts = {}
-      allowed_hosts.each { |host| @allowed_hosts[host.downcase] = true }
+      self.allowed_hosts = allowed_hosts
     end
 
     # sets the list of valid hosts with provided value (val)
     def allowed_hosts=(val)
-      @allowed_hosts = {}
-      val.each { |host| @allowed_hosts[host.downcase] = true }
+      hosts = {}
+      val.each do |host|
+        raise ArgumentError, "host should not contain http or https prefix: #{host}" if host.match?(%r{\Ahttps?://}i)
+
+        hosts[host.downcase] = true
+      end
+      @allowed_hosts = hosts
     end
 
     # checks whether the provided host is valid

data/lib/microsoft_kiota_abstractions/multipart_body.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+require_relative 'serialization/parsable'
+
+module MicrosoftKiotaAbstractions
+  class MultipartBody
+    include Parsable
+
+    Part = Struct.new(:name, :content_type, :value, :filename)
+    private_constant :Part
+
+    attr_reader :boundary
+    attr_accessor :request_adapter
+
+    def initialize
+      @boundary = SecureRandom.uuid
+      @parts = {}
+    end
+
+    def add_or_replace_part(part_name, content_type, part_value, filename = nil)
+      raise ArgumentError, 'Part name cannot be null' if blank?(part_name)
+      raise ArgumentError, 'Content type cannot be null' if blank?(content_type)
+      raise ArgumentError, 'Content type cannot contain line breaks' if content_type.to_s.match?(/[\r\n]/)
+      raise ArgumentError, 'Part value cannot be null' if part_value.nil?
+
+      @parts[normalize(part_name)] = Part.new(part_name, content_type, part_value, filename)
+    end
+
+    def get_part_value(part_name)
+      raise ArgumentError, 'Part name cannot be null' if blank?(part_name)
+
+      @parts[normalize(part_name)]&.value
+    end
+
+    def remove_part(part_name) # rubocop:disable Naming/PredicateMethod
+      raise ArgumentError, 'Part name cannot be null' if blank?(part_name)
+
+      !@parts.delete(normalize(part_name)).nil?
+    end
+
+    def serialize(writer)
+      raise ArgumentError, 'Serialization writer cannot be null' if writer.nil?
+      raise ArgumentError, 'Request adapter or serialization writer factory cannot be null' if request_adapter&.get_serialization_writer_factory.nil?
+      raise ArgumentError, 'No parts to serialize' if @parts.empty?
+
+      @parts.each_value.with_index do |part, index|
+        add_new_line(writer) unless index.zero?
+        writer.write_string_value('', "--#{boundary}")
+        writer.write_string_value('Content-Type', part.content_type)
+        writer.write_string_value('Content-Disposition', content_disposition(part))
+        add_new_line(writer)
+        write_part_value(writer, part)
+      end
+      add_new_line(writer)
+      writer.write_string_value('', "--#{boundary}--")
+    end
+
+    private
+
+    def blank?(value)
+      value.nil? || (value.respond_to?(:empty?) && value.empty?)
+    end
+
+    def normalize(part_name)
+      part_name.downcase
+    end
+
+    def add_new_line(writer)
+      writer.write_string_value('', '')
+    end
+
+    def content_disposition(part)
+      disposition = %(form-data; name="#{escape(part.name)}")
+      disposition += %(; filename="#{escape(part.filename)}") unless part.filename.nil?
+      disposition
+    end
+
+    # as browsers escape names and file names in multipart/form-data
+    def escape(value)
+      value.to_s.gsub(/["\r\n]/, '"' => '%22', "\r" => '%0D', "\n" => '%0A')
+    end
+
+    def write_part_value(writer, part)
+      value = part.value
+      if value.is_a?(Parsable)
+        writer.write_byte_array_value('', serialize_parsable(part))
+      elsif value.is_a?(String)
+        writer.write_byte_array_value('', value)
+      elsif value.respond_to?(:read)
+        rewind(value)
+        writer.write_byte_array_value('', value.read)
+      else
+        raise ArgumentError, "Unsupported type #{value.class} for part #{part.name}"
+      end
+    end
+
+    # read from the start each time the body is written, as .NET does for a seekable stream
+    def rewind(stream)
+      stream.rewind if stream.respond_to?(:rewind)
+    rescue SystemCallError
+      nil
+    end
+
+    def serialize_parsable(part)
+      part_writer = request_adapter.get_serialization_writer_factory.get_serialization_writer(part.content_type)
+      part_writer.write_object_value(nil, part.value)
+      content = part_writer.get_serialized_content
+      return content unless content.respond_to?(:read)
+
+      content.rewind if content.respond_to?(:rewind)
+      content.read
+    end
+  end
+end

data/lib/microsoft_kiota_abstractions/request_adapter.rb

@@ -28,6 +28,11 @@ module MicrosoftKiotaAbstractions
       raise NotImplementedError
     end
 
+    # enables the backing store on the models this adapter reads and writes
+    def enable_backing_store(_backing_store_factory = nil)
+      raise NotImplementedError
+    end
+
     def set_base_url(_base_url)
       raise NotImplementedError
     end

data/lib/microsoft_kiota_abstractions/request_information.rb

@@ -1,8 +1,11 @@
 # frozen_string_literal: true
 
+require 'date'
+require 'time'
 require 'uri'
 require 'stduritemplate'
 require_relative 'http_method'
+require_relative 'multipart_body'
 require_relative 'request_headers'
 
 module MicrosoftKiotaAbstractions
@@ -32,7 +35,8 @@ module MicrosoftKiotaAbstractions
       return @uri unless @uri.nil?
 
       if path_parameters[@@raw_url_key].nil?
-        return URI(StdUriTemplate.expand(@url_template, path_parameters.merge(query_parameters)))
+        values = path_parameters.merge(query_parameters).transform_values { |v| template_value(v) }
+        return URI(StdUriTemplate.expand(@url_template, values))
       end
 
       self.uri = path_parameters[@@raw_url_key]
@@ -111,6 +115,11 @@ module MicrosoftKiotaAbstractions
 
     def set_content_from_parsable(request_adapter, content_type, values)
       writer = request_adapter.get_serialization_writer_factory.get_serialization_writer(content_type)
+      if values.is_a?(MultipartBody)
+        content_type = "#{content_type.gsub(/;\s*boundary=[^;]*/i, '')}; boundary=#{values.boundary}"
+        values.request_adapter = request_adapter
+        @headers.remove(@@content_type_header)
+      end
       @headers.try_add(@@content_type_header, content_type)
       if !values.nil? && values.is_a?(Array)
         writer.write_collection_of_object_values(nil, values)
@@ -144,5 +153,19 @@ module MicrosoftKiotaAbstractions
         query_parameters[key] = value unless value.nil?
       end
     end
+
+    private
+
+    # the template engine only takes strings, numbers, booleans and lists of them
+    def template_value(value)
+      case value
+      when nil, String, Integer, Float, true, false then value
+      when Array then value.map { |v| template_value(v) }
+      when Hash then value.transform_values { |v| template_value(v) }
+      when Date, Time then value.iso8601
+      when MicrosoftKiotaAbstractions::ISODuration then value.string
+      else value.to_s
+      end
+    end
   end
 end

data/lib/microsoft_kiota_abstractions/serialization/iso_duration.rb

@@ -49,7 +49,7 @@ module MicrosoftKiotaAbstractions
       end
       iso_str = iso_str.strip
       iso_str = iso_str.chomp('T') if iso_str[-1].eql? 'T'
-      iso_str
+      iso_str == 'P' ? 'PT0S' : iso_str
     end
 
     def normalize
@@ -182,7 +182,7 @@ module MicrosoftKiotaAbstractions
       end
       iso_str = iso_str.strip
       iso_str = iso_str.chomp('T') if iso_str[-1].eql? 'T'
-      ISO8601::Duration.new(iso_str)
+      ISO8601::Duration.new(iso_str == 'P' ? 'PT0S' : iso_str)
     end
 
     def update_member_variables

data/lib/microsoft_kiota_abstractions/serialization/parse_node.rb

@@ -2,6 +2,9 @@
 
 module MicrosoftKiotaAbstractions
   module ParseNode
+    # called with the model before and after its fields are filled, see ParseNodeProxyFactory
+    attr_accessor :on_before_assign_field_values, :on_after_assign_field_values
+
     def get_string_value
       raise NotImplementedError
     end
@@ -34,6 +37,10 @@ module MicrosoftKiotaAbstractions
       raise NotImplementedError
     end
 
+    def get_byte_array_value
+      raise NotImplementedError
+    end
+
     def get_collection_of_primitive_values
       raise NotImplementedError
     end

data/lib/microsoft_kiota_abstractions/serialization/parse_node_proxy_factory.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative 'parse_node_factory'
+
+module MicrosoftKiotaAbstractions
+  # Wraps a parse node factory to run callbacks before and after every model is filled
+  class ParseNodeProxyFactory
+    include ParseNodeFactory
+
+    def initialize(concrete, on_before, on_after)
+      raise ArgumentError, 'concrete factory cannot be nil' if concrete.nil?
+
+      @concrete = concrete
+      @on_before = on_before
+      @on_after = on_after
+    end
+
+    def get_valid_content_type
+      @concrete.get_valid_content_type
+    end
+
+    def get_parse_node(content_type, content)
+      node = @concrete.get_parse_node(content_type, content)
+      original_before = node.on_before_assign_field_values
+      original_after = node.on_after_assign_field_values
+      node.on_before_assign_field_values = lambda do |value|
+        @on_before&.call(value)
+        original_before&.call(value)
+      end
+      # after callbacks unwind the before ones, and run even when an inner one raised
+      node.on_after_assign_field_values = lambda do |value|
+        original_after&.call(value)
+      ensure
+        @on_after&.call(value)
+      end
+      node
+    end
+  end
+end

data/lib/microsoft_kiota_abstractions/serialization/serialization_writer.rb

@@ -2,6 +2,13 @@
 
 module MicrosoftKiotaAbstractions
   module SerializationWriter
+    # called with the model before and after it is written, and with the model and its writer when it starts
+    attr_accessor :on_before_object_serialization, :on_after_object_serialization, :on_start_object_serialization
+
+    def write_null_value(_key)
+      raise NotImplementedError
+    end
+
     def write_string_value(_key, _value)
       raise NotImplementedError
     end
@@ -42,6 +49,10 @@ module MicrosoftKiotaAbstractions
       raise NotImplementedError
     end
 
+    def write_byte_array_value(_key, _value)
+      raise NotImplementedError
+    end
+
     def write_collection_of_primitive_values(_key, _value)
       raise NotImplementedError
     end

data/lib/microsoft_kiota_abstractions/serialization/serialization_writer_proxy_factory.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative 'serialization_writer_factory'
+
+module MicrosoftKiotaAbstractions
+  # Wraps a serialization writer factory to run callbacks around every model it writes
+  class SerializationWriterProxyFactory
+    include SerializationWriterFactory
+
+    def initialize(concrete, on_before, on_after, on_start)
+      raise ArgumentError, 'concrete factory cannot be nil' if concrete.nil?
+
+      @concrete = concrete
+      @on_before = on_before
+      @on_after = on_after
+      @on_start = on_start
+    end
+
+    def get_valid_content_type
+      @concrete.get_valid_content_type
+    end
+
+    def get_serialization_writer(content_type)
+      wrap(@concrete.get_serialization_writer(content_type), @on_before, @on_after, @on_start)
+    end
+
+    protected
+
+    def wrap(writer, on_before, on_after, on_start)
+      original_before = writer.on_before_object_serialization
+      original_after = writer.on_after_object_serialization
+      original_start = writer.on_start_object_serialization
+      writer.on_before_object_serialization = lambda do |value|
+        on_before&.call(value)
+        original_before&.call(value)
+      end
+      # after callbacks unwind the before ones, and run even when an inner one raised
+      writer.on_after_object_serialization = lambda do |value|
+        original_after&.call(value)
+      ensure
+        on_after&.call(value)
+      end
+      writer.on_start_object_serialization = lambda do |value, object_writer|
+        on_start&.call(value, object_writer)
+        original_start&.call(value, object_writer)
+      end
+      writer
+    end
+  end
+end

data/lib/microsoft_kiota_abstractions/store/backed_model.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module MicrosoftKiotaAbstractions
+  # A model that keeps its values in a backing store
+  module BackedModel
+    attr_reader :backing_store
+  end
+end

data/lib/microsoft_kiota_abstractions/store/backing_store.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module MicrosoftKiotaAbstractions
+  # Stores the values of a model and tracks which ones changed since it was read
+  module BackingStore
+    def get(_key)
+      raise NotImplementedError
+    end
+
+    def set(_key, _value)
+      raise NotImplementedError
+    end
+
+    # the stored key and value pairs, or only the changed ones when return_only_changed_values is set
+    def enumerate
+      raise NotImplementedError
+    end
+
+    def enumerate_keys_for_values_changed_to_nil
+      raise NotImplementedError
+    end
+
+    # registers a callback called with (key, old_value, new_value) on every set, returns its id
+    def subscribe(_callback, _subscription_id = nil)
+      raise NotImplementedError
+    end
+
+    def unsubscribe(_subscription_id)
+      raise NotImplementedError
+    end
+
+    def clear
+      raise NotImplementedError
+    end
+
+    def initialization_completed
+      raise NotImplementedError
+    end
+
+    def initialization_completed=(_value)
+      raise NotImplementedError
+    end
+
+    def return_only_changed_values
+      raise NotImplementedError
+    end
+
+    def return_only_changed_values=(_value)
+      raise NotImplementedError
+    end
+  end
+end

data/lib/microsoft_kiota_abstractions/store/backing_store_factory.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module MicrosoftKiotaAbstractions
+  # Creates the backing store of a new model
+  module BackingStoreFactory
+    def create_backing_store
+      raise NotImplementedError
+    end
+  end
+end

data/lib/microsoft_kiota_abstractions/store/backing_store_factory_singleton.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative 'in_memory_backing_store_factory'
+
+module MicrosoftKiotaAbstractions
+  # Holds the backing store factory generated models use
+  module BackingStoreFactorySingleton
+    class << self
+      attr_writer :instance
+
+      def instance
+        @instance ||= InMemoryBackingStoreFactory.new
+      end
+    end
+  end
+end

data/lib/microsoft_kiota_abstractions/store/backing_store_parse_node_factory.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative '../serialization/parse_node_proxy_factory'
+require_relative 'backed_model'
+
+module MicrosoftKiotaAbstractions
+  # Marks a model's values as not changed once it has been read
+  class BackingStoreParseNodeFactory < ParseNodeProxyFactory
+    def initialize(concrete)
+      super(concrete,
+            ->(value) { value.backing_store.initialization_completed = false if value.is_a?(BackedModel) && value.backing_store },
+            ->(value) { value.backing_store.initialization_completed = true if value.is_a?(BackedModel) && value.backing_store })
+    end
+  end
+end

data/lib/microsoft_kiota_abstractions/store/backing_store_serialization_writer_proxy_factory.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require 'English'
+require 'delegate'
+require_relative '../serialization/serialization_writer_proxy_factory'
+require_relative 'backed_model'
+
+module MicrosoftKiotaAbstractions
+  # Writes only the values of a model that changed, including the ones set back to nil
+  class BackingStoreSerializationWriterProxyFactory < SerializationWriterProxyFactory
+    def initialize(concrete)
+      super(concrete, nil, nil, nil)
+    end
+
+    def get_serialization_writer(content_type)
+      session = Session.new
+      writer = wrap(@concrete.get_serialization_writer(content_type),
+                    session.method(:before), session.method(:after), session.method(:start))
+      DocumentWriter.new(writer, session)
+    end
+
+    # the document is complete once its content is produced: only then do the written models become clean
+    class DocumentWriter < SimpleDelegator
+      def initialize(writer, session)
+        super(writer)
+        @session = session
+      end
+
+      def get_serialized_content
+        content = __getobj__.get_serialized_content
+        @session.finish
+        content
+      end
+    end
+
+    # one per writer: tracks the models written into the document
+    class Session
+      def initialize
+        @depth = 0
+        @filtering = {}.compare_by_identity
+        @written = {}.compare_by_identity
+        @failed = false
+      end
+
+      def before(value)
+        if @depth.zero?
+          # an exception already being handled around the write is not a failure of the write
+          @outer_error = $ERROR_INFO
+          open_documents.push(self)
+        end
+        @depth += 1
+        store = store_of(value)
+        return unless store
+
+        @filtering[store] = store.return_only_changed_values unless @filtering.key?(store)
+        store.return_only_changed_values = true
+        @written[store] = true
+      end
+
+      def start(value, writer)
+        store_of(value)&.enumerate_keys_for_values_changed_to_nil&.each { |key| writer.write_null_value(key) }
+      end
+
+      # runs even when writing the model raised: the store reads every value again, and keeps its changes
+      def after(value)
+        @depth -= 1
+        open_documents.pop if @depth.zero? && open_documents.last.equal?(self)
+        @failed ||= !$ERROR_INFO.nil? && !$ERROR_INFO.equal?(@outer_error)
+        store = store_of(value)
+        store.return_only_changed_values = @filtering.delete(store) if store && @filtering.key?(store)
+      end
+
+      # a document produced while another is written, such as a multipart part, leaves the models to that one
+      def finish
+        unless @failed
+          enclosing = open_documents.last
+          enclosing ? enclosing.adopt(@written) : @written.each_key { |store| store.initialization_completed = true }
+        end
+        @written.clear
+        @failed = false
+      end
+
+      def adopt(written)
+        @written.merge!(written)
+      end
+
+      private
+
+      def open_documents
+        Thread.current[:microsoft_kiota_open_documents] ||= []
+      end
+
+      def store_of(value)
+        value.backing_store if value.is_a?(BackedModel)
+      end
+    end
+    private_constant :DocumentWriter, :Session
+  end
+end

data/lib/microsoft_kiota_abstractions/store/in_memory_backing_store.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+require_relative 'backing_store'
+require_relative 'backed_model'
+
+module MicrosoftKiotaAbstractions
+  # A backing store that keeps the values in memory
+  class InMemoryBackingStore
+    include BackingStore
+
+    # changed: set after initialization completed; snapshot: a copy of a mutable value when it was set
+    Entry = Struct.new(:changed, :value, :snapshot)
+
+    attr_reader :initialization_completed
+    attr_accessor :return_only_changed_values
+
+    def initialize
+      @store = {}
+      @subscriptions = {}
+      @member_subscriptions = {}
+      @walking = {}
+      @initialization_completed = true
+      @return_only_changed_values = false
+    end
+
+    def initialization_completed=(value)
+      @initialization_completed = value
+      walk_once(:initialization) do
+        @store.each_key do |key|
+          backed_models(@store[key].value).each { |model| model.backing_store.initialization_completed = value }
+          ensure_value_is_consistent(key)
+          @store[key].changed = !value
+        end
+      end
+    end
+
+    def get(key)
+      validate(key)
+      return unless @store.key?(key)
+
+      ensure_value_is_consistent(key)
+      entry = @store[key]
+      entry.value if !@return_only_changed_values || entry.changed
+    end
+
+    def set(key, value)
+      validate(key)
+      old_value = @store[key]&.value
+      mark_assigned(value) if @initialization_completed
+      @store[key] = Entry.new(@initialization_completed, value, snapshot_of(value))
+      follow_members(key, value)
+      notify(key, old_value, value)
+    end
+
+    def enumerate
+      @store.each_key { |key| ensure_value_is_consistent(key) } if @return_only_changed_values
+      @store.select { |_, entry| !@return_only_changed_values || entry.changed }.map { |key, entry| [key, entry.value] }
+    end
+
+    def enumerate_keys_for_values_changed_to_nil
+      @store.select { |_, entry| entry.changed && entry.value.nil? }.keys
+    end
+
+    def subscribe(callback, subscription_id = nil)
+      raise ArgumentError, 'callback cannot be nil' if callback.nil?
+
+      subscription_id ||= SecureRandom.uuid
+      @subscriptions[subscription_id] = callback
+      subscription_id
+    end
+
+    def unsubscribe(subscription_id)
+      @subscriptions.delete(subscription_id)
+    end
+
+    def clear
+      @member_subscriptions.each_key.to_a.each { |key| follow_members(key, nil) }
+      @store.clear
+    end
+
+    protected
+
+    def mark_all_changed
+      walk_once(:marking) do
+        @store.each_value do |entry|
+          entry.changed = true
+          mark_assigned(entry.value)
+        end
+      end
+    end
+
+    private
+
+    # a model assigned after initialization is written in full, as .NET does for the items of a collection
+    def mark_assigned(value)
+      backed_models(value).each { |model| model.backing_store.mark_all_changed if model.backing_store.is_a?(InMemoryBackingStore) }
+    end
+
+    def validate(key)
+      raise ArgumentError, 'key cannot be nil or empty' if key.nil? || key.empty?
+    end
+
+    def backed_models(value)
+      (value.is_a?(Array) ? value : [value]).select { |model| model.is_a?(BackedModel) && model.backing_store }
+    end
+
+    def snapshot_of(value)
+      case value
+      when Array then value.map { |item| snapshot_item(item) }
+      when Hash then value.transform_values { |item| snapshot_item(item) }
+      when String then value.dup unless value.frozen?
+      end
+    end
+
+    # copies what could be edited in place; a nested model is compared by identity and tracked by its own store
+    def snapshot_item(item)
+      case item
+      when Array, Hash then snapshot_of(item)
+      when String then item.frozen? ? item : item.dup
+      else item
+      end
+    end
+
+    # the nested models a property holds report their changes to it, for as long as they are in it
+    def follow_members(key, value)
+      followed = @member_subscriptions[key] ||= {}.compare_by_identity
+      members = backed_models(value).to_h { |model| [model, true] }.compare_by_identity
+      followed.keys.reject { |model| members.key?(model) }.each { |model| model.backing_store.unsubscribe(followed.delete(model)) }
+      members.each_key { |model| followed[model] ||= model.backing_store.subscribe(->(*) { member_changed(key) }) }
+      @member_subscriptions.delete(key) if followed.empty?
+    end
+
+    def member_changed(key)
+      entry = @store[key]
+      return if entry.nil?
+
+      entry.changed = true if @initialization_completed
+      notify(key, entry.value, entry.value)
+    end
+
+    def notify(key, old_value, new_value)
+      walk_once(:notification) { @subscriptions.each_value { |callback| callback.call(key, old_value, new_value) } }
+    end
+
+    # models can reference each other or themselves: a store reached again while it is being walked is skipped
+    def walk_once(walk)
+      return if @walking[walk]
+
+      @walking[walk] = true
+      begin
+        yield
+      ensure
+        @walking.delete(walk)
+      end
+    end
+
+    # a value changed in place since it was set, or holding a changed model, is marked as changed
+    def ensure_value_is_consistent(key)
+      entry = @store[key]
+      walk_once(:consistency) do
+        backed_models(entry.value).each { |model| model.backing_store.enumerate.map(&:first).each { |k| model.backing_store.get(k) } }
+      end
+      set(key, entry.value) unless entry.snapshot.nil? || entry.value == entry.snapshot
+    end
+  end
+end

data/lib/microsoft_kiota_abstractions/store/in_memory_backing_store_factory.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative 'backing_store_factory'
+require_relative 'in_memory_backing_store'
+
+module MicrosoftKiotaAbstractions
+  # Creates in memory backing stores
+  class InMemoryBackingStoreFactory
+    include BackingStoreFactory
+
+    def create_backing_store
+      InMemoryBackingStore.new
+    end
+  end
+end

data/lib/microsoft_kiota_abstractions/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MicrosoftKiotaAbstractions
-  VERSION = '0.24.0' # x-release-please-version
+  VERSION = '0.25.0' # x-release-please-version
 end

data/lib/microsoft_kiota_abstractions.rb

@@ -12,6 +12,7 @@ require_relative 'microsoft_kiota_abstractions/request_configuration'
 require_relative 'microsoft_kiota_abstractions/request_option'
 require_relative 'microsoft_kiota_abstractions/request_headers'
 require_relative 'microsoft_kiota_abstractions/request_information'
+require_relative 'microsoft_kiota_abstractions/multipart_body'
 require_relative 'microsoft_kiota_abstractions/version'
 require_relative 'microsoft_kiota_abstractions/serialization/parsable'
 require_relative 'microsoft_kiota_abstractions/serialization/iso_duration'
@@ -24,6 +25,16 @@ require_relative 'microsoft_kiota_abstractions/serialization/serialization_write
 require_relative 'microsoft_kiota_abstractions/serialization/serialization_writer_factory_registry'
 require_relative 'microsoft_kiota_abstractions/serialization/composed_type_wrapper'
 require_relative 'microsoft_kiota_abstractions/serialization/parse_node_helper'
+require_relative 'microsoft_kiota_abstractions/serialization/parse_node_proxy_factory'
+require_relative 'microsoft_kiota_abstractions/serialization/serialization_writer_proxy_factory'
+require_relative 'microsoft_kiota_abstractions/store/backing_store'
+require_relative 'microsoft_kiota_abstractions/store/backed_model'
+require_relative 'microsoft_kiota_abstractions/store/backing_store_factory'
+require_relative 'microsoft_kiota_abstractions/store/in_memory_backing_store'
+require_relative 'microsoft_kiota_abstractions/store/in_memory_backing_store_factory'
+require_relative 'microsoft_kiota_abstractions/store/backing_store_factory_singleton'
+require_relative 'microsoft_kiota_abstractions/store/backing_store_parse_node_factory'
+require_relative 'microsoft_kiota_abstractions/store/backing_store_serialization_writer_proxy_factory'
 
 module MicrosoftKiotaAbstractions
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: microsoft_kiota_abstractions
 version: !ruby/object:Gem::Version
-  version: 0.24.0
+  version: 0.25.0
 platform: ruby
 authors:
 - Microsoft Corporation
@@ -104,6 +104,7 @@ files:
 - lib/microsoft_kiota_abstractions/authentication/base_bearer_token_authentication_provider.rb
 - lib/microsoft_kiota_abstractions/base_request_builder.rb
 - lib/microsoft_kiota_abstractions/http_method.rb
+- lib/microsoft_kiota_abstractions/multipart_body.rb
 - lib/microsoft_kiota_abstractions/request_adapter.rb
 - lib/microsoft_kiota_abstractions/request_configuration.rb
 - lib/microsoft_kiota_abstractions/request_headers.rb
@@ -117,9 +118,19 @@ files:
 - lib/microsoft_kiota_abstractions/serialization/parse_node_factory.rb
 - lib/microsoft_kiota_abstractions/serialization/parse_node_factory_registry.rb
 - lib/microsoft_kiota_abstractions/serialization/parse_node_helper.rb
+- lib/microsoft_kiota_abstractions/serialization/parse_node_proxy_factory.rb
 - lib/microsoft_kiota_abstractions/serialization/serialization_writer.rb
 - lib/microsoft_kiota_abstractions/serialization/serialization_writer_factory.rb
 - lib/microsoft_kiota_abstractions/serialization/serialization_writer_factory_registry.rb
+- lib/microsoft_kiota_abstractions/serialization/serialization_writer_proxy_factory.rb
+- lib/microsoft_kiota_abstractions/store/backed_model.rb
+- lib/microsoft_kiota_abstractions/store/backing_store.rb
+- lib/microsoft_kiota_abstractions/store/backing_store_factory.rb
+- lib/microsoft_kiota_abstractions/store/backing_store_factory_singleton.rb
+- lib/microsoft_kiota_abstractions/store/backing_store_parse_node_factory.rb
+- lib/microsoft_kiota_abstractions/store/backing_store_serialization_writer_proxy_factory.rb
+- lib/microsoft_kiota_abstractions/store/in_memory_backing_store.rb
+- lib/microsoft_kiota_abstractions/store/in_memory_backing_store_factory.rb
 - lib/microsoft_kiota_abstractions/version.rb
 - microsoft_kiota_abstractions.gemspec
 homepage: https://learn.microsoft.com/openapi/kiota/