microsoft_kiota_serialization_form 0.25.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1bc7ad42ac19325bb2e213d2728f629c4273c7a1601120cff1ae0d302400f1ba
+  data.tar.gz: 2ea16cd5ba5613d9c77a66b3dd642eae15b301cdc481336989da5b1c6f96e769
+SHA512:
+  metadata.gz: cfb4db07a7a567722d8a248c6c00b16c1611da8ed6377c0060be3f8f92f8aca30a2cd71135cc7bd8aea5a73722991a2a74dddfdb008322684c809cab81a0486a
+  data.tar.gz: 923d15873ca60031e87048d452fe2dcef198cc249a7afbc52a4c9747e81249b09949f040c18559082c9125839c7d74bd0a4ec9bf034e4d34414482f13811c109

data/Gemfile

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+ruby '>= 3.3.0'
+
+gem 'microsoft_kiota_abstractions', path: '../../abstractions'
+gem 'rake', '~> 13.0'
+gem 'rspec', '~> 3.0'
+
+gemspec

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/lib/microsoft_kiota_serialization_form/form_parse_node.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+require 'date'
+require 'time'
+require 'uri'
+require 'uuidtools'
+require 'microsoft_kiota_abstractions'
+
+module MicrosoftKiotaSerializationForm
+  class FormParseNode
+    include MicrosoftKiotaAbstractions::ParseNode
+
+    attr_accessor :on_before_assign_field_values, :on_after_assign_field_values
+
+    # temporal readers take only their own shape, as in Go, so a union picks the right member
+    DATE = /\A\d{4}-\d{2}-\d{2}\z/
+    TIME = /\A\d{2}:\d{2}(:\d{2}(\.\d+)?)?\z/
+    DATE_TIME = /\A\d{4}-\d{2}-\d{2}[Tt ]\d{2}:\d{2}(:\d{2}(\.\d+)?)?([Zz]|[+-]\d{2}(:?\d{2})?)?\z/
+
+    READERS = {
+      string: ->(value) { value },
+      boolean: ->(value) { { 'true' => true, 'false' => false }[value.downcase] },
+      number: ->(value) { Integer(value, 10) },
+      float: ->(value) { Float(value) },
+      guid: ->(value) { UUIDTools::UUID.parse(value) },
+      date: ->(value) { Date.parse(value) if DATE.match?(value) },
+      time: ->(value) { Time.parse(value) if TIME.match?(value) },
+      date_time: ->(value) { DateTime.parse(value) if DATE_TIME.match?(value) },
+      duration: ->(value) { MicrosoftKiotaAbstractions::ISODuration.new(value) },
+      byte_array: ->(value) { value.unpack1('m0') }
+    }.freeze
+
+    # keyed by the constant the generator passes; an untyped collection arrives as Object
+    PRIMITIVE_TYPES = {
+      String => :string,
+      Object => :string,
+      Integer => :number,
+      Float => :float,
+      UUIDTools::UUID => :guid,
+      Date => :date,
+      DateTime => :date_time,
+      Time => :time,
+      MicrosoftKiotaAbstractions::ISODuration => :duration,
+      'boolean' => :boolean,
+      'Boolean' => :boolean
+    }.freeze
+
+    def initialize(raw_value, raw_items = nil)
+      raw_value = raw_value.to_s.b
+      @raw_value = raw_value
+      @value = decode(raw_value)
+      @fields = parse_fields(raw_value)
+      @raw_items = raw_items
+    end
+
+    # an empty value is an empty string, as .NET reads it; only null is nil
+    def get_string_value
+      @value unless @value == 'null'
+    end
+
+    def get_boolean_value = read(:boolean)
+
+    def get_number_value = read(:number)
+
+    def get_float_value = read(:float)
+
+    def get_guid_value = read(:guid)
+
+    def get_date_value = read(:date)
+
+    def get_time_value = read(:time)
+
+    def get_date_time_value = read(:date_time)
+
+    def get_duration_value = read(:duration)
+
+    def get_byte_array_value = read(:byte_array)
+
+    def get_collection_of_primitive_values(type)
+      raise StandardError, 'Primitive type for deserialization cannot be null' if type.nil?
+
+      kind = PRIMITIVE_TYPES[type]
+      raise StandardError, "Encountered an unknown type during deserialization #{type}" if kind.nil?
+
+      primitive_items.map { |item| read(kind, item) }
+    end
+
+    def get_collection_of_object_values(_factory)
+      raise StandardError, 'Collection of object values is not supported with uri form encoding.'
+    end
+
+    def get_object_value(factory)
+      raise StandardError, 'Factory cannot be null' if factory.nil?
+
+      item = factory.call(self)
+      begin
+        on_before_assign_field_values&.call(item)
+        assign_field_values(item)
+      ensure
+        on_after_assign_field_values&.call(item)
+      end
+      item
+    end
+
+    def assign_field_values(item)
+      deserializers = item.get_field_deserializers
+      by_lower_name = deserializers.transform_keys(&:downcase)
+      additional_data = item.respond_to?(:additional_data) ? item.additional_data : nil
+      @fields.each_value do |key, raw_values|
+        deserializer = deserializers[key] || by_lower_name[key.downcase]
+        value = decode(raw_values.join(','))
+        if deserializer
+          deserializer.call(child_node(raw_values)) unless value == 'null'
+        elsif additional_data
+          additional_data[key] = value
+        end
+      end
+    end
+
+    def get_enum_value(type)
+      get_enum_values(type).first
+    end
+
+    def get_enum_values(type)
+      items.map { |value| enum_member(type, value) unless blank?(value) }
+    end
+
+    alias get_collection_of_enum_values get_enum_values
+
+    def get_child_node(name)
+      raise StandardError, 'Name cannot be null' if name.nil? || name.empty?
+
+      field = @fields[name.downcase]
+      child_node(field[1]) if field
+    end
+
+    private
+
+    # a stray % is kept as is, like Python's unquote_plus
+    def decode(value)
+      URI.decode_www_form_component(value.gsub(/%(?!\h\h)/, '%25')).scrub
+    end
+
+    def blank?(value)
+      value.nil? || value.empty? || value == 'null'
+    end
+
+    def read(kind, value = @value)
+      return if blank?(value)
+
+      READERS.fetch(kind).call(value)
+    rescue StandardError
+      nil
+    end
+
+    # the items of a repeated key stay apart; a single value is split on commas
+    def items
+      return @raw_items.map { |raw| decode(raw) } if @raw_items && @raw_items.size > 1
+
+      @value.split(',')
+    end
+
+    # only a comma sent as is separates primitive items; the writer encodes one inside an item
+    def primitive_items
+      (@raw_items || [@raw_value]).flat_map { |raw| raw.split(',') }.map { |raw| decode(raw) }
+    end
+
+    def parse_fields(raw)
+      fields = {}
+      raw.split('&').each do |pair|
+        next unless pair.include?('=')
+
+        key, value = pair.split('=', 2)
+        key = decode(key)
+        (fields[key.downcase] ||= [key, []])[1] << value
+      end
+      fields
+    end
+
+    def child_node(raw_values)
+      FormParseNode.new(raw_values.join(','), raw_values).tap do |node|
+        node.on_before_assign_field_values = on_before_assign_field_values
+        node.on_after_assign_field_values = on_after_assign_field_values
+      end
+    end
+
+    # same resolution as JsonParseNode: the wire value first, then the member name
+    def enum_member(type, value)
+      return value.to_sym unless type.is_a?(Hash)
+
+      type.each_value { |member| return member if member.to_s == value }
+      type[value.to_sym] || type[(value[0].to_s.upcase + value[1..].to_s).to_sym]
+    end
+  end
+end

