modern_treasury 0.1.0.pre.alpha.17 → 0.1.0.pre.alpha.19

data/lib/modern_treasury/internal/util.rb

@@ -122,12 +122,28 @@ module ModernTreasury
         # @return [Hash{Object=>Object}, Object]
         def coerce_hash(input)
           case input
-          in NilClass | Array | Set | Enumerator
+          in NilClass | Array | Set | Enumerator | StringIO | IO
             input
           else
             input.respond_to?(:to_h) ? input.to_h : input
           end
         end
+
+        # @api private
+        #
+        # @param input [Object]
+        #
+        # @raise [ArgumentError]
+        # @return [Hash{Object=>Object}, nil]
+        def coerce_hash!(input)
+          case coerce_hash(input)
+          in Hash | nil => coerced
+            coerced
+          else
+            message = "Expected a #{Hash} or #{ModernTreasury::Internal::Type::BaseModel}, got #{data.inspect}"
+            raise ArgumentError.new(message)
+          end
+        end
       end
 
       class << self
@@ -175,18 +191,17 @@ module ModernTreasury
         # @api private
         #
         # @param data [Hash{Symbol=>Object}, Array<Object>, Object]
-        # @param pick [Symbol, Integer, Array<Symbol, Integer>, nil]
-        # @param sentinel [Object, nil]
+        # @param pick [Symbol, Integer, Array<Symbol, Integer>, Proc, nil]
         # @param blk [Proc, nil]
         #
         # @return [Object, nil]
-        def dig(data, pick, sentinel = nil, &blk)
-          case [data, pick, blk]
-          in [_, nil, nil]
+        def dig(data, pick, &blk)
+          case [data, pick]
+          in [_, nil]
             data
-          in [Hash, Symbol, _] | [Array, Integer, _]
-            blk.nil? ? data.fetch(pick, sentinel) : data.fetch(pick, &blk)
-          in [Hash | Array, Array, _]
+          in [Hash, Symbol] | [Array, Integer]
+            data.fetch(pick) { blk&.call }
+          in [Hash | Array, Array]
             pick.reduce(data) do |acc, key|
               case acc
               in Hash if acc.key?(key)
@@ -194,11 +209,13 @@ module ModernTreasury
               in Array if key.is_a?(Integer) && key < acc.length
                 acc[key]
               else
-                return blk.nil? ? sentinel : blk.call
+                return blk&.call
               end
             end
-          in _
-            blk.nil? ? sentinel : blk.call
+          in [_, Proc]
+            pick.call(data)
+          else
+            blk&.call
           end
         end
       end
@@ -352,6 +369,22 @@ module ModernTreasury
       #
       # An adapter that satisfies the IO interface required by `::IO.copy_stream`
       class ReadIOAdapter
+        # @api private
+        #
+        # @return [Boolean, nil]
+        def close? = @closing
+
+        # @api private
+        def close
+          case @stream
+          in Enumerator
+            ModernTreasury::Internal::Util.close_fused!(@stream)
+          in IO if close?
+            @stream.close
+          else
+          end
+        end
+
         # @api private
         #
         # @param max_len [Integer, nil]
@@ -396,13 +429,22 @@ module ModernTreasury
 
         # @api private
         #
-        # @param stream [String, IO, StringIO, Enumerable<String>]
+        # @param src [String, Pathname, StringIO, Enumerable<String>]
         # @param blk [Proc]
         #
         # @yieldparam [String]
-        def initialize(stream, &blk)
-          @stream = stream.is_a?(String) ? StringIO.new(stream) : stream
-          @buf = String.new.b
+        def initialize(src, &blk)
+          @stream =
+            case src
+            in String
+              StringIO.new(src)
+            in Pathname
+              @closing = true
+              src.open(binmode: true)
+            else
+              src
+            end
+          @buf = String.new
           @blk = blk
         end
       end
@@ -414,9 +456,10 @@ module ModernTreasury
         # @return [Enumerable<String>]
         def writable_enum(&blk)
           Enumerator.new do |y|
+            buf = String.new
             y.define_singleton_method(:write) do
