sorbet-runtime 0.4.4355 → 0.4.4375

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c20d0628aa85a684b88e4737a8e717fe91a7f15d
-  data.tar.gz: a5af90068a95344d3beeac78c6ad8d3ba334ad88
+  metadata.gz: 62d9529bff7ed508939f3a8afec4dd9b2795190c
+  data.tar.gz: 6101b7766ca75e44e1372931b124c9ad505bb4e1
 SHA512:
-  metadata.gz: 85dd318b56ab855f315742cbd5e3ea380990aa6a377be7d6fee40f0ac7fa5ac8f388abfb51fa0b2aea8af0c89c7df15857983bd3c799f281ccf7b20557832c4b
-  data.tar.gz: 3f8f068484b137a255cf122a5e94c36799410d4207f352e6ba881d7cd1d58b9f11d2f7b52a6f32cee52fa41cd69c40d2fa60f0cec75c538582c01e39e5a476d0
+  metadata.gz: c2220c978ad9e510fde8ee0435d12a334b670fbb94178ba3a79217ade6e1b34931596a6d57616445887e951bf0f69ac6e9e9b18096235ce71d8d78da7a2319bc
+  data.tar.gz: ef8dd00fea3274ef9b2847c519388a7a2949a619cdae065361bc34fbe74f2343a1207ae6069805f0e08b0d24934102e6d9234f2fda844159310f942d02f09b37

data/lib/types/_types.rb

@@ -176,20 +176,13 @@ module T
   # Intended to be used to promise sorbet that a given nilable value happens
   # to contain a non-nil value at this point.
   #
-  # sig {params(arg: T.nilable(A), msg: T.nilable(String)).returns(A)}
-  def self.must(arg, msg=nil)
+  # sig {params(arg: T.nilable(A)).returns(A)}
+  def self.must(arg)
     return arg if arg
     return arg if arg == false
 
     begin
-      if msg
-        if !T.unsafe(msg).is_a?(String)
-          raise TypeError.new("T.must expects a string as second argument")
-        end
-      else
-        msg = "Passed `nil` into T.must"
-      end
-      raise TypeError.new(msg)
+      raise TypeError.new("Passed `nil` into T.must")
     rescue TypeError => e # raise into rescue to ensure e.backtrace is populated
       T::Private::ErrorHandler.handle_inline_type_error(e)
     end

data/lib/types/configuration.rb

@@ -17,6 +17,19 @@ module T::Configuration
     T::Private::RuntimeLevels.enable_checking_in_tests
   end
 
+  # Configure the default checked level for a sig with no explicit `.checked`
+  # builder. When unset, the default checked level is `:always`.
+  #
+  # Note: setting this option is potentially dangerous! Sorbet can't check all
+  # code statically. The runtime checks complement the checks that Sorbet does
+  # statically, so that methods don't have to guard themselves from being
+  # called incorrectly by untyped code.
+  #
+  # @param [:never, :tests, :always] default_checked_level
+  def self.default_checked_level=(default_checked_level)
+    T::Private::RuntimeLevels.default_checked_level = default_checked_level
+  end
+
   # Set a handler to handle `TypeError`s raised by any in-line type assertions,
   # including `T.must`, `T.let`, `T.cast`, and `T.assert_type!`.
   #

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

@@ -43,8 +43,8 @@ module T::Private::Methods
     if decl.returns == ARG_NOT_PROVIDED
       raise "Procs must specify a return type"
     end
-    if decl.soft_notify != ARG_NOT_PROVIDED
-      raise "Procs cannot use .soft"
+    if decl.on_failure != ARG_NOT_PROVIDED
+      raise "Procs cannot use .on_failure"
     end
 
     if decl.params == ARG_NOT_PROVIDED
@@ -224,7 +224,7 @@ module T::Private::Methods
         bind: current_declaration.bind,
         mode: current_declaration.mode,
         check_level: current_declaration.checked,
-        soft_notify: current_declaration.soft_notify,
+        on_failure: current_declaration.on_failure,
         override_allow_incompatible: current_declaration.override_allow_incompatible,
         generated: current_declaration.generated,
       )

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

@@ -2,7 +2,7 @@
 # typed: true
 
 module T::Private::Methods
-  Declaration = Struct.new(:mod, :params, :returns, :bind, :mode, :checked, :finalized, :soft_notify, :override_allow_incompatible, :type_parameters, :generated)
+  Declaration = Struct.new(:mod, :params, :returns, :bind, :mode, :checked, :finalized, :on_failure, :override_allow_incompatible, :type_parameters, :generated)
 
   class DeclBuilder
     attr_reader :decl
