sorbet-runtime 0.0.1.pre.prealpha → 0.4.4253

data/lib/types/props/type_validation.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+# typed: false
+
+module T::Props::TypeValidation
+  include T::Props::Plugin
+
+  BANNED_TYPES = [Object, BasicObject, Kernel]
+
+  class UnderspecifiedType < ArgumentError; end
+
+  module DecoratorMethods
+    extend T::Sig
+
+    sig {returns(T::Array[Symbol])}
+    def valid_props
+      super + [:DEPRECATED_underspecified_type]
+    end
+
+    sig do
+      params(
+        name: T.any(Symbol, String),
+        _cls: Module,
+        rules: T::Hash[Symbol, T.untyped],
+        type: T.any(T::Types::Base, Module)
+      )
+      .void
+    end
+    def prop_validate_definition!(name, _cls, rules, type)
+      super
+
+      if !rules[:DEPRECATED_underspecified_type] && !(type.singleton_class <= T::Props::CustomType)
+        validate_type(type, field_name: name)
+      elsif rules[:DEPRECATED_underspecified_type] && find_invalid_subtype(type).nil?
+        raise ArgumentError.new("DEPRECATED_underspecified_type set unnecessarily for #{@class.name}.#{name} - #{type} is a valid type")
+      end
+    end
+
+    sig do
+      params(
+        type: T::Types::Base,
+        field_name: T.any(Symbol, String),
+      )
+      .void
+    end
+    private def validate_type(type, field_name:)
+      if (invalid_subtype = find_invalid_subtype(type))
+        raise UnderspecifiedType.new(type_error_message(invalid_subtype, field_name, type))
+      end
+    end
+
+    # Returns an invalid type, if any, found in the given top-level type.
+    # This might be the type itself, if it is e.g. "Object", or might be
+    # a subtype like the type of the values of a typed hash.
+    #
+    # If the type is fully valid, returns nil.
+    sig {params(type: T::Types::Base).returns(T.nilable(T::Types::Base))}
+    private def find_invalid_subtype(type)
+      case type
+      when T::Types::TypedEnumerable
+        find_invalid_subtype(type.type)
+      when T::Types::FixedHash
+        type.types.values.map {|subtype| find_invalid_subtype(subtype)}.compact.first
+      when T::Types::Union, T::Types::FixedArray
+        type.types.map {|subtype| find_invalid_subtype(subtype)}.compact.first
+      when T::Types::Enum, T::Types::ClassOf
+        nil
+      when T::Types::Simple
+        # TODO Could we manage to define a whitelist, consisting of something
+        # like primitives, subdocs, DataInterfaces, and collections/enums/unions
+        # thereof?
+        if BANNED_TYPES.include?(type.raw_type)
+          type
+        else
+          nil
+        end
+      else
+        type
+      end
+    end
+
+    sig do
+      params(
+        type: T::Types::Base,
+        field_name: T.any(Symbol, String),
+        orig_type: T::Types::Base,
+      )
+      .returns(String)
+    end
+    private def type_error_message(type, field_name, orig_type)
+      msg_prefix = "#{@class.name}.#{field_name}: #{orig_type} is invalid in prop definition"
+      if type == orig_type
+        "#{msg_prefix}. Please choose a more specific type (T.untyped and ~equivalents like Object are banned)."
+      else
+        "#{msg_prefix}. Please choose a subtype more specific than #{type} (T.untyped and ~equivalents like Object are banned)."
+      end
+    end
+  end
+end

data/lib/types/props/utils.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Props::Utils
+  # Deep copy an object. The object must consist of Ruby primitive
+  # types and Hashes and Arrays.
+  def self.deep_clone_object(what, freeze: false)
+    result = case what
+    when true
+      true
+    when false
+      false
+    when Symbol, NilClass, Numeric
+      what
+    when Array
+      what.map {|v| deep_clone_object(v, freeze: freeze)}
+    when Hash
+      h = what.class.new
+      what.each do |k, v|
+        k.freeze if freeze
+        h[k] = deep_clone_object(v, freeze: freeze)
+      end
+      h
+    when Regexp
+      what.dup
+    else
+      # Some unfortunate nastiness to get around Opus::Enum potentially not
+      # being defined.
+      if defined?(Opus) && defined?(Opus::Enum) && what.class == Opus::Enum
+        what
+      else
+        what.clone
+      end
+    end
+    freeze ? result.freeze : result
+  end
+
+  # The prop_rules indicate whether we should check for reading a nil value for the prop/field.
+  # This is mostly for the compatibility check that we allow existing documents carry some nil prop/field.
+  def self.need_nil_read_check?(prop_rules)
+    # . :on_load allows nil read, but we need to check for the read for future writes
+    prop_rules[:optional] == :on_load || prop_rules[:raise_on_nil_write]
+  end
+
+  # The prop_rules indicate whether we should check for writing a nil value for the prop/field.
+  def self.need_nil_write_check?(prop_rules)
+    need_nil_read_check?(prop_rules) || T::Utils::Props.required_prop?(prop_rules)
+  end
+end

