sorbet-runtime 0.0.1.pre.prealpha → 0.4.4253

data/lib/types/props/errors.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Props
+  class Error < StandardError; end
+  class InvalidValueError < Error; end
+  class ImmutableProp < Error; end
+end

data/lib/types/props/optional.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+# typed: false
+
+module T::Props::Optional
+  include T::Props::Plugin
+end
+
+
+##############################################
+
+
+# NB: This must stay in the same file where T::Props::Optional is defined due to
+# T::Props::Decorator#apply_plugin; see https://git.corp.stripe.com/stripe-internal/pay-server/blob/fc7f15593b49875f2d0499ffecfd19798bac05b3/chalk/odm/lib/chalk-odm/document_decorator.rb#L716-L717
+module T::Props::Optional::DecoratorMethods
+  # TODO: clean this up. This set of options is confusing, and some of them are not universally
+  # applicable (e.g., :on_load only applies when using T::Serializable).
+  VALID_OPTIONAL_RULES = Set[
+    :existing, # deprecated
+    :on_load,
+    false,
+    true,
+  ].freeze
+
+  def valid_props
+    super + [
+      :default,
+      :factory,
+      :optional,
+    ]
+  end
+
+  def prop_optional?(prop); prop_rules(prop)[:fully_optional]; end
+
+  def add_prop_definition(prop, rules)
+    rules[:fully_optional] = !T::Props::Utils.need_nil_write_check?(rules)
+    super
+  end
+
+  def prop_validate_definition!(name, cls, rules, type)
+    result = super
+
+    if (rules_optional = rules[:optional])
+      if !VALID_OPTIONAL_RULES.include?(rules_optional)
+        raise ArgumentError.new(":optional must be one of #{VALID_OPTIONAL_RULES.inspect}")
+      end
+    end
+
+    if rules.key?(:default) && rules.key?(:factory)
+      raise ArgumentError.new("Setting both :default and :factory is invalid. See: go/chalk-docs")
+    end
+
+    result
+  end
+
+  def has_default?(rules)
+    rules.include?(:default) || rules.include?(:factory)
+  end
+
+  def get_default(rules, instance_class)
+    if rules.include?(:default)
+      default = rules[:default]
+      T::Props::Utils.deep_clone_object(default)
+    elsif rules.include?(:factory)
+      # Factory should never be nil if the key is specified, but
+      # we do this rather than 'elsif rules[:factory]' for
+      # consistency with :default.
+      factory = rules[:factory]
+      instance_class.class_exec(&factory)
+    else
+      nil
+    end
+  end
+end

data/lib/types/props/plugin.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Props::Plugin
+  include T::Props
+  extend T::Helpers
+
+  module ClassMethods
+    def included(child)
+      super
+      child.plugin(self)
+    end
+  end
+  mixes_in_class_methods(ClassMethods)
+end

