microsoft_kiota_serialization_text 0.25.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0b3c4ccf35a126e8f4efcb4660abe9b8bb77aff722dc7da29fb11fd87ed2183c
+  data.tar.gz: 15d90adcf5d3ff5fd0bbf427a3dd4942aa8f5d63734fccdb1546b1d1d4e36c79
+SHA512:
+  metadata.gz: 507035c41b383628515e5c00a36f1df458dc4d22a11fa6b2c47e7b3a1f9f97ab2455261b972e874392e1fca37079c632e749e62ebce3493ecfc7c481255e481b
+  data.tar.gz: 2f60bd6fff2b8ae402ab6940bf5ebff31ece25153e1269ea5968cfdeeea3d255cd8d3c93e8e5cfedd33f71f2522d3fdecfb4b3f0c65d50d2b6a7226401834854

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_text/encoding.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module MicrosoftKiotaSerializationText
+  # bytes are read as UTF-8; a string Faraday tagged with its charset is converted
+  def self.to_utf8(text)
+    text.encoding == Encoding::BINARY ? text.dup.force_encoding(Encoding::UTF_8) : text.encode(Encoding::UTF_8)
+  end
+end

data/lib/microsoft_kiota_serialization_text/text_parse_node.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require 'time'
+require 'date'
+require 'uuidtools'
+require 'microsoft_kiota_abstractions'
+
+module MicrosoftKiotaSerializationText
+  class TextParseNode
+    include MicrosoftKiotaAbstractions::ParseNode
+
+    NO_STRUCTURED_DATA_MESSAGE = 'Text does not support structured data'
+
+    # temporal readers take only their own shape, as in the form gem, 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/
+
+    def initialize(text)
+      @text = text
+    end
+
+    def get_string_value
+      @text unless @text.nil? || @text.empty?
+    end
+
+    def get_boolean_value
+      case scalar_text&.downcase
+      when 'true' then true
+      when 'false' then false
+      end
+    end
+
+    def get_number_value
+      text = scalar_text
+      Integer(text, 10, exception: false) if text
+    end
+
+    def get_float_value
+      text = scalar_text
+      Float(text, exception: false) if text
+    end
+
+    def get_guid_value
+      parsed { |text| UUIDTools::UUID.parse(text) }
+    end
+
+    def get_date_value
+      parsed { |text| Date.parse(text) if DATE.match?(text) }
+    end
+
+    def get_time_value
+      parsed { |text| Time.parse(text) if TIME.match?(text) }
+    end
+
+    def get_date_time_value
+      parsed { |text| DateTime.parse(text) if DATE_TIME.match?(text) }
+    end
+
+    def get_duration_value
+      parsed { |text| MicrosoftKiotaAbstractions::ISODuration.new(text) }
+    end
+
+    def get_byte_array_value
+      scalar_text&.unpack1('m')
+    end
+
+    def get_enum_value(type)
+      text = scalar_text
+      resolve_enum_member(type, text) if text
+    end
+
+    def get_child_node(_name)
+      raise StandardError, NO_STRUCTURED_DATA_MESSAGE
+    end
+
+    def get_collection_of_primitive_values(_type)
+      raise StandardError, NO_STRUCTURED_DATA_MESSAGE
+    end
+
+    def get_collection_of_object_values(_factory)
+      raise StandardError, NO_STRUCTURED_DATA_MESSAGE
+    end
+
+    def get_collection_of_enum_values(_type)
+      raise StandardError, NO_STRUCTURED_DATA_MESSAGE
+    end
+
+    def get_object_value(_factory)
+      raise StandardError, NO_STRUCTURED_DATA_MESSAGE
+    end
+
+    private
+
+    # text that does not parse reads as nil, as .NET's TryParse and the form gem do
+    def parsed
+      text = scalar_text
+      yield text if text
+    rescue StandardError
+      nil
+    end
+
+    # typed values ignore surrounding whitespace, as .NET's TryParse does
+    def scalar_text
+      text = get_string_value&.strip
+      text unless text.nil? || text.empty?
+    end
+
+    # same resolution as JsonParseNode: the wire value first, then the member name
+    def resolve_enum_member(type, raw)
+      return raw.to_sym unless type.is_a?(Hash)
+
+      type.each_value { |value| return value if value.to_s == raw }
+      type[raw.to_sym] || type[(raw[0].to_s.upcase + raw[1..].to_s).to_sym]
+    end
+  end
+end

