lithic 0.1.0.pre.alpha.7 → 0.1.0.pre.alpha.9

data/lib/lithic.rb

@@ -40,6 +40,7 @@ require_relative "lithic/internal/util"
 require_relative "lithic/internal/type/converter"
 require_relative "lithic/internal/type/unknown"
 require_relative "lithic/internal/type/boolean"
+require_relative "lithic/internal/type/io_like"
 require_relative "lithic/internal/type/enum"
 require_relative "lithic/internal/type/union"
 require_relative "lithic/internal/type/array_of"

data/rbi/lib/lithic/internal/transport/pooled_net_requester.rbi

@@ -35,7 +35,7 @@ module Lithic
               request: Lithic::Internal::Transport::PooledNetRequester::RequestShape,
               blk: T.proc.params(arg0: String).void
             )
-              .returns(Net::HTTPGenericRequest)
+              .returns([Net::HTTPGenericRequest, T.proc.void])
           end
           def build_request(request, &blk); end
         end

data/rbi/lib/lithic/internal/type/array_of.rbi

@@ -36,11 +36,10 @@ module Lithic
         # @api private
         sig(:final) do
           override
-            .params(value: T.any(
-              T::Array[T.anything],
-              T.anything
-            ),
-                    state: Lithic::Internal::Type::Converter::State)
+            .params(
+              value: T.any(T::Array[T.anything], T.anything),
+              state: Lithic::Internal::Type::Converter::CoerceState
+            )
             .returns(T.any(T::Array[T.anything], T.anything))
         end
         def coerce(value, state:); end
@@ -48,10 +47,13 @@ module Lithic
         # @api private
         sig(:final) do
           override
-            .params(value: T.any(T::Array[T.anything], T.anything))
+            .params(
+              value: T.any(T::Array[T.anything], T.anything),
+              state: Lithic::Internal::Type::Converter::DumpState
+            )
             .returns(T.any(T::Array[T.anything], T.anything))
         end
-        def dump(value); end
+        def dump(value, state:); end
 
         # @api private
         sig(:final) { returns(Elem) }

data/rbi/lib/lithic/internal/type/base_model.rbi

@@ -122,7 +122,7 @@ module Lithic
             override
               .params(
                 value: T.any(Lithic::Internal::Type::BaseModel, T::Hash[T.anything, T.anything], T.anything),
-                state: Lithic::Internal::Type::Converter::State
+                state: Lithic::Internal::Type::Converter::CoerceState
               )
               .returns(T.any(T.attached_class, T.anything))
           end
@@ -131,10 +131,14 @@ module Lithic
           # @api private
           sig do
             override
-              .params(value: T.any(T.attached_class, T.anything))
+              .params(value: T.any(
+                T.attached_class,
+                T.anything
+              ),
+                      state: Lithic::Internal::Type::Converter::DumpState)
               .returns(T.any(T::Hash[T.anything, T.anything], T.anything))
           end
-          def dump(value); end
+          def dump(value, state:); end
         end
 
         # Returns the raw value associated with the given key, if found. Otherwise, nil is

data/rbi/lib/lithic/internal/type/boolean.rbi

@@ -22,16 +22,26 @@ module Lithic
           # @api private
           sig(:final) do
             override
-              .params(value: T.any(T::Boolean, T.anything), state: Lithic::Internal::Type::Converter::State)
+              .params(value: T.any(
+                T::Boolean,
+                T.anything
+              ),
+                      state: Lithic::Internal::Type::Converter::CoerceState)
               .returns(T.any(T::Boolean, T.anything))
           end
           def coerce(value, state:); end
 
           # @api private
           sig(:final) do
-            override.params(value: T.any(T::Boolean, T.anything)).returns(T.any(T::Boolean, T.anything))
+            override
+              .params(value: T.any(
+                T::Boolean,
+                T.anything
+              ),
+                      state: Lithic::Internal::Type::Converter::DumpState)
+              .returns(T.any(T::Boolean, T.anything))
           end
-          def dump(value); end
+          def dump(value, state:); end
         end
       end
     end

data/rbi/lib/lithic/internal/type/converter.rbi

@@ -7,7 +7,7 @@ module Lithic
       module Converter
         Input = T.type_alias { T.any(Lithic::Internal::Type::Converter, T::Class[T.anything]) }
 
-        State =
+        CoerceState =
           T.type_alias do
             {
               strictness: T.any(T::Boolean, Symbol),
@@ -16,18 +16,23 @@ module Lithic
             }
           end
 
+        DumpState = T.type_alias { {can_retry: T::Boolean} }
+
         # @api private
         sig do
-          overridable.params(
-            value: T.anything,
-            state: Lithic::Internal::Type::Converter::State
-          ).returns(T.anything)
+          overridable
+            .params(value: T.anything, state: Lithic::Internal::Type::Converter::CoerceState)
+            .returns(T.anything)
         end
         def coerce(value, state:); end
 
         # @api private
-        sig { overridable.params(value: T.anything).returns(T.anything) }
-        def dump(value); end
+        sig do
+          overridable
+            .params(value: T.anything, state: Lithic::Internal::Type::Converter::DumpState)
+            .returns(T.anything)
+        end
+        def dump(value, state:); end
 
         class << self
           # @api private
@@ -62,7 +67,7 @@ module Lithic
             params(
               target: Lithic::Internal::Type::Converter::Input,
               value: T.anything,
-              state: Lithic::Internal::Type::Converter::State
+              state: Lithic::Internal::Type::Converter::CoerceState
             )
               .returns(T.anything)
           end
@@ -92,9 +97,14 @@ module Lithic
           ); end
           # @api private
           sig do
-            params(target: Lithic::Internal::Type::Converter::Input, value: T.anything).returns(T.anything)
+            params(
+              target: Lithic::Internal::Type::Converter::Input,
+              value: T.anything,
+              state: Lithic::Internal::Type::Converter::DumpState
+            )
+              .returns(T.anything)
           end
-          def self.dump(target, value); end
+          def self.dump(target, value, state: {can_retry: true}); end
         end
       end
     end

data/rbi/lib/lithic/internal/type/enum.rbi

@@ -40,14 +40,23 @@ module Lithic
         # of the enum.
         sig do
           override
-            .params(value: T.any(String, Symbol, T.anything), state: Lithic::Internal::Type::Converter::State)
+            .params(value: T.any(
+              String,
+              Symbol,
+              T.anything
+            ),
+                    state: Lithic::Internal::Type::Converter::CoerceState)
             .returns(T.any(Symbol, T.anything))
         end
         def coerce(value, state:); end
 
         # @api private
-        sig { override.params(value: T.any(Symbol, T.anything)).returns(T.any(Symbol, T.anything)) }
-        def dump(value); end
+        sig do
+          override
+            .params(value: T.any(Symbol, T.anything), state: Lithic::Internal::Type::Converter::DumpState)
+            .returns(T.any(Symbol, T.anything))
+        end
+        def dump(value, state:); end
       end
     end
   end

data/rbi/lib/lithic/internal/type/hash_of.rbi

@@ -38,7 +38,7 @@ module Lithic
           override
             .params(
               value: T.any(T::Hash[T.anything, T.anything], T.anything),
-              state: Lithic::Internal::Type::Converter::State
+              state: Lithic::Internal::Type::Converter::CoerceState
             )
             .returns(T.any(Lithic::Internal::AnyHash, T.anything))
         end
@@ -47,10 +47,13 @@ module Lithic
         # @api private
         sig(:final) do
           override
-            .params(value: T.any(T::Hash[T.anything, T.anything], T.anything))
+            .params(
+              value: T.any(T::Hash[T.anything, T.anything], T.anything),
+              state: Lithic::Internal::Type::Converter::DumpState
+            )
             .returns(T.any(Lithic::Internal::AnyHash, T.anything))
         end
-        def dump(value); end
+        def dump(value, state:); end
 
         # @api private
         sig(:final) { returns(Elem) }

data/rbi/lib/lithic/internal/type/io_like.rbi