-              self << _1.clone
-              _1.bytesize
+              self << buf.replace(_1)
+              buf.bytesize
             end
 
             blk.call(y)
@@ -424,45 +467,83 @@ module ModernTreasury
         end
       end
 
+      # @type [Regexp]
+      JSON_CONTENT = %r{^application/(?:vnd(?:\.[^.]+)*\+)?json(?!l)}
+      # @type [Regexp]
+      JSONL_CONTENT = %r{^application/(:?x-(?:n|l)djson)|(:?(?:x-)?jsonl)}
+
       class << self
         # @api private
         #
         # @param y [Enumerator::Yielder]
-        # @param boundary [String]
-        # @param key [Symbol, String]
         # @param val [Object]
-        private def write_multipart_chunk(y, boundary:, key:, val:)
-          y << "--#{boundary}\r\n"
-          y << "Content-Disposition: form-data"
-          unless key.nil?
-            name = ERB::Util.url_encode(key.to_s)
-            y << "; name=\"#{name}\""
-          end
-          if val.is_a?(IO)
-            filename = ERB::Util.url_encode(File.basename(val.to_path))
-            y << "; filename=\"#{filename}\""
-          end
-          y << "\r\n"
+        # @param closing [Array<Proc>]
+        # @param content_type [String, nil]
+        private def write_multipart_content(y, val:, closing:, content_type: nil)
+          content_type ||= "application/octet-stream"
+
           case val
+          in ModernTreasury::FilePart
+            return write_multipart_content(
+              y,
+              val: val.content,
+              closing: closing,
+              content_type: val.content_type
+            )
+          in Pathname
+            y << "Content-Type: #{content_type}\r\n\r\n"
+            io = val.open(binmode: true)
+            closing << io.method(:close)
+            IO.copy_stream(io, y)
           in IO
-            y << "Content-Type: application/octet-stream\r\n\r\n"
-            IO.copy_stream(val.tap(&:rewind), y)
+            y << "Content-Type: #{content_type}\r\n\r\n"
+            IO.copy_stream(val, y)
           in StringIO
-            y << "Content-Type: application/octet-stream\r\n\r\n"
+            y << "Content-Type: #{content_type}\r\n\r\n"
             y << val.string
           in String
-            y << "Content-Type: application/octet-stream\r\n\r\n"
+            y << "Content-Type: #{content_type}\r\n\r\n"
             y << val.to_s
-          in true | false | Integer | Float | Symbol
+          in -> { primitive?(_1) }
             y << "Content-Type: text/plain\r\n\r\n"
             y << val.to_s
           else
             y << "Content-Type: application/json\r\n\r\n"
-            y << JSON.fast_generate(val)
+            y << JSON.generate(val)
           end
           y << "\r\n"
         end
 
+        # @api private
+        #
+        # @param y [Enumerator::Yielder]
+        # @param boundary [String]
+        # @param key [Symbol, String]
+        # @param val [Object]
+        # @param closing [Array<Proc>]
+        private def write_multipart_chunk(y, boundary:, key:, val:, closing:)
+          y << "--#{boundary}\r\n"
+          y << "Content-Disposition: form-data"
+
+          unless key.nil?
+            name = ERB::Util.url_encode(key.to_s)
+            y << "; name=\"#{name}\""
+          end
+
+          case val
+          in ModernTreasury::FilePart unless val.filename.nil?
+            filename = ERB::Util.url_encode(val.filename)
+            y << "; filename=\"#{filename}\""
+          in Pathname | IO
+            filename = ERB::Util.url_encode(::File.basename(val.to_path))
+            y << "; filename=\"#{filename}\""
+          else
+          end
+          y << "\r\n"
+
+          write_multipart_content(y, val: val, closing: closing)
+        end
+
         # @api private
         #
         # @param body [Object]
@@ -471,6 +552,7 @@ module ModernTreasury
         private def encode_multipart_streaming(body)
           boundary = SecureRandom.urlsafe_base64(60)
 
+          closing = []
           strio = writable_enum do |y|
             case body
             in Hash
@@ -478,19 +560,20 @@ module ModernTreasury
                 case val
                 in Array if val.all? { primitive?(_1) }
                   val.each do |v|