data/lib/types/props/weak_constructor.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+# typed: false
+
+module T::Props::WeakConstructor
+  include T::Props::Optional
+
+  def initialize(hash={})
+    expected_keys = {}
+    hash.each_key {|key| expected_keys[key] = true}
+
+    decorator = self.class.decorator
+
+    decorator.props.each do |p, rules|
+      if hash.key?(p)
+        expected_keys.delete(p)
+        val = hash[p]
+      elsif decorator.has_default?(rules)
+        val = decorator.get_default(rules, self.class)
+      else
+        next
+      end
+
+      decorator.prop_set(self, p, val, rules)
+    end
+
+    unless expected_keys.empty?
+      raise ArgumentError.new("#{@class}: Unrecognized properties in #with_props: #{expected_keys.keys.join(', ')}")
+    end
+  end
+end

data/lib/types/runtime_profiled.rb

@@ -0,0 +1,36 @@
+# typed: true
+# frozen_string_literal: true
+
+#
+# Hey there!
+#
+# T::Utils::Runtime is just a random class. Chances are[^1] it's not a class
+# that your variables are instances of, which means that using it in a type
+# signature will always create a type error.
+#
+# At first, it doesn't seem like a good thing to have a type that's sole
+# purpose is to cause type errors. The trick is that within the ruby-types
+# team, we only use T::Utils::RuntimeProfiled within 'generated' sigs.
+#
+# Unlike normal sigs, generated sigs never raise at runtime. They also log the
+# actual, observed type on type error to a central location. We're using these
+# observed types to refine and expand our type coverage in pay-server.
+#
+# What does this all mean for you?
+#
+# - If you were just curious, that's it! Leave the sig as is, and carry on.
+# - If you wanted to replace this sig with a better, hand-authored one:
+#
+#   1. Remove 'generated' from the sig.
+#   2. Update the sig to your liking
+#
+# Questions? :portal-to: => #ruby-types
+#
+# [^1]: Unless you happen to be calling T::Utils::RuntimeProfiled.new directly...
+#
+
+module T; end
+module T::Utils; end
+# Sorbet guesses this type instead of T.untyped when passed --suggest-runtime-profiled
+
+class T::Utils::RuntimeProfiled; end

data/lib/types/sig.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+# typed: true
+# rubocop:disable PrisonGuard/NoTopLevelDeclarations, PrisonGuard/PackageMatchesDirectory
+
+# Used as a mixin to any class so that you can call `sig`.
+# Docs at http://go/types
+module T::Sig
+  module WithoutRuntime
+    # 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.
+    def self.sig(&blk); end # rubocop:disable PrisonGuard/BanBuiltinMethodOverride
+
+    # 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(blk: T.proc.bind(T::Private::Methods::DeclBuilder).void).void} # rubocop:disable PrisonGuard/PrivateModule
+    def self.sig(&blk); end # rubocop:disable PrisonGuard/BanBuiltinMethodOverride, Lint/DuplicateMethods
+  end
+
+  # Declares a method with type signatures and/or
+  # abstract/override/... helpers. See the documentation URL on
+  # {T::Helpers}
+  T::Sig::WithoutRuntime.sig {params(blk: T.proc.bind(T::Private::Methods::DeclBuilder).void).void}
+  def sig(&blk) # rubocop:disable PrisonGuard/BanBuiltinMethodOverride
+    T::Private::Methods.declare_sig(self, &blk)
+  end
+end
+
+# rubocop:enable PrisonGuard/NoTopLevelDeclarations, PrisonGuard/PackageMatchesDirectory

data/lib/types/struct.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+# typed: true
+
+class T::Struct
+  include T::Props
+  include T::Props::Serializable
+  include T::Props::Constructor
+end