@@ -0,0 +1,49 @@
+# typed: strong
+
+module Lithic
+  module Internal
+    module Type
+      # @api private
+      #
+      # Either `Pathname` or `StringIO`.
+      class IOLike
+        extend Lithic::Internal::Type::Converter
+
+        abstract!
+        final!
+
+        sig(:final) { params(other: T.anything).returns(T::Boolean) }
+        def self.===(other); end
+
+        sig(:final) { params(other: T.anything).returns(T::Boolean) }
+        def self.==(other); end
+
+        class << self
+          # @api private
+          sig(:final) do
+            override
+              .params(value: T.any(
+                StringIO,
+                String,
+                T.anything
+              ),
+                      state: Lithic::Internal::Type::Converter::CoerceState)
+              .returns(T.any(StringIO, T.anything))
+          end
+          def coerce(value, state:); end
+
+          # @api private
+          sig(:final) do
+            override
+              .params(
+                value: T.any(Pathname, StringIO, IO, String, T.anything),
+                state: Lithic::Internal::Type::Converter::DumpState
+              )
+              .returns(T.any(Pathname, StringIO, IO, String, T.anything))
+          end
+          def dump(value, state:); end
+        end
+      end
+    end
+  end
+end

data/rbi/lib/lithic/internal/type/union.rbi

@@ -49,16 +49,20 @@ module Lithic
 
         # @api private
         sig do
-          override.params(
-            value: T.anything,
-            state: Lithic::Internal::Type::Converter::State
-          ).returns(T.anything)
+          override
+            .params(value: T.anything, state: Lithic::Internal::Type::Converter::CoerceState)
+            .returns(T.anything)
         end
         def coerce(value, state:); end
 
         # @api private
-        sig { override.params(value: T.anything).returns(T.anything) }
-        def dump(value); end
+        sig do
+          override.params(
+            value: T.anything,
+            state: Lithic::Internal::Type::Converter::DumpState
+          ).returns(T.anything)
+        end
+        def dump(value, state:); end
       end
     end
   end

data/rbi/lib/lithic/internal/type/unknown.rbi

@@ -21,16 +21,20 @@ module Lithic
         class << self
           # @api private
           sig(:final) do
-            override.params(
-              value: T.anything,
-              state: Lithic::Internal::Type::Converter::State
-            ).returns(T.anything)
+            override
+              .params(value: T.anything, state: Lithic::Internal::Type::Converter::CoerceState)
+              .returns(T.anything)
           end
           def coerce(value, state:); end
 
           # @api private
-          sig(:final) { override.params(value: T.anything).returns(T.anything) }
-          def dump(value); end
+          sig(:final) do
+            override.params(
+              value: T.anything,
+              state: Lithic::Internal::Type::Converter::DumpState
+            ).returns(T.anything)
+          end
+          def dump(value, state:); end
         end
       end
     end

data/rbi/lib/lithic/internal/util.rbi

@@ -140,10 +140,34 @@ module Lithic
         def normalized_headers(*headers); end
       end
 
+      # @api private
+      class SerializationAdapter
+        sig { returns(T.any(Pathname, IO)) }
+        attr_reader :inner
+
+        sig { params(a: T.anything).returns(String) }
+        def to_json(*a); end
+
+        sig { params(a: T.anything).returns(String) }
+        def to_yaml(*a); end
+
+        # @api private
+        sig { params(inner: T.any(Pathname, IO)).returns(T.attached_class) }
+        def self.new(inner); end
+      end
+
       # @api private
       #
       # An adapter that satisfies the IO interface required by `::IO.copy_stream`
       class ReadIOAdapter
+        # @api private
+        sig { returns(T.nilable(T::Boolean)) }
+        def close?; end
+
+        # @api private
+        sig { void }
+        def close; end
+
         # @api private
         sig { params(max_len: T.nilable(Integer)).returns(String) }
         private def read_enum(max_len); end
@@ -155,12 +179,12 @@ module Lithic
         # @api private
         sig do
           params(
-            stream: T.any(String, IO, StringIO, T::Enumerable[String]),
+            src: T.any(String, Pathname, StringIO, T::Enumerable[String]),
             blk: T.proc.params(arg0: String).void
           )
             .returns(T.attached_class)
         end
-        def self.new(stream, &blk); end
+        def self.new(src, &blk); end
       end
 
       class << self