-                    write_multipart_chunk(y, boundary: boundary, key: key, val: v)
+                    write_multipart_chunk(y, boundary: boundary, key: key, val: v, closing: closing)
                   end
                 else
-                  write_multipart_chunk(y, boundary: boundary, key: key, val: val)
+                  write_multipart_chunk(y, boundary: boundary, key: key, val: val, closing: closing)
                 end
               end
             else
-              write_multipart_chunk(y, boundary: boundary, key: nil, val: body)
+              write_multipart_chunk(y, boundary: boundary, key: nil, val: body, closing: closing)
             end
             y << "--#{boundary}--\r\n"
           end
 
-          [boundary, strio]
+          fused_io = fused_enum(strio) { closing.each(&:call) }
+          [boundary, fused_io]
         end
 
         # @api private
@@ -502,20 +585,20 @@ module ModernTreasury
         def encode_content(headers, body)
           content_type = headers["content-type"]
           case [content_type, body]
-          in [%r{^application/(?:vnd\.api\+)?json}, _] unless body.nil?
-            [headers, JSON.fast_generate(body)]
-          in [%r{^application/(?:x-)?jsonl}, Enumerable]
-            [headers, body.lazy.map { JSON.fast_generate(_1) }]
-          in [%r{^multipart/form-data}, Hash | IO | StringIO]
+          in [ModernTreasury::Internal::Util::JSON_CONTENT, Hash | Array | -> { primitive?(_1) }]
+            [headers, JSON.generate(body)]
+          in [ModernTreasury::Internal::Util::JSONL_CONTENT, Enumerable] unless body.is_a?(ModernTreasury::Internal::Type::FileInput)
+            [headers, body.lazy.map { JSON.generate(_1) }]
+          in [%r{^multipart/form-data}, Hash | ModernTreasury::Internal::Type::FileInput]
             boundary, strio = encode_multipart_streaming(body)
             headers = {**headers, "content-type" => "#{content_type}; boundary=#{boundary}"}
             [headers, strio]
-          in [_, IO]
-            [headers, body.tap(&:rewind)]
-          in [_, StringIO]
-            [headers, body.string]
           in [_, Symbol | Numeric]
             [headers, body.to_s]
+          in [_, StringIO]
+            [headers, body.string]
+          in [_, ModernTreasury::FilePart]
+            [headers, body.content]
           else
             [headers, body]
           end
@@ -523,6 +606,27 @@ module ModernTreasury
 
         # @api private
         #
+        # https://www.iana.org/assignments/character-sets/character-sets.xhtml
+        #
+        # @param content_type [String]
+        # @param text [String]
+        def force_charset!(content_type, text:)
+          charset = /charset=([^;\s]+)/.match(content_type)&.captures&.first
+
+          return unless charset
+
+          begin
+            encoding = Encoding.find(charset)
+            text.force_encoding(encoding)
+          rescue ArgumentError
+            nil
+          end
+        end
+
+        # @api private
+        #
+        # Assumes each chunk in stream has `Encoding::BINARY`.
+        #
         # @param headers [Hash{String=>String}, Net::HTTPHeader]
         # @param stream [Enumerable<String>]
         # @param suppress_error [Boolean]
@@ -530,8 +634,8 @@ module ModernTreasury
         # @raise [JSON::ParserError]
         # @return [Object]
         def decode_content(headers, stream:, suppress_error: false)
-          case headers["content-type"]
-          in %r{^application/(?:vnd\.api\+)?json}
+          case (content_type = headers["content-type"])
+          in ModernTreasury::Internal::Util::JSON_CONTENT
             json = stream.to_a.join
             begin
               JSON.parse(json, symbolize_names: true)
@@ -539,7 +643,7 @@ module ModernTreasury
               raise e unless suppress_error
               json
             end
-          in %r{^application/(?:x-)?jsonl}
+          in ModernTreasury::Internal::Util::JSONL_CONTENT
             lines = decode_lines(stream)
             chain_fused(lines) do |y|
               lines.each { y << JSON.parse(_1, symbolize_names: true) }
