sorbet-runtime 0.5.5576 → 0.5.5579

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4597a9465352354d6c9500c16f55a3ab0370d472dd88efaa3ead9a1566094628
-  data.tar.gz: 7edc121b16f8622fa77bfc5cc50ccaadac729f648a5f01af824b8ae4c3391ed2
+  metadata.gz: 64118c41b03c7b4d993275e0ff71f853fa8ffa2078fbaf769ca6755564fb0ef8
+  data.tar.gz: ae794f0928f3b8fbf95e154afccb21b3fc206a3c096eb9b9bdaa159638fe6599
 SHA512:
-  metadata.gz: 03ae7012e856f3cdbbc07a3017b97dfed7521f9328acfb3e3f0377f2f741b541c67c12976cabe72df8629ebedc0f52f2dbbf38dfdebf4155152ab7dcde4df058
-  data.tar.gz: 5577c156d4b817f0b58ff480fbba30dc3ed22afa55e5a0213e340b172f5ff48d18ac6e6ea3c86fbdfea9b5f6baa2a98d34132c079ee1a4b779bd95590318114e
+  metadata.gz: 27ebb20c813c95d0d3b4e354d72f4cae80297050fbf3697fd9fa9512fed0c9cc04f9fc7a315e25aad267c222fc2e0fc05bb2e2436877d0e0b8ad97ebe87a5a18
+  data.tar.gz: c0b048e1a48b5481ad65b81d1a0cdeeab956b4aa3edf61f2e7381cfc077996ce459899cc680ac1948fe68a4e892c05f8b9c7510ac3412f4cb3f9db623ef131e7

data/lib/types/enum.rb

@@ -97,17 +97,8 @@ class T::Enum
     @mapping.include?(serialized_val)
   end
 
-
-  ## T::Props::CustomType
-
-  # Note: Failed CriticalMethodsNoRuntimeTypingTest
-  sig {params(value: T.untyped).returns(T::Boolean).checked(:never)}
-  def self.instance?(value)
-    value.is_a?(self)
-  end
-
   # Note: Failed CriticalMethodsNoRuntimeTypingTest
-  sig {params(instance: T.nilable(T::Enum)).returns(SerializedVal).checked(:never)}
+  sig {override.params(instance: T.nilable(T::Enum)).returns(SerializedVal).checked(:never)}
   def self.serialize(instance)
     # This is needed otherwise if a Chalk::ODM::Document with a property of the shape
     # T::Hash[T.nilable(MyEnum), Integer] and a value that looks like {nil => 0} is
@@ -124,7 +115,7 @@ class T::Enum
   end
 
   # Note: Failed CriticalMethodsNoRuntimeTypingTest
-  sig {params(mongo_value: SerializedVal).returns(T.attached_class).checked(:never)}
+  sig {override.params(mongo_value: SerializedVal).returns(T.attached_class).checked(:never)}
   def self.deserialize(mongo_value)
     if self == T::Enum
       raise "Cannot call T::Enum.deserialize directly. You must call on a specific child class."

data/lib/types/props/_props.rb

@@ -39,7 +39,7 @@ module T::Props
     # a document class.
     #
     # @param name [Symbol] The name of this property
-    # @param cls [Class,T::Props::CustomType] (String) The type of this
+    # @param cls [Class,T::Types::Base] The type of this
     #   property. If the type is itself a {Document} subclass, this
     #   property will be recursively serialized/deserialized.
     # @param rules [Hash] Options to control this property's behavior.
@@ -90,10 +90,6 @@ module T::Props
     #   none is provided.
     # @option rules [T::Boolean] :immutable If true, this prop cannot be
     #   modified after an instance is created or loaded from a hash.
-    # @option rules [Class,T::Props::CustomType] :array If set, specifies the
-    #   type of individual members of a prop with `type` `Array`. This
-    #   allows for typechecking of arrays, and also for recursive
-    #   serialization of arrays of sub-{Document}s.
     # @option rules [T::Boolean] :override It is an error to redeclare a
     #   `prop` that has already been declared (including on a
     #   superclass), unless `:override` is set to `true`.

data/lib/types/props/custom_type.rb

@@ -1,20 +1,35 @@
 # frozen_string_literal: true
-# typed: false
+# typed: strict
 
 module T::Props
   module CustomType