data/lib/types/types/base.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Types
+  class Base
+    def self.method_added(method_name)
+      # What is now `subtype_of_single?` used to be named `subtype_of?`. Make sure people don't
+      # override the wrong thing.
+      #
+      # NB: Outside of T::Types, we would enforce this by using `sig` and not declaring the method
+      # as overridable, but doing so here would result in a dependency cycle.
+      if method_name == :subtype_of? && self != T::Types::Base
+        raise "`subtype_of?` should not be overridden. You probably want to override " \
+              "`subtype_of_single?` instead."
+      end
+    end
+
+    def valid?(obj)
+      raise NotImplementedError
+    end
+
+    # @return [T::Boolean] This method must be implemented to return whether the subclass is a subtype
+    # of `type`. This should only be called by `subtype_of?`, which guarantees that `type` will be
+    # a "single" type, by which we mean it won't be a Union or an Intersection (c.f.
+    # `isSubTypeSingle` in sorbet).
+    private def subtype_of_single?(type)
+      raise NotImplementedError
+    end
+
+    # Equality is based on name, so be sure the name reflects all relevant state when implementing.
+    def name
+      raise NotImplementedError
+    end
+
+    # Mirrors ruby_typer::core::Types::isSubType
+    # See https://git.corp.stripe.com/stripe-internal/ruby-typer/blob/9fc8ed998c04ac0b96592ae6bb3493b8a925c5c1/core/types/subtyping.cc#L912-L950
+    #
+    # This method cannot be overridden (see `method_added` above).
+    # Subclasses only need to implement `subtype_of_single?`).
+    def subtype_of?(t2)
+      t1 = self
+
+      # pairs to cover: 1  (_, _)
+      #                 2  (_, And)
+      #                 3  (_, Or)
+      #                 4  (And, _)
+      #                 5  (And, And)
+      #                 6  (And, Or)
+      #                 7  (Or, _)
+      #                 8  (Or, And)
+      #                 9  (Or, Or)
+
+      # 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)}
+      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)}
+      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)}
+        end
+        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)}
+      end
+
+      # 1; Start with some special cases
+      if t1.is_a?(T::Private::Types::Void)
+        return t2.is_a?(T::Private::Types::Void)
+      end
+
+      if t1.is_a?(T::Types::Untyped) || t2.is_a?(T::Types::Untyped)
+        return true
+      end
+
+      # Rest of (1)
+      subtype_of_single?(t2)
+    end
+
+    def to_s
+      name
+    end
+
+    def describe_obj(obj)
+      # Would be redundant to print class and value in these common cases.
+      case obj
+      when nil, true, false
+        return "type #{obj.class}"
+      end
+
+      # In rare cases, obj.inspect may fail, or be undefined, so rescue.
+      begin
+        # Default inspect behavior of, eg; `#<Object:0x0...>` is ugly; just print the hash instead, which is more concise/readable.
+        if obj.method(:inspect).owner == Kernel
+          "type #{obj.class} with hash #{obj.hash}"
+        else
+          "type #{obj.class} with value #{T::Utils.string_truncate_middle(obj.inspect, 30, 30)}"
+        end
+      rescue StandardError, SystemStackError
+        "type #{obj.class} with unprintable value"
+      end
+    end
+
+    def error_message_for_obj(obj)
+      if valid?(obj)
+        nil
+      else
+        "Expected type #{self.name}, got #{describe_obj(obj)}"
+      end
+    end
+
+    def validate!(obj)
+      err = error_message_for_obj(obj)
+      raise TypeError.new(err) if err
+    end
+
+    ### Equality methods (necessary for deduping types with `uniq`)
+
+    def hash
+      name.hash
+    end
+
+    def ==(other)
+      other.class == self.class && other.name == self.name
+    end
+
+    alias_method :eql?, :==
+  end
+end

data/lib/types/types/class_of.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Types
+  # Validates that an object belongs to the specified class.
+  class ClassOf < Base
+    attr_reader :type
+
+    def initialize(type)
+      @type = type
+    end
+
+    # @override Base
+    def name
+      "T.class_of(#{@type})"
+    end
+
+    # @override Base
+    def valid?(obj)
+      obj.is_a?(Module) && obj <= @type
+    end
+
+    # @override Base
+    def subtype_of_single?(other)
+      case other
+      when ClassOf
+        @type <= other.type
+      else
+        false
+      end
+    end
+
+    # @override Base
+    def describe_obj(obj)
+      obj.inspect
+    end
+  end
+end

data/lib/types/types/enum.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Types
+  # validates that the provided value is within a given set/enum
+  class Enum < Base
+    extend T::Sig
+
+    attr_reader :values
+
+    # TODO Ideally Hash would not be accepted but there are a lot of uses with prop enum.
+    sig {params(values: T.any(Array, Set, Hash, T::Range[T.untyped])).void}
+    def initialize(values)
+      @values = values
+    end
+
+    # @override Base
+    def valid?(obj)
+      @values.member?(obj)
+    end
+
+    # @override Base
+    private def subtype_of_single?(other)
+      case other
+      when Enum
+        (other.values - @values).empty?
+      else
+        false
+      end
+    end
+
+    # @override Base
+    def name
+      "T.enum([#{@values.map(&:inspect).join(', ')}])"
+    end
+
+    # @override Base
+    def describe_obj(obj)
+      obj.inspect
+    end
+  end
+end