sorbet-runtime 0.5.11190 → 0.5.11200

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 533fd9ec399ceffbb032f86c6b9b9a9e4efedb86dd0425bebaa471fc09036cdf
-  data.tar.gz: ef0fcf828932347277f8833d285cc64812b4196363428a71eae019d351af98a4
+  metadata.gz: 03f7a85e5b0a63ac54fdd4f82cbfcf269484cf649bb1778006e0b41d3a800eba
+  data.tar.gz: b5b2f87adfd29488c1ad748de84c676a73903055f79a8d136f7300960dcc850b
 SHA512:
-  metadata.gz: 1adb69699281832dbe6bfe654c7d71635654a59383f1825651d98edb809dc13f51746113b4d179d42fba0135943153cbe544b8d124f6020d7637df1bb50f9988
-  data.tar.gz: fae00525324c43395367cfd8706729376a35badd76dbc89ff33ace7dfce758e02f837f5258384b6a5327209a25fd022d29b82dad7fabf9ea57b4635a930e6771
+  metadata.gz: 3d043f9735a22824b4c07d1130dbf0a6a9306dbe5005b7be487db8b5a4e53dba14b41e0cf8118e93de1ffafaa1d1fe8c2fd546eed426c4661e12745000152e3f
+  data.tar.gz: 8204b78b673773bb91ac61fa7079ad1a6552370825c5cff4130b5aa4e25bb18fdea397378f05918c861d50398cd75bd449d18795b3968d988c87bcf4e0fa47c6

data/lib/sorbet-runtime.rb

@@ -73,7 +73,6 @@ require_relative 'types/private/abstract/validate'
 
 # Catch all. Sort of built by `cd extn; find types -type f | grep -v test | sort`
 require_relative 'types/generic'
-require_relative 'types/interface_wrapper'
 require_relative 'types/private/abstract/declare'
 require_relative 'types/private/abstract/hooks'
 require_relative 'types/private/casts'

data/lib/types/private/abstract/declare.rb

@@ -18,7 +18,6 @@ module T::Private::Abstract::Declare
     Abstract::Data.set(mod, :abstract_type, type)
 
     mod.extend(Abstract::Hooks)
-    mod.extend(T::InterfaceWrapper::Helpers)
 
     if mod.is_a?(Class)
       if type == :interface

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

@@ -183,7 +183,7 @@ module T::Private::Methods
       self
     end
 
-    # Declares valid type paramaters which can be used with `T.type_parameter` in
+    # Declares valid type parameters which can be used with `T.type_parameter` in
     # this `sig`.
     #
     # This is used for generic methods. Example usage:

data/lib/types/props/decorator.rb

@@ -332,7 +332,7 @@ class T::Props::Decorator
 
     prop_validate_definition!(name, cls, rules, type_object)
 
-    # Retrive the possible underlying object with T.nilable.
+    # Retrieve the possible underlying object with T.nilable.
     type = T::Utils::Nilable.get_underlying_type(type)
 
     rules_sensitivity = rules[:sensitivity]

data/lib/types/types/typed_enumerable.rb

@@ -54,7 +54,7 @@ module T::Types
         value_type = types[1]
         obj.each_pair do |key, val|
           # Some objects (I'm looking at you Rack::Utils::HeaderHash) don't
-          # iterate over a [key, value] array, so we can't juse use the type.recursively_valid?(v)
+          # iterate over a [key, value] array, so we can't just use the type.recursively_valid?(v)
           return false if !key_type.recursively_valid?(key) || !value_type.recursively_valid?(val)
         end
         true

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sorbet-runtime
 version: !ruby/object:Gem::Version
-  version: 0.5.11190
+  version: 0.5.11200
 platform: ruby
 authors:
 - Stripe
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-01-12 00:00:00.000000000 Z
+date: 2024-01-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -165,7 +165,6 @@ files:
 - lib/types/enum.rb
 - lib/types/generic.rb
 - lib/types/helpers.rb
-- lib/types/interface_wrapper.rb
 - lib/types/non_forcing_constants.rb
 - lib/types/private/abstract/data.rb
 - lib/types/private/abstract/declare.rb

data/lib/types/interface_wrapper.rb