+    extend T::Sig
+    extend T::Helpers
+
+    abstract!
+
     include Kernel # for `is_a?`
 
-    # Returns true if the given Ruby value can be assigned to a T::Props field
-    # of this type.
-    #
-    # @param [Object] _value
-    # @return T::Boolean
-    def instance?(_value)
-      raise NotImplementedError.new('Must override in included class')
+    # Alias for backwards compatibility
+    sig(:final) do
+      params(
+        value: BasicObject,
+      )
+      .returns(T::Boolean)
+      .checked(:never)
+    end
+    def instance?(value)
+      self.===(value)
     end
 
-    # Alias for consistent interface with T::Types::Base
+    # Alias for backwards compatibility
+    sig(:final) do
+      params(
+        value: BasicObject,
+      )
+      .returns(T::Boolean)
+      .checked(:never)
+    end
     def valid?(value)
       instance?(value)
     end
@@ -24,30 +39,30 @@ module T::Props
     #
     # @param [Object] _instance
     # @return An instance of one of T::Configuration.scalar_types
-    def serialize(_instance)
-      raise NotImplementedError.new('Must override in included class')
-    end
+    sig {abstract.params(instance: T.untyped).returns(T.untyped).checked(:never)}
+    def serialize(instance); end
 
     # Given the serialized form of your type, this returns an instance
     # of that custom type representing that value.
     #
-    # @param _mongo_scalar One of T::Configuration.scalar_types
+    # @param scalar One of T::Configuration.scalar_types
     # @return Object
-    def deserialize(_mongo_scalar)
-      raise NotImplementedError.new('Must override in included class')
-    end
+    sig {abstract.params(scalar: T.untyped).returns(T.untyped).checked(:never)}
+    def deserialize(scalar); end
 
+    sig {override.params(_base: Module).void}
     def self.included(_base)
       super
 
       raise 'Please use "extend", not "include" to attach this module'
     end
 
+    sig(:final) {params(val: Object).returns(T::Boolean).checked(:never)}
     def self.scalar_type?(val)
       # We don't need to check for val's included modules in
       # T::Configuration.scalar_types, because T::Configuration.scalar_types
       # are all classes.
-      klass = val.class
+      klass = T.let(val.class, T.nilable(Class))
       until klass.nil?
         return true if T::Configuration.scalar_types.include?(klass.to_s)
         klass = klass.superclass
@@ -59,16 +74,8 @@ module T::Props
     # implement set-like fields that store a unique-array, but forbid
     # hashes; Custom hash types should be implemented via an emebdded
     # T::Struct (or a subclass like Chalk::ODM::Document) or via T.
-    def self.valid_serialization?(val, type=nil)
-      if type&.name == 'Chalk::ODM::BsonTypes::BsonObject'
-        # Special case we allow for backwards compatibility with props formerly
-        # typed as "Object" or "Hash", which contain arbitrarily-nested BSON
-        # data (e.g. parsed API request bodies). In general, we aren't pushing
-        # to convert these to Chalk::ODM::BsonTypes - we'd rather delurk them -
-        # but this lets us convert events with these types to Proto.
-        return true
-      end
-
+    sig(:final) {params(val: Object).returns(T::Boolean).checked(:never)}
+    def self.valid_serialization?(val)
       case val
       when Array
         val.each do |v|
@@ -81,10 +88,15 @@ module T::Props
       end
     end
 
-    def self.checked_serialize(type, instance)
-      val = type.serialize(instance)
-      unless valid_serialization?(val, type)
-        msg = "#{type} did not serialize to a valid scalar type. It became a: #{val.class}"
+    sig(:final) do
+      params(instance: Object)
+      .returns(T.untyped)
+      .checked(:never)
+    end
+    def self.checked_serialize(instance)
+      val = T.cast(instance.class, T::Props::CustomType).serialize(instance)
+      unless valid_serialization?(val)
+        msg = "#{instance.class} did not serialize to a valid scalar type. It became a: #{val.class}"
         if val.is_a?(Hash)
           msg += "\nIf you want to store a structured Hash, consider using a T::Struct as your type."
         end

data/lib/types/props/decorator.rb