@@ -25,7 +25,7 @@ module T::Private::Methods
         Modes.standard, # mode
         ARG_NOT_PROVIDED, # checked
         false, # finalized
-        ARG_NOT_PROVIDED, # soft_notify
+        ARG_NOT_PROVIDED, # on_failure
         nil, # override_allow_incompatible
         ARG_NOT_PROVIDED, # type_parameters
         ARG_NOT_PROVIDED, # generated
@@ -80,16 +80,13 @@ module T::Private::Methods
     end
 
     def checked(level)
-      if T.unsafe(true)
-        raise "The .checked API is unstable, so we don't want it used until we redesign it. To change Sorbet's runtime behavior, see https://sorbet.org/docs/tconfiguration"
-      end
       check_live!
 
       if !decl.checked.equal?(ARG_NOT_PROVIDED)
         raise BuilderError.new("You can't call .checked multiple times in a signature.")
       end
-      if !decl.soft_notify.equal?(ARG_NOT_PROVIDED)
-        raise BuilderError.new("You can't use .checked with .soft.")
+      if level == :never && !decl.on_failure.equal?(ARG_NOT_PROVIDED)
+        raise BuilderError.new("You can't use .checked(:never) with .on_failure because .on_failure will have no effect.")
       end
       if !decl.generated.equal?(ARG_NOT_PROVIDED)
         raise BuilderError.new("You can't use .checked with .generated.")
@@ -103,29 +100,20 @@ module T::Private::Methods
       self
     end
 
-    def soft(notify:)
-      if T.unsafe(true)
-        raise "The .soft API is unstable, so we don't want it used until we redesign it. To change Sorbet's runtime behavior, see https://sorbet.org/docs/tconfiguration"
-      end
+    def on_failure(*args)
       check_live!
 
-      if !decl.soft_notify.equal?(ARG_NOT_PROVIDED)
-        raise BuilderError.new("You can't call .soft multiple times in a signature.")
+      if !decl.on_failure.equal?(ARG_NOT_PROVIDED)
+        raise BuilderError.new("You can't call .on_failure multiple times in a signature.")
       end
-      if !decl.checked.equal?(ARG_NOT_PROVIDED)
-        raise BuilderError.new("You can't use .soft with .checked.")
+      if decl.checked == :never
+        raise BuilderError.new("You can't use .on_failure with .checked(:never) because .on_failure will have no effect.")
       end
       if !decl.generated.equal?(ARG_NOT_PROVIDED)
-        raise BuilderError.new("You can't use .soft with .generated.")
-      end
-
-      # TODO consider validating that :notify is a project that sentry knows about,
-      # as per https://git.corp.stripe.com/stripe-internal/pay-server/blob/master/lib/event/job/sentry_job.rb#L125
-      if !notify || notify == ''
-        raise BuilderError.new("You can't provide an empty notify to .soft().")
+        raise BuilderError.new("You can't use .on_failure with .generated.")
       end
 
-      decl.soft_notify = notify
+      decl.on_failure = args
 
       self
     end
@@ -139,8 +127,8 @@ module T::Private::Methods
       if !decl.checked.equal?(ARG_NOT_PROVIDED)
         raise BuilderError.new("You can't use .generated with .checked.")
       end
-      if !decl.soft_notify.equal?(ARG_NOT_PROVIDED)
-        raise BuilderError.new("You can't use .generated with .soft.")
+      if !decl.on_failure.equal?(ARG_NOT_PROVIDED)
+        raise BuilderError.new("You can't use .generated with .on_failure.")
       end
 
       decl.generated = true
@@ -249,10 +237,14 @@ module T::Private::Methods
         decl.bind = nil
       end
       if decl.checked.equal?(ARG_NOT_PROVIDED)
-        decl.checked = :always
+        default_checked_level = T::Private::RuntimeLevels.default_checked_level
+        if default_checked_level == :never && !decl.on_failure.equal?(ARG_NOT_PROVIDED)
+          raise BuilderError.new("To use .on_failure you must additionally call .checked(:tests) or .checked(:always), otherwise, the .on_failure has no effect.")
+        end
+        decl.checked = default_checked_level
       end