data/lib/microsoft_kiota_serialization_text/text_parse_node_factory.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'microsoft_kiota_abstractions'
+require_relative 'encoding'
+
+module MicrosoftKiotaSerializationText
+  class TextParseNodeFactory
+    include MicrosoftKiotaAbstractions::ParseNodeFactory
+
+    def get_valid_content_type
+      'text/plain'
+    end
+
+    def get_parse_node(content_type, 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? || content.empty?
+
+      TextParseNode.new(MicrosoftKiotaSerializationText.to_utf8(content).delete_prefix("\uFEFF"))
+    end
+  end
+end

data/lib/microsoft_kiota_serialization_text/text_serialization_writer.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require 'time'
+require 'date'
+require 'uuidtools'
+require 'microsoft_kiota_abstractions'
+require_relative 'encoding'
+require_relative 'text_parse_node'
+
+module MicrosoftKiotaSerializationText
+  class TextSerializationWriter
+    include MicrosoftKiotaAbstractions::SerializationWriter
+
+    NO_STRUCTURED_DATA_MESSAGE = TextParseNode::NO_STRUCTURED_DATA_MESSAGE
+    VALUE_ALREADY_WRITTEN_MESSAGE =
+      'a value was already written for this serialization writer, text content only supports a single value'
+
+    def initialize
+      @content = nil
+    end
+
+    def write_string_value(key, value)
+      return if value.nil?
+      raise StandardError, NO_STRUCTURED_DATA_MESSAGE unless key.nil? || key.empty?
+      raise StandardError, VALUE_ALREADY_WRITTEN_MESSAGE unless @content.nil?
+
+      @content = value
+    end
+
+    def write_boolean_value(key, value)
+      write_string_value(key, value&.to_s)
+    end
+
+    def write_number_value(key, value)
+      write_string_value(key, value&.to_s)
+    end
+
+    def write_float_value(key, value)
+      write_string_value(key, value&.to_s)
+    end
+
+    def write_guid_value(key, value)
+      write_string_value(key, value&.to_s)
+    end
+
+    def write_date_value(key, value)
+      write_string_value(key, value&.strftime('%Y-%m-%d'))
+    end
+
+    def write_time_value(key, value)
+      return if value.nil?
+
+      digits = fraction_digits(value)
+      write_string_value(key, value.strftime(digits.zero? ? '%H:%M:%S' : "%H:%M:%S.%#{digits}N"))
+    end
+
+    def write_date_time_value(key, value)
+      write_string_value(key, value&.iso8601(fraction_digits(value)))
+    end
+
+    def write_duration_value(key, value)
+      write_string_value(key, value&.string)
+    end
+
+    def write_enum_value(key, value)
+      write_string_value(key, value&.to_s)
+    end
+
+    def write_byte_array_value(key, value)
+      write_string_value(key, value && [value].pack('m0'))
+    end
+
+    def write_null_value(key)
+      write_string_value(key, 'null')
+    end
+
+    def write_any_value(key, value)
+      case value
+      when nil then nil
+      when String then write_string_value(key, value)
+      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 DateTime then write_date_time_value(key, value)
+      when Date then write_date_value(key, value)
+      when Time then write_time_value(key, value)
+      when MicrosoftKiotaAbstractions::ISODuration then write_duration_value(key, value)
+      when UUIDTools::UUID then write_guid_value(key, value)
+      when Symbol then write_enum_value(key, value)
+      when Array, Hash, MicrosoftKiotaAbstractions::Parsable then raise StandardError, NO_STRUCTURED_DATA_MESSAGE
+      else raise StandardError, "encountered unknown value type during serialization #{value}"
+      end
+    end
+
+    def write_collection_of_primitive_values(_key, _values)
+      raise StandardError, NO_STRUCTURED_DATA_MESSAGE
+    end
+
+    def write_collection_of_object_values(_key, _values)
+      raise StandardError, NO_STRUCTURED_DATA_MESSAGE
+    end
+
+    def write_collection_of_enum_values(_key, _values)
+      raise StandardError, NO_STRUCTURED_DATA_MESSAGE
+    end
+
+    def write_object_value(_key, _value, *_additional_values_to_merge)
+      raise StandardError, NO_STRUCTURED_DATA_MESSAGE
+    end
+
+    def write_additional_data(_value)
+      raise StandardError, NO_STRUCTURED_DATA_MESSAGE
+    end
+
+    def get_serialized_content
+      @content.nil? ? '' : MicrosoftKiotaSerializationText.to_utf8(@content)
+    end
+
+    private
+
+    def fraction_digits(value)
+      value.strftime('%N').sub(/0+\z/, '').length
+    end
+  end
+end

data/lib/microsoft_kiota_serialization_text/text_serialization_writer_factory.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'microsoft_kiota_abstractions'
+
+module MicrosoftKiotaSerializationText
+  class TextSerializationWriterFactory
+    include MicrosoftKiotaAbstractions::SerializationWriterFactory
+
+    def get_valid_content_type
+      'text/plain'
+    end
+
+    def get_serialization_writer(content_type)
+      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)
+
+      TextSerializationWriter.new
+    end
+  end
+end

data/lib/microsoft_kiota_serialization_text/version.rb

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

data/lib/microsoft_kiota_serialization_text.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative 'microsoft_kiota_serialization_text/text_parse_node'
+require_relative 'microsoft_kiota_serialization_text/text_parse_node_factory'
+require_relative 'microsoft_kiota_serialization_text/text_serialization_writer'
+require_relative 'microsoft_kiota_serialization_text/text_serialization_writer_factory'
+require_relative 'microsoft_kiota_serialization_text/version'
+
+module MicrosoftKiotaSerializationText
+end

data/microsoft_kiota_serialization_text.gemspec

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative 'lib/microsoft_kiota_serialization_text/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'microsoft_kiota_serialization_text'
+  spec.version       = MicrosoftKiotaSerializationText::VERSION
+  spec.authors       = 'Microsoft Corporation'
+  spec.email         = 'graphsdkpub+ruby@microsoft.com'
+  spec.description   = 'Implementation of Kiota Serialization interfaces for text'
+  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/text',
+    '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', MicrosoftKiotaSerializationText::VERSION
+  spec.add_dependency 'uuidtools', '>= 2.2', '< 3.1'
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification
+name: microsoft_kiota_serialization_text
+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 text
+email: graphsdkpub+ruby@microsoft.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Rakefile
+- lib/microsoft_kiota_serialization_text.rb
+- lib/microsoft_kiota_serialization_text/encoding.rb
+- lib/microsoft_kiota_serialization_text/text_parse_node.rb
+- lib/microsoft_kiota_serialization_text/text_parse_node_factory.rb
+- lib/microsoft_kiota_serialization_text/text_serialization_writer.rb
+- lib/microsoft_kiota_serialization_text/text_serialization_writer_factory.rb
+- lib/microsoft_kiota_serialization_text/version.rb
+- microsoft_kiota_serialization_text.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/text
+  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: []