@@ -12,7 +12,7 @@ class T::Props::Decorator
 
   Rules = T.type_alias {T::Hash[Symbol, T.untyped]}
   DecoratedInstance = T.type_alias {Object} # Would be T::Props, but that produces circular reference errors in some circumstances
-  PropType = T.type_alias {T.any(T::Types::Base, T::Props::CustomType)}
+  PropType = T.type_alias {T::Types::Base}
   PropTypeOrClass = T.type_alias {T.any(PropType, Module)}
 
   class NoRulesError < StandardError; end
@@ -335,10 +335,7 @@ class T::Props::Decorator
     if !cls.is_a?(Module)
       cls = convert_type_to_class(cls)
     end
-    type_object = type
-    if !(type_object.singleton_class < T::Props::CustomType)
-      type_object = smart_coerce(type_object, array: rules[:array], enum: rules[:enum])
-    end
+    type_object = smart_coerce(type, array: rules[:array], enum: rules[:enum])
 
     prop_validate_definition!(name, cls, rules, type_object)
 

data/lib/types/props/private/serde_transform.rb

@@ -128,8 +128,7 @@ module T::Props
       private_class_method def self.handle_custom_type(varname, type, mode)
         case mode
         when Serialize
-          type_name = T.must(module_name(type))
-          "T::Props::CustomType.checked_serialize(#{type_name}, #{varname})"
+          "T::Props::CustomType.checked_serialize(#{varname})"
         when Deserialize
           type_name = T.must(module_name(type))
           "#{type_name}.deserialize(#{varname})"

data/lib/types/props/private/setter_factory.rb

@@ -20,17 +20,10 @@ module T::Props
       end
       def self.build_setter_proc(klass, prop, rules)
         # Our nil check works differently than a simple T.nilable for various
-        # reasons (including the `raise_on_nil_write` setting, the existence
-        # of defaults & factories, and the fact that we allow `T.nilable(Foo)`
-        # where Foo < T::Props::CustomType as a prop type even though calling
-        # `valid?` on it won't work as expected), so unwrap any T.nilable and
-        # do a check manually. (Note this hack does not fix custom types as
-        # collection elements.)
+        # reasons (including the `raise_on_nil_write` setting and the existence
+        # of defaults & factories), so unwrap any T.nilable and do a check
+        # manually.
         non_nil_type = T::Utils::Nilable.get_underlying_type_object(rules.fetch(:type_object))
-        if non_nil_type.is_a?(T::Types::Simple) && non_nil_type.raw_type.singleton_class < T::Props::CustomType
-          non_nil_type = non_nil_type.raw_type
-        end
-
         accessor_key = rules.fetch(:accessor_key)
         validate = rules[:setter_validate]
 
@@ -51,7 +44,7 @@ module T::Props
         params(
           prop: Symbol,
           accessor_key: Symbol,
-          non_nil_type: T.any(T::Types::Base, T.all(T::Props::CustomType, Module)),
+          non_nil_type: T::Types::Base,
           klass: T.all(Module, T::Props::ClassMethods),
           validate: T.nilable(ValidateProc)
         )
@@ -80,7 +73,7 @@ module T::Props
         params(
           prop: Symbol,
           accessor_key: Symbol,
-          non_nil_type: T.any(T::Types::Base, T.all(T::Props::CustomType, Module)),
+          non_nil_type: T::Types::Base,
           klass: T.all(Module, T::Props::ClassMethods),
           validate: T.nilable(ValidateProc),
         )

data/lib/types/props/type_validation.rb

@@ -28,7 +28,7 @@ module T::Props::TypeValidation
     def prop_validate_definition!(name, _cls, rules, type)
       super
 
-      if !rules[:DEPRECATED_underspecified_type] && !(type.singleton_class <= T::Props::CustomType)
+      if !rules[:DEPRECATED_underspecified_type]
         validate_type(type, field_name: name)
       elsif rules[:DEPRECATED_underspecified_type] && find_invalid_subtype(type).nil?
         raise ArgumentError.new("DEPRECATED_underspecified_type set unnecessarily for #{@class.name}.#{name} - #{type} is a valid type")

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sorbet-runtime
 version: !ruby/object:Gem::Version
-  version: 0.5.5576
+  version: 0.5.5579
 platform: ruby
 authors:
 - Stripe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-05-04 00:00:00.000000000 Z
+date: 2020-05-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest