authlete_ruby_test 0.0.1.beta

data/lib/authlete_ruby_test.rb

@@ -0,0 +1,45 @@
+# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+
+# typed: true
+# frozen_string_literal: true
+
+module Authlete
+  autoload :Client, 'authlete/client'
+  autoload :Services, 'authlete/services'
+  autoload :Clients, 'authlete/clients'
+  autoload :ClientManagement, 'authlete/client_management'
+  autoload :Authorization, 'authlete/authorization'
+  autoload :PushedAuthorization, 'authlete/pushed_authorization'
+  autoload :Tokens, 'authlete/tokens'
+  autoload :Introspection, 'authlete/introspection'
+  autoload :Revocation, 'authlete/revocation'
+  autoload :Userinfo, 'authlete/userinfo'
+  autoload :TokenManagement, 'authlete/token_management'
+  autoload :GrantManagement, 'authlete/grant_management'
+  autoload :JWKSetEndpoint, 'authlete/jwk_set_endpoint'
+  autoload :DynamicClientRegistration, 'authlete/dynamic_client_registration'
+  autoload :Ciba, 'authlete/ciba'
+  autoload :DeviceFlow, 'authlete/device_flow'
+  autoload :JoseObject, 'authlete/jose_object'
+  autoload :Federation, 'authlete/federation'
+  autoload :HardwareSecurityKeys, 'authlete/hardware_security_keys'
+  autoload :VerifiableCredentials, 'authlete/verifiable_credentials'
+  autoload :AuthorizationManagement, 'authlete/authorization_management'
+  autoload :NativeSso, 'authlete/native_sso'
+  module Models
+    autoload :Components, 'authlete/models/components'
+    autoload :Operations, 'authlete/models/operations'
+    autoload :Errors, 'authlete/models/errors'
+    autoload :Callbacks, 'authlete/models/callbacks'
+  end
+end
+
+require_relative 'authlete/utils/utils'
+require_relative 'authlete/utils/request_bodies'
+require_relative 'authlete/utils/query_params'
+require_relative 'authlete/utils/forms'
+require_relative 'authlete/utils/headers'
+require_relative 'authlete/utils/url'
+require_relative 'authlete/utils/security'
+require_relative 'crystalline'
+require_relative 'authlete/sdkconfiguration'

data/lib/crystalline/metadata_fields.rb

