sorbet-runtime 0.5.12152 → 0.5.12167

data/lib/types/props/weak_constructor.rb

@@ -6,7 +6,7 @@ module T::Props::WeakConstructor
   extend T::Sig
 
   # checked(:never) - O(runtime object construction)
-  sig {params(hash: T::Hash[Symbol, T.untyped]).void.checked(:never)}
+  sig { params(hash: T::Hash[Symbol, T.untyped]).void.checked(:never) }
   def initialize(hash={})
     decorator = self.class.decorator
 
@@ -28,7 +28,7 @@ module T::Props::WeakConstructor::DecoratorMethods
   # we'll use to check for any unrecognized input.)
   #
   # checked(:never) - O(runtime object construction)
-  sig {params(instance: T::Props::WeakConstructor, hash: T::Hash[Symbol, T.untyped]).returns(Integer).checked(:never)}
+  sig { params(instance: T::Props::WeakConstructor, hash: T::Hash[Symbol, T.untyped]).returns(Integer).checked(:never) }
   def construct_props_without_defaults(instance, hash)
     # Use `each_pair` rather than `count` because, as of Ruby 2.6, the latter delegates to Enumerator
     # and therefore allocates for each entry.
@@ -49,7 +49,7 @@ module T::Props::WeakConstructor::DecoratorMethods
   # we'll use to check for any unrecognized input.)
   #
   # checked(:never) - O(runtime object construction)
-  sig {params(instance: T::Props::WeakConstructor, hash: T::Hash[Symbol, T.untyped]).returns(Integer).checked(:never)}
+  sig { params(instance: T::Props::WeakConstructor, hash: T::Hash[Symbol, T.untyped]).returns(Integer).checked(:never) }
   def construct_props_with_defaults(instance, hash)
     # Use `each_pair` rather than `count` because, as of Ruby 2.6, the latter delegates to Enumerator
     # and therefore allocates for each entry.

data/lib/types/sig.rb

@@ -14,7 +14,7 @@ module T::Sig
 
     # At runtime, does nothing, but statically it is treated exactly the same
     # as T::Sig#sig. Only use it in cases where you can't use T::Sig#sig.
-    T::Sig::WithoutRuntime.sig {params(arg0: T.nilable(Symbol), blk: T.proc.bind(T::Private::Methods::DeclBuilder).void).void}
+    T::Sig::WithoutRuntime.sig { params(arg0: T.nilable(Symbol), blk: T.proc.bind(T::Private::Methods::DeclBuilder).void).void }
     def self.sig(arg0=nil, &blk); end # rubocop:disable Lint/DuplicateMethods
 
     $VERBOSE = original_verbose
@@ -23,7 +23,7 @@ module T::Sig
   # Declares a method with type signatures and/or
   # abstract/override/... helpers. See the documentation URL on
   # {T::Helpers}
-  T::Sig::WithoutRuntime.sig {params(arg0: T.nilable(Symbol), blk: T.proc.bind(T::Private::Methods::DeclBuilder).void).void}
+  T::Sig::WithoutRuntime.sig { params(arg0: T.nilable(Symbol), blk: T.proc.bind(T::Private::Methods::DeclBuilder).void).void }
   def sig(arg0=nil, &blk)
     T::Private::Methods.declare_sig(self, Kernel.caller_locations(1, 1)&.first, arg0, &blk)
   end

data/lib/types/struct.rb

@@ -30,7 +30,7 @@ class T::ImmutableStruct < T::InexactStruct
   end
 
   # Matches the one in WeakConstructor, but freezes the object
-  sig {params(hash: T::Hash[Symbol, T.untyped]).void.checked(:never)}
+  sig { params(hash: T::Hash[Symbol, T.untyped]).void.checked(:never) }
   def initialize(hash={})
     super
 
@@ -38,7 +38,7 @@ class T::ImmutableStruct < T::InexactStruct
   end
 
   # Matches the signature in Props, but raises since this is an immutable struct and only const is allowed
-  sig {params(name: Symbol, cls: T.untyped, rules: T.untyped).void}
+  sig { params(name: Symbol, cls: T.untyped, rules: T.untyped).void }
   def self.prop(name, cls, **rules)
     return super if (cls.is_a?(Hash) && cls[:immutable]) || rules[:immutable]
 

data/lib/types/types/base.rb

@@ -83,27 +83,27 @@ module T::Types
       # Note: order of cases here matters!
       if t1.is_a?(T::Types::Union) # 7, 8, 9
         # this will be incorrect if/when we have Type members
-        return t1.types.all? {|t1_member| t1_member.subtype_of?(t2)}
+        return t1.types.all? { |t1_member| t1_member.subtype_of?(t2) }
       end
 
       if t2.is_a?(T::Types::Intersection) # 2, 5
         # this will be incorrect if/when we have Type members
-        return t2.types.all? {|t2_member| t1.subtype_of?(t2_member)}
+        return t2.types.all? { |t2_member| t1.subtype_of?(t2_member) }
       end
 
       if t2.is_a?(T::Types::Union)
         if t1.is_a?(T::Types::Intersection) # 6
           # dropping either of parts eagerly make subtype test be too strict.
           # we have to try both cases, when we normally try only one