@@ -171,9 +195,16 @@ module Lithic
       class << self
         # @api private
         sig do
-          params(y: Enumerator::Yielder, boundary: String, key: T.any(Symbol, String), val: T.anything).void
+          params(
+            y: Enumerator::Yielder,
+            boundary: String,
+            key: T.any(Symbol, String),
+            val: T.anything,
+            closing: T::Array[T.proc.void]
+          )
+            .void
         end
-        private def write_multipart_chunk(y, boundary:, key:, val:); end
+        private def write_multipart_chunk(y, boundary:, key:, val:, closing:); end
 
         # @api private
         sig { params(body: T.anything).returns([String, T::Enumerable[String]]) }

data/sig/lithic/internal/transport/pooled_net_requester.rbs

@@ -21,7 +21,7 @@ module Lithic
           Lithic::Internal::Transport::PooledNetRequester::request request
         ) {
           (String arg0) -> void
-        } -> top
+        } -> [top, (^-> void)]
 
         private def with_pool: (
           URI::Generic url,

data/sig/lithic/internal/type/array_of.rbs

@@ -17,10 +17,13 @@ module Lithic
 
         def coerce: (
           ::Array[top] | top value,
-          state: Lithic::Internal::Type::Converter::state
+          state: Lithic::Internal::Type::Converter::coerce_state
         ) -> (::Array[top] | top)
 
-        def dump: (::Array[top] | top value) -> (::Array[top] | top)
+        def dump: (
+          ::Array[top] | top value,
+          state: Lithic::Internal::Type::Converter::dump_state
+        ) -> (::Array[top] | top)
 
         def item_type: -> Elem
 

data/sig/lithic/internal/type/base_model.rbs

@@ -53,10 +53,13 @@ module Lithic
 
         def self.coerce: (
           Lithic::Internal::Type::BaseModel | ::Hash[top, top] | top value,
-          state: Lithic::Internal::Type::Converter::state
+          state: Lithic::Internal::Type::Converter::coerce_state
         ) -> (instance | top)
 
-        def self.dump: (instance | top value) -> (::Hash[top, top] | top)
+        def self.dump: (
+          instance | top value,
+          state: Lithic::Internal::Type::Converter::dump_state
+        ) -> (::Hash[top, top] | top)
 
         def []: (Symbol key) -> top?
 

data/sig/lithic/internal/type/boolean.rbs

@@ -10,10 +10,13 @@ module Lithic
 
         def self.coerce: (
           bool | top value,
-          state: Lithic::Internal::Type::Converter::state
+          state: Lithic::Internal::Type::Converter::coerce_state
         ) -> (bool | top)
 
-        def self.dump: (bool | top value) -> (bool | top)
+        def self.dump: (
+          bool | top value,
+          state: Lithic::Internal::Type::Converter::dump_state
+        ) -> (bool | top)
       end
     end
   end

data/sig/lithic/internal/type/converter.rbs

@@ -4,19 +4,24 @@ module Lithic
       module Converter
         type input = Lithic::Internal::Type::Converter | Class
 
-        type state =
+        type coerce_state =
           {
             strictness: bool | :strong,
             exactness: { yes: Integer, no: Integer, maybe: Integer },
             branched: Integer
           }
 
+        type dump_state = { can_retry: bool }
+
         def coerce: (
           top value,
-          state: Lithic::Internal::Type::Converter::state
+          state: Lithic::Internal::Type::Converter::coerce_state
         ) -> top
 
-        def dump: (top value) -> top
+        def dump: (
+          top value,
+          state: Lithic::Internal::Type::Converter::dump_state
+        ) -> top
 
         def self.type_info: (
           {
@@ -31,12 +36,13 @@ module Lithic
         def self.coerce: (
           Lithic::Internal::Type::Converter::input target,
           top value,
-          ?state: Lithic::Internal::Type::Converter::state
+          ?state: Lithic::Internal::Type::Converter::coerce_state
         ) -> top
 
         def self.dump: (
           Lithic::Internal::Type::Converter::input target,
-          top value
+          top value,
+          ?state: Lithic::Internal::Type::Converter::dump_state
         ) -> top
       end
     end

data/sig/lithic/internal/type/enum.rbs

@@ -14,10 +14,13 @@ module Lithic
 
         def coerce: (
           String | Symbol | top value,
-          state: Lithic::Internal::Type::Converter::state
+          state: Lithic::Internal::Type::Converter::coerce_state
         ) -> (Symbol | top)
 
-        def dump: (Symbol | top value) -> (Symbol | top)
+        def dump: (
+          Symbol | top value,
+          state: Lithic::Internal::Type::Converter::dump_state
+        ) -> (Symbol | top)
       end
     end
   end

data/sig/lithic/internal/type/hash_of.rbs

@@ -17,10 +17,13 @@ module Lithic
 
         def coerce: (
           ::Hash[top, top] | top value,
-          state: Lithic::Internal::Type::Converter::state
+          state: Lithic::Internal::Type::Converter::coerce_state
         ) -> (::Hash[Symbol, top] | top)
 
-        def dump: (::Hash[top, top] | top value) -> (::Hash[Symbol, top] | top)
+        def dump: (
+          ::Hash[top, top] | top value,
+          state: Lithic::Internal::Type::Converter::dump_state
+        ) -> (::Hash[Symbol, top] | top)
 
         def item_type: -> Elem
 

data/sig/lithic/internal/type/io_like.rbs

@@ -0,0 +1,23 @@
+module Lithic
+  module Internal
+    module Type
+      class IOLike
+        extend Lithic::Internal::Type::Converter
+
+        def self.===: (top other) -> bool
+
+        def self.==: (top other) -> bool
+
+        def self.coerce: (
+          StringIO | String | top value,
+          state: Lithic::Internal::Type::Converter::coerce_state
+        ) -> (StringIO | top)
+
+        def self.dump: (
+          Pathname | StringIO | IO | String | top value,
+          state: Lithic::Internal::Type::Converter::dump_state
+        ) -> (Pathname | StringIO | IO | String | top)
+      end
+    end
+  end
+end

data/sig/lithic/internal/type/union.rbs

@@ -32,10 +32,13 @@ module Lithic
 
         def coerce: (
           top value,
-          state: Lithic::Internal::Type::Converter::state
+          state: Lithic::Internal::Type::Converter::coerce_state
         ) -> top
 
-        def dump: (top value) -> top
+        def dump: (
+          top value,
+          state: Lithic::Internal::Type::Converter::dump_state
+        ) -> top
       end
     end
   end

data/sig/lithic/internal/type/unknown.rbs

@@ -10,10 +10,13 @@ module Lithic
 
         def self.coerce: (
           top value,
-          state: Lithic::Internal::Type::Converter::state
+          state: Lithic::Internal::Type::Converter::coerce_state
         ) -> top
 
-        def self.dump: (top value) -> top
+        def self.dump: (
+          top value,
+          state: Lithic::Internal::Type::Converter::dump_state
+        ) -> top
       end
     end
   end

data/sig/lithic/internal/util.rbs

@@ -73,13 +73,27 @@ module Lithic
         | ::Array[(String | Integer)?])?] headers
       ) -> ::Hash[String, String]
 
+      class SerializationAdapter
+        attr_reader inner: Pathname | IO
+
+        def to_json: (*top a) -> String
+
+        def to_yaml: (*top a) -> String
+
+        def initialize: (Pathname | IO inner) -> void
+      end
+
       class ReadIOAdapter
+        def close?: -> bool?
+
+        def close: -> void
+
         private def read_enum: (Integer? max_len) -> String
 
         def read: (?Integer? max_len, ?String? out_string) -> String?
 
         def initialize: (
-          String | IO | StringIO | Enumerable[String] stream
+          String | Pathname | StringIO | Enumerable[String] src
         ) {
           (String arg0) -> void
         } -> void
@@ -93,7 +107,8 @@ module Lithic
         Enumerator::Yielder y,
         boundary: String,
         key: Symbol | String,
-        val: top
+        val: top,
+        closing: ::Array[^-> void]
       ) -> void
 
       def self?.encode_multipart_streaming: (