@@ -0,0 +1,209 @@
+# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+
+# typed: false
+# frozen_string_literal: true
+
+module Crystalline
+  module MetadataFields
+
+    class Field
+      attr_accessor :name, :type, :metadata
+
+      def initialize(name, type, metadata)
+        @name = name
+        @type = type
+        @metadata = metadata
+      end
+    end
+
+    module ClassMethods
+
+      def fields
+        @__fields__ = [] if @__fields__.nil?
+
+        @__fields__
+      end
+
+      def field(field_name, type, metadata = {})
+        attr_accessor field_name
+
+        fields << Field.new(field_name, type, metadata)
+      end
+
+      def field_augmented?
+        true
+      end
+
+      def unmarshal_single(field_type, value, format_metadata = nil)
+        decoder = format_metadata.fetch(:decoder, nil)
+
+        if field_type.instance_of?(Class) && field_type.include?(::Crystalline::MetadataFields)
+          return field_type.from_dict(value)
+        elsif field_type.to_s == 'Date'
+          return Date.parse(value)
+        elsif field_type.to_s == 'DateTime'
+          return DateTime.parse(value)
+        elsif field_type.to_s == 'Object'
+          # rubocop:disable Lint/SuppressedException
+          begin
+            value = JSON.parse(value)
+          rescue TypeError, JSON::ParserError
+          end
+          # rubocop:enable Lint/SuppressedException
+          return value
+        elsif field_type.to_s == 'Float'
+          return value.to_f
+
+        end
+        if decoder.nil?
+          value
+        else
+          decoder.call(value)
+        end
+      end
+
+      def from_json(json_obj)
+        case json_obj
+        when String
+          begin
+            d = JSON.parse(json_obj)
+          rescue JSON::ParserError
+            d = json_obj
+          end
+        else
+          d = json_obj
+        end
+        from_json(d)
+      end
+
+      def from_dict(d)
+        to_build = {}
+
+        fields.each do |field|
+          key = field.name
+          format_metadata = field.metadata.fetch(:format_json, {})
+          lookup = format_metadata.fetch(:letter_case, nil).call
+          value = d[lookup]
+          field_type = field.type
+          if ::Crystalline::Utils.nilable? field_type
+            if value == 'null'
+              to_build[key] = nil
+              next
+            end
+            field_type = ::Crystalline::Utils.nilable_of(field_type)
+          end
+          
+          # 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? && !::Crystalline::Utils.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 Crystalline::Utils.arr? field_type
+            inner_type = Crystalline::Utils.arr_of(field_type)
+            unmarshalled_array = value.map { |f| unmarshal_single(inner_type, f, format_metadata) }
+            to_build[key] = unmarshalled_array
+          elsif Crystalline::Utils.hash? field_type
+            val_type = Crystalline::Utils.hash_of(field_type)
+
+            # rubocop:disable Style/HashTransformValues
+            unmarshalled_hash = value.map { |k, v| [k, unmarshal_single(val_type, v, format_metadata)] }.to_h
+            # rubocop:enable Style/HashTransformValues
+            to_build[key] = unmarshalled_hash
+          elsif Crystalline::Utils.union? field_type
+            discriminator = field.metadata.fetch(:discriminator, nil)
+            if !discriminator.nil?
+              type_to_deserialize = value.fetch(discriminator)
+              type_to_deserialize = Crystalline::Utils.get_union_types(field_type).find { |t| t.name.split('::').last == type_to_deserialize }
+              to_build[key] = Crystalline.unmarshal_json(value, type_to_deserialize)
+            else
+              union_types = Crystalline::Utils.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
+                  to_build[key] = Crystalline.unmarshal_json(value, union_type)
+                rescue TypeError
+                  next
+                rescue NoMethodError
+                  next
+                rescue KeyError
+                  next
+                end
+                break
+              end
+            end
+          elsif field_type.instance_of?(Class) && field_type.include?(::Crystalline::MetadataFields)
+            to_build[key] = Crystalline.unmarshal_json(value, field_type)
+          else
+            to_build[key] = unmarshal_single(field_type, value, format_metadata)
+          end
+        end
+        new(**to_build)
+      end
+    end
+
+    def initialize
+      instance = allocate
+      fields.each { |mod| instance.singleton_class.include(mod) }
+      instance.send(:initialize)
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    def fields
+      self.class.fields
+    end
+
+    def field(field_name)
+      fields.each do |f|
+        return f if f.name == field_name
+      end
+    end
+
+    def marshal_single(field)
+      if field.class.include? ::Crystalline::MetadataFields
+        field.to_dict
+      else
+        if ::Crystalline.needs_string_conversion field
+          ::Crystalline.json_encode field
+        else
+          field
+        end
+      end
+    end
+
+    def to_dict
+      result = {}
+      fields.sort_by(&:name).each do |field|
+        format_json_meta = field.metadata[:format_json]
+        required = !format_json_meta.nil? && format_json_meta.include?(:required)
+        if !format_json_meta.nil? && format_json_meta.include?(:letter_case)
+          key = format_json_meta[:letter_case].call(field.name)
+        else
+          key = field.name
+        end
+
+        f = send(field.name)
+        next if f.nil? && !required
+        result[key] = nil if f.nil? && required
+
+        if f.is_a? Array
+          result[key] = f.map { |o| marshal_single(o) }
+        elsif f.is_a? Hash
+          result[key] = f.map { |k, v| [k, marshal_single(v)] }
+        else
+          result[key] = marshal_single(f)
+        end
+      end
+      result
+    end
+
+    def to_json(*args)
+      JSON.generate(to_dict, *args)
+    end
+  end
+
+
+end

data/lib/crystalline/module.rb

