sorbet-runtime 0.5.6189 → 0.5.6277

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '078455e4f5dfee05efee1b1dc5283a572d80e4583699ef18fbd51cc606c1a559'
-  data.tar.gz: 6d77cb7b423ae756a33c04e15a50ff0d7d17a0cbd0e25460c0ce89b25959fa97
+  metadata.gz: 22707230a23f48bfd62933d0a85920876e2ac38dc8b78c3306d205c8247e0c69
+  data.tar.gz: e5c3afa7f8dc8eb5dab01edd0086062c0597306ddd5a985b4ddde0da5e9c5a9f
 SHA512:
-  metadata.gz: 171c564c0b615d126fa8e14bff2dc5567baa53a2c0d702032f8971fd4f83e1cd3c3d888e4c4ac0e9843e0b516fe1563807cd6d8afcb9d8c0dfa15da28ff8758d
-  data.tar.gz: 967a1bb33ed88e50c31bf01dbbfdaad43e7ef7f66723c5648a58bc47d19cb5f5c46b7fd9a3733310cc07eb72743d32bb80341aa7e3f529ea5584def01195591e
+  metadata.gz: cd1d3b58bf2c258db84c6abffedd63c406bc4145f9484265a7ad988eb73dab15f0fb3186b880461ce810eb5cad494fd07fcca381694fc13d9826bd9711bdbd1b
+  data.tar.gz: d7ea87fcf45c0995cf0d14551ab8ad30441d6fcd43375f27e53b529b129180dd5c9a34b31db56e4994eaa8ce762fb25148fb24540f1b6a280df02e91ab77d6ee

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/helpers.rb

@@ -33,7 +33,7 @@ module T::Helpers
   #  end
   #
   # Except that it is statically analyzed by sorbet.
-  def mixes_in_class_methods(mod)
-    Private::Mixins.declare_mixes_in_class_methods(self, mod)
+  def mixes_in_class_methods(mod, *mods)
+    Private::Mixins.declare_mixes_in_class_methods(self, [mod].concat(mods))
   end
 end

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/private/mixins/mixins.rb

@@ -4,8 +4,8 @@
 module T::Private
   module MixesInClassMethods
     def included(other)
-      mod = Abstract::Data.get(self, :class_methods_mixin)
-      other.extend(mod)
+      mods = Abstract::Data.get(self, :class_methods_mixins)
+      mods.each {|mod| other.extend(mod)}
       super
     end
   end
@@ -16,12 +16,12 @@ module T::Private
         raise "Classes cannot be used as mixins, and so mixes_in_class_methods cannot be used on a Class."
       end
 
-      if Abstract::Data.key?(mixin, :class_methods_mixin)
-        raise "mixes_in_class_methods can only be used once per module."
+      if Abstract::Data.key?(mixin, :class_methods_mixins)
+        class_methods = Abstract::Data.get(mixin, :class_methods_mixins) + class_methods
       end
 
       mixin.singleton_class.include(MixesInClassMethods)
-      Abstract::Data.set(mixin, :class_methods_mixin, class_methods)
+      Abstract::Data.set(mixin, :class_methods_mixins, class_methods)
     end
   end
 end

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/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.6189
+  version: 0.5.6277
 platform: ruby
 authors:
 - Stripe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-12-26 00:00:00.000000000 Z
+date: 2021-02-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest