sorbet-runtime 0.5.6229 → 0.5.6257

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b502e1602055bd3d9f75671c0261e4dd1544aa4faefd5750bdff385843cfbac9
-  data.tar.gz: 2b9b067b20641e5a881c8e14350053a6a63578a5abd956f2bd6b072914f804c5
+  metadata.gz: 2869f8c9854f5900c8321d756b478077af3d9656b932bb3b31d3ffe180c00ee4
+  data.tar.gz: f844a05089620d58a2fbbf6fd33445502efb6d3d5395044b2c0bf1b03c868741
 SHA512:
-  metadata.gz: 3cdff26a4225bef4e61323f4b7b45d5866585af11309ec1ffe34175b387aa35f76e1f26150cc59db28d7f55958e90bf91820070c11b779341e1895cbbaf7e8f5
-  data.tar.gz: 0032ed7d97c722066dedfbb790a3c45edf8ba03942ebd2c513b0aefcb4b78dc24f3b4982f649a424774a0ba0e9e9a8aae2d4279c82462962a4786f4ce948acca
+  metadata.gz: 233e4afe3e043ab5c6098eb6c75876882169568800f7cc8fc8e103a97bb776be20ad556541a99589e65c0c5d5af061f14aceb0daaf08762e7316096d4c6432d3
+  data.tar.gz: eab9556baf8e777ac6983bfd0ab57d7ce1c38a94a1a10401d5d0d393f1aa8fba47e52b330562dfa2f1bd6dfc1db21d900249f5aa31647f94059e8719b54ea4b0

data/lib/types/configuration.rb

@@ -412,6 +412,32 @@ module T::Configuration
     @module_name_mangler = handler
   end
 
+  # Set to a PII handler function. This will be called with the `sensitivity:`
+  # annotations on things that use `T::Props` and can modify them ahead-of-time.
+  #
+  # @param [Lambda, Proc, nil] value Proc that takes a hash mapping symbols to the
+  # prop values. Pass nil to avoid changing `sensitivity:` annotations.
+  def self.normalize_sensitivity_and_pii_handler=(handler)
+    @sensitivity_and_pii_handler = handler
+  end
+
+  def self.normalize_sensitivity_and_pii_handler
+    @sensitivity_and_pii_handler
+  end
+
+  # Set to a function which can get the 'owner' of a class. This is
+  # used in reporting deserialization errors
+  #
+  # @param [Lambda, Proc, nil] value Proc that takes a class and
+  # produces its owner, or `nil` if it does not have one.
+  def self.class_owner_finder=(handler)
+    @class_owner_finder = handler
+  end
+
+  def self.class_owner_finder
+    @class_owner_finder
+  end
+
   # Temporarily disable ruby warnings while executing the given block. This is
   # useful when doing something that would normally cause a warning to be
   # emitted in Ruby verbose mode ($VERBOSE = true).

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

@@ -75,40 +75,6 @@ module T::Private::Methods
     T::Types::Proc.new(decl.params, decl.returns)
   end
 
-  # See docs at T::Utils.register_forwarder.
-  def self.register_forwarder(from_method, to_method, mode: Modes.overridable, remove_first_param: false)
-    # Normalize the method (see comment in signature_for_key).
-    from_method = from_method.owner.instance_method(from_method.name)
-
-    from_key = method_to_key(from_method)
-    maybe_run_sig_block_for_key(from_key)
-    if @signatures_by_method.key?(from_key)
-      raise "#{from_method} already has a method signature"
-    end
-
-    from_params = from_method.parameters
-    if from_params.length != 2 || from_params[0][0] != :rest || from_params[1][0] != :block
-      raise "forwarder methods should take a single splat param and a block param. `#{from_method}` " \
-            "takes these params: #{from_params}. For help, ask #dev-productivity."
-    end
-
-    # If there's already a signature for to_method, we get `parameters` from there, to enable
-    # chained forwarding. NB: we don't use `signature_for_key` here, because the normalization it
-    # does is broken when `to_method` has been clobbered by another method.
-    to_key = method_to_key(to_method)
-    maybe_run_sig_block_for_key(to_key)
-    to_params = @signatures_by_method[to_key]&.parameters || to_method.parameters
-
-    if remove_first_param
-      to_params = to_params[1..-1]
-    end
-
-    # We don't bother trying to preserve any types from to_signature because this won't be
-    # statically analyzed, and the types will just get checked when the forwarding happens.
-    from_signature = Signature.new_untyped(method: from_method, mode: mode, parameters: to_params)
-    @signatures_by_method[from_key] = from_signature
-  end
-
   # Returns the signature for a method whose definition was preceded by `sig`.
   #
   # @param method [UnboundMethod]

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

@@ -11,6 +11,10 @@ class T::Private::Methods::Signature
     # Using `Untyped` ensures we'll get an error if we ever try validation on these.
     not_typed = T::Private::Types::NotTyped.new
     raw_return_type = not_typed
+    # Map missing parameter names to "argN" positionally
+    parameters = parameters.each_with_index.map do |(param_kind, param_name), index|
+      [param_kind, param_name || "arg#{index}"]
+    end
     raw_arg_types = parameters.map do |_param_kind, param_name|
       [param_name, not_typed]
     end.to_h