data/lib/microsoft_kiota_serialization_form/form_parse_node_factory.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'microsoft_kiota_abstractions'
+
+module MicrosoftKiotaSerializationForm
+  class FormParseNodeFactory
+    include MicrosoftKiotaAbstractions::ParseNodeFactory
+
+    def get_valid_content_type
+      'application/x-www-form-urlencoded'
+    end
+
+    def get_parse_node(content_type, content)
+      valid = get_valid_content_type
+      raise ArgumentError, 'content type cannot be undefined or empty' if content_type.nil? || content_type.empty?
+      raise ArgumentError, "expected a #{valid} content type" unless content_type.casecmp?(valid)
+      raise ArgumentError, 'content cannot be undefined or empty' if content.nil?
+
+      FormParseNode.new(content)
+    end
+  end
+end

data/lib/microsoft_kiota_serialization_form/form_serialization_writer.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require 'date'
+require 'time'
+require 'uri'
+require 'uuidtools'
+require 'microsoft_kiota_abstractions'
+
+module MicrosoftKiotaSerializationForm
+  class FormSerializationWriter
+    include MicrosoftKiotaAbstractions::SerializationWriter
+
+    NESTED_OBJECTS = 'Form serialization does not support nested objects.'
+
+    attr_accessor :on_before_object_serialization, :on_after_object_serialization, :on_start_object_serialization
+
+    def initialize
+      @buffer = +''
+      @depth = 0
+    end
+
+    def write_string_value(key, value)
+      return if key.nil? || key.empty? || value.nil?
+
+      @buffer << '&' unless @buffer.empty?
+      @buffer << URI.encode_www_form_component(key) << '=' << URI.encode_www_form_component(value)
+    end
+
+    def write_boolean_value(key, value) = write_string_value(key, value&.to_s)
+
+    def write_number_value(key, value) = write_string_value(key, value&.to_s)
+
+    def write_float_value(key, value) = write_string_value(key, value&.to_s)
+
+    def write_guid_value(key, value) = write_string_value(key, value&.to_s)
+
+    def write_date_value(key, value)
+      value = value.strftime('%Y-%m-%d') if value.respond_to?(:strftime)
+      write_string_value(key, value)
+    end
+
+    def write_time_value(key, value)
+      value = value.strftime(fraction?(value) ? '%H:%M:%S.%6N' : '%H:%M:%S') if value.respond_to?(:strftime)
+      write_string_value(key, value)
+    end
+
+    def write_date_time_value(key, value)
+      value = value.iso8601(fraction?(value) ? 6 : 0) if value.is_a?(Time) || value.is_a?(DateTime)
+      write_string_value(key, value)
+    end
+
+    def write_duration_value(key, value)
+      value = value.string if value.is_a?(MicrosoftKiotaAbstractions::ISODuration)
+      write_string_value(key, value)
+    end
+
+    def write_byte_array_value(key, value)
+      write_string_value(key, [value].pack('m0')) unless value.nil?
+    end
+
+    # a flags value is an Array of members
+    def write_enum_value(key, value)
+      members = Array(value).compact
+      write_string_value(key, members.join(',')) unless members.empty?
+    end
+
+    def write_null_value(key) = write_string_value(key, 'null')
+
+    def write_collection_of_primitive_values(key, values)
+      values&.each { |value| write_any_value(key, value) }
+    end
+
+    def write_collection_of_enum_values(key, values)
+      values&.each { |value| write_string_value(key, value&.to_s) }
+    end
+
+    def write_collection_of_object_values(_key, values)
+      return if values.nil?
+
+      raise StandardError, 'Form serialization does not support collections.'
+    end
+
+    # written flat, as .NET does; inside a model only a composed type member (nil key) is allowed
+    def write_object_value(key, value, *additional_values_to_merge)
+      values = [value, *additional_values_to_merge].compact
+      return if values.empty?
+      raise StandardError, NESTED_OBJECTS if @depth.positive? && !(key.nil? || key.empty?)
+
+      writer = child_writer
+      values.each { |v| serialize_object(v, writer) }
+      content = writer.get_serialized_content
+      return if content.empty?
+
+      @buffer << '&' unless @buffer.empty?
+      @buffer << content
+    end
+
+    def write_additional_data(value)
+      value&.each { |key, data| write_any_value(key, data) }
+    end
+
+    def write_any_value(key, value)
+      case value
+      when nil then nil
+      when String, Symbol then write_string_value(key, value.to_s)
+      when true, false then write_boolean_value(key, value)
+      when Integer then write_number_value(key, value)
+      when Float then write_float_value(key, value)
+      when UUIDTools::UUID then write_guid_value(key, value)
+      when DateTime, Time then write_date_time_value(key, value)
+      when Date then write_date_value(key, value)
+      when MicrosoftKiotaAbstractions::ISODuration then write_duration_value(key, value)
+      when Array then write_collection_of_primitive_values(key, value)
+      when Hash, MicrosoftKiotaAbstractions::Parsable then raise StandardError, NESTED_OBJECTS
+      else raise StandardError, "Encountered an unknown type during serialization #{value.class} with key #{key}"
+      end
+    end
+
+    def get_serialized_content
+      @buffer.dup
+    end
+
+    protected
+
+    attr_writer :depth
+
+    private
+
+    def fraction?(value)
+      fraction = if value.respond_to?(:subsec) then value.subsec
+                 elsif value.respond_to?(:sec_fraction) then value.sec_fraction
+                 else 0
+                 end
+      !fraction.zero?
+    end
+
+    # the after hook runs even when writing the model raised, so callbacks can restore their state
+    def serialize_object(value, writer)
+      on_before_object_serialization&.call(value)
+      on_start_object_serialization&.call(value, writer)
+      value.serialize(writer)
+    ensure
+      on_after_object_serialization&.call(value)
+    end
+
+    def child_writer
+      FormSerializationWriter.new.tap do |writer|
+        writer.depth = @depth + 1
+        writer.on_before_object_serialization = on_before_object_serialization
+        writer.on_after_object_serialization = on_after_object_serialization
+        writer.on_start_object_serialization = on_start_object_serialization
+      end
+    end
+  end
+end