-      if decl.soft_notify.equal?(ARG_NOT_PROVIDED)
-        decl.soft_notify = nil
+      if decl.on_failure.equal?(ARG_NOT_PROVIDED)
+        decl.on_failure = nil
       end
       if decl.generated.equal?(ARG_NOT_PROVIDED)
         decl.generated = false

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

@@ -5,7 +5,7 @@ class T::Private::Methods::Signature
   attr_reader :method, :method_name, :arg_types, :kwarg_types, :block_type, :block_name,
               :rest_type, :rest_name, :keyrest_type, :keyrest_name, :bind,
               :return_type, :mode, :req_arg_count, :req_kwarg_names, :has_rest, :has_keyrest,
-              :check_level, :generated, :parameters, :soft_notify, :override_allow_incompatible, :ever_failed
+              :check_level, :generated, :parameters, :on_failure, :override_allow_incompatible, :ever_failed
 
   def self.new_untyped(method:, mode: T::Private::Methods::Modes.untyped, parameters: method.parameters)
     # Using `Untyped` ensures we'll get an error if we ever try validation on these.
@@ -24,7 +24,7 @@ class T::Private::Methods::Signature
       mode: mode,
       check_level: :never,
       parameters: parameters,
-      soft_notify: nil,
+      on_failure: nil,
     )
   end
 
@@ -32,7 +32,7 @@ class T::Private::Methods::Signature
     @ever_failed = true
   end
 
-  def initialize(method:, method_name:, raw_arg_types:, raw_return_type:, bind:, mode:, check_level:, parameters: method.parameters, soft_notify:, generated: false, override_allow_incompatible: false)
+  def initialize(method:, method_name:, raw_arg_types:, raw_return_type:, bind:, mode:, check_level:, parameters: method.parameters, on_failure:, generated: false, override_allow_incompatible: false)
     @method = method
     @method_name = method_name
     @arg_types = []
@@ -52,7 +52,7 @@ class T::Private::Methods::Signature
     @has_rest = false
     @has_keyrest = false
     @parameters = parameters
-    @soft_notify = soft_notify
+    @on_failure = on_failure
     @override_allow_incompatible = override_allow_incompatible
     @generated = generated
     @ever_failed = false

data/lib/types/private/runtime_levels.rb

@@ -17,6 +17,9 @@ module T::Private::RuntimeLevels
   @check_tests = false
   @wrapped_tests_with_validation = false
 
+  @has_read_default_checked_level = false
+  @default_checked_level = :always
+
   def self.check_tests?
     # Assume that this code path means that some `sig.checked(:tests)`
     # has been wrapped (or not wrapped) already, which is a trapdoor
@@ -35,6 +38,18 @@ module T::Private::RuntimeLevels
     _toggle_checking_tests(true)
   end
 
+  def self.default_checked_level
+    @has_read_default_checked_level = true
+    @default_checked_level
+  end
+
+  def self.default_checked_level=(default_checked_level)
+    if @has_read_default_checked_level
+      raise "Set the default checked level earlier. There are already some methods whose sig blocks have evaluated which would not be affected by the new default."
+    end
+    @default_checked_level = default_checked_level
+  end
+
   def self._toggle_checking_tests(checked)
     @check_tests = checked
   end

data/lib/types/props/decorator.rb

@@ -18,7 +18,7 @@ class T::Props::Decorator
 
   class NoRulesError < StandardError; end
 
-  sig {params(klass: DecoratedClass).void}
+  T::Sig::WithoutRuntime.sig {params(klass: DecoratedClass).void}
   def initialize(klass)
     @class = klass
     klass.plugins.each do |mod|
@@ -27,7 +27,7 @@ class T::Props::Decorator
   end
 
   # prop stuff
-  sig {returns(T::Hash[Symbol, Rules])}
+  sig {returns(T::Hash[Symbol, Rules]).checked(:never)}
   def props
     @props ||= {}.freeze
   end
@@ -44,7 +44,7 @@ class T::Props::Decorator
   sig {returns(T::Array[Symbol])}
   def all_props; props.keys; end
 
-  sig {params(prop: T.any(Symbol, String)).returns(Rules)}
+  sig {params(prop: T.any(Symbol, String)).returns(Rules).checked(:never)}
   def prop_rules(prop); props[prop.to_sym] || raise("No such prop: #{prop.inspect}"); end
 
   sig {params(prop: Symbol, rules: Rules).void}
@@ -80,7 +80,7 @@ class T::Props::Decorator
     }
   end
 
