sorbet-runtime 0.0.1.pre.prealpha → 0.4.4253

data/lib/types/types/typed_enumerator.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Types
+  class TypedEnumerator < TypedEnumerable
+    attr_reader :type
+
+    # @override Base
+    def name
+      "T::Enumerator[#{@type.name}]"
+    end
+
+    # @override Base
+    def valid?(obj)
+      obj.is_a?(Enumerator) && super
+    end
+
+    def new(*args, &blk) # rubocop:disable PrisonGuard/BanBuiltinMethodOverride
+      T.unsafe(Enumerator).new(*args, &blk)
+    end
+  end
+end

data/lib/types/types/typed_hash.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Types
+  class TypedHash < TypedEnumerable
+    # Technically we don't need these, but they are a nice api
+    attr_reader :keys, :values
+
+    def initialize(keys:, values:)
+      @keys = T::Utils.coerce(keys)
+      @values = T::Utils.coerce(values)
+      @type = T::Utils.coerce([keys, values])
+    end
+
+    # @override Base
+    def name
+      "T::Hash[#{@keys.name}, #{@values.name}]"
+    end
+
+    # @override Base
+    def valid?(obj)
+      obj.is_a?(Hash) && super
+    end
+
+    def new(*args, &blk) # rubocop:disable PrisonGuard/BanBuiltinMethodOverride
+      Hash.new(*T.unsafe(args), &blk) # rubocop:disable PrisonGuard/RestrictHashDefaults
+    end
+  end
+end

data/lib/types/types/typed_range.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Types
+  class TypedRange < TypedEnumerable
+    attr_reader :type
+
+    # @override Base
+    def name
+      "T::Range[#{@type.name}]"
+    end
+
+    # @override Base
+    def valid?(obj)
+      obj.is_a?(Range) && super
+    end
+
+    def new(*args) # rubocop:disable PrisonGuard/BanBuiltinMethodOverride
+      T.unsafe(Range).new(*args)
+    end
+  end
+end

data/lib/types/types/typed_set.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Types
+  class TypedSet < TypedEnumerable
+    attr_reader :type
+
+    # @override Base
+    def name
+      "T::Set[#{@type.name}]"
+    end
+
+    # @override Base
+    def valid?(obj)
+      obj.is_a?(Set) && super
+    end
+
+    def new(*args) # rubocop:disable PrisonGuard/BanBuiltinMethodOverride
+      Set.new(*T.unsafe(args))
+    end
+  end
+end

data/lib/types/types/union.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Types
+  # Takes a list of types. Validates that an object matches at least one of the types.
+  class Union < Base
+    attr_reader :types
+
+    def initialize(types)
+      @types = types.flat_map do |type|
+        if type.is_a?(Union)
+          # Simplify nested unions (mostly so `name` returns a nicer value)
+          type.types
+        else
+          T::Utils.coerce(type)
+        end
+      end.uniq
+    end
+
+    # @override Base
+    def name
+      type_shortcuts(@types)
+    end
+
+    private def type_shortcuts(types)
+      if types.size == 1
+        return types[0].name
+      end
+      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}
+        "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}
+        type_shortcuts([T::Private::Types::StringHolder.new("T::Boolean")] + remaining_types)
+      else
+        names = types.map(&:name).compact.sort
+        "T.any(#{names.join(', ')})"
+      end
+    end
+
+    # @override Base
+    def valid?(obj)
+      @types.each do |type|
+        return true if type.valid?(obj)
+      end
+
+      false
+    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/untyped.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Types
+  # A dynamic type, which permits whatever
+  class Untyped < Base
+
+    def initialize; end
+
+    # @override Base
+    def name
+      "T.untyped"
+    end
+
+    # @override Base
+    def valid?(obj)
+      true
+    end
+
+    # @override Base
+    private def subtype_of_single?(other)
+      true
+    end
+  end
+end