@@ -1,162 +0,0 @@
-# frozen_string_literal: true
-# typed: false
-
-# Wraps an object, exposing only the methods defined on a given class/module. The idea is that, in
-# the absence of a static type checker that would prevent you from calling non-Bar methods on a
-# variable of type Bar, we can use these wrappers as a way of enforcing it at runtime.
-#
-# Once we ship static type checking, we should get rid of this entirely.
-class T::InterfaceWrapper
-  extend T::Sig
-
-  module Helpers
-    def wrap_instance(obj)
-      T::InterfaceWrapper.wrap_instance(obj, self)
-    end
-
-    def wrap_instances(arr)
-      T::InterfaceWrapper.wrap_instances(arr, self)
-    end
-  end
-
-  private_class_method :new # use `wrap_instance`
-
-  def self.wrap_instance(obj, interface_mod)
-    wrapper = wrapped_dynamic_cast(obj, interface_mod)
-    if wrapper.nil?
-      raise "#{obj.class} cannot be cast to #{interface_mod}"
-    end
-    wrapper
-  end
-
-  sig do
-    params(
-      arr: Array,
-      interface_mod: T.untyped
-    )
-    .returns(Array)
-  end
-  def self.wrap_instances(arr, interface_mod)
-    arr.map {|instance| self.wrap_instance(instance, interface_mod)}
-  end
-
-  def initialize(target_obj, interface_mod)
-    if target_obj.is_a?(T::InterfaceWrapper)
-      # wrapped_dynamic_cast should guarantee this never happens.
-      raise "Unexpected: wrapping a wrapper. Please report this bug at https://github.com/sorbet/sorbet/issues"
-    end
-
-    if !target_obj.is_a?(interface_mod)
-      # wrapped_dynamic_cast should guarantee this never happens.
-      raise "Unexpected: `is_a?` failed. Please report this bug at https://github.com/sorbet/sorbet/issues"
-    end
-
-    if target_obj.class == interface_mod
-      # wrapped_dynamic_cast should guarantee this never happens.
-      raise "Unexpected: exact class match. Please report this bug at https://github.com/sorbet/sorbet/issues"
-    end
-
-    @target_obj = target_obj
-    @interface_mod = interface_mod
-    self_methods = self.class.self_methods
-
-    # If perf becomes an issue, we can define these on an anonymous subclass, and keep a cache
-    # so we only need to do it once per unique `interface_mod`
-    T::Utils.methods_excluding_object(interface_mod).each do |method_name|
-      if self_methods.include?(method_name)
-        raise "interface_mod has a method that conflicts with #{self.class}: #{method_name}"
-      end
-
-      define_singleton_method(method_name) do |*args, &blk|
-        target_obj.send(method_name, *args, &blk)
-      end
-
-      if singleton_class.respond_to?(:ruby2_keywords, true)
-        singleton_class.send(:ruby2_keywords, method_name)
-      end
-
-      if target_obj.singleton_class.public_method_defined?(method_name)
-        # no-op, it's already public
-      elsif target_obj.singleton_class.protected_method_defined?(method_name)
-        singleton_class.send(:protected, method_name)
-      elsif target_obj.singleton_class.private_method_defined?(method_name)
-        singleton_class.send(:private, method_name)
-      else
-        raise "This should never happen. Report this bug at https://github.com/sorbet/sorbet/issues"
-      end
-    end
-  end
-
-  def kind_of?(other)
-    is_a?(other)
-  end
-
-  def is_a?(other)
-    if !other.is_a?(Module)
-      raise TypeError.new("class or module required")
-    end
-
-    # This makes is_a? return true for T::InterfaceWrapper (and its ancestors),
-    # as well as for @interface_mod and its ancestors.
-    self.class <= other || @interface_mod <= other
-  end
-
-  # Prefixed because we're polluting the namespace of the interface we're wrapping, and we don't
-  # want anyone else (besides dynamic_cast) calling it.
-  def __target_obj_DO_NOT_USE # rubocop:disable Naming/MethodName
-    @target_obj
-  end
-
-  # Prefixed because we're polluting the namespace of the interface we're wrapping, and we don't
-  # want anyone else (besides wrapped_dynamic_cast) calling it.
-  def __interface_mod_DO_NOT_USE # rubocop:disable Naming/MethodName
-    @interface_mod
-  end
-
-  # "Cast" an object to another type. If `obj` is an InterfaceWrapper, returns the the wrapped
-  # object if that matches `type`. Otherwise, returns `obj` if it matches `type`. Otherwise,
-  # returns nil.
-  #
-  # @param obj [Object] object to cast
-  # @param mod [Module] type to cast `obj` to
-  #
-  # @example
-  #   if (impl = T::InterfaceWrapper.dynamic_cast(iface, MyImplementation))
-  #     impl.do_things
-  #   end
-  def self.dynamic_cast(obj, mod)
-    if obj.is_a?(T::InterfaceWrapper)
-      target_obj = obj.__target_obj_DO_NOT_USE
-      target_obj.is_a?(mod) ? target_obj : nil
-    elsif obj.is_a?(mod)
-      obj
-    else
-      nil
-    end
-  end
-
-  # Like dynamic_cast, but puts the result in its own wrapper if necessary.
-  #
-  # @param obj [Object] object to cast
-  # @param mod [Module] type to cast `obj` to
-  def self.wrapped_dynamic_cast(obj, mod)
-    # Avoid unwrapping and creating an equivalent wrapper.
-    if obj.is_a?(T::InterfaceWrapper) && obj.__interface_mod_DO_NOT_USE == mod
-      return obj
-    end
-
-    cast_obj = dynamic_cast(obj, mod)
-    if cast_obj.nil?
-      nil
-    elsif cast_obj.class == mod
-      # Nothing to wrap, they want the full class
-      cast_obj
-    else
-      new(cast_obj, mod)
-    end
-  end
-
-  def self.self_methods
-    @self_methods ||= self.instance_methods(false).to_set
-  end
-end