data/lib/microsoft_kiota_serialization_form/form_serialization_writer_factory.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'microsoft_kiota_abstractions'
+
+module MicrosoftKiotaSerializationForm
+  class FormSerializationWriterFactory
+    include MicrosoftKiotaAbstractions::SerializationWriterFactory
+
+    def get_valid_content_type
+      'application/x-www-form-urlencoded'
+    end
+
+    def get_serialization_writer(content_type)
+      valid = get_valid_content_type
+      raise ArgumentError, 'content type cannot be undefined or empty' if content_type.nil? || content_type.empty?
+      raise ArgumentError, "expected a #{valid} content type" unless content_type.casecmp?(valid)
+
+      FormSerializationWriter.new
+    end
+  end
+end

data/lib/microsoft_kiota_serialization_form/version.rb

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

data/lib/microsoft_kiota_serialization_form.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative 'microsoft_kiota_serialization_form/form_parse_node'
+require_relative 'microsoft_kiota_serialization_form/form_parse_node_factory'
+require_relative 'microsoft_kiota_serialization_form/form_serialization_writer'
+require_relative 'microsoft_kiota_serialization_form/form_serialization_writer_factory'
+require_relative 'microsoft_kiota_serialization_form/version'
+
+module MicrosoftKiotaSerializationForm
+end