data/lib/types/props/pretty_printable.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Props::PrettyPrintable
+  include T::Props::Plugin
+
+  # Return a string representation of this object and all of its props
+  def inspect
+    T.unsafe(T.cast(self, Object).class).decorator.inspect_instance(self)
+  end
+
+  # Override the PP gem with something that's similar, but gives us a hook
+  # to do redaction
+  def pretty_inspect
+    T.unsafe(T.cast(self, Object).class).decorator.inspect_instance(self, multiline: true)
+  end
+
+  module DecoratorMethods
+    extend T::Sig
+
+    sig {returns(T::Array[Symbol])}
+    def valid_props
+      super + [:inspect]
+    end
+
+    sig do
+      params(instance: T::Props::PrettyPrintable, multiline: T::Boolean, indent: String)
+      .returns(String)
+    end
+    def inspect_instance(instance, multiline: false, indent: '  ')
+      components =
+        inspect_instance_components(
+          instance,
+          multiline: multiline,
+          indent: indent
+        )
+          .reject(&:empty?)
+
+      # Not using #<> here as that makes pry highlight these objects
+      # as if they were all comments, whereas this makes them look
+      # like the structured thing they are.
+      if multiline
+        "#{components[0]}:\n" + T.must(components[1..-1]).join("\n")
+      else
+        "<#{components.join(' ')}>"
+      end
+    end
+
+    sig do
+      params(instance: T::Props::PrettyPrintable, multiline: T::Boolean, indent: String)
+      .returns(T::Array[String])
+    end
+    private def inspect_instance_components(instance, multiline:, indent:)
+      pretty_props = T.unsafe(self).all_props.map do |prop|
+        [prop, inspect_prop_value(instance, prop, multiline: multiline, indent: indent)]
+      end
+
+      joined_props = join_props_with_pretty_values(
+        pretty_props,
+        multiline: multiline,
+        indent: indent
+      )
+
+      [
+        T.unsafe(self).decorated_class.to_s,
+        joined_props,
+      ]
+    end
+
+    sig do
+      params(instance: T::Props::PrettyPrintable, prop: Symbol, multiline: T::Boolean, indent: String)
+      .returns(String)
+    end
+    private def inspect_prop_value(instance, prop, multiline:, indent:)
+      val = T.unsafe(self).get(instance, prop)
+      rules = T.unsafe(self).prop_rules(prop)
+      if (custom_inspect = rules[:inspect])
+        if T::Utils.arity(custom_inspect) == 1
+          custom_inspect.call(val)
+        else
+          custom_inspect.call(val, {multiline: multiline, indent: indent})
+        end
+      elsif rules[:sensitivity] && !rules[:sensitivity].empty? && !val.nil?
+        "<REDACTED #{rules[:sensitivity].join(', ')}>"
+      else
+        val.inspect
+      end
+    end
+
+    sig do
+      params(pretty_kvs: T::Array[[Symbol, String]], multiline: T::Boolean, indent: String)
+      .returns(String)
+    end
+    private def join_props_with_pretty_values(pretty_kvs, multiline:, indent: '  ')
+      pairs = pretty_kvs
+        .sort_by {|k, _v| k.to_s}
+        .map {|k, v| "#{k}=#{v}"}
+
+      if multiline
+        indent + pairs.join("\n#{indent}")
+      else
+        pairs.join(', ')
+      end
+    end
+  end
+end

data/lib/types/props/serializable.rb

@@ -0,0 +1,376 @@
+# frozen_string_literal: true
+# typed: false
+
+module T::Props::Serializable
+  include T::Props::Plugin
+  # Required because we have special handling for `optional: false`
+  include T::Props::Optional
+  # Required because we have special handling for extra_props
+  include T::Props::PrettyPrintable
+
+  # Serializes this object to a hash, suitable for conversion to
+  # JSON/BSON.
+  #
+  # @param strict [T::Boolean] (true) If false, do not raise an
+  #   exception if this object has mandatory props with missing
+  #   values.
+  # @return [Hash] A serialization of this object.
+  def serialize(strict=true)
+    decorator = self.class.decorator
+    h = {}
+
+    decorator.props.keys.each do |prop|
+      rules = decorator.prop_rules(prop)
+      hkey = rules[:serialized_form]
+
+      val = decorator.get(self, prop)
+
+      if strict && val.nil? && T::Props::Utils.need_nil_write_check?(rules)
+        # If the prop was already missing during deserialization, that means the application
+        # code already had to deal with a nil value, which means we wouldn't be accomplishing
+        # much by raising here (other than causing an unnecessary breakage).
+        if self.required_prop_missing_from_deserialize?(prop)
+          T::Configuration.log_info_handler(
+            "chalk-odm: missing required property in serialize",
+            prop: prop, class: self.class.name, id: decorator.get_id(self)
+          )
+        else
+          raise T::Props::InvalidValueError.new("#{self.class.name}.#{prop} not set for non-optional prop")
+        end
+      end
+
+      # Don't serialize values that are nil to save space (both the
+      # nil value itself and the field name in the serialized BSON
+      # document)
+      next if decorator.prop_dont_store?(prop) || val.nil?
+
+      if rules[:type_is_serializable]
+        val = val.serialize(strict)
+      elsif rules[:type_is_array_of_serializable]
+        if (subtype = rules[:serializable_subtype]).is_a?(T::Props::CustomType)
+          val = val.map {|el| el && subtype.serialize(el)}
+        else
+          val = val.map {|el| el && el.serialize(strict)}
+        end
+      elsif rules[:type_is_hash_of_serializable_values] && rules[:type_is_hash_of_custom_type_keys]
+        key_subtype = rules[:serializable_subtype][:keys]
+        value_subtype = rules[:serializable_subtype][:values]
+        if value_subtype.is_a?(T::Props::CustomType)
+          val = val.each_with_object({}) do |(key, value), result|
+            result[key_subtype.serialize(key)] = value && value_subtype.serialize(value)
+          end
+        else
+          val = val.each_with_object({}) do |(key, value), result|
+            result[key_subtype.serialize(key)] = value && value.serialize(strict)
+          end
+        end
+      elsif rules[:type_is_hash_of_serializable_values]
+        value_subtype = rules[:serializable_subtype]
+        if value_subtype.is_a?(T::Props::CustomType)
+          val = val.transform_values {|v| v && value_subtype.serialize(v)}
+        else
+          val = val.transform_values {|v| v && v.serialize(strict)}
+        end
+      elsif rules[:type_is_hash_of_custom_type_keys]
+        key_subtype = rules[:serializable_subtype]
+        val = val.each_with_object({}) do |(key, value), result|
+          result[key_subtype.serialize(key)] = value
+        end
+      elsif rules[:type_is_custom_type]
+        val = rules[:type].serialize(val)
+
+        unless T::Props::CustomType.valid_serialization?(val, rules[:type])
+          msg = "#{rules[:type]} did not serialize to a valid scalar type. It became a: #{val.class}"
+          if val.is_a?(Hash)
+            msg += "\nIf you want to store a structured Hash, consider using a T::Struct as your type."
+          end
+          raise T::Props::InvalidValueError.new(msg)
+        end
+      end
+
+      h[hkey] = T::Props::Utils.deep_clone_object(val)
+    end
+
+    extra_props = decorator.extra_props(self)
+    h.merge!(extra_props) if extra_props
+
+    h
+  end
+
+  # Populates the property values on this object with the values
+  # from a hash. In general, prefer to use {.from_hash} to construct
+  # a new instance, instead of loading into an existing instance.
+  #
+  # @param hash [Hash<String, Object>] The hash to take property
+  #  values from.
+  # @param strict [T::Boolean] (false) If true, raise an exception if
+  #  the hash contains keys that do not correspond to any known
+  #  props on this instance.
+  # @return [void]
+  def deserialize(hash, strict=false)
+    decorator = self.class.decorator
+
+    matching_props = 0
+
+    decorator.props.each do |p, rules|
+      hkey = rules[:serialized_form]
+      val = hash[hkey]
+      if val.nil?
+        if T::Utils::Props.required_prop?(rules)
+          val = decorator.get_default(rules, self.class)
+          if val.nil?
+            msg = "Tried to deserialize a required prop from a nil value. It's "\
+              "possible that a nil value exists in the database, so you should "\
+              "provide a `default: or factory:` for this prop (see go/optional "\
+              "for more details). If this is already the case, you probably "\
+              "omitted a required prop from the `fields:` option when doing a "\
+              "partial load."
+            storytime = {prop: hkey, klass: self.class.name}
+
+            # Notify the model owner if it exists, and always notify the API owner.
+            begin
+              if defined?(Opus) && defined?(Opus::Ownership) && decorator.decorated_class < Opus::Ownership
+                T::Configuration.hard_assert_handler(
+                  msg,
+                  storytime: storytime,
+                  project: decorator.decorated_class.get_owner
+                )
+              end
+            ensure
+              T::Configuration.hard_assert_handler(msg, storytime: storytime)
+            end
+          end
+        elsif T::Props::Utils.need_nil_read_check?(rules)
+          self.required_prop_missing_from_deserialize(p)
+        end
+
+        matching_props += 1 if hash.key?(hkey)
+      else
+        if (subtype = rules[:serializable_subtype])
+          val =
+            if rules[:type_is_array_of_serializable]
+              if subtype.is_a?(T::Props::CustomType)
+                val.map {|el| el && subtype.deserialize(el)}
+              else
+                val.map {|el| el && subtype.from_hash(el)}
+              end
+            elsif rules[:type_is_hash_of_serializable_values] && rules[:type_is_hash_of_custom_type_keys]
+              key_subtype = subtype[:keys]
+              values_subtype = subtype[:values]
+              if values_subtype.is_a?(T::Props::CustomType)
+                val.each_with_object({}) do |(key, value), result|
+                  result[key_subtype.deserialize(key)] = value && values_subtype.deserialize(value)
+                end
+              else
+                val.each_with_object({}) do |(key, value), result|
+                  result[key_subtype.deserialize(key)] = value && values_subtype.from_hash(value)
+                end
+              end
+            elsif rules[:type_is_hash_of_serializable_values]
+              if subtype.is_a?(T::Props::CustomType)
+                val.transform_values {|v| v && subtype.deserialize(v)}
+              else
+                val.transform_values {|v| v && subtype.from_hash(v)}
+              end
+            elsif rules[:type_is_hash_of_custom_type_keys]
+              val.map do |key, value|
+                [subtype.deserialize(key), value]
+              end.to_h
+            else
+              subtype.from_hash(val)
+            end
+        elsif (needs_clone = rules[:type_needs_clone])
+          val =
+            if needs_clone == :shallow
+              val.dup
+            else
+              T::Props::Utils.deep_clone_object(val)
+            end
+        elsif rules[:type_is_custom_type]
+          val = rules[:type].deserialize(val)
+        end
+
+        matching_props += 1
+      end
+
+      self.instance_variable_set(rules[:accessor_key], val) # rubocop:disable PrisonGuard/NoLurkyInstanceVariableAccess
+    end
+
+    # We compute extra_props this way specifically for performance
+    if matching_props < hash.size
+      pbsf = decorator.prop_by_serialized_forms
+      h = hash.reject {|k, _| pbsf.key?(k)}
+
+      if strict
+        raise "Unknown properties for #{self.class.name}: #{h.keys.inspect}"
+      else
+        @_extra_props = h
+      end
+    end
+  end
+
+  # with() will clone the old object to the new object and merge the specified props to the new object.
+  def with(changed_props)
+    with_existing_hash(changed_props, existing_hash: self.serialize)
+  end
+
+  private def recursive_stringify_keys(obj)
+    if obj.is_a?(Hash)
+      new_obj = obj.class.new
+      obj.each do |k, v|
+        new_obj[k.to_s] = recursive_stringify_keys(v)
+      end
+    elsif obj.is_a?(Array)
+      new_obj = obj.map {|v| recursive_stringify_keys(v)}
+    else
+      new_obj = obj
+    end
+    new_obj
+  end
+
+  private def with_existing_hash(changed_props, existing_hash:)
+    serialized = existing_hash
+    new_val = self.class.from_hash(serialized.merge(recursive_stringify_keys(changed_props)))
+    old_extra = self.instance_variable_get(:@_extra_props) # rubocop:disable PrisonGuard/NoLurkyInstanceVariableAccess
+    new_extra = new_val.instance_variable_get(:@_extra_props) # rubocop:disable PrisonGuard/NoLurkyInstanceVariableAccess
+    if old_extra != new_extra
+      difference =
+        if old_extra
+          new_extra.reject {|k, v| old_extra[k] == v}
+        else
+          new_extra
+        end
+      raise ArgumentError.new("Unexpected arguments: input(#{changed_props}), unexpected(#{difference})")
+    end
+    new_val
+  end
+
+  # @return [T::Boolean] Was this property missing during deserialize?
+  def required_prop_missing_from_deserialize?(prop)
+    return false if @_required_props_missing_from_deserialize.nil?
+    @_required_props_missing_from_deserialize.include?(prop)
+  end
+
+  # @return Marks this property as missing during deserialize
+  def required_prop_missing_from_deserialize(prop)
+    @_required_props_missing_from_deserialize ||= Set[]
+    @_required_props_missing_from_deserialize << prop
+    nil
+  end
+end
+
+
+##############################################
+
+# NB: This must stay in the same file where T::Props::Serializable is defined due to
+# T::Props::Decorator#apply_plugin; see https://git.corp.stripe.com/stripe-internal/pay-server/blob/fc7f15593b49875f2d0499ffecfd19798bac05b3/chalk/odm/lib/chalk-odm/document_decorator.rb#L716-L717
+module T::Props::Serializable::DecoratorMethods
+  def valid_props
+    super + [
+      :dont_store,
+      :name,
+      :raise_on_nil_write,
+    ]
+  end
+
+  def required_props
+    @class.props.select {|_, v| T::Utils::Props.required_prop?(v)}.keys
+  end
+
+  def prop_dont_store?(prop); prop_rules(prop)[:dont_store]; end
+  def prop_by_serialized_forms; @class.prop_by_serialized_forms; end
+
+  def from_hash(hash, strict=false)
+    raise ArgumentError.new("#{hash.inspect} provided to from_hash") if !(hash && hash.is_a?(Hash))
+
+    i = @class.allocate
+    i.deserialize(hash, strict)
+
+    i
+  end
+
+  def prop_serialized_form(prop)
+    prop_rules(prop)[:serialized_form]
+  end
+
+  def serialized_form_prop(serialized_form)
+    prop_by_serialized_forms[serialized_form.to_s] || raise("No such serialized form: #{serialized_form.inspect}")
+  end
+
+  def add_prop_definition(prop, rules)
+    rules[:serialized_form] = rules.fetch(:name, prop.to_s)
+    res = super
+    prop_by_serialized_forms[rules[:serialized_form]] = prop
+    res
+  end
+
+  def prop_validate_definition!(name, cls, rules, type)
+    result = super
+
+    if (rules_name = rules[:name])
+      unless rules_name.is_a?(String)
+        raise ArgumentError.new("Invalid name in prop #{@class.name}.#{name}: #{rules_name.inspect}")
+      end
+
+      validate_prop_name(rules_name)
+    end
+
+    if !rules[:raise_on_nil_write].nil? && rules[:raise_on_nil_write] != true
+        raise ArgumentError.new("The value of `raise_on_nil_write` if specified must be `true` (given: #{rules[:raise_on_nil_write]}).")
+    end
+
+    result
+  end
+
+  def get_id(instance)
+    prop = prop_by_serialized_forms['_id']
+    if prop
+      get(instance, prop)
+    else
+      nil
+    end
+  end
+
+  EMPTY_EXTRA_PROPS = {}.freeze
+  private_constant :EMPTY_EXTRA_PROPS
+
+  def extra_props(instance)
+    get(instance, '_extra_props') || EMPTY_EXTRA_PROPS
+  end
+
+  # @override T::Props::PrettyPrintable
+  private def inspect_instance_components(instance, multiline:, indent:)
+    if (extra_props = extra_props(instance)) && !extra_props.empty?
+      pretty_kvs = extra_props.map {|k, v| [k.to_sym, v.inspect]}
+      extra = join_props_with_pretty_values(pretty_kvs, multiline: false)
+      super + ["@_extra_props=<#{extra}>"]
+    else
+      super
+    end
+  end
+end
+
+
+##############################################
+
+
+# NB: This must stay in the same file where T::Props::Serializable is defined due to
+# T::Props::Decorator#apply_plugin; see https://git.corp.stripe.com/stripe-internal/pay-server/blob/fc7f15593b49875f2d0499ffecfd19798bac05b3/chalk/odm/lib/chalk-odm/document_decorator.rb#L716-L717
+module T::Props::Serializable::ClassMethods
+  def prop_by_serialized_forms; @prop_by_serialized_forms ||= {}; end
+
+  # @!method self.from_hash(hash, strict)
+  #
+  # Allocate a new instance and call {#deserialize} to load a new
+  # object from a hash.
+  # @return [Serializable]
+  def from_hash(hash, strict=false)
+    self.decorator.from_hash(hash, strict)
+  end
+
+  # Equivalent to {.from_hash} with `strict` set to true.
+  # @return [Serializable]
+  def from_hash!(hash)
+    self.decorator.from_hash(hash, true)
+  end
+end