sorbet-runtime 0.4.4321 → 0.4.4322

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 55f2218bd8ea16d7c8390da6504451472425f6b0
-  data.tar.gz: 150dde097f793876984025db081e6bbe5fca6e53
+  metadata.gz: f4467e9a187ef1afa84f78db3ee5771e61b6727f
+  data.tar.gz: b1b92e841097fecfffd2137e8bc572960c762ff6
 SHA512:
-  metadata.gz: 859b2d4e8c767b2975188828bddf1fb8c1779f2dee1c5781742c8c012501266d2330a22d9ecb048e19f857b33294019b3faacc17b15d0df1575f6aea32a638d4
-  data.tar.gz: 2821f3baf23d4bf62f2c5ea4b770f7bf385f802ba4d18fe95c69c07b10066f289c38499665f716ed59c227e0a57e3bab74e241e36f51808deb59aec4fa02dc70
+  metadata.gz: c840637529ae6864501dd9132d272b02fafb9d91366c487919ac9e307d467d6343af8d9816c6227140cf8cbe48c74cdb9a4582f29fece604258f7a37b72179fb
+  data.tar.gz: 4120461d62a00240114e6a146fc91dee43e108fac23d0f02db18dddd69cf103472429f043463253184aaf0ac4309ee46d947b6d8becd530bb907b142abad2794

data/lib/types/compatibility_patches.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 # typed: ignore
 
 require_relative 'private/methods/_methods'

data/lib/types/private/abstract/declare.rb

@@ -18,10 +18,6 @@ module T::Private::Abstract::Declare
     mod.extend(T::InterfaceWrapper::Helpers)
 
     if mod.is_a?(Class)
-      if mod < T::Struct
-        raise "#{mod.name} is a subclass of T::Struct and cannot be declared abstract"
-      end
-
       if type == :interface
         # Since `interface!` is just `abstract!` with some extra validation, we could technically
         # allow this, but it's unclear there are good use cases, and it might be confusing.

data/lib/types/private/methods/signature_validation.rb

@@ -11,7 +11,7 @@ module T::Private::Methods::SignatureValidation
       # but in practice, you never call them polymorphically. Conceptually, they're standard
       # methods (this is consistent with how they're treated in other languages, e.g. Java)
       if signature.mode != Modes.standard
-        raise "Constructor methods should always be declared using `sig`."
+        raise "`initialize` should not use `.abstract` or `.implementation` or any other inheritance modifiers."
       end
       return
     end

data/lib/types/props/constructor.rb

@@ -10,7 +10,7 @@ module T::Props::Constructor
     decorator.props.each do |prop, rules|
       # It's important to explicitly compare against `true` here; the value can also be :existing or
       # :on_load (which are truthy) but we don't want to treat those as optional in this context.
-      if T::Utils::Props.required_prop?(rules) && !decorator.has_default?(rules) && !hash.key?(prop)
+      if T::Props::Utils.required_prop?(rules) && !decorator.has_default?(rules) && !hash.key?(prop)
         raise ArgumentError.new("Missing required prop `#{prop}` for class `#{self.class}`")
       end
     end

data/lib/types/props/decorator.rb

@@ -149,7 +149,7 @@ class T::Props::Decorator
     # T::Props::CustomType is not a real object based class so that we can not run real type check call.
     # T::Props::CustomType.valid?() is only a helper function call.
     valid =
-      if type.is_a?(T::Props::CustomType) && T::Utils::Props.optional_prop?(rules)
+      if type.is_a?(T::Props::CustomType) && T::Props::Utils.optional_prop?(rules)
         type.valid?(val)
       else
         type_object.valid?(val)
@@ -371,8 +371,8 @@ class T::Props::Decorator
     if T::Utils::Nilable.is_union_with_nilclass(cls)
       # :_tnilable is introduced internally for performance purpose so that clients do not need to call
       # T::Utils::Nilable.is_tnilable(cls) again.
-      # It is strictly internal: clients should always use T::Utils::Props.required_prop?() or
-      # T::Utils::Props.optional_prop?() for checking whether a field is required or optional.
+      # It is strictly internal: clients should always use T::Props::Utils.required_prop?() or
+      # T::Props::Utils.optional_prop?() for checking whether a field is required or optional.
       rules[:_tnilable] = true
     end
 

data/lib/types/props/optional.rb

@@ -31,8 +31,20 @@ module T::Props::Optional::DecoratorMethods
 
   def prop_optional?(prop); prop_rules(prop)[:fully_optional]; end
 
