sorbet-runtime 0.5.5841

data/lib/types/private/mixins/mixins.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Private
+  module MixesInClassMethods
+    def included(other)
+      mod = Abstract::Data.get(self, :class_methods_mixin)
+      other.extend(mod)
+      super
+    end
+  end
+
+  module Mixins
+    def self.declare_mixes_in_class_methods(mixin, class_methods)
+      if mixin.is_a?(Class)
+        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."
+      end
+
+      mixin.singleton_class.include(MixesInClassMethods)
+      Abstract::Data.set(mixin, :class_methods_mixin, class_methods)
+    end
+  end
+end

data/lib/types/private/retry.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Private::Retry
+
+  # A special singleton used for static analysis of exceptions.
+  module RETRY
+    freeze
+  end
+end

data/lib/types/private/runtime_levels.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+# typed: true
+
+# Used in `sig.checked(level)` to determine when runtime type checking
+# is enabled on a method.
+module T::Private::RuntimeLevels
+  LEVELS = [
+    # Validate every call in every environment
+    :always,
+    # Validate in tests, but not in production
+    :tests,
+    # Don't even validate in tests, b/c too expensive,
+    # or b/c we fully trust the static typing
+    :never,
+  ].freeze
+
+  @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
+    # for toggling `@check_tests`.
+    @wrapped_tests_with_validation = true
+
+    @check_tests
+  end
+
+  def self.enable_checking_in_tests
+    if !@check_tests && @wrapped_tests_with_validation
+      raise "Toggle `:tests`-level runtime type checking earlier. " \
+        "There are already some methods wrapped with `sig.checked(:tests)`." \
+    end
+
+    _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
+end