@@ -0,0 +1,92 @@
+# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+
+# typed: false
+# frozen_string_literal: true
+
+module Crystalline
+
+  def self.to_dict(complex)
+    if complex.is_a? Array
+      complex.map { |v| Crystalline.to_dict(v) }
+    elsif complex.is_a? Hash
+      complex.transform_values { |v| Crystalline.to_dict(v) }
+    elsif complex.respond_to?(:class) && complex.class.include?(::Crystalline::MetadataFields)
+      complex.to_dict
+    else
+      json_encode complex, primitives: false
+    end
+  end
+
+  def self.needs_string_conversion(val)
+    val.class.respond_to?(:enums) || val.is_a?(DateTime) || val.nil?
+  end
+
+  def self.to_json(complex)
+    JSON.dump(to_dict(complex))
+  end
+
+  def self.unmarshal_json(data, type)
+    if Crystalline::Utils.nilable? type
+      type = Crystalline::Utils.nilable_of type
+    end
+    if type.instance_of?(Class) && type.include?(::Crystalline::MetadataFields)
+      type.from_dict(data)
+    elsif Crystalline::Utils.union? type
+      union_types = Crystalline::Utils.get_union_types(type)
+      union_types = union_types.sort_by { |klass| Crystalline.non_nilable_attr_count(klass) }
+
+      union_types.each do |union_type|
+        unmarshalled_val = Crystalline.unmarshal_json(data, union_type)
+        return unmarshalled_val
+      rescue TypeError
+        next
+      rescue NoMethodError
+        next
+      rescue KeyError
+        next
+      end
+    elsif Crystalline::Utils.arr? type
+      data.map { |v| Crystalline.unmarshal_json(v, Crystalline::Utils.arr_of(type)) }
+    elsif Crystalline::Utils.hash? type
+      data.transform_values { |v| Crystalline.unmarshal_json(v, Crystalline::Utils.hash_of(type)) }
+    elsif Crystalline::Utils.nilable?(type) && data == 'null'
+      nil
+    else
+      data
+    end
+  end
+
+  def self.json_encode(val, primitives: true)
+    if val.class.respond_to? :enums
+      val.serialize
+    elsif val.is_a? DateTime
+      val.strftime('%Y-%m-%dT%H:%M:%S.%NZ')
+    elsif val.nil?
+      nil
+    elsif primitives
+      val.to_s
+    else
+      val
+    end
+  end
+
+  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|
+        !::Crystalline::Utils.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

data/lib/crystalline/types.rb

@@ -0,0 +1,78 @@
+# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+
+# typed: false
+# frozen_string_literal: true
+
+module Crystalline
+  class Array
+    attr_accessor :inner_type
+
+    def initialize(inner_type)
+      @inner_type = inner_type
+    end
+  end
+
+  class Hash
+    attr_accessor :key_type, :value_type
+    
+    def initialize(key_type, value_type)
+      @key_type = key_type
+      @value_type = value_type
+    end
+  end
+
+  class Union
+    attr_accessor :types
+    
+    def initialize(*types)
+      @types = types
+    end
+  end
+
+  class Nilable
+    attr_accessor :inner_type
+    
+    def initialize(inner_type)
+      @inner_type = inner_type
+    end
+  end
+
+  class Boolean
+  end
+
+  module Enum
+    def initialize(val)
+      puts methods
+      if instance_methods(false).include?(:initialize)
+        super(val)
+      else
+        @val = val
+      end
+    end
+
+    def self.enums(&blk)
+      @mapping = {}
+
+      yield
+      constants(false).each do |const_name|
+        instance = const_get(const_name, false)
+        unless instance.is_a? self
+          raise 'Enum constants must be instances of the Enum class (e.g. `Foo = new`)'
+        end
+        @mapping[instance.serialize] = instance
+      end
+    end
+
+    def serialize
+      @val
+    end
+
+    def deserialize(val)
+      if @mapping.include? val
+        @mapping[val]
+      else
+        raise "Invalid value for enum: #{val}"
+      end
+    end
+  end
+end

data/lib/crystalline/utils.rb

@@ -0,0 +1,56 @@
+# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+
+# typed: false
+# frozen_string_literal: true
+
+module Crystalline
+  module Utils
+    def self.arr?(t)
+      if t.instance_of? Crystalline::Array
+        return true
+      end
+      false
+    end
+
+    def self.arr_of(t)
+      t.inner_type
+    end
+
+    def self.hash?(t)
+      if t.instance_of? Crystalline::Hash
+        return true
+      end
+      false
+    end
+
+    def self.hash_of(t)
+      t.value_type
+    end
+
+    def self.nilable?(t)
+      if t.instance_of? Crystalline::Nilable
+        return true
+      end
+      if t.instance_of? Crystalline::Union
+        return t.types.any? { |tt| tt.instance_of? Crystalline::Nilable }
+      end
+      false
+    end
+
+    def self.nilable_of(t)
+      
+      if nilable? t
+        return t.inner_type
+      end
+      nil
+    end
+
+    def self.union?(t)
+      return t.instance_of? Crystalline::Union
+    end
+
+    def self.get_union_types(t)
+      t.types
+    end
+  end
+end

data/lib/crystalline.rb

@@ -0,0 +1,13 @@
+# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+
+# typed: false
+# frozen_string_literal: true
+
+module Crystalline
+  autoload :MetadataFields, 'crystalline/metadata_fields'
+end
+
+
+require_relative 'crystalline/utils'
+require_relative 'crystalline/module'
+require_relative 'crystalline/types'