-  def add_prop_definition(prop, rules)
+  def mutate_prop_backdoor!(prop, key, value)
+    rules = props.fetch(prop)
+    rules = rules.merge(key => value)
+    compute_derived_rules(rules)
+    @props = props.merge(prop => rules.freeze).freeze
+  end
+
+  def compute_derived_rules(rules)
     rules[:fully_optional] = !T::Props::Utils.need_nil_write_check?(rules)
+    rules[:need_nil_read_check] = T::Props::Utils.need_nil_read_check?(rules)
+  end
+
+  def add_prop_definition(prop, rules)
+    compute_derived_rules(rules)
     super
   end
 

data/lib/types/props/serializable.rb

@@ -19,13 +19,12 @@ module T::Props::Serializable
     decorator = self.class.decorator
     h = {}
 
-    decorator.props.keys.each do |prop|
-      rules = decorator.prop_rules(prop)
+    decorator.props.each do |prop, rules|
       hkey = rules[:serialized_form]
 
-      val = decorator.get(self, prop)
+      val = decorator.get(self, prop, rules)
 
-      if strict && val.nil? && T::Props::Utils.need_nil_write_check?(rules)
+      if val.nil? && strict && !rules[:fully_optional]
         # If the prop was already missing during deserialization, that means the application
         # code already had to deal with a nil value, which means we wouldn't be accomplishing
         # much by raising here (other than causing an unnecessary breakage).
@@ -42,40 +41,42 @@ module T::Props::Serializable
       # Don't serialize values that are nil to save space (both the
       # nil value itself and the field name in the serialized BSON
       # document)
-      next if decorator.prop_dont_store?(prop) || val.nil?
-
-      if rules[:type_is_serializable]
-        val = val.serialize(strict)
-      elsif rules[:type_is_array_of_serializable]
-        if (subtype = rules[:serializable_subtype]).is_a?(T::Props::CustomType)
-          val = val.map {|el| el && subtype.serialize(el)}
-        else
-          val = val.map {|el| el && el.serialize(strict)}
-        end
-      elsif rules[:type_is_hash_of_serializable_values] && rules[:type_is_hash_of_custom_type_keys]
-        key_subtype = rules[:serializable_subtype][:keys]
-        value_subtype = rules[:serializable_subtype][:values]
-        if value_subtype.is_a?(T::Props::CustomType)
-          val = val.each_with_object({}) do |(key, value), result|
-            result[key_subtype.serialize(key)] = value && value_subtype.serialize(value)
+      next if rules[:dont_store] || val.nil?
+
+      if rules[:serializable_subtype]
+        if rules[:type_is_serializable]
+          val = val.serialize(strict)
+        elsif rules[:type_is_array_of_serializable]
+          if (subtype = rules[:serializable_subtype]).is_a?(T::Props::CustomType)
+            val = val.map {|el| el && subtype.serialize(el)}
+          else
+            val = val.map {|el| el && el.serialize(strict)}
           end
-        else
+        elsif rules[:type_is_hash_of_serializable_values] && rules[:type_is_hash_of_custom_type_keys]
+          key_subtype = rules[:serializable_subtype][:keys]
+          value_subtype = rules[:serializable_subtype][:values]
+          if value_subtype.is_a?(T::Props::CustomType)
+            val = val.each_with_object({}) do |(key, value), result|
+              result[key_subtype.serialize(key)] = value && value_subtype.serialize(value)
+            end
+          else
+            val = val.each_with_object({}) do |(key, value), result|
+              result[key_subtype.serialize(key)] = value && value.serialize(strict)
+            end
+          end
+        elsif rules[:type_is_hash_of_serializable_values]
+          value_subtype = rules[:serializable_subtype]
+          if value_subtype.is_a?(T::Props::CustomType)
+            val = val.transform_values {|v| v && value_subtype.serialize(v)}
+          else
+            val = val.transform_values {|v| v && v.serialize(strict)}
+          end
+        elsif rules[:type_is_hash_of_custom_type_keys]
+          key_subtype = rules[:serializable_subtype]
           val = val.each_with_object({}) do |(key, value), result|
-            result[key_subtype.serialize(key)] = value && value.serialize(strict)
+            result[key_subtype.serialize(key)] = value
           end
         end
-      elsif rules[:type_is_hash_of_serializable_values]
-        value_subtype = rules[:serializable_subtype]
-        if value_subtype.is_a?(T::Props::CustomType)
-          val = val.transform_values {|v| v && value_subtype.serialize(v)}
-        else
-          val = val.transform_values {|v| v && v.serialize(strict)}
-        end
-      elsif rules[:type_is_hash_of_custom_type_keys]
-        key_subtype = rules[:serializable_subtype]
-        val = val.each_with_object({}) do |(key, value), result|
-          result[key_subtype.serialize(key)] = value
-        end
       elsif rules[:type_is_custom_type]
         val = rules[:type].serialize(val)
 
