sorbet-runtime 0.5.6223 → 0.5.6249

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e4965b0c556acb24bfe27316314910f4439226de05f4958f08438d92ab3854ed
-  data.tar.gz: 5ac1bb6baaf1e96d8d010924f0b0b8916807bf50a6009cdba4d605eceb41ac2c
+  metadata.gz: 836a1fbf0f8401ea225ae5124205ba0cdcfccab4164ab3b1e342bf285d7ea19b
+  data.tar.gz: 8758dcc34d96534830fc097a269d45c307f6841a9f20643c633be33eca142816
 SHA512:
-  metadata.gz: 24272d365d1295e5edd880fa4f3f984191cca6e6f29431cc8c20d8531fa811df1f328533b16f2784c7cba6e2460e4c7e0276ca1e3c240a54234661d39d7e1abf
-  data.tar.gz: 7ac8f9af520dca8a514678db4b08c4b89d8366e98b8c57be053494128f0c82e585a35e7355ac5d037d3e3d07e063885921a5ac86dbc53804841c694201491ed8
+  metadata.gz: 54ad13d894a1a35e28735d4e20f785e8cee486c8acf2786587639c1084ad2a881c36e0e3b8799553fb9fcc73bb7354fb085cd59402a83ff4259c7a0ef34fc935
+  data.tar.gz: 854336ccb394ab1524e171a29f130227dfc1cc8d8cf72b1ce6453c4c2a773d9e1ecd02393b0084eca6e6cdd1e9b5c5d999305c48bee051902b917ab754b07988

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/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.6223
+  version: 0.5.6249
 platform: ruby
 authors:
 - Stripe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-01-20 00:00:00.000000000 Z
+date: 2021-01-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest