sorbet-runtime 0.5.5841

data/lib/types/props/plugin.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+# typed: false
+
+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)
+
+  module Private
+    # These need to be non-instance methods so we can use them without prematurely creating the
+    # child decorator in `model_inherited` (see comments there for details).
+    #
+    # The dynamic constant access below forces this file to be `typed: false`
+    def self.apply_class_methods(plugin, target)
+      if plugin.const_defined?('ClassMethods')
+        # FIXME: This will break preloading, selective test execution, etc if `mod::ClassMethods`
+        # is ever defined in a separate file from `mod`.
+        target.extend(plugin::ClassMethods) # rubocop:disable PrisonGuard/NoDynamicConstAccess
+      end
+    end
+
+    def self.apply_decorator_methods(plugin, target)
+      if plugin.const_defined?('DecoratorMethods')
+        # FIXME: This will break preloading, selective test execution, etc if `mod::DecoratorMethods`
+        # is ever defined in a separate file from `mod`.
+        target.extend(plugin::DecoratorMethods) # rubocop:disable PrisonGuard/NoDynamicConstAccess
+      end
+    end
+  end
+end

data/lib/types/props/pretty_printable.rb

@@ -0,0 +1,107 @@
+# 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 {params(key: Symbol).returns(T::Boolean).checked(:never)}
+    def valid_rule_key?(key)
+      super || key == :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)
+      .checked(:never)
+    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/private/apply_default.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+# typed: strict
+
+module T::Props
+  module Private
+    class ApplyDefault
+      extend T::Sig
+      extend T::Helpers
+      abstract!
+
+      # checked(:never) - O(object construction x prop count)
+      sig {returns(SetterFactory::SetterProc).checked(:never)}
+      attr_reader :setter_proc
+
+      # checked(:never) - We do this with `T.let` instead
+      sig {params(accessor_key: Symbol, setter_proc: SetterFactory::SetterProc).void.checked(:never)}
+      def initialize(accessor_key, setter_proc)
+        @accessor_key = T.let(accessor_key, Symbol)
+        @setter_proc = T.let(setter_proc, SetterFactory::SetterProc)
+      end
+
+      # checked(:never) - O(object construction x prop count)
+      sig {abstract.returns(T.untyped).checked(:never)}
+      def default; end
+
+      # checked(:never) - O(object construction x prop count)
+      sig {abstract.params(instance: T.all(T::Props::Optional, Object)).void.checked(:never)}
+      def set_default(instance); end
+
+      NO_CLONE_TYPES = T.let([TrueClass, FalseClass, NilClass, Symbol, Numeric, T::Enum].freeze, T::Array[Module])
+
+      # checked(:never) - Rules hash is expensive to check
+      sig {params(cls: Module, rules: T::Hash[Symbol, T.untyped]).returns(T.nilable(ApplyDefault)).checked(:never)}
+      def self.for(cls, rules)
+        accessor_key = rules.fetch(:accessor_key)
+        setter = rules.fetch(:setter_proc)
+
+        if rules.key?(:factory)
+          ApplyDefaultFactory.new(cls, rules.fetch(:factory), accessor_key, setter)
+        elsif rules.key?(:default)
+          default = rules.fetch(:default)
+          case default
+          when *NO_CLONE_TYPES
+            return ApplyPrimitiveDefault.new(default, accessor_key, setter)
+          when String
+            if default.frozen?
+              return ApplyPrimitiveDefault.new(default, accessor_key, setter)
+            end
+          when Array
+            if default.empty? && default.class == Array
+              return ApplyEmptyArrayDefault.new(accessor_key, setter)
+            end
+          when Hash
+            if default.empty? && default.default.nil? && T.unsafe(default).default_proc.nil? && default.class == Hash
+              return ApplyEmptyHashDefault.new(accessor_key, setter)
+            end
+          end
+
+          ApplyComplexDefault.new(default, accessor_key, setter)
+        else
+          nil
+        end
+      end
+    end
+
+    class ApplyFixedDefault < ApplyDefault
+      abstract!
+
+      # checked(:never) - We do this with `T.let` instead
+      sig {params(default: BasicObject, accessor_key: Symbol, setter_proc: SetterFactory::SetterProc).void.checked(:never)}
+      def initialize(default, accessor_key, setter_proc)
+        # FIXME: Ideally we'd check here that the default is actually a valid
+        # value for this field, but existing code relies on the fact that we don't.
+        #
+        # :(
+        #
+        # setter_proc.call(default)
+        @default = T.let(default, BasicObject)
+        super(accessor_key, setter_proc)
+      end
+
+      # checked(:never) - O(object construction x prop count)
+      sig {override.params(instance: T.all(T::Props::Optional, Object)).void.checked(:never)}
+      def set_default(instance)
+        instance.instance_variable_set(@accessor_key, default)
+      end
+    end
+
+    class ApplyPrimitiveDefault < ApplyFixedDefault
+      # checked(:never) - O(object construction x prop count)
+      sig {override.returns(T.untyped).checked(:never)}
+      attr_reader :default
+    end
+
+    class ApplyComplexDefault < ApplyFixedDefault
+      # checked(:never) - O(object construction x prop count)
+      sig {override.returns(T.untyped).checked(:never)}
+      def default
+        T::Props::Utils.deep_clone_object(@default)
+      end
+    end
+
+    # Special case since it's so common, and a literal `[]` is meaningfully
+    # faster than falling back to ApplyComplexDefault or even calling
+    # `some_empty_array.dup`
+    class ApplyEmptyArrayDefault < ApplyDefault
+      # checked(:never) - O(object construction x prop count)
+      sig {override.params(instance: T.all(T::Props::Optional, Object)).void.checked(:never)}
+      def set_default(instance)
+        instance.instance_variable_set(@accessor_key, [])
+      end
+
+      # checked(:never) - O(object construction x prop count)
+      sig {override.returns(T::Array[T.untyped]).checked(:never)}
+      def default
+        []
+      end
+    end
+
+    # Special case since it's so common, and a literal `{}` is meaningfully
+    # faster than falling back to ApplyComplexDefault or even calling
+    # `some_empty_hash.dup`
+    class ApplyEmptyHashDefault < ApplyDefault
+      # checked(:never) - O(object construction x prop count)
+      sig {override.params(instance: T.all(T::Props::Optional, Object)).void.checked(:never)}
+      def set_default(instance)
+        instance.instance_variable_set(@accessor_key, {})
+      end
+
+      # checked(:never) - O(object construction x prop count)
+      sig {override.returns(T::Hash[T.untyped, T.untyped]).checked(:never)}
+      def default
+        {}
+      end
+    end
+
+    class ApplyDefaultFactory < ApplyDefault
+      # checked(:never) - We do this with `T.let` instead
+      sig do
+        params(
+          cls: Module,
+          factory: T.any(Proc, Method),
+          accessor_key: Symbol,
+          setter_proc: SetterFactory::SetterProc,
+        )
+        .void
+        .checked(:never)
+      end
+      def initialize(cls, factory, accessor_key, setter_proc)
+        @class = T.let(cls, Module)
+        @factory = T.let(factory, T.any(Proc, Method))
+        super(accessor_key, setter_proc)
+      end
+
+      # checked(:never) - O(object construction x prop count)
+      sig {override.params(instance: T.all(T::Props::Optional, Object)).void.checked(:never)}
+      def set_default(instance)
+        # Use the actual setter to validate the factory returns a legitimate
+        # value every time
+        instance.instance_exec(default, &@setter_proc)
+      end
+
+      # checked(:never) - O(object construction x prop count)
+      sig {override.returns(T.untyped).checked(:never)}
+      def default
+        @class.class_exec(&@factory)
+      end
+    end
+  end
+end

data/lib/types/props/private/deserializer_generator.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+# typed: strict
+
+module T::Props
+  module Private
+
+    # Generates a specialized `deserialize` implementation for a subclass of
+    # T::Props::Serializable.
+    #
+    # The basic idea is that we analyze the props and for each prop, generate
+    # the simplest possible logic as a block of Ruby source, so that we don't
+    # pay the cost of supporting types like T:::Hash[CustomType, SubstructType]
+    # when deserializing a simple Integer. Then we join those together,
+    # with a little shared logic to be able to detect when we get input keys
+    # that don't match any prop.
+    module DeserializerGenerator
+      extend T::Sig
+
+      # Generate a method that takes a T::Hash[String, T.untyped] representing
+      # serialized props, sets instance variables for each prop found in the
+      # input, and returns the count of we props set (which we can use to check
+      # for unexpected input keys with minimal effect on the fast path).
+      sig do
+        params(
+          props: T::Hash[Symbol, T::Hash[Symbol, T.untyped]],
+          defaults: T::Hash[Symbol, T::Props::Private::ApplyDefault],
+        )
+        .returns(String)
+        .checked(:never)
+      end
+      def self.generate(props, defaults)
+        stored_props = props.reject {|_, rules| rules[:dont_store]}
+        parts = stored_props.map do |prop, rules|
+          # All of these strings should already be validated (directly or
+          # indirectly) in `validate_prop_name`, so we don't bother with a nice
+          # error message, but we double check here to prevent a refactoring
+          # from introducing a security vulnerability.
+          raise unless T::Props::Decorator::SAFE_NAME.match?(prop.to_s)
+
+          hash_key = rules.fetch(:serialized_form)
+          raise unless T::Props::Decorator::SAFE_NAME.match?(hash_key)
+
+          ivar_name = rules.fetch(:accessor_key).to_s
+          raise unless ivar_name.start_with?('@') && T::Props::Decorator::SAFE_NAME.match?(ivar_name[1..-1])
+
+          transformation = SerdeTransform.generate(
+            T::Utils::Nilable.get_underlying_type_object(rules.fetch(:type_object)),
+            SerdeTransform::Mode::DESERIALIZE,
+            'val'
+          )
+          if transformation
+            # Rescuing exactly NoMethodError is intended as a temporary hack
+            # to preserve the semantics from before codegen. More generally
+            # we are inconsistent about typechecking on deser and need to decide
+            # our strategy here.
+            transformed_val = <<~RUBY
+              begin
+                #{transformation}
+              rescue NoMethodError => e
+                T::Configuration.soft_assert_handler(
+                  'Deserialization error (probably unexpected stored type)',
+                  storytime: {
+                    klass: self.class,
+                    prop: #{prop.inspect},
+                    value: val,
+                    error: e.message,
+                    notify: 'djudd'
+                  }
+                )
+                val
+              end
+            RUBY
+          else
+            transformed_val = 'val'
+          end
+
+          nil_handler = generate_nil_handler(
+            prop: prop,
+            serialized_form: hash_key,
+            default: defaults[prop],
+            nilable_type: T::Props::Utils.optional_prop?(rules),
+            raise_on_nil_write: !!rules[:raise_on_nil_write],
+          )
+
+          <<~RUBY
+            val = hash[#{hash_key.inspect}]
+            #{ivar_name} = if val.nil?
+              found -= 1 unless hash.key?(#{hash_key.inspect})
+              #{nil_handler}
+            else
+              #{transformed_val}
+            end
+          RUBY
+        end
+
+        <<~RUBY
+          def __t_props_generated_deserialize(hash)
+            found = #{stored_props.size}
+            #{parts.join("\n\n")}
+            found
+          end
+        RUBY
+      end
+
+      # This is very similar to what we do in ApplyDefault, but has a few
+      # key differences that mean we don't just re-use the code:
+      #
+      # 1. Where the logic in construction is that we generate a default
+      #    if & only if the prop key isn't present in the input, here we'll
+      #    generate a default even to override an explicit nil, but only
+      #    if the prop is actually required.
+      # 2. Since we're generating raw Ruby source, we can remove a layer
+      #    of indirection for marginally better performance; this seems worth
+      #    it for the common cases of literals and empty arrays/hashes.
+      # 3. We need to care about the distinction between `raise_on_nil_write`
+      #    and actually non-nilable, where new-instance construction doesn't.
+      #
+      # So we fall back to ApplyDefault only when one of the cases just
+      # mentioned doesn't apply.
+      sig do
+        params(
+          prop: Symbol,
+          serialized_form: String,
+          default: T.nilable(ApplyDefault),
+          nilable_type: T::Boolean,
+          raise_on_nil_write: T::Boolean,
+        )
+        .returns(String)
+        .checked(:never)
+      end
+      private_class_method def self.generate_nil_handler(
+        prop:,
+        serialized_form:,
+        default:,
+        nilable_type:,
+        raise_on_nil_write:
+      )
+        if !nilable_type
+          case default
+          when NilClass
+            "self.class.decorator.raise_nil_deserialize_error(#{serialized_form.inspect})"
+          when ApplyPrimitiveDefault
+            literal = default.default
+            case literal
+            when String, Integer, Symbol, Float, TrueClass, FalseClass, NilClass
+              literal.inspect
+            else
+              "self.class.decorator.props_with_defaults.fetch(#{prop.inspect}).default"
+            end
+          when ApplyEmptyArrayDefault
+            '[]'
+          when ApplyEmptyHashDefault
+            '{}'
+          else
+            "self.class.decorator.props_with_defaults.fetch(#{prop.inspect}).default"
+          end
+        elsif raise_on_nil_write
+          "required_prop_missing_from_deserialize(#{prop.inspect})"
+        else
+          'nil'
+        end
+      end
+    end
+  end
+end