data/lib/types/utils.rb

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Utils
+  # Used to convert from a type specification to a `T::Types::Base`.
+  def self.coerce(val)
+    if val.is_a?(T::Types::Base)
+      val
+    elsif val == ::Array
+      T::Array[T.untyped]
+    elsif val == ::Set
+      T::Set[T.untyped]
+    elsif val == ::Hash
+      T::Hash[T.untyped, T.untyped]
+    elsif val == ::Enumerable
+      T::Enumerable[T.untyped]
+    elsif val == ::Enumerator
+      T::Enumerator[T.untyped]
+    elsif val == ::Range
+      T::Range[T.untyped]
+    elsif val.is_a?(Module)
+      T::Types::Simple.new(val) # rubocop:disable PrisonGuard/UseOpusTypesShortcut
+    elsif val.is_a?(::Array)
+      T::Types::FixedArray.new(val) # rubocop:disable PrisonGuard/UseOpusTypesShortcut
+    elsif val.is_a?(::Hash)
+      T::Types::FixedHash.new(val) # rubocop:disable PrisonGuard/UseOpusTypesShortcut
+    elsif val.is_a?(T::Private::Methods::DeclBuilder)
+      T::Private::Methods.finalize_proc(val.decl)
+    else
+      raise "Invalid value for type constraint. Must be an #{T::Types::Base}, a " \
+            "class/module, or an array. Got a `#{val.class}`."
+    end
+  end
+
+  # Returns the set of all methods (public, protected, private) defined on a module or its
+  # ancestors, excluding Object and its ancestors. Overrides of methods from Object (and its
+  # ancestors) are included.
+  def self.methods_excluding_object(mod)
+    # We can't just do mod.instance_methods - Object.instance_methods, because that would leave out
+    # any methods from Object that are overridden in mod.
+    mod.ancestors.flat_map do |ancestor|
+      # equivalent to checking Object.ancestors.include?(ancestor)
+      next [] if Object <= ancestor
+      ancestor.instance_methods(false) + ancestor.private_instance_methods(false)
+    end.uniq
+  end
+
+  # Associates a signature with a forwarder method that matches the signature of the method it
+  # forwards to. This is necessary because forwarder methods are often declared with catch-all
+  # splat parameters, rather than the exact set of parameters ultimately used by the target method,
+  # so they cannot be validated as strictly.
+  #
+  # The caller of this method must ensure that the forwarder method properly forwards all parameters
+  # such that the signature is accurate.
+  def self.register_forwarder(from_method, to_method, remove_first_param: false)
+    T::Private::Methods.register_forwarder(
+      from_method, to_method, remove_first_param: remove_first_param
+    )
+  end
+
+  # Returns the signature for the instance method on the supplied module, or nil if it's not found or not typed.
+  #
+  # @example T::Utils.signature_for_instance_method(MyClass, :my_method)
+  def self.signature_for_instance_method(mod, method_name)
+    T::Private::Methods.signature_for_method(mod.instance_method(method_name))
+  end
+
+  def self.wrap_method_with_call_validation_if_needed(mod, method_sig, original_method)
+    T::Private::Methods::CallValidation.wrap_method_if_needed(mod, method_sig, original_method)
+  end
+
+  # Unwraps all the sigs.
+  def self.run_all_sig_blocks
+    T::Private::Methods.run_all_sig_blocks
+  end
+
+  # This can be called in a wholesome test to make sure all the `sig`s are well
+  # formed.
+  def self.validate_sigs
+    exceptions = []
+    run_all_sig_blocks
+    ObjectSpace.each_object(Module) do |mod| # rubocop:disable PrisonGuard/NoDynamicConstAccess
+      begin
+        T::Private::Abstract::Validate.validate_subclass(mod)
+        if T::AbstractUtils.abstract_module?(mod)
+          T::Private::Abstract::Validate.validate_abstract_module(mod)
+        end
+      rescue => e
+        exceptions << e
+      end
+    end
+    if !exceptions.empty?
+      raise "#{exceptions.count} exception thrown during validation:\n\n#{exceptions.map(&:message).sort.join("\n\n")}"
+    end
+  end
+
+  # Give a type which is a subclass of T::Types::Base, determines if the type is a simple nilable type (union of NilClass and something else).
+  # If so, returns the T::Types::Base of the something else. Otherwise, returns nil.
+  def self.unwrap_nilable(type)
+    case type
+    when T::Types::Union
+      non_nil_types = type.types.reject {|t| t == T::Utils.coerce(NilClass)}
+      if non_nil_types.length == 1
+        non_nil_types.first
+      else
+        nil
+      end
+    else
+      nil
+    end
+  end
+
+  def self.DANGER_enable_checking_in_tests
+    T::Private::RuntimeLevels.enable_checking_in_tests
+  end
+
+  # Returns the arity of a method, unwrapping the sig if needed
+  def self.arity(method)
+    arity = method.arity # rubocop:disable PrisonGuard/NoArity
+    return arity if arity != -1 || method.is_a?(Proc)
+    sig = T::Private::Methods.signature_for_method(method)
+    sig ? sig.method.arity : arity # rubocop:disable PrisonGuard/NoArity
+  end
+
+  # Elide the middle of a string as needed and replace it with an ellipsis.
+  # Keep the given number of characters at the start and end of the string.
+  #
+  # This method operates on string length, not byte length.
+  #
+  # If the string is shorter than the requested truncation length, return it
+  # without adding an ellipsis. This method may return a longer string than
+  # the original if the characters removed are shorter than the ellipsis.
+  #
+  # @param [String] str
+  #
+  # @param [Fixnum] start_len The length of string before the ellipsis
+  # @param [Fixnum] end_len The length of string after the ellipsis
+  #
+  # @param [String] ellipsis The string to add in place of the elided text
+  #
+  # @return [String]
+  #
+  def self.string_truncate_middle(str, start_len, end_len, ellipsis='...')
+    return unless str
+
+    raise ArgumentError.new('must provide start_len') unless start_len
+    raise ArgumentError.new('must provide end_len') unless end_len
+
+    raise ArgumentError.new('start_len must be >= 0') if start_len < 0
+    raise ArgumentError.new('end_len must be >= 0') if end_len < 0
+
+    str = str.to_s
+    return str if str.length <= start_len + end_len
+
+    start_part = str[0...start_len - ellipsis.length]
+    end_part = end_len == 0 ? '' : str[-end_len..-1]
+
+    "#{start_part}#{ellipsis}#{end_part}"
+  end
+
+  module Props
+    def self.required_prop?(prop_rules)
+      # Clients should never reference :_tnilable as the implementation can change.
+      !prop_rules[:_tnilable]
+    end
+
+    def self.optional_prop?(prop_rules)
+      # Clients should never reference :_tnilable as the implementation can change.
+      !!prop_rules[:_tnilable]
+    end
+
+    def self.merge_serialized_optional_rule(prop_rules)
+      {'_tnilable' => true}.merge(prop_rules.merge('_tnilable' => true))
+    end
+  end
+
+  module Nilable
+    # :is_union_type, T::Boolean: whether the type is an T::Types::Union type
+    # :non_nilable_type, Class: if it is an T.nilable type, the corresponding underlying type; otherwise, nil.
+    TypeInfo = Struct.new(:is_union_type, :non_nilable_type)
+
+    def self.get_type_info(prop_type)
+      if prop_type.is_a?(T::Types::Union)
+        non_nilable_type = T::Utils.unwrap_nilable(prop_type)
+        if non_nilable_type && non_nilable_type.is_a?(T::Types::Simple)
+          non_nilable_type = non_nilable_type.raw_type
+        end
+        TypeInfo.new(true, non_nilable_type)
+      else
+        TypeInfo.new(false, nil)
+      end
+    end
+
+    # Get the underlying type inside prop_type:
+    #  - if the type is A, the function returns A
+    #  - if the type is T.nilable(A), the function returns A
+    def self.get_underlying_type(prop_type)
+      type_info = get_type_info(prop_type)
+      if type_info.is_union_type
+        type_info.non_nilable_type || prop_type
+      elsif prop_type.is_a?(T::Types::Simple)
+        prop_type.raw_type
+      else
+        prop_type
+      end
+    end
+
+    # The difference between this function and the above function is that the Sorbet type, like T::Types::Simple
+    # is preserved.
+    def self.get_underlying_type_object(prop_type)
+      T::Utils.unwrap_nilable(prop_type) || prop_type
+    end
+
+    def self.is_union_with_nilclass(prop_type)
+      case prop_type
+      when T::Types::Union
+        prop_type.types.any? {|t| t == T::Utils.coerce(NilClass)}
+      else
+        false
+      end
+    end
+  end
+end