@@ -547,11 +651,10 @@ module ModernTreasury
           in %r{^text/event-stream}
             lines = decode_lines(stream)
             decode_sse(lines)
-          in %r{^text/}
-            stream.to_a.join
           else
-            # TODO: parsing other response types
-            StringIO.new(stream.to_a.join)
+            text = stream.to_a.join
+            force_charset!(content_type, text: text)
+            StringIO.new(text)
           end
         end
       end
@@ -616,12 +719,17 @@ module ModernTreasury
       class << self
         # @api private
         #
+        # Assumes Strings have been forced into having `Encoding::BINARY`.
+        #
+        # This decoder is responsible for reassembling lines split across multiple
+        # fragments.
+        #
         # @param enum [Enumerable<String>]
         #
         # @return [Enumerable<String>]
         def decode_lines(enum)
           re = /(\r\n|\r|\n)/
-          buffer = String.new.b
+          buffer = String.new
           cr_seen = nil
 
           chain_fused(enum) do |y|
@@ -652,6 +760,8 @@ module ModernTreasury
         #
         # https://html.spec.whatwg.org/multipage/server-sent-events.html#parsing-an-event-stream
         #
+        # Assumes that `lines` has been decoded with `#decode_lines`.
+        #
         # @param lines [Enumerable<String>]
         #
         # @return [Enumerable<Hash{Symbol=>Object}>]
@@ -675,7 +785,7 @@ module ModernTreasury
                 in "event"
                   current.merge!(event: value)
                 in "data"
-                  (current[:data] ||= String.new.b) << (value << "\n")
+                  (current[:data] ||= String.new) << (value << "\n")
                 in "id" unless value.include?("\0")
                   current.merge!(id: value)
                 in "retry" if /^\d+$/ =~ value
@@ -691,6 +801,62 @@ module ModernTreasury
           end
         end
       end
+
+      # @api private
+      module SorbetRuntimeSupport
+        class MissingSorbetRuntimeError < ::RuntimeError
+        end
+
+        # @api private
+        #
+        # @return [Hash{Symbol=>Object}]
+        private def sorbet_runtime_constants = @sorbet_runtime_constants ||= {}
+
+        # @api private
+        #
+        # @param name [Symbol]
+        def const_missing(name)
+          super unless sorbet_runtime_constants.key?(name)
+
+          unless Object.const_defined?(:T)
+            message = "Trying to access a Sorbet constant #{name.inspect} without `sorbet-runtime`."
+            raise MissingSorbetRuntimeError.new(message)
+          end
+
+          sorbet_runtime_constants.fetch(name).call
+        end
+
+        # @api private
+        #
+        # @param name [Symbol]
+        # @param blk [Proc]
+        def define_sorbet_constant!(name, &blk) = sorbet_runtime_constants.store(name, blk)
+      end
+
+      extend ModernTreasury::Internal::Util::SorbetRuntimeSupport
+
+      define_sorbet_constant!(:ParsedUri) do
+        T.type_alias do
+          {
+            scheme: T.nilable(String),
+            host: T.nilable(String),
+            port: T.nilable(Integer),
+            path: T.nilable(String),
+            query: T::Hash[String, T::Array[String]]
+          }
+        end
+      end
+
+      define_sorbet_constant!(:ServerSentEvent) do
+        T.type_alias do
+          {
+            event: T.nilable(String),
+            data: T.nilable(String),
+            id: T.nilable(String),
+            retry: T.nilable(Integer)
+          }
+        end
+      end
     end
   end
 end

data/lib/modern_treasury/internal.rb

@@ -1,8 +1,17 @@
 # frozen_string_literal: true
 
 module ModernTreasury
-  # @api private
   module Internal
-    OMIT = Object.new.freeze
+    extend ModernTreasury::Internal::Util::SorbetRuntimeSupport
+
+    OMIT =
+      Object.new.tap do
+        _1.define_singleton_method(:inspect) { "#<#{ModernTreasury::Internal}::OMIT>" }
+      end
+        .freeze
+
+    define_sorbet_constant!(:AnyHash) do
+      T.type_alias { T::Hash[Symbol, T.anything] }
+    end
   end
 end