-          return t2.types.any? {|t2_member| t1.subtype_of?(t2_member)} ||
-              t1.types.any? {|t1_member| t1_member.subtype_of?(t2)}
+          return t2.types.any? { |t2_member| t1.subtype_of?(t2_member) } ||
+              t1.types.any? { |t1_member| t1_member.subtype_of?(t2) }
         end
-        return t2.types.any? {|t2_member| t1.subtype_of?(t2_member)} # 3
+        return t2.types.any? { |t2_member| t1.subtype_of?(t2_member) } # 3
       end
 
       if t1.is_a?(T::Types::Intersection) # 4
         # this will be incorrect if/when we have Type members
-        return t1.types.any? {|t1_member| t1_member.subtype_of?(t2)}
+        return t1.types.any? { |t1_member| t1_member.subtype_of?(t2) }
       end
 
       # 1; Start with some special cases

data/lib/types/types/fixed_array.rb

@@ -11,7 +11,7 @@ module T::Types
     end
 
     def types
-      @types ||= @inner_types.map {|type| T::Utils.coerce(type)}
+      @types ||= @inner_types.map { |type| T::Utils.coerce(type) }
     end
 
     def build_type

data/lib/types/types/fixed_hash.rb

@@ -10,7 +10,7 @@ module T::Types
     end
 
     def types
-      @types ||= @inner_types.transform_values {|v| T::Utils.coerce(v)}
+      @types ||= @inner_types.transform_values { |v| T::Utils.coerce(v) }
     end
 
     def build_type
@@ -26,16 +26,16 @@ module T::Types
     # overrides Base
     def recursively_valid?(obj)
       return false unless obj.is_a?(Hash)
-      return false if types.any? {|key, type| !type.recursively_valid?(obj[key])}
-      return false if obj.any? {|key, _| !types[key]}
+      return false if types.any? { |key, type| !type.recursively_valid?(obj[key]) }
+      return false if obj.any? { |key, _| !types[key] }
       true
     end
 
     # overrides Base
     def valid?(obj)
       return false unless obj.is_a?(Hash)
-      return false if types.any? {|key, type| !type.valid?(obj[key])}
-      return false if obj.any? {|key, _| !types[key]}
+      return false if types.any? { |key, type| !type.valid?(obj[key]) }
+      return false if obj.any? { |key, _| !types[key] }
       true
     end
 
@@ -48,7 +48,7 @@ module T::Types
       when TypedHash
         # warning: covariant hashes
 
-        key1, key2, *keys_rest = types.keys.map {|key| T::Utils.coerce(key.class)}
+        key1, key2, *keys_rest = types.keys.map { |key| T::Utils.coerce(key.class) }
         key_type = if !key2.nil?
           T::Types::Union::Private::Pool.union_of_types(key1, key2, keys_rest)
         elsif key1.nil?

data/lib/types/types/intersection.rb

@@ -32,12 +32,12 @@ module T::Types
 
     # overrides Base
     def recursively_valid?(obj)
-      types.all? {|type| type.recursively_valid?(obj)}
+      types.all? { |type| type.recursively_valid?(obj) }
     end
 
     # overrides Base
     def valid?(obj)
-      types.all? {|type| type.valid?(obj)}
+      types.all? { |type| type.valid?(obj) }
     end
 
     # overrides Base

data/lib/types/types/union.rb

@@ -44,11 +44,11 @@ module T::Types
       nilable = T::Utils.coerce(NilClass)
       trueclass = T::Utils.coerce(TrueClass)
       falseclass = T::Utils.coerce(FalseClass)
-      if types.any? {|t| t == nilable}
-        remaining_types = types.reject {|t| t == nilable}
+      if types.any? { |t| t == nilable }
+        remaining_types = types.reject { |t| t == nilable }
         "T.nilable(#{type_shortcuts(remaining_types)})"
-      elsif types.any? {|t| t == trueclass} && types.any? {|t| t == falseclass}
-        remaining_types = types.reject {|t| t == trueclass || t == falseclass}
+      elsif types.any? { |t| t == trueclass } && types.any? { |t| t == falseclass }
+        remaining_types = types.reject { |t| t == trueclass || t == falseclass }
         type_shortcuts([T::Private::Types::StringHolder.new("T::Boolean")] + remaining_types)
       else
         names = types.map(&:name).compact.sort
@@ -58,12 +58,12 @@ module T::Types
 
     # overrides Base
     def recursively_valid?(obj)
-      types.any? {|type| type.recursively_valid?(obj)}
+      types.any? { |type| type.recursively_valid?(obj) }
     end
 
     # overrides Base
     def valid?(obj)
-      types.any? {|type| type.valid?(obj)}
+      types.any? { |type| type.valid?(obj) }
     end
 
     # overrides Base
@@ -72,7 +72,7 @@ module T::Types
     end
 
     def unwrap_nilable
-      non_nil_types = types.reject {|t| t == T::Utils::Nilable::NIL_TYPE}
+      non_nil_types = types.reject { |t| t == T::Utils::Nilable::NIL_TYPE }
       return nil if types.length == non_nil_types.length
       case non_nil_types.length
       when 0 then nil

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sorbet-runtime
 version: !ruby/object:Gem::Version
-  version: 0.5.12152
+  version: 0.5.12167
 platform: ruby
 authors:
 - Stripe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2025-06-04 00:00:00.000000000 Z
+date: 2025-06-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest