dub 0.12.5 → 1.0.0

checksums.yaml

@@ -1,7 +0,0 @@
----
-SHA256:
-  metadata.gz: 41735c609fdd842dc1c2cbc512b1131e3e3ca825b233a70b5251e36137970a86
-  data.tar.gz: 7f7f5975a408bf9a6969d1f6f086b07dacf325fe19edf4ee910b9cea37daf200
-SHA512:
-  metadata.gz: 6f051245203954c7078adb22c10d73fafd4778e20b9eb2ff983a02f947c56c3d6d0201aef1da5f8924549a424bf39413a7c65637bf9e7cadb8309b13c5b25058
-  data.tar.gz: 3d032d1af64548fedd00a6b7123d26488f25091b8788b7751512895f8f0f9d00e1aee241b59adb97da988fb4b66662a6c8092d52131946ac5338db62cefec9a1

data/lib/crystalline/enum.rbi

@@ -1,17 +0,0 @@
-# typed: true
-
-module Crystalline
-  module Enum
-    mixes_in_class_methods(ClassMethods)
-
-    module ClassMethods
-      def enums(&blk); end
-      def open!; end
-      def open?; end
-      def deserialize(val); end
-    end
-
-    def serialize; end
-    def known?; end
-  end
-end

data/lib/crystalline/metadata_fields.rb

@@ -1,208 +0,0 @@
-# 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_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 field_type.is_a?(Crystalline::DiscriminatedUnion)
-            to_build[key] = field_type.parse(value)
-          elsif 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)
-            discriminator_mapping = field.metadata.fetch(:discriminator_mapping, nil)
-            if !discriminator.nil?
-              discriminator_value = value.fetch(discriminator)
-              if !discriminator_mapping.nil?
-                # Use explicit mapping from discriminator value to type
-                type_to_deserialize = discriminator_mapping[discriminator_value]
-              else
-                # Fallback: try to match discriminator value against type name
-                type_to_deserialize = Crystalline::Utils.get_union_types(field_type).find { |t| t.name.split('::').last == discriminator_value }
-              end
-              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) }
-
-              if Crystalline.union_strategy == :populated_fields
-                to_build[key] = Crystalline.unmarshal_union_populated_fields(value, union_types)
-              else
-                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
-            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.transform_values { |v| 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

@@ -1,182 +0,0 @@
-# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
-
-# typed: false
-# frozen_string_literal: true
-
-module Crystalline
-  @union_strategy = :left_to_right
-
-  class << self
-    attr_accessor :union_strategy
-  end
-
-  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.is_a?(Crystalline::DiscriminatedUnion)
-      type.parse(data)
-    elsif 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) }
-
-      if Crystalline.union_strategy == :populated_fields
-        Crystalline.unmarshal_union_populated_fields(data, union_types)
-      else
-        Crystalline.unmarshal_union_left_to_right(data, union_types)
-      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
-    elsif Crystalline::Utils.boolean? type
-      Crystalline::Utils.to_boolean(data)
-    elsif type.is_a?(Class) && type < T::Enum
-      type.deserialize(data)
-    elsif type.is_a?(Class) && type.respond_to?(:enums) && type.respond_to?(:deserialize)
-      type.deserialize(data)
-    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.unmarshal_union_left_to_right(data, union_types)
-    union_types.each do |union_type|
-      return Crystalline.unmarshal_json(data, union_type)
-    rescue TypeError
-      next
-    rescue NoMethodError
-      next
-    rescue KeyError
-      next
-    end
-    nil
-  end
-
-  def self.unmarshal_union_populated_fields(data, union_types)
-    best_value = nil
-    best_matched = -1
-    best_inexact = 0
-    best_unmatched = 0
-
-    union_types.each do |union_type|
-      value = Crystalline.unmarshal_json(data, union_type)
-      matched, inexact, unmatched = count_matched_fields(value, data)
-
-      if best_value.nil? ||
-         matched > best_matched ||
-         (matched == best_matched && inexact < best_inexact) ||
-         (matched == best_matched && inexact == best_inexact && unmatched < best_unmatched)
-        best_value = value
-        best_matched = matched
-        best_inexact = inexact
-        best_unmatched = unmatched
-      end
-    rescue TypeError
-      next
-    rescue NoMethodError
-      next
-    rescue KeyError
-      next
-    end
-    best_value
-  end
-
-  def self.count_matched_fields(value, raw_data)
-    matched = 0
-    inexact = 0
-    unmatched = 0
-
-    if value.is_a?(Crystalline::Unknown)
-      return [0, 0, 0]
-    elsif value.class.include?(::Crystalline::MetadataFields)
-      value.fields.each do |field|
-        format_metadata = field.metadata.fetch(:format_json, {})
-        lookup = format_metadata.fetch(:letter_case, nil)&.call
-        field_val = value.send(field.name)
-
-        if raw_data.is_a?(::Hash) && lookup && raw_data.key?(lookup)
-          if field_val.class.include?(::Crystalline::MetadataFields) && raw_data[lookup].is_a?(::Hash)
-            nested_matched, nested_inexact, nested_unmatched = count_matched_fields(field_val, raw_data[lookup])
-            matched += nested_matched
-            inexact += nested_inexact
-            unmatched += nested_unmatched
-          else
-            matched += 1
-            if field_val.respond_to?(:known?) && !field_val.known?
-              inexact += 1
-            end
-          end
-        elsif !::Crystalline::Utils.nilable?(field.type)
-          unmatched += 1
-        end
-      end
-    elsif value.is_a?(::Array)
-      matched = value.length
-    elsif value.is_a?(::Hash)
-      matched = value.length
-    else
-      matched = 1
-    end
-
-    [matched, inexact, unmatched]
-  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

