sorbet-runtime 0.5.5841

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

data/lib/types/types/fixed_array.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+# https://jira.corp.stripe.com/browse/RUBYPLAT-1107
+# typed: false
+
+module T::Types
+  # Takes a list of types. Validates each item in an array using the type in the same position
+  # in the list.
+  class FixedArray < Base
+    attr_reader :types
+
+    def initialize(types)
+      @types = types.map {|type| T::Utils.coerce(type)}
+    end
+
+    # @override Base
+    def name
+      "[#{@types.join(', ')}]"
+    end
+
+    # @override Base
+    def valid?(obj)
+      obj.is_a?(Array) && obj.length == @types.length &&
+        obj.zip(@types).all? {|item, type| type.valid?(item)}
+    end
+
+    # @override Base
+    private def subtype_of_single?(other)
+      case other
+      when FixedArray
+        # Properly speaking, covariance here is unsound since arrays
+        # can be mutated, but sorbet implements covariant tuples for
+        # ease of adoption.
+        @types.size == other.types.size && @types.zip(other.types).all? do |t1, t2|
+          t1.subtype_of?(t2)
+        end
+      else
+        false
+      end
+    end
+
+    # This gives us better errors, e.g.:
+    # "Expected [String, Symbol], got [String, String]"
+    # instead of
+    # "Expected [String, Symbol], got Array".
+    #
+    # @override Base
+    def describe_obj(obj)
+      if obj.is_a?(Array)
+        if obj.length == @types.length
+          item_classes = obj.map(&:class).join(', ')
+          "type [#{item_classes}]"
+        else
+          "array of size #{obj.length}"
+        end
+      else
+        super
+      end
+    end
+  end
+end

data/lib/types/types/fixed_hash.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Types
+  # Takes a hash of types. Validates each item in an hash using the type in the same position
+  # in the list.
+  class FixedHash < Base
+    attr_reader :types
+
+    def initialize(types)
+      @types = types.each_with_object({}) {|(k, v), h| h[k] = T::Utils.coerce(v)}
+    end
+
+    # @override Base
+    def name
+      "{#{@types.map {|(k, v)| "#{k}: #{v}"}.join(', ')}}"
+    end
+
+    # @override Base
+    def valid?(obj)
+      return false unless obj.is_a?(Hash)
+
+      @types.each do |key, type|
+        return false unless type.valid?(obj[key])
+      end
+
+      obj.each_key do |key|
+        return false unless @types[key]
+      end
+
+      true
+    end
+
+    # @override Base
+    private def subtype_of_single?(other)
+      case other
+      when FixedHash
+        # Using `subtype_of?` here instead of == would be unsound
+        @types == other.types
+      else
+        false
+      end
+    end
+
+    # This gives us better errors, e.g.:
+    # "Expected {a: String}, got {a: TrueClass}"
+    # instead of
+    # "Expected {a: String}, got Hash".
+    #
+    # @override Base
+    def describe_obj(obj)
+      if obj.is_a?(Hash)
+        "type {#{obj.map {|(k, v)| "#{k}: #{v.class}"}.join(', ')}}"
+      else
+        super
+      end
+    end
+  end
+end

data/lib/types/types/intersection.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Types
+  # Takes a list of types. Validates that an object matches all of the types.
+  class Intersection < Base
+    attr_reader :types
+
+    def initialize(types)
+      @types = types.flat_map do |type|
+        type = T::Utils.resolve_alias(type)
+        if type.is_a?(Intersection)
+          # Simplify nested intersections (mostly so `name` returns a nicer value)
+          type.types
+        else
+          T::Utils.coerce(type)
+        end
+      end.uniq
+    end
+
+    # @override Base
+    def name
+      "T.all(#{@types.map(&:name).sort.join(', ')})"
+    end
+
+    # @override Base
+    def valid?(obj)
+      @types.all? {|type| type.valid?(obj)}
+    end
+
+    # @override Base
+    private def subtype_of_single?(other)
+      raise "This should never be reached if you're going through `subtype_of?` (and you should be)"
+    end
+
+  end
+end