data/lib/types/props/_props.rb

@@ -100,6 +100,7 @@ module T::Props
     #   form.
     #
     # @return [void]
+    sig {params(name: Symbol, cls: T.untyped, rules: T.untyped).void}
     def prop(name, cls, rules={})
       cls = T::Utils.coerce(cls) if !cls.is_a?(Module)
       decorator.prop_defined(name, cls, rules)
@@ -124,7 +125,7 @@ module T::Props
     end
 
     # Shorthand helper to define a `prop` with `immutable => true`
-    sig {params(name: T.any(Symbol, String), cls_or_args: T.untyped, args: T::Hash[Symbol, T.untyped]).void}
+    sig {params(name: Symbol, cls_or_args: T.untyped, args: T::Hash[Symbol, T.untyped]).void}
     def const(name, cls_or_args, args={})
       if (cls_or_args.is_a?(Hash) && cls_or_args.key?(:immutable)) || args.key?(:immutable)
         Kernel.raise ArgumentError.new("Cannot pass 'immutable' argument when using 'const' keyword to define a prop")

data/lib/types/props/decorator.rb

@@ -306,8 +306,9 @@ class T::Props::Decorator
     type = T::Utils::Nilable.get_underlying_type(type)
 
     sensitivity_and_pii = {sensitivity: rules[:sensitivity]}
-    if defined?(Opus) && defined?(Opus::Sensitivity) && defined?(Opus::Sensitivity::Utils)
-      sensitivity_and_pii = Opus::Sensitivity::Utils.normalize_sensitivity_and_pii_annotation(sensitivity_and_pii)
+    normalize = T::Configuration.normalize_sensitivity_and_pii_handler
+    if normalize
+      sensitivity_and_pii = normalize.call(sensitivity_and_pii)
 
       # We check for Class so this is only applied on concrete
       # documents/models; We allow mixins containing props to not

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

@@ -99,21 +99,18 @@ module T::Props
             else
               "#{varname}.nil? ? nil : #{inner}"
             end
+          elsif type.types.all? {|t| generate(t, mode, varname).nil?}
+            # Handle, e.g., T::Boolean
+            nil
           else
-            inners = type.types.map {|t| generate(t, mode, varname)}.uniq
-            if inners.length <= 1
-              # Handle, e.g., T::Boolean
-              inners.first
-            else
-              # We currently deep_clone_object if the type was T.any(Integer, Float).
-              # When we get better support for union types (maybe this specific
-              # union type, because it would be a replacement for
-              # Chalk::ODM::DeprecatedNumemric), we could opt to special case
-              # this union to have no specific serde transform (the only reason
-              # why Float has a special case is because round tripping through
-              # JSON might normalize Floats to Integers)
-              "T::Props::Utils.deep_clone_object(#{varname})"
-            end
+            # We currently deep_clone_object if the type was T.any(Integer, Float).
+            # When we get better support for union types (maybe this specific
+            # union type, because it would be a replacement for
+            # Chalk::ODM::DeprecatedNumemric), we could opt to special case
+            # this union to have no specific serde transform (the only reason
+            # why Float has a special case is because round tripping through
+            # JSON might normalize Floats to Integers)
+            "T::Props::Utils.deep_clone_object(#{varname})"
           end
         when T::Types::Intersection
           dynamic_fallback = "T::Props::Utils.deep_clone_object(#{varname})"

data/lib/types/props/serializable.rb

@@ -246,11 +246,11 @@ module T::Props::Serializable::DecoratorMethods
 
     # Notify the model owner if it exists, and always notify the API owner.
     begin
-      if defined?(Opus) && defined?(Opus::Ownership) && decorated_class < Opus::Ownership
+      if T::Configuration.class_owner_finder && (owner = T::Configuration.class_owner_finder.call(decorated_class))
         T::Configuration.hard_assert_handler(
           msg,
           storytime: storytime,
-          project: decorated_class.get_owner
+          project: owner
         )
       end
     ensure

data/lib/types/utils.rb

@@ -52,19 +52,6 @@ module T::Utils
     end.uniq
   end
 
-  # Associates a signature with a forwarder method that matches the signature of the method it
-  # forwards to. This is necessary because forwarder methods are often declared with catch-all
-  # splat parameters, rather than the exact set of parameters ultimately used by the target method,
-  # so they cannot be validated as strictly.
-  #
-  # The caller of this method must ensure that the forwarder method properly forwards all parameters
-  # such that the signature is accurate.
-  def self.register_forwarder(from_method, to_method, remove_first_param: false)
-    T::Private::Methods.register_forwarder(
-      from_method, to_method, remove_first_param: remove_first_param
-    )
-  end
-
   # Returns the signature for the instance method on the supplied module, or nil if it's not found or not typed.
   #
   # @example T::Utils.signature_for_instance_method(MyClass, :my_method)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sorbet-runtime
 version: !ruby/object:Gem::Version
-  version: 0.5.6229
+  version: 0.5.6257
 platform: ruby
 authors:
 - Stripe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-01-22 00:00:00.000000000 Z
+date: 2021-01-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest