noresponse 2.0.17

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 11bfa2970f31bcc0378fb41e28e49ef1110deabe3465de79f3ade73edc0d4925
+  data.tar.gz: 18e90777775e84f17ad88fe7ac513890e81bb8d9e94da0d9f32acccfff6ae4c4
+SHA512:
+  metadata.gz: 47b473b6bd4a15e0ecd98201a5d091cb79a1132e2f994f98e596ac53a2f2c5a7f28906042736f9429b6738959cbc68ee67bddbce04b595a0849d6f7bcd815513
+  data.tar.gz: 40db1e2297e6b58cddf46fea5ef5ae3fbdb21942991367592c47182985e55e6d34e8296737c2027bf699b0fc33ab8bd63c876d38b3b6e4b92e9b7267e4a05004

data/lib/crystalline/enum.rbi

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

@@ -0,0 +1,263 @@
+# 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)
+
+        # Delegate complex Crystalline types to unmarshal_json
+        if field_type.is_a?(Crystalline::DiscriminatedUnion) ||
+           Crystalline::Utils.arr?(field_type) ||
+           Crystalline::Utils.hash?(field_type) ||
+           Crystalline::Utils.union?(field_type)
+          return Crystalline.unmarshal_json(value, field_type)
+        elsif 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'
+          if value.is_a?(::String)
+            trimmed = value.lstrip
+            if trimmed.start_with?('{') || trimmed.start_with?('[')
+              # rubocop:disable Lint/SuppressedException
+              begin
+                value = JSON.parse(value)
+              rescue TypeError, JSON::ParserError
+              end
+              # rubocop:enable Lint/SuppressedException
+            end
+          end
+          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 = {}
+
+        # Collect lookup keys for regular fields so we can identify additional properties later
+        known_keys = {}
+        additional_props_fields = []
+        fields.each do |field|
+          format_metadata = field.metadata.fetch(:format_json, {})
+          if format_metadata.fetch(:additional_properties, false)
+            additional_props_fields << field
+          else
+            lookup = format_metadata.fetch(:letter_case, nil).call
+            known_keys[lookup] = true
+          end
+        end
+
+        # Process regular fields
+        (fields - additional_props_fields).each do |field|
+          key = field.name
+          format_metadata = field.metadata.fetch(:format_json, {})
+          field_type = field.type
+
+          lookup = format_metadata.fetch(:letter_case, nil).call
+          value = d[lookup]
+          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
+
+        # Process additional properties fields: collect remaining keys from the dict
+        additional_props_fields.each do |field|
+          key = field.name
+          format_metadata = field.metadata.fetch(:format_json, {})
+          field_type = field.type
+
+          remaining = d.reject { |k, _| known_keys.key?(k) }
+          if remaining.empty?
+            next if ::Crystalline::Utils.nilable?(field.type)
+
+            raise KeyError, 'no additional properties found in hash'
+          end
+
+          inner_field_type = field_type
+          inner_field_type = ::Crystalline::Utils.nilable_of(inner_field_type) if ::Crystalline::Utils.nilable?(inner_field_type)
+          if Crystalline::Utils.hash?(inner_field_type)
+            val_type = Crystalline::Utils.hash_of(inner_field_type)
+            # rubocop:disable Style/HashTransformValues
+            to_build[key] = remaining.map { |k, v| [k, unmarshal_single(val_type, v, format_metadata)] }.to_h
+            # rubocop:enable Style/HashTransformValues
+          else
+            to_build[key] = remaining
+          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)
+        is_additional_props = !format_json_meta.nil? && format_json_meta.fetch(:additional_properties, false)
+
+        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
+
+        # Flatten additional properties into the parent object
+        if is_additional_props && f.is_a?(::Hash)
+          f.each { |k, v| result[k] = marshal_single(v) }
+        elsif 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

@@ -0,0 +1,186 @@
+# typed: false
+# frozen_string_literal: true
+
+module Crystalline
+  @union_strategy = :populated_fields
+
+  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").sub(/(\.\d*[1-9])0+Z\z/, "\\1Z").sub(/\.0+Z\z/, "Z")
+    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

@@ -0,0 +1,168 @@
+# 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 to_s
+      serialize.to_s
+    end
+
+    def inspect
+      "#<#{self.class} #{serialize.inspect}>"
+    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

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