-  sig {returns(DecoratedClass)}
+  sig {returns(DecoratedClass).checked(:never)}
   def decorated_class; @class; end
 
   # Accessors
@@ -94,6 +94,7 @@ class T::Props::Decorator
       rules: T.nilable(Rules)
     )
     .returns(T.untyped)
+    .checked(:never)
   end
   def get(instance, prop, rules=props[prop.to_sym])
     # For backwards compatibility, fall back to reconstructing the accessor key
@@ -111,6 +112,7 @@ class T::Props::Decorator
       rules: T.nilable(Rules)
     )
     .void
+    .checked(:never)
   end
   def set(instance, prop, value, rules=props[prop.to_sym])
     # For backwards compatibility, fall back to reconstructing the accessor key
@@ -119,7 +121,7 @@ class T::Props::Decorator
   end
 
   # Use this to validate that a value will validate for a given prop. Useful for knowing whether a value can be set on a model without setting it.
-  sig {params(prop: Symbol, val: T.untyped).void}
+  sig {params(prop: Symbol, val: T.untyped).void.checked(:never)}
   def validate_prop_value(prop, val)
     # This implements a 'public api' on document so that we don't allow callers to pass in rules
     # Rules seem like an implementation detail so it seems good to now allow people to specify them manually.
@@ -127,7 +129,7 @@ class T::Props::Decorator
   end
 
   # Passing in rules here is purely a performance optimization.
-  sig {params(prop: Symbol, val: T.untyped, rules: Rules).void}
+  sig {params(prop: Symbol, val: T.untyped, rules: Rules).void.checked(:never)}
   private def check_prop_type(prop, val, rules=prop_rules(prop))
     type_object = rules.fetch(:type_object)
     type = rules.fetch(:type)
@@ -173,6 +175,7 @@ class T::Props::Decorator
       rules: T.nilable(Rules)
     )
     .void
+    .checked(:never)
   end
   def prop_set(instance, prop, val, rules=prop_rules(prop))
     check_prop_type(prop, val, T.must(rules))
@@ -188,6 +191,7 @@ class T::Props::Decorator
       rules: T.nilable(Rules)
     )
     .returns(T.untyped)
+    .checked(:never)
   end
   def prop_get(instance, prop, rules=props[prop.to_sym])
     val = get(instance, prop, rules)
@@ -222,6 +226,7 @@ class T::Props::Decorator
       opts: Hash
     )
     .returns(T.untyped)
+    .checked(:never)
   end
   def foreign_prop_get(instance, prop, foreign_class, rules=props[prop.to_sym], opts={})
     return if !(value = prop_get(instance, prop, rules))
@@ -325,7 +330,6 @@ class T::Props::Decorator
     .void
   end
   def prop_defined(name, cls, rules={})
-    # TODO(jerry): Create similar soft assertions against false
     if rules[:optional] == true
       T::Configuration.hard_assert_handler(
         'Use of `optional: true` is deprecated, please use `T.nilable(...)` instead.',
@@ -776,7 +780,7 @@ class T::Props::Decorator
   #
   # This gets called when a module or class that extends T::Props gets included, extended,
   # prepended, or inherited.
-  sig {params(child: DecoratedClass).void}
+  T::Sig::WithoutRuntime.sig {params(child: DecoratedClass).void}
   def model_inherited(child)
     child.extend(T::Props::ClassMethods)
     child.plugins.concat(decorated_class.plugins)
@@ -797,7 +801,7 @@ class T::Props::Decorator
     end
   end
 
-  sig {params(mod: Module).void}
+  T::Sig::WithoutRuntime.sig {params(mod: Module).void}
   def plugin(mod)
     decorated_class.plugins << mod
     Private.apply_class_methods(mod, decorated_class)

data/lib/types/props/pretty_printable.rb

@@ -70,6 +70,7 @@ module T::Props::PrettyPrintable
     sig do
       params(instance: T::Props::PrettyPrintable, prop: Symbol, multiline: T::Boolean, indent: String)
       .returns(String)
+      .checked(:never)
     end
     private def inspect_prop_value(instance, prop, multiline:, indent:)
       val = T.unsafe(self).get(instance, prop)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sorbet-runtime
 version: !ruby/object:Gem::Version
-  version: 0.4.4355
+  version: 0.4.4375
 platform: ruby
 authors:
 - Stripe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-06-28 00:00:00.000000000 Z
+date: 2019-07-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest