sorbet-schema 0.4.0 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9af17198e776435ac97075ce33b365c34fd539aa7998ca9f60f9eef1a57ddd95
-  data.tar.gz: 8afbc08bc51a6cdc849803273af0c44e9f8a86e04991d9cd70767e565b3c68ca
+  metadata.gz: 3fc3ec89812a6517931d09a61a6f4049b85db1661b92e5cb7353c7c62207afab
+  data.tar.gz: 45daa92727807fb2c80bff1fad0b84684c435cde7c1460478741da74fcc0d9c3
 SHA512:
-  metadata.gz: 260e1ee1603ef6ae6ddd5cc20544a874a097b65f95736e42dc97f489b979df5a6a41d48124d2a5f5c2643e9f0989de0e67ed7a7f787adabf39fd12168bc05b65
-  data.tar.gz: 94836f2ea97f2c4ac158562f2a6b9ffdd05d4ad2a0f34423e77d42b989c894caf08e6fdc28693491d8903d826aa3da860a4d85ceb14ba37b0a448542a41b51e7
+  metadata.gz: 5ad688ac1f0b61c309d9e016baffcab03b61f6c1c0b17b86721580d9f9ed75b86901f9c31a2b3407356f3abaf0ed64c75294d8a6a60a39d11220320c80253308
+  data.tar.gz: d4ec8208184dfe939122d345ec1e1cbb2a8b3f9d840af984e772c6c85d7985fe34f5678ba6b2fa7ef9f85157af90c4e5990f1f2472a025c195255f0d9a5527fe

data/CHANGELOG.md

@@ -4,6 +4,26 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.4.2](https://github.com/maxveldink/sorbet-schema/compare/v0.4.1...v0.4.2) (2024-03-21)
+
+
+### Features
+
+* Add Schema#add_serializer to easily update serializer ([f665a2a](https://github.com/maxveldink/sorbet-schema/commit/f665a2ab3afbdaa3757c2d9fa489602edbdf8f8f))
+
+
+### Bug Fixes
+
+* Field equality factors in inline serializer ([8049ddf](https://github.com/maxveldink/sorbet-schema/commit/8049ddf2e1a2af45d6591c2689f2fde60afb5839))
+
+## [0.4.1](https://github.com/maxveldink/sorbet-schema/compare/v0.4.0...v0.4.1) (2024-03-21)
+
+
+### Features
+
+* Add DateCoercer ([ef8c1db](https://github.com/maxveldink/sorbet-schema/commit/ef8c1dbdf3bd87ab2e64102fbd1434811aa353d8))
+* Add inline serializer to fields ([dd8042d](https://github.com/maxveldink/sorbet-schema/commit/dd8042d8d88d67d530c7619ee3cbb108957990d1))
+
 ## [0.4.0](https://github.com/maxveldink/sorbet-schema/compare/v0.3.0...v0.4.0) (2024-03-14)
 
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    sorbet-schema (0.4.0)
+    sorbet-schema (0.4.2)
       sorbet-result (~> 1.1)
       sorbet-runtime (~> 0.5)
       sorbet-struct-comparable (~> 1.3)
@@ -18,13 +18,13 @@ GEM
       reline (>= 0.3.8)
     erubi (1.12.0)
     io-console (0.7.2)
-    irb (1.11.2)
+    irb (1.12.0)
       rdoc
       reline (>= 0.4.2)
     json (2.7.1)
     language_server-protocol (3.17.0.3)
     lint_roller (1.1.0)
-    minitest (5.22.2)
+    minitest (5.22.3)
     minitest-focus (1.4.0)
       minitest (>= 4, < 6)
     minitest-reporters (1.6.1)
@@ -53,7 +53,7 @@ GEM
     reline (0.4.3)
       io-console (~> 0.5)
     rexml (3.2.6)
-    rubocop (1.61.0)
+    rubocop (1.62.1)
       json (~> 2.3)
       language_server-protocol (>= 3.17.0)
       parallel (~> 1.10)
@@ -61,27 +61,27 @@ GEM
       rainbow (>= 2.2.2, < 4.0)
       regexp_parser (>= 1.8, < 3.0)
       rexml (>= 3.2.5, < 4.0)
-      rubocop-ast (>= 1.30.0, < 2.0)
+      rubocop-ast (>= 1.31.1, < 2.0)
       ruby-progressbar (~> 1.7)
       unicode-display_width (>= 2.4.0, < 3.0)
-    rubocop-ast (1.31.1)
+    rubocop-ast (1.31.2)
       parser (>= 3.3.0.4)
     rubocop-performance (1.20.2)
       rubocop (>= 1.48.1, < 2.0)
       rubocop-ast (>= 1.30.0, < 2.0)
-    rubocop-sorbet (0.7.7)
+    rubocop-sorbet (0.7.8)
       rubocop (>= 0.90.0)
     ruby-progressbar (1.13.0)
-    sorbet (0.5.11287)
-      sorbet-static (= 0.5.11287)
+    sorbet (0.5.11295)
+      sorbet-static (= 0.5.11295)
     sorbet-result (1.1.0)
       sorbet-runtime (~> 0.5)
-    sorbet-runtime (0.5.11287)
-    sorbet-static (0.5.11287-universal-darwin)
-    sorbet-static (0.5.11287-x86_64-linux)
-    sorbet-static-and-runtime (0.5.11287)
-      sorbet (= 0.5.11287)
-      sorbet-runtime (= 0.5.11287)
+    sorbet-runtime (0.5.11295)
+    sorbet-static (0.5.11295-universal-darwin)
+    sorbet-static (0.5.11295-x86_64-linux)
+    sorbet-static-and-runtime (0.5.11295)
+      sorbet (= 0.5.11295)
+      sorbet-runtime (= 0.5.11295)
     sorbet-struct-comparable (1.3.0)
       sorbet-runtime (>= 0.5)
     spoom (1.2.4)
@@ -89,10 +89,10 @@ GEM
       sorbet-static-and-runtime (>= 0.5.10187)
       syntax_tree (>= 6.1.1)
       thor (>= 0.19.2)
-    standard (1.34.0)
+    standard (1.35.1)
       language_server-protocol (~> 3.17.0.2)
       lint_roller (~> 1.0)
-      rubocop (~> 1.60)
+      rubocop (~> 1.62.0)
       standard-custom (~> 1.0.0)
       standard-performance (~> 1.3)
     standard-custom (1.0.2)

data/lib/sorbet-schema/version.rb

@@ -1,5 +1,5 @@
 # typed: strict
 
 module SorbetSchema
-  VERSION = "0.4.0"
+  VERSION = "0.4.2"
 end

data/lib/typed/coercion/boolean_coercer.rb

@@ -7,14 +7,16 @@ module Typed
 
       Target = type_member { {fixed: T::Boolean} }
 
-      sig { override.params(type: Field::Type).returns(T::Boolean) }
+      sig { override.params(type: T::Types::Base).returns(T::Boolean) }
       def used_for_type?(type)
         type == T::Utils.coerce(T::Boolean)
       end
 
-      sig { override.params(type: Field::Type, value: Value).returns(Result[Target, CoercionError]) }
+      sig { override.params(type: T::Types::Base, value: Value).returns(Result[Target, CoercionError]) }
       def coerce(type:, value:)
-        if T.cast(type, T::Types::Base).recursively_valid?(value)
+        return Failure.new(CoercionError.new("Type must be a T::Boolean.")) unless used_for_type?(type)
+
+        if type.recursively_valid?(value)
           Success.new(value)
         elsif value == "true"
           Success.new(true)
@@ -23,8 +25,6 @@ module Typed
         else
           Failure.new(CoercionError.new)
         end
-      rescue TypeError
-        Failure.new(CoercionError.new("Field type must be a T::Boolean."))
       end
     end
   end

data/lib/typed/coercion/coercer.rb

@@ -10,11 +10,11 @@ module Typed
 
       Target = type_member(:out)
 
-      sig { abstract.params(type: Field::Type).returns(T::Boolean) }
+      sig { abstract.params(type: T::Types::Base).returns(T::Boolean) }
       def used_for_type?(type)
       end
 
-      sig { abstract.params(type: Field::Type, value: Value).returns(Result[Target, CoercionError]) }
+      sig { abstract.params(type: T::Types::Base, value: Value).returns(Result[Target, CoercionError]) }
       def coerce(type:, value:)
       end
     end

data/lib/typed/coercion/coercer_registry.rb

@@ -17,6 +17,7 @@ module Typed
           BooleanCoercer,
           IntegerCoercer,
           FloatCoercer,
+          DateCoercer,
           EnumCoercer,
           StructCoercer,
           TypedArrayCoercer
@@ -39,7 +40,7 @@ module Typed
         @available = DEFAULT_COERCERS.clone
       end
 
-      sig { params(type: Field::Type).returns(T.nilable(T.class_of(Coercer))) }
+      sig { params(type: T::Types::Base).returns(T.nilable(T.class_of(Coercer))) }
       def select_coercer_by(type:)
         @available.find { |coercer| coercer.new.used_for_type?(type) }
       end

data/lib/typed/coercion/date_coercer.rb

@@ -0,0 +1,29 @@
+# typed: strict
+
+require "date"
+
+module Typed
+  module Coercion
+    class DateCoercer < Coercer
+      extend T::Generic
+
+      Target = type_member { {fixed: Date} }
+
+      sig { override.params(type: T::Types::Base).returns(T::Boolean) }
+      def used_for_type?(type)
+        T::Utils.coerce(type) == T::Utils.coerce(Date)
+      end
+
+      sig { override.params(type: T::Types::Base, value: Value).returns(Result[Target, CoercionError]) }
+      def coerce(type:, value:)
+        return Failure.new(CoercionError.new("Type must be a Date.")) unless used_for_type?(type)
+
+        return Success.new(value) if value.is_a?(Date)
+
+        Success.new(Date.parse(value))
+      rescue Date::Error, TypeError
+        Failure.new(CoercionError.new("'#{value}' cannot be coerced into Date."))
+      end
+    end
+  end
+end

data/lib/typed/coercion/enum_coercer.rb

@@ -7,16 +7,18 @@ module Typed
 
       Target = type_member { {fixed: T::Enum} }
 
-      sig { override.params(type: Field::Type).returns(T::Boolean) }
+      sig { override.params(type: T::Types::Base).returns(T::Boolean) }
       def used_for_type?(type)
-        type.is_a?(Class) && !!(type < T::Enum)
+        return false unless type.respond_to?(:raw_type)
+
+        !!(T.cast(type, T::Types::Simple).raw_type < T::Enum)
       end
 
-      sig { override.params(type: Field::Type, value: Value).returns(Result[Target, CoercionError]) }
+      sig { override.params(type: T::Types::Base, value: Value).returns(Result[Target, CoercionError]) }
       def coerce(type:, value:)
-        return Failure.new(CoercionError.new("Field type must inherit from T::Enum for Enum coercion.")) unless type.is_a?(Class) && !!(type < T::Enum)
+        return Failure.new(CoercionError.new("Field type must inherit from T::Enum for Enum coercion.")) unless used_for_type?(type)
 
-        Success.new(type.from_serialized(value))
+        Success.new(T.cast(type, T::Types::Simple).raw_type.from_serialized(value))
       rescue KeyError => e
         Failure.new(CoercionError.new(e.message))
       end

data/lib/typed/coercion/float_coercer.rb

@@ -7,13 +7,15 @@ module Typed
 
       Target = type_member { {fixed: Float} }
 
-      sig { override.params(type: Field::Type).returns(T::Boolean) }
+      sig { override.params(type: T::Types::Base).returns(T::Boolean) }
       def used_for_type?(type)
         T::Utils.coerce(type) == T::Utils.coerce(Float)
       end
 
-      sig { override.params(type: Field::Type, value: Value).returns(Result[Target, CoercionError]) }
+      sig { override.params(type: T::Types::Base, value: Value).returns(Result[Target, CoercionError]) }
       def coerce(type:, value:)
+        return Failure.new(CoercionError.new("Type must be a Float.")) unless used_for_type?(type)
+
         Success.new(Float(value))
       rescue ArgumentError, TypeError
         Failure.new(CoercionError.new("'#{value}' cannot be coerced into Float."))

data/lib/typed/coercion/integer_coercer.rb

@@ -7,13 +7,15 @@ module Typed
 
       Target = type_member { {fixed: Integer} }
 
-      sig { override.params(type: Field::Type).returns(T::Boolean) }
+      sig { override.params(type: T::Types::Base).returns(T::Boolean) }
       def used_for_type?(type)
-        type == Integer
+        type == T::Utils.coerce(Integer)
       end
 
-      sig { override.params(type: Field::Type, value: Value).returns(Result[Target, CoercionError]) }
+      sig { override.params(type: T::Types::Base, value: Value).returns(Result[Target, CoercionError]) }
       def coerce(type:, value:)
+        return Failure.new(CoercionError.new("Type must be a Integer.")) unless used_for_type?(type)
+
         Success.new(Integer(value))
       rescue ArgumentError, TypeError
         Failure.new(CoercionError.new("'#{value}' cannot be coerced into Integer."))

data/lib/typed/coercion/string_coercer.rb

@@ -7,13 +7,15 @@ module Typed
 
       Target = type_member { {fixed: String} }
 
-      sig { override.params(type: Field::Type).returns(T::Boolean) }
+      sig { override.params(type: T::Types::Base).returns(T::Boolean) }
       def used_for_type?(type)
-        type == String
+        type == T::Utils.coerce(String)
       end
 
-      sig { override.params(type: Field::Type, value: Value).returns(Result[Target, CoercionError]) }
+      sig { override.params(type: T::Types::Base, value: Value).returns(Result[Target, CoercionError]) }
       def coerce(type:, value:)
+        return Failure.new(CoercionError.new("Type must be a String.")) unless used_for_type?(type)
+
         Success.new(String(value))
       end
     end

data/lib/typed/coercion/struct_coercer.rb

@@ -7,21 +7,23 @@ module Typed
 
       Target = type_member { {fixed: T::Struct} }
 
-      sig { override.params(type: Field::Type).returns(T::Boolean) }
+      sig { override.params(type: T::Types::Base).returns(T::Boolean) }
       def used_for_type?(type)
-        type.is_a?(Class) && !!(type < T::Struct)
+        return false unless type.respond_to?(:raw_type)
+
+        !!(T.cast(type, T::Types::Simple).raw_type < T::Struct)
       end
 
-      sig { override.params(type: Field::Type, value: Value).returns(Result[Target, CoercionError]) }
+      sig { override.params(type: T::Types::Base, value: Value).returns(Result[Target, CoercionError]) }
       def coerce(type:, value:)
-        return Failure.new(CoercionError.new("Field type must inherit from T::Struct for Struct coercion.")) unless type.is_a?(Class) && type < T::Struct
-        return Success.new(value) if value.instance_of?(type)
+        return Failure.new(CoercionError.new("Field type must inherit from T::Struct for Struct coercion.")) unless used_for_type?(type)
+        return Success.new(value) if type.recursively_valid?(value)
 
         return Failure.new(CoercionError.new("Value of type '#{value.class}' cannot be coerced to #{type} Struct.")) unless value.is_a?(Hash)
 
-        Success.new(type.from_hash!(HashTransformer.new.deep_stringify_keys(value)))
-      rescue ArgumentError => e
-        Failure.new(CoercionError.new(e.message))
+        Success.new(T.cast(type, T::Types::Simple).raw_type.from_hash!(HashTransformer.new.deep_stringify_keys(value)))
+      rescue ArgumentError, RuntimeError
+        Failure.new(CoercionError.new("Given hash could not be coerced to #{type}."))
       end
     end
   end

data/lib/typed/coercion/typed_array_coercer.rb

@@ -7,20 +7,20 @@ module Typed
 
       Target = type_member { {fixed: T::Array[T.untyped]} }
 
-      sig { override.params(type: Field::Type).returns(T::Boolean) }
+      sig { override.params(type: T::Types::Base).returns(T::Boolean) }
       def used_for_type?(type)
         type.is_a?(T::Types::TypedArray)
       end
 
-      sig { override.params(type: Field::Type, value: Value).returns(Result[Target, CoercionError]) }
+      sig { override.params(type: T::Types::Base, value: Value).returns(Result[Target, CoercionError]) }
       def coerce(type:, value:)
-        return Failure.new(CoercionError.new("Field type must be a T::Array.")) unless type.is_a?(T::Types::TypedArray)
+        return Failure.new(CoercionError.new("Field type must be a T::Array.")) unless used_for_type?(type)
         return Failure.new(CoercionError.new("Value must be an Array.")) unless value.is_a?(Array)
 
         return Success.new(value) if type.recursively_valid?(value)
 
         coerced_results = value.map do |item|
-          Coercion.coerce(type: type.type.raw_type, value: item)
+          Coercion.coerce(type: T.cast(type, T::Types::TypedArray).type, value: item)
         end
 
         if coerced_results.all?(&:success?)

data/lib/typed/coercion.rb

@@ -9,7 +9,7 @@ module Typed
       CoercerRegistry.instance.register(coercer)
     end
 
-    sig { type_parameters(:U).params(type: Field::Type, value: Value).returns(Result[Value, CoercionError]) }
+    sig { type_parameters(:U).params(type: T::Types::Base, value: Value).returns(Result[Value, CoercionError]) }
     def self.coerce(type:, value:)
       coercer = CoercerRegistry.instance.select_coercer_by(type: type)
 

data/lib/typed/field.rb

@@ -1,16 +1,45 @@
 # typed: strict
 
 module Typed
-  class Field < T::Struct
+  class Field
     extend T::Sig
 
-    include ActsAsComparable
+    InlineSerializer = T.type_alias { T.proc.params(arg0: T.untyped).returns(T.untyped) }
 
-    Type = T.type_alias { T.any(T::Class[T.anything], T::Types::Base) }
+    sig { returns(Symbol) }
+    attr_reader :name
 
-    const :name, Symbol
-    const :type, Type
-    const :required, T::Boolean, default: true
+    sig { returns(T::Types::Base) }
+    attr_reader :type
+
+    sig { returns(T::Boolean) }
+    attr_reader :required
+
+    sig { returns(T.nilable(InlineSerializer)) }
+    attr_reader :inline_serializer
+
+    sig do
+      params(
+        name: Symbol,
+        type: T.any(T::Class[T.anything], T::Types::Base),
+        required: T::Boolean,
+        inline_serializer: T.nilable(InlineSerializer)
+      ).void
+    end
+    def initialize(name:, type:, required: true, inline_serializer: nil)
+      @name = name
+      @type = T.let(T::Utils.coerce(type), T::Types::Base)
+      @required = required
+      @inline_serializer = inline_serializer
+    end
+
+    sig { params(other: Field).returns(T.nilable(T::Boolean)) }
+    def ==(other)
+      name == other.name &&
+        type == other.type &&
+        required == other.required &&
+        inline_serializer == other.inline_serializer
+    end
 
     sig { returns(T::Boolean) }
     def required?
@@ -22,6 +51,15 @@ module Typed
       !required
     end
 
+    sig { params(value: Value).returns(Value) }
+    def serialize(value)
+      if inline_serializer && value
+        T.must(inline_serializer).call(value)
+      else
+        value
+      end
+    end
+
     sig { params(value: Value).returns(Validations::ValidationResult) }
     def validate(value)
       Validations::FieldTypeValidator.new.validate(field: self, value: value)
@@ -29,9 +67,7 @@ module Typed
 
     sig { params(value: Value).returns(T::Boolean) }
     def works_with?(value)
-      value.class == type || T.cast(type, T::Types::Base).recursively_valid?(value) # standard:disable Style/ClassEqualityComparison
-    rescue TypeError
-      false
+      type.recursively_valid?(value)
     end
   end
 end

data/lib/typed/hash_serializer.rb

@@ -22,9 +22,7 @@ module Typed
     def serialize(struct)
       return Failure.new(SerializeError.new("'#{struct.class}' cannot be serialized to target type of '#{schema.target}'.")) if struct.class != schema.target
 
-      hsh = schema.fields.each_with_object({}) { |field, hsh| hsh[field.name] = struct.send(field.name) }
-
-      Success.new(HashTransformer.new(should_serialize_values: should_serialize_values).deep_symbolize_keys(hsh.compact))
+      Success.new(serialize_from_struct(struct: struct, should_serialize_values: should_serialize_values))
     end
 
     private

data/lib/typed/json_serializer.rb

@@ -24,7 +24,7 @@ module Typed
     def serialize(struct)
       return Failure.new(SerializeError.new("'#{struct.class}' cannot be serialized to target type of '#{schema.target}'.")) if struct.class != schema.target
 
-      Success.new(JSON.generate(struct.serialize))
+      Success.new(JSON.generate(serialize_from_struct(struct: struct, should_serialize_values: true)))
     end
   end
 end

data/lib/typed/schema.rb

@@ -27,5 +27,19 @@ module Typed
     def from_json(json)
       Typed::JSONSerializer.new(schema: self).deserialize(json)
     end
+
+    sig { params(field_name: Symbol, serializer: Field::InlineSerializer).returns(Schema) }
+    def add_serializer(field_name, serializer)
+      self.class.new(
+        target: target,
+        fields: fields.map do |field|
+          if field.name == field_name
+            Field.new(name: field.name, type: field.type, required: field.required, inline_serializer: serializer)
+          else
+            field
+          end
+        end
+      )
+    end
   end
 end

data/lib/typed/serializer.rb

@@ -55,5 +55,12 @@ module Typed
           Success.new(schema.target.new(**validated_params))
         end
     end
+
+    sig { params(struct: T::Struct, should_serialize_values: T::Boolean).returns(T::Hash[Symbol, T.untyped]) }
+    def serialize_from_struct(struct:, should_serialize_values: false)
+      hsh = schema.fields.each_with_object({}) { |field, hsh| hsh[field.name] = field.serialize(struct.send(field.name)) }.compact
+
+      HashTransformer.new(should_serialize_values: should_serialize_values).deep_symbolize_keys(hsh)
+    end
   end
 end

data/lib/typed/validations/type_mismatch_error.rb

@@ -5,7 +5,7 @@ module Typed
     class TypeMismatchError < ValidationError
       extend T::Sig
 
-      sig { params(field_name: Symbol, field_type: Field::Type, given_type: T::Class[T.anything]).void }
+      sig { params(field_name: Symbol, field_type: T::Types::Base, given_type: T::Class[T.anything]).void }
       def initialize(field_name:, field_type:, given_type:)
         super("Invalid type given to #{field_name}. Expected #{field_type}, got #{given_type}.")
       end

data/sorbet/rbi/gems/{minitest@5.22.2.rbi → minitest@5.22.3.rbi}

@@ -1988,27 +1988,27 @@ class Minitest::Test < ::Minitest::Runnable
 
   # LifecycleHooks
   #
-  # source://minitest//lib/minitest/test.rb#190
+  # source://minitest//lib/minitest/test.rb#191
   def capture_exceptions; end
 
   # source://minitest//lib/minitest/test.rb#15
   def class_name; end
 
-  # source://minitest//lib/minitest/test.rb#207
+  # source://minitest//lib/minitest/test.rb#208
   def neuter_exception(e); end
 
-  # source://minitest//lib/minitest/test.rb#218
+  # source://minitest//lib/minitest/test.rb#219
   def new_exception(klass, msg, bt, kill = T.unsafe(nil)); end
 
   # Runs a single test with setup/teardown hooks.
   #
-  # source://minitest//lib/minitest/test.rb#86
+  # source://minitest//lib/minitest/test.rb#87
   def run; end
 
-  # source://minitest//lib/minitest/test.rb#200
+  # source://minitest//lib/minitest/test.rb#201
   def sanitize_exception(e); end
 
-  # source://minitest//lib/minitest/test.rb#232
+  # source://minitest//lib/minitest/test.rb#233
   def with_info_handler(&block); end
 
   class << self
@@ -2048,18 +2048,19 @@ class Minitest::Test < ::Minitest::Runnable
     # source://minitest//lib/minitest/test.rb#48
     def make_my_diffs_pretty!; end
 
-    # Call this at the top of your tests when you want to run your
-    # tests in parallel. In doing so, you're admitting that you rule
-    # and your tests are awesome.
+    # Call this at the top of your tests (inside the +Minitest::Test+
+    # subclass or +describe+ block) when you want to run your tests in
+    # parallel. In doing so, you're admitting that you rule and your
+    # tests are awesome.
     #
-    # source://minitest//lib/minitest/test.rb#59
+    # source://minitest//lib/minitest/test.rb#60
     def parallelize_me!; end
 
     # Returns all instance methods starting with "test_". Based on
     # #test_order, the methods are either sorted, randomized
     # (default), or run in parallel.
     #
-    # source://minitest//lib/minitest/test.rb#69
+    # source://minitest//lib/minitest/test.rb#70
     def runnable_methods; end
 
     # source://minitest-focus/1.4.0/lib/minitest/focus.rb#52
@@ -2071,7 +2072,7 @@ end
 # meant for library writers, NOT for regular test authors. See
 # #before_setup for an example.
 #
-# source://minitest//lib/minitest/test.rb#113
+# source://minitest//lib/minitest/test.rb#114
 module Minitest::Test::LifecycleHooks
   # Runs before every test, after setup. This hook is meant for
   # libraries to extend minitest. It is not meant to be used by
@@ -2079,7 +2080,7 @@ module Minitest::Test::LifecycleHooks
   #
   # See #before_setup for an example.
   #
-  # source://minitest//lib/minitest/test.rb#163
+  # source://minitest//lib/minitest/test.rb#164
   def after_setup; end
 
   # Runs after every test, after teardown. This hook is meant for
@@ -2088,7 +2089,7 @@ module Minitest::Test::LifecycleHooks
   #
   # See #before_setup for an example.
   #
-  # source://minitest//lib/minitest/test.rb#187
+  # source://minitest//lib/minitest/test.rb#188
   def after_teardown; end
 
   # Runs before every test, before setup. This hook is meant for
@@ -2123,7 +2124,7 @@ module Minitest::Test::LifecycleHooks
   #     include MyMinitestPlugin
   #   end
   #
-  # source://minitest//lib/minitest/test.rb#148
+  # source://minitest//lib/minitest/test.rb#149
   def before_setup; end
 
   # Runs after every test, before teardown. This hook is meant for
@@ -2132,19 +2133,19 @@ module Minitest::Test::LifecycleHooks
   #
   # See #before_setup for an example.
   #
-  # source://minitest//lib/minitest/test.rb#172
+  # source://minitest//lib/minitest/test.rb#173
   def before_teardown; end
 
   # Runs before every test. Use this to set up before each test
   # run.
   #
-  # source://minitest//lib/minitest/test.rb#154
+  # source://minitest//lib/minitest/test.rb#155
   def setup; end
 
   # Runs after every test. Use this to clean up after each test
   # run.
   #
-  # source://minitest//lib/minitest/test.rb#178
+  # source://minitest//lib/minitest/test.rb#179
   def teardown; end
 end