data/lib/types/private/sealed.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+# typed: false
+
+module T::Private::Sealed
+  module NoInherit
+    def inherited(other)
+      super
+      this_line = Kernel.caller.find {|line| !line.match(/in `inherited'$/)}
+      T::Private::Sealed.validate_inheritance(this_line, self, 'inherited')
+    end
+  end
+
+  module NoIncludeExtend
+    def included(other)
+      super
+      this_line = Kernel.caller.find {|line| !line.match(/in `included'$/)}
+      T::Private::Sealed.validate_inheritance(this_line, self, 'included')
+    end
+
+    def extended(other)
+      super
+      this_line = Kernel.caller.find {|line| !line.match(/in `extended'$/)}
+      T::Private::Sealed.validate_inheritance(this_line, self, 'extended')
+    end
+  end
+
+  def self.declare(mod, decl_file)
+    if !mod.is_a?(Module)
+      raise "#{mod} is not a class or module and cannot be declared `sealed!`"
+    end
+    if sealed_module?(mod)
+      raise "#{mod} was already declared `sealed!` and cannot be re-declared `sealed!`"
+    end
+    if T::Private::Final.final_module?(mod)
+      raise "#{mod} was already declared `final!` and cannot be declared `sealed!`"
+    end
+    mod.extend(mod.is_a?(Class) ? NoInherit : NoIncludeExtend)
+    if !decl_file
+      raise "Couldn't determine declaration file for sealed class."
+    end
+    mod.instance_variable_set(:@sorbet_sealed_module_decl_file, decl_file)
+  end
+
+  def self.sealed_module?(mod)
+    mod.instance_variable_defined?(:@sorbet_sealed_module_decl_file)
+  end
+
+  def self.validate_inheritance(this_line, parent, verb)
+    this_file = this_line&.split(':').first
+    decl_file = parent.instance_variable_get(:@sorbet_sealed_module_decl_file)
+
+    if !this_file || !decl_file
+      raise "Couldn't determine enough file information for checking sealed modules"
+    end
+
+    if !this_file.start_with?(decl_file)
+      whitelist = T::Configuration.sealed_violation_whitelist
+      if whitelist != nil && whitelist.any? {|pattern| this_file =~ pattern}
+        return
+      end
+
+      raise "#{parent} was declared sealed and can only be #{verb} in #{decl_file}, not #{this_file}"
+    end
+  end
+end

data/lib/types/private/types/not_typed.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+# typed: true
+
+# A placeholder for when an untyped thing must provide a type.
+# Raises an exception if it is ever used for validation.
+class T::Private::Types::NotTyped < T::Types::Base
+  ERROR_MESSAGE = "Validation is being done on a `NotTyped`. Please report to #dev-productivity."
+
+  # @override Base
+  def name
+    "<NOT-TYPED>"
+  end
+
+  # @override Base
+  def valid?(obj)
+    raise ERROR_MESSAGE
+  end
+
+  # @override Base
+  private def subtype_of_single?(other)
+    raise ERROR_MESSAGE
+  end
+end

data/lib/types/private/types/string_holder.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+# typed: true
+
+# Holds a string. Useful for showing type aliases in error messages
+class T::Private::Types::StringHolder < T::Types::Base
+  attr_reader :string
+
+  def initialize(string)
+    @string = string
+  end
+
+  # @override Base
+  def name
+    string
+  end
+
+  # @override Base
+  def valid?(obj)
+    false
+  end
+
+  # @override Base
+  private def subtype_of_single?(other)
+    false
+  end
+end

data/lib/types/private/types/type_alias.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Private::Types
+  # Wraps a proc for a type alias to defer its evaluation.
+  class TypeAlias < T::Types::Base
+
+    def initialize(callable)
+      @callable = callable
+    end
+
+    def aliased_type
+      @aliased_type ||= T::Utils.coerce(@callable.call)
+    end
+
+    # @override Base
+    def name
+      aliased_type.name
+    end
+
+    # @override Base
+    def valid?(obj)
+      aliased_type.valid?(obj)
+    end
+  end
+end

data/lib/types/private/types/void.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+# typed: true
+
+# A marking class for when methods return void.
+# Should never appear in types directly.
+class T::Private::Types::Void < T::Types::Base
+  ERROR_MESSAGE = "Validation is being done on an `Void`. Please report to #dev-productivity."
+
+  # The actual return value of `.void` methods.
+  #
+  # Uses `module VOID` because this gives it a readable name when someone
+  # examines it in Pry or with `#inspect` like:
+  #
+  #     T::Private::Types::Void::VOID
+  #
+  module VOID
+    freeze
+  end
+
+  # @override Base
+  def name
+    "<VOID>"
+  end
+
+  # @override Base
+  def valid?(obj)
+    raise ERROR_MESSAGE
+  end
+
+  # @override Base
+  private def subtype_of_single?(other)
+    raise ERROR_MESSAGE
+  end
+end

data/lib/types/profile.rb

@@ -0,0 +1,31 @@
+# typed: true
+# frozen_string_literal: true
+
+module T::Profile
+  SAMPLE_RATE = 101 # 1 out of that many typechecks will be measured
+  class <<self
+    attr_accessor :typecheck_duration
+    attr_accessor :typecheck_samples
+    attr_accessor :typecheck_sample_attempts
+    def typecheck_duration_estimate
+      total_typechecks = typecheck_samples * SAMPLE_RATE + (SAMPLE_RATE - typecheck_sample_attempts)
+      typechecks_measured = typecheck_samples * SAMPLE_RATE
+      if typechecks_measured.positive?
+        typecheck_duration * SAMPLE_RATE * 1.0 * total_typechecks / typechecks_measured
+      else
+        0.0
+      end
+    end
+
+    def typecheck_count_estimate
+      typecheck_samples * SAMPLE_RATE
+    end
+
+    def reset
+      @typecheck_duration = 0
+      @typecheck_samples = 0
+      @typecheck_sample_attempts = SAMPLE_RATE
+    end
+  end
+  self.reset
+end

data/lib/types/props/_props.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+# typed: true
+
+# A mixin for defining typed properties (attributes).
+# To get serialization methods (to/from JSON-style hashes), add T::Props::Serializable.
+# To get a constructor based on these properties, inherit from T::Struct.
+module T::Props
+  extend T::Helpers
+
+  #####
+  # CAUTION: This mixin is used in hundreds of classes; we want to keep its surface area as narrow
+  # as possible and avoid polluting (and possibly conflicting with) the classes that use it.
+  #
+  # It currently has *zero* instance methods; let's try to keep it that way.
+  # For ClassMethods (below), try to add things to T::Props::Decorator instead unless you are sure
+  # it needs to be exposed here.
+  #####
+
+  module ClassMethods
+    extend T::Sig
+    extend T::Helpers
+
+    def props; decorator.props; end
+    def plugins; @plugins ||= []; end
+
+    def decorator_class; Decorator; end
+
+    def decorator; @decorator ||= decorator_class.new(self); end
+    def reload_decorator!; @decorator = decorator_class.new(self); end
+
+    # @!method self.prop(name, type, opts={})
+    #
+    # Define a new property. See {file:README.md} for some concrete
+    #  examples.
+    #
+    # Defining a property defines a method with the same name as the
+    # property, that returns the current value, and a `prop=` method
+    # to set its value. Properties will be inherited by subclasses of
+    # a document class.
+    #
+    # @param name [Symbol] The name of this property
+    # @param cls [Class,T::Types::Base] The type of this
+    #   property. If the type is itself a {Document} subclass, this
+    #   property will be recursively serialized/deserialized.
+    # @param rules [Hash] Options to control this property's behavior.
+    # @option rules [T::Boolean,Symbol] :optional If `true`, this property
+    #   is never required to be set before an instance is serialized.
+    #   If `:on_load` (default), when this property is missing or nil, a
+    #   new model cannot be saved, and an existing model can only be
+    #   saved if the property was already missing when it was loaded.
+    #   If `false`, when the property is missing/nil after deserialization, it
+    #   will be set to the default value (as defined by the `default` or
+    #   `factory` option) or will raise if they are not present.
+    #   Deprecated: For {Model}s, if `:optional` is set to the special value
+    #   `:existing`, the property can be saved as nil even if it was
+    #   deserialized with a non-nil value. (Deprecated because there should
+    #   never be a need for this behavior; the new behavior of non-optional
+    #   properties should be sufficient.)
+    # @option rules [Array] :enum An array of legal values; The
+    #  property is required to take on one of those values.
+    # @option rules [T::Boolean] :dont_store If true, this property will
+    #   not be saved on the hash resulting from {#serialize}
+    # @option rules [Object] :ifunset A value to be returned if this
+    #   property is requested but has never been set (is set to
+    #   `nil`). It is applied at property-access time, and never saved
+    #   back onto the object or into the database.
+    #
+    #   ``:ifunset`` is considered **DEPRECATED** and should not be used
+    #    in new code, in favor of just setting a default value.
+    # @option rules [Model, Symbol, Proc] :foreign A model class that this
+    #  property is a reference to. Passing `:foreign` will define a
+    #  `:"#{name}_"` method, that will load and return the
+    #  corresponding foreign model.
+    #
+    #  A symbol can be passed to avoid load-order dependencies; It
+    #  will be lazily resolved relative to the enclosing module of the
+    #  defining class.
+    #
+    #  A callable (proc or method) can be passed to dynamically specify the
+    #  foreign model. This will be passed the object instance so that other
+    #  properties of the object can be used to determine the relevant model
+    #  class. It should return a string/symbol class name or the foreign model
+    #  class directly.
+    #
+    # @option rules [Object] :default A default value that will be set
+    #   by {#initialize} if none is provided in the initialization
+    #   hash. This will not affect objects loaded by {.from_hash}.
+    # @option rules [Proc] :factory A `Proc` that will be called to
+    #   generate an initial value for this prop on {#initialize}, if
+    #   none is provided.
+    # @option rules [T::Boolean] :immutable If true, this prop cannot be
+    #   modified after an instance is created or loaded from a hash.
+    # @option rules [T::Boolean] :override It is an error to redeclare a
+    #   `prop` that has already been declared (including on a
+    #   superclass), unless `:override` is set to `true`.
+    # @option rules [Symbol, Array] :redaction A redaction directive that may
+    #   be passed to Chalk::Tools::RedactionUtils.redact_with_directive to
+    #   sanitize this parameter for display. Will define a
+    #   `:"#{name}_redacted"` method, which will return the value in sanitized
+    #   form.
+    #
+    # @return [void]
+    def prop(name, cls, rules={})
+      cls = T::Utils.coerce(cls) if !cls.is_a?(Module)
+      decorator.prop_defined(name, cls, rules)
+    end
+
+    # @!method validate_prop_value(propname, value)
+    #
+    # Validates the value of the specified prop. This method allows the caller to
+    #  validate a value for a prop without having to set the data on the instance.
+    #  Throws if invalid.
+    #
+    # @param prop [Symbol]
+    # @param val [Object]
+    # @return [void]
+    def validate_prop_value(prop, val)
+      decorator.validate_prop_value(prop, val)
+    end
+
+    # Needs to be documented
+    def plugin(mod)
+      decorator.plugin(mod)
+    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}
+    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")
+      end
+
+      if cls_or_args.is_a?(Hash)
+        self.prop(name, cls_or_args.merge(immutable: true))
+      else
+        self.prop(name, cls_or_args, args.merge(immutable: true))
+      end
+    end
+
+    def included(child)
+      decorator.model_inherited(child)
+      super
+    end
+
+    def prepended(child)
+      decorator.model_inherited(child)
+      super
+    end
+
+    def extended(child)
+      decorator.model_inherited(child.singleton_class)
+      super
+    end
+
+    def inherited(child)
+      decorator.model_inherited(child)
+      super
+    end
+  end
+  mixes_in_class_methods(ClassMethods)
+end