data/lib/types/types/noreturn.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Types
+  # The bottom type
+  class NoReturn < Base
+
+    def initialize; end
+
+    # @override Base
+    def name
+      "T.noreturn"
+    end
+
+    # @override Base
+    def valid?(obj)
+      false
+    end
+
+    # @override Base
+    private def subtype_of_single?(other)
+      true
+    end
+
+    module Private
+      INSTANCE = NoReturn.new.freeze
+    end
+  end
+end

data/lib/types/types/proc.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Types
+  # Defines the type of a proc (a ruby callable). At runtime, only
+  # validates that the value is a `::Proc`.
+  #
+  # At present, we only support fixed-arity procs with no optional or
+  # keyword arguments.
+  class Proc < Base
+    attr_reader :arg_types
+    attr_reader :returns
+
+    def initialize(arg_types, returns)
+      @arg_types = {}
+      arg_types.each do |key, raw_type|
+        @arg_types[key] = T::Utils.coerce(raw_type)
+      end
+      @returns = T::Utils.coerce(returns)
+    end
+
+    # @override Base
+    def name
+      args = []
+      @arg_types.each do |k, v|
+        args << "#{k}: #{v.name}"
+      end
+      "T.proc.params(#{args.join(', ')}).returns(#{returns})"
+    end
+
+    # @override Base
+    def valid?(obj)
+      obj.is_a?(::Proc)
+    end
+
+    # @override Base
+    private def subtype_of_single?(other)
+      case other
+      when self.class
+        if arg_types.size != other.arg_types.size
+          return false
+        end
+        arg_types.values.zip(other.arg_types.values).all? do |a, b|
+          b.subtype_of?(a)
+        end && returns.subtype_of?(other.returns)
+      else
+        false
+      end
+    end
+  end
+end

data/lib/types/types/self_type.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Types
+  # Modeling self-types properly at runtime would require additional tracking,
+  # so at runtime we permit all values and rely on the static checker.
+  class SelfType < Base
+
+    def initialize(); end
+
+    # @override Base
+    def name
+      "T.self_type"
+    end
+
+    # @override Base
+    def valid?(obj)
+      true
+    end
+
+    # @override Base
+    private def subtype_of_single?(other)
+      case other
+      when SelfType
+          true
+        else
+          false
+      end
+    end
+
+    module Private
+      INSTANCE = SelfType.new.freeze
+    end
+  end
+end

data/lib/types/types/simple.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Types
+  # Validates that an object belongs to the specified class.
+  class Simple < Base
+    attr_reader :raw_type
+
+    def initialize(raw_type)
+      @raw_type = raw_type
+    end
+
+    # @override Base
+    def name
+      @raw_type.name
+    end
+
+    # @override Base
+    def valid?(obj)
+      obj.is_a?(@raw_type)
+    end
+
+    # @override Base
+    private def subtype_of_single?(other)
+      case other
+      when Simple
+        @raw_type <= other.raw_type
+      else
+        false
+      end
+    end
+  end
+end

data/lib/types/types/t_enum.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Types
+  # Validates that an object is equal to another T::Enum singleton value.
+  class TEnum < Base
+    attr_reader :val
+
+    def initialize(val)
+      @val = val
+    end
+
+    # @override Base
+    def name
+      # Strips the #<...> off, just leaving the ...
+      # Reasoning: the user will have written something like
+      #   T.any(MyEnum::A, MyEnum::B)
+      # in the type, so we should print what they wrote in errors, not:
+      #   T.any(#<MyEnum::A>, #<MyEnum::B>)
+      @val.inspect[2..-2]
+    end
+
+    # @override Base
+    def valid?(obj)
+      @val == obj
+    end
+
+    # @override Base
+    private def subtype_of_single?(other)
+      case other
+      when TEnum
+        @val == other.val
+      else
+        false
+      end
+    end
+  end
+end

data/lib/types/types/type_member.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+# typed: strict
+
+module T::Types
+  class TypeMember < TypeVariable
+  end
+end

data/lib/types/types/type_parameter.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Types
+  class TypeParameter < Base
+    def initialize(name)
+      raise ArgumentError.new("not a symbol: #{name}") unless name.is_a?(Symbol)
+      @name = name
+    end
+
+    def valid?(obj)
+      true
+    end
+
+    def subtype_of_single?(type)
+      true
+    end
+
+    def name
+      "T.type_parameter(:#{@name})"
+    end
+  end
+end