metadata

@@ -1,27 +1,133 @@
 --- !ruby/object:Gem::Specification
 name: sorbet-runtime
 version: !ruby/object:Gem::Version
-  version: 0.0.1.pre.prealpha
+  version: 0.4.4253
 platform: ruby
 authors:
-- Dmitry Petrashko
-- Nelson Elhage
-- Paul Tarjan
+- Stripe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-05-17 00:00:00.000000000 Z
-dependencies: []
-description: '"There will be a description here one day"'
-email:
-- sorbet@stripe.com
+date: 2019-06-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.11'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Sorbet's runtime type checking component
+email: 
 executables: []
 extensions: []
 extra_rdoc_files: []
-files: []
+files:
+- lib/sorbet-runtime.rb
+- lib/types/_types.rb
+- lib/types/abstract_utils.rb
+- lib/types/boolean.rb
+- lib/types/compatibility_patches.rb
+- lib/types/configuration.rb
+- lib/types/generic.rb
+- lib/types/helpers.rb
+- lib/types/interface_wrapper.rb
+- lib/types/private/abstract/data.rb
+- lib/types/private/abstract/declare.rb
+- lib/types/private/abstract/hooks.rb
+- lib/types/private/abstract/validate.rb
+- lib/types/private/casts.rb
+- lib/types/private/class_utils.rb
+- lib/types/private/decl_state.rb
+- lib/types/private/error_handler.rb
+- lib/types/private/methods/_methods.rb
+- lib/types/private/methods/call_validation.rb
+- lib/types/private/methods/decl_builder.rb
+- lib/types/private/methods/modes.rb
+- lib/types/private/methods/signature.rb
+- lib/types/private/methods/signature_validation.rb
+- lib/types/private/mixins/mixins.rb
+- lib/types/private/runtime_levels.rb
+- lib/types/private/types/not_typed.rb
+- lib/types/private/types/string_holder.rb
+- lib/types/private/types/void.rb
+- lib/types/profile.rb
+- lib/types/props/_props.rb
+- lib/types/props/constructor.rb
+- lib/types/props/custom_type.rb
+- lib/types/props/decorator.rb
+- lib/types/props/errors.rb
+- lib/types/props/optional.rb
+- lib/types/props/plugin.rb
+- lib/types/props/pretty_printable.rb
+- lib/types/props/serializable.rb
+- lib/types/props/type_validation.rb
+- lib/types/props/utils.rb
+- lib/types/props/weak_constructor.rb
+- lib/types/runtime_profiled.rb
+- lib/types/sig.rb
+- lib/types/struct.rb
+- lib/types/types/base.rb
+- lib/types/types/class_of.rb
+- lib/types/types/enum.rb
+- lib/types/types/fixed_array.rb
+- lib/types/types/fixed_hash.rb
+- lib/types/types/intersection.rb
+- lib/types/types/noreturn.rb
+- lib/types/types/proc.rb
+- lib/types/types/self_type.rb
+- lib/types/types/simple.rb
+- lib/types/types/type_member.rb
+- lib/types/types/type_parameter.rb
+- lib/types/types/type_template.rb
+- lib/types/types/type_variable.rb
+- lib/types/types/typed_array.rb
+- lib/types/types/typed_enumerable.rb
+- lib/types/types/typed_enumerator.rb
+- lib/types/types/typed_hash.rb
+- lib/types/types/typed_range.rb
+- lib/types/types/typed_set.rb
+- lib/types/types/union.rb
+- lib/types/types/untyped.rb
+- lib/types/utils.rb
 homepage: https://sorbet.run
 licenses:
-- Nonstandard
+- Apache-2.0
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -34,12 +140,13 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubyforge_project: 
+rubygems_version: 2.6.14
 signing_key: 
 specification_version: 4
-summary: '"There will be sorbet typechecker here one day"'
+summary: Sorbet runtime
 test_files: []