dub 0.10.3 → 1.0.0

checksums.yaml

@@ -1,7 +0,0 @@
----
-SHA256:
-  metadata.gz: 6d704bd2d8f1357605137a99d2154405db12f973f085be950ed14f10f36a5b05
-  data.tar.gz: 195d2ac9d4b023d5be3644cfa9f284027ce9651ad87eace33a370347fc144c68
-SHA512:
-  metadata.gz: 585cc01fcab801381da3e11f0014f11c189cef93fd17e7e7283aadc99ba8a990faef1319d3d0ceb10870d9cc6dbc05f91cc80f0e5fa424e7c555237d3e1f28ac
-  data.tar.gz: e1adce9cd6ab080924bb4a4c5986d70c414dd0f244160b74e892a967a960f0c0e4d6a878b1c723ee685b748be21597c297ed7aba726d4ef7d0bbe6f8a04420fa

data/lib/crystalline/metadata_fields.rb

@@ -1,209 +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_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

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

@@ -1,78 +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
-
-  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

@@ -1,56 +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
-  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'