@@ -88,11 +89,19 @@ module T::Props::Serializable
         end
       end
 
-      h[hkey] = T::Props::Utils.deep_clone_object(val)
+      needs_clone = rules[:type_needs_clone]
+      if needs_clone
+        if needs_clone == :shallow
+          val = val.dup
+        else
+          val = T::Props::Utils.deep_clone_object(val)
+        end
+      end
+
+      h[hkey] = val
     end
 
-    extra_props = decorator.extra_props(self)
-    h.merge!(extra_props) if extra_props
+    h.merge!(@_extra_props) if @_extra_props
 
     h
   end
@@ -116,7 +125,7 @@ module T::Props::Serializable
       hkey = rules[:serialized_form]
       val = hash[hkey]
       if val.nil?
-        if T::Utils::Props.required_prop?(rules)
+        if T::Props::Utils.required_prop?(rules)
           val = decorator.get_default(rules, self.class)
           if val.nil?
             msg = "Tried to deserialize a required prop from a nil value. It's "\
@@ -140,7 +149,7 @@ module T::Props::Serializable
               T::Configuration.hard_assert_handler(msg, storytime: storytime)
             end
           end
-        elsif T::Props::Utils.need_nil_read_check?(rules)
+        elsif rules[:need_nil_read_check]
           self.required_prop_missing_from_deserialize(p)
         end
 
@@ -274,7 +283,7 @@ module T::Props::Serializable::DecoratorMethods
   end
 
   def required_props
-    @class.props.select {|_, v| T::Utils::Props.required_prop?(v)}.keys
+    @class.props.select {|_, v| T::Props::Utils.required_prop?(v)}.keys
   end
 
   def prop_dont_store?(prop); prop_rules(prop)[:dont_store]; end

data/lib/types/props/utils.rb

@@ -44,6 +44,20 @@ module T::Props::Utils
 
   # The prop_rules indicate whether we should check for writing a nil value for the prop/field.
   def self.need_nil_write_check?(prop_rules)
-    need_nil_read_check?(prop_rules) || T::Utils::Props.required_prop?(prop_rules)
+    need_nil_read_check?(prop_rules) || T::Props::Utils.required_prop?(prop_rules)
+  end
+
+  def self.required_prop?(prop_rules)
+    # Clients should never reference :_tnilable as the implementation can change.
+    !prop_rules[:_tnilable]
+  end
+
+  def self.optional_prop?(prop_rules)
+    # Clients should never reference :_tnilable as the implementation can change.
+    !!prop_rules[:_tnilable]
+  end
+
+  def self.merge_serialized_optional_rule(prop_rules)
+    {'_tnilable' => true}.merge(prop_rules.merge('_tnilable' => true))
   end
 end

data/lib/types/sig.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 # typed: true
-# rubocop:disable PrisonGuard/NoTopLevelDeclarations, PrisonGuard/PackageMatchesDirectory
 
 # Used as a mixin to any class so that you can call `sig`.
 # Docs at https://sorbet.org/docs/sigs
@@ -24,5 +23,3 @@ module T::Sig
     T::Private::Methods.declare_sig(self, &blk)
   end
 end
-
-# rubocop:enable PrisonGuard/NoTopLevelDeclarations, PrisonGuard/PackageMatchesDirectory

data/lib/types/utils.rb

@@ -154,22 +154,6 @@ module T::Utils
     "#{start_part}#{ellipsis}#{end_part}"
   end
 
-  module Props
-    def self.required_prop?(prop_rules)
-      # Clients should never reference :_tnilable as the implementation can change.
-      !prop_rules[:_tnilable]
-    end
-
-    def self.optional_prop?(prop_rules)
-      # Clients should never reference :_tnilable as the implementation can change.
-      !!prop_rules[:_tnilable]
-    end
-
-    def self.merge_serialized_optional_rule(prop_rules)
-      {'_tnilable' => true}.merge(prop_rules.merge('_tnilable' => true))
-    end
-  end
-
   module Nilable
     # :is_union_type, T::Boolean: whether the type is an T::Types::Union type
     # :non_nilable_type, Class: if it is an T.nilable type, the corresponding underlying type; otherwise, nil.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sorbet-runtime
 version: !ruby/object:Gem::Version
-  version: 0.4.4321
+  version: 0.4.4322
 platform: ruby
 authors:
 - Stripe