@@ -1,162 +0,0 @@
-# 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
-
-  # Wraps an unrecognized payload from an open discriminated union.
-  # Produced when the discriminator value is missing, unknown, or schema validation fails.
-  class Unknown
-    attr_reader :raw
-
-    def initialize(raw:)
-      @raw = raw
-    end
-
-    def unknown?
-      true
-    end
-  end
-
-  # Forward-compatible discriminated union parser.
-  # Known discriminator values are deserialized to their mapped types.
-  # Unknown or invalid payloads are captured as Crystalline::Unknown.
-  class DiscriminatedUnion
-    attr_reader :discriminator, :variants
-
-    def initialize(discriminator, variants)
-      @discriminator = discriminator
-      @variants = variants
-    end
-
-    def parse(payload)
-      unless payload.is_a?(::Hash)
-        return Unknown.new(raw: payload)
-      end
-
-      disc_value = payload[@discriminator]
-      unless disc_value.is_a?(::String)
-        return Unknown.new(raw: payload)
-      end
-
-      variant_type = @variants[disc_value]
-      unless variant_type
-        return Unknown.new(raw: payload)
-      end
-
-      begin
-        Crystalline.unmarshal_json(payload, variant_type)
-      rescue StandardError
-        Unknown.new(raw: payload)
-      end
-    end
-  end
-
-  def self.unknown?(value)
-    value.is_a?(Unknown)
-  end
-
-  module Enum
-    def self.included(base)
-      base.extend(ClassMethods)
-    end
-
-    def initialize(val)
-      if self.class.instance_methods(false).include?(:initialize)
-        super(val)
-      else
-        @val = val
-      end
-    end
-
-    module ClassMethods
-      def 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 open!
-        @open = true
-      end
-
-      def open?
-        @open == true
-      end
-
-      def deserialize(val)
-        if @mapping.include? val
-          @mapping[val]
-        elsif open?
-          new(val)
-        else
-          raise "Invalid value for enum: #{val}"
-        end
-      end
-    end
-
-    def serialize
-      @val
-    end
-
-    def known?
-      self.class.instance_variable_get(:@mapping)&.value?(self) || false
-    end
-
-    def ==(other)
-      other = other.serialize if other.is_a?(self.class)
-      @val == other
-    end
-
-    def eql?(other)
-      self == other
-    end
-
-    def hash
-      @val.hash
-    end
-  end
-end

data/lib/crystalline/utils.rb

@@ -1,69 +0,0 @@
-# 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
-
-    def self.boolean?(t)
-      t.instance_of? Crystalline::Boolean
-    end
-
-    def self.to_boolean(value)
-      case value
-      when true, false
-        value
-      else
-        raise TypeError, "Cannot convert #{value.inspect} to boolean. The value is of type #{value.class}"
-      end
-    end
-  end
-end

data/lib/crystalline.rb

@@ -1,13 +0,0 @@
-# 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'