data/microsoft_kiota_serialization_form.gemspec

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative 'lib/microsoft_kiota_serialization_form/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'microsoft_kiota_serialization_form'
+  spec.version       = MicrosoftKiotaSerializationForm::VERSION
+  spec.authors       = 'Microsoft Corporation'
+  spec.email         = 'graphsdkpub+ruby@microsoft.com'
+  spec.description   = 'Implementation of Kiota Serialization interfaces for URL-encoded forms'
+  spec.summary       = 'Microsoft Kiota Serialization - Ruby serialization for building library agnostic http client'
+  spec.homepage      = 'https://learn.microsoft.com/openapi/kiota/'
+  spec.license       = 'MIT'
+  spec.metadata      = {
+    'bug_tracker_uri' => 'https://github.com/microsoft/kiota-ruby/issues',
+    'changelog_uri' => 'https://github.com/microsoft/kiota-ruby/blob/main/CHANGELOG.md',
+    'homepage_uri' => spec.homepage,
+    'source_code_uri' => 'https://github.com/microsoft/kiota-ruby/tree/main/components/serialization/form',
+    'github_repo' => 'ssh://github.com/microsoft/kiota-ruby',
+    'rubygems_mfa_required' => 'true'
+  }
+  spec.required_ruby_version = '>= 3.3.0'
+
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
+  end
+  spec.bindir        = 'bin'
+  spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+  spec.add_dependency 'microsoft_kiota_abstractions', MicrosoftKiotaSerializationForm::VERSION
+  spec.add_dependency 'uuidtools', '>= 2.2', '< 3.1'
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: microsoft_kiota_serialization_form
+version: !ruby/object:Gem::Version
+  version: 0.25.0
+platform: ruby
+authors:
+- Microsoft Corporation
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: microsoft_kiota_abstractions
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.25.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.25.0
+- !ruby/object:Gem::Dependency
+  name: uuidtools
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+description: Implementation of Kiota Serialization interfaces for URL-encoded forms
+email: graphsdkpub+ruby@microsoft.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Rakefile
+- lib/microsoft_kiota_serialization_form.rb
+- lib/microsoft_kiota_serialization_form/form_parse_node.rb
+- lib/microsoft_kiota_serialization_form/form_parse_node_factory.rb
+- lib/microsoft_kiota_serialization_form/form_serialization_writer.rb
+- lib/microsoft_kiota_serialization_form/form_serialization_writer_factory.rb
+- lib/microsoft_kiota_serialization_form/version.rb
+- microsoft_kiota_serialization_form.gemspec
+homepage: https://learn.microsoft.com/openapi/kiota/
+licenses:
+- MIT
+metadata:
+  bug_tracker_uri: https://github.com/microsoft/kiota-ruby/issues
+  changelog_uri: https://github.com/microsoft/kiota-ruby/blob/main/CHANGELOG.md
+  homepage_uri: https://learn.microsoft.com/openapi/kiota/
+  source_code_uri: https://github.com/microsoft/kiota-ruby/tree/main/components/serialization/form
+  github_repo: ssh://github.com/microsoft/kiota-ruby
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Microsoft Kiota Serialization - Ruby serialization for building library agnostic
+  http client
+test_files: []