httpx 0.20.0 → 1.3.1

data/lib/httpx/plugins/compression.rb

@@ -1,164 +0,0 @@
-# frozen_string_literal: true
-
-module HTTPX
-  module Plugins
-    #
-    # This plugin adds compression support. Namely it:
-    #
-    # * Compresses the request body when passed a supported "Content-Encoding" mime-type;
-    # * Decompresses the response body from a supported "Content-Encoding" mime-type;
-    #
-    # It supports both *gzip* and *deflate*.
-    #
-    # https://gitlab.com/honeyryderchuck/httpx/wikis/Compression
-    #
-    module Compression
-      class << self
-        def configure(klass)
-          klass.plugin(:"compression/gzip")
-          klass.plugin(:"compression/deflate")
-        end
-
-        def extra_options(options)
-          encodings = Module.new do
-            extend Registry
-          end
-          options.merge(encodings: encodings)
-        end
-      end
-
-      module OptionsMethods
-        def option_compression_threshold_size(value)
-          bytes = Integer(value)
-          raise TypeError, ":expect_threshold_size must be positive" unless bytes.positive?
-
-          bytes
-        end
-
-        def option_encodings(value)
-          raise TypeError, ":encodings must be a registry" unless value.respond_to?(:registry)
-
-          value
-        end
-      end
-
-      module RequestMethods
-        def initialize(*)
-          super
-          # forego compression in the Range cases
-          if @headers.key?("range")
-            @headers.delete("accept-encoding")
-          else
-            @headers["accept-encoding"] ||= @options.encodings.registry.keys
-          end
-        end
-      end
-
-      module RequestBodyMethods
-        def initialize(*, options)
-          super
-          return if @body.nil?
-
-          threshold = options.compression_threshold_size
-          return if threshold && !unbounded_body? && @body.bytesize < threshold
-
-          @headers.get("content-encoding").each do |encoding|
-            next if encoding == "identity"
-
-            @body = Encoder.new(@body, options.encodings.registry(encoding).deflater)
-          end
-          @headers["content-length"] = @body.bytesize unless unbounded_body?
-        end
-      end
-
-      module ResponseBodyMethods
-        using ArrayExtensions
-
-        attr_reader :encodings
-
-        def initialize(*)
-          @encodings = []
-
-          super
-
-          return unless @headers.key?("content-encoding")
-
-          # remove encodings that we are able to decode
-          @headers["content-encoding"] = @headers.get("content-encoding") - @encodings
-
-          compressed_length = if @headers.key?("content-length")
-            @headers["content-length"].to_i
-          else
-            Float::INFINITY
-          end
-
-          @_inflaters = @headers.get("content-encoding").filter_map do |encoding|
-            next if encoding == "identity"
-
-            inflater = @options.encodings.registry(encoding).inflater(compressed_length)
-            # do not uncompress if there is no decoder available. In fact, we can't reliably
-            # continue decompressing beyond that, so ignore.
-            break unless inflater
-
-            @encodings << encoding
-            inflater
-          end
-
-          # this can happen if the only declared encoding is "identity"
-          remove_instance_variable(:@_inflaters) if @_inflaters.empty?
-        end
-
-        def write(chunk)
-          return super unless defined?(@_inflaters) && !chunk.empty?
-
-          chunk = decompress(chunk)
-          super(chunk)
-        end
-
-        private
-
-        def decompress(buffer)
-          @_inflaters.reverse_each do |inflater|
-            buffer = inflater.inflate(buffer)
-          end
-          buffer
-        end
-      end
-
-      class Encoder
-        attr_reader :content_type
-
-        def initialize(body, deflater)
-          @content_type = body.content_type
-          @body = body.respond_to?(:read) ? body : StringIO.new(body.to_s)
-          @buffer = StringIO.new("".b, File::RDWR)
-          @deflater = deflater
-        end
-
-        def each(&blk)
-          return enum_for(__method__) unless blk
-
-          return deflate(&blk) if @buffer.size.zero?
-
-          @buffer.rewind
-          @buffer.each(&blk)
-        end
-
-        def bytesize
-          deflate
-          @buffer.size
-        end
-
-        private
-
-        def deflate(&blk)
-          return unless @buffer.size.zero?
-
-          @body.rewind
-          @deflater.deflate(@body, @buffer, chunk_size: 16_384, &blk)
-        end
-      end
-    end
-    register_plugin :compression, Compression
-  end
-end

data/lib/httpx/plugins/multipart/decoder.rb

@@ -1,187 +0,0 @@
-# frozen_string_literal: true
-
-require "tempfile"
-require "delegate"
-
-module HTTPX::Plugins
-  module Multipart
-    using HTTPX::RegexpExtensions unless Regexp.method_defined?(:match?)
-
-    CRLF = "\r\n"
-
-    class FilePart < SimpleDelegator
-      attr_reader :original_filename, :content_type
-
-      def initialize(filename, content_type)
-        @original_filename = filename
-        @content_type = content_type
-        @file = Tempfile.new("httpx", encoding: Encoding::BINARY, mode: File::RDWR)
-        super(@file)
-      end
-    end
-
-    TOKEN = %r{[^\s()<>,;:\\"/\[\]?=]+}.freeze
-    VALUE = /"(?:\\"|[^"])*"|#{TOKEN}/.freeze
-    CONDISP = /Content-Disposition:\s*#{TOKEN}\s*/i.freeze
-    BROKEN_QUOTED = /^#{CONDISP}.*;\s*filename="(.*?)"(?:\s*$|\s*;\s*#{TOKEN}=)/i.freeze
-    BROKEN_UNQUOTED = /^#{CONDISP}.*;\s*filename=(#{TOKEN})/i.freeze
-    MULTIPART_CONTENT_TYPE = /Content-Type: (.*)#{CRLF}/ni.freeze
-    MULTIPART_CONTENT_DISPOSITION = /Content-Disposition:.*;\s*name=(#{VALUE})/ni.freeze
-    MULTIPART_CONTENT_ID = /Content-ID:\s*([^#{CRLF}]*)/ni.freeze
-    # Updated definitions from RFC 2231
-    ATTRIBUTE_CHAR = %r{[^ \t\v\n\r)(><@,;:\\"/\[\]?='*%]}.freeze
-    ATTRIBUTE = /#{ATTRIBUTE_CHAR}+/.freeze
-    SECTION = /\*[0-9]+/.freeze
-    REGULAR_PARAMETER_NAME = /#{ATTRIBUTE}#{SECTION}?/.freeze
-    REGULAR_PARAMETER = /(#{REGULAR_PARAMETER_NAME})=(#{VALUE})/.freeze
-    EXTENDED_OTHER_NAME = /#{ATTRIBUTE}\*[1-9][0-9]*\*/.freeze
-    EXTENDED_OTHER_VALUE = /%[0-9a-fA-F]{2}|#{ATTRIBUTE_CHAR}/.freeze
-    EXTENDED_OTHER_PARAMETER = /(#{EXTENDED_OTHER_NAME})=(#{EXTENDED_OTHER_VALUE}*)/.freeze
-    EXTENDED_INITIAL_NAME = /#{ATTRIBUTE}(?:\*0)?\*/.freeze
-    EXTENDED_INITIAL_VALUE = /[a-zA-Z0-9\-]*'[a-zA-Z0-9\-]*'#{EXTENDED_OTHER_VALUE}*/.freeze
-    EXTENDED_INITIAL_PARAMETER = /(#{EXTENDED_INITIAL_NAME})=(#{EXTENDED_INITIAL_VALUE})/.freeze
-    EXTENDED_PARAMETER = /#{EXTENDED_INITIAL_PARAMETER}|#{EXTENDED_OTHER_PARAMETER}/.freeze
-    DISPPARM = /;\s*(?:#{REGULAR_PARAMETER}|#{EXTENDED_PARAMETER})\s*/.freeze
-    RFC2183 = /^#{CONDISP}(#{DISPPARM})+$/i.freeze
-
-    class Decoder
-      BOUNDARY_RE = /;\s*boundary=([^;]+)/i.freeze
-      WINDOW_SIZE = 2 << 14
-
-      def initialize(response)
-        @boundary = begin
-          m = response.headers["content-type"].to_s[BOUNDARY_RE, 1]
-          raise Error, "no boundary declared in content-type header" unless m
-
-          m.strip
-        end
-        @buffer = "".b
-        @parts = {}
-        @intermediate_boundary = "--#{@boundary}"
-        @state = :idle
-      end
-
-      def call(response, _)
-        response.body.each do |chunk|
-          @buffer << chunk
-
-          parse
-        end
-
-        raise Error, "invalid or unsupported multipart format" unless @buffer.empty?
-
-        @parts
-      end
-
-      private
-
-      def parse
-        case @state
-        when :idle
-          raise Error, "payload does not start with boundary" unless @buffer.start_with?("#{@intermediate_boundary}#{CRLF}")
-
-          @buffer = @buffer.byteslice(@intermediate_boundary.bytesize + 2..-1)
-
-          @state = :part_header
-        when :part_header
-          idx = @buffer.index("#{CRLF}#{CRLF}")
-
-          # raise Error, "couldn't parse part headers" unless idx
-          return unless idx
-
-          head = @buffer.byteslice(0..idx + 4 - 1)
-
-          @buffer = @buffer.byteslice(head.bytesize..-1)
-
-          content_type = head[MULTIPART_CONTENT_TYPE, 1]
-          if (name = head[MULTIPART_CONTENT_DISPOSITION, 1])
-            name = /\A"(.*)"\Z/ =~ name ? Regexp.last_match(1) : name.dup
-            name.gsub!(/\\(.)/, "\\1")
-            name
-          else
-            name = head[MULTIPART_CONTENT_ID, 1]
-          end
-
-          filename = get_filename(head)
-
-          name = filename || +"#{content_type || "text/plain"}[]" if name.nil? || name.empty?
-
-          @current = name
-
-          @parts[name] = if filename
-            FilePart.new(filename, content_type)
-          else
-            "".b
-          end
-
-          @state = :part_body
-        when :part_body
-          part = @parts[@current]
-
-          body_separator = if part.is_a?(FilePart)
-            "#{CRLF}#{CRLF}"
-          else
-            CRLF
-          end
-          idx = @buffer.index(body_separator)
-
-          if idx
-            payload = @buffer.byteslice(0..idx - 1)
-            @buffer = @buffer.byteslice(idx + body_separator.bytesize..-1)
-            part << payload
-            part.rewind if part.respond_to?(:rewind)
-            @state = :parse_boundary
-          else
-            part << @buffer
-            @buffer.clear
-          end
-        when :parse_boundary
-          raise Error, "payload does not start with boundary" unless @buffer.start_with?(@intermediate_boundary)
-
-          @buffer = @buffer.byteslice(@intermediate_boundary.bytesize..-1)
-
-          if @buffer == "--"
-            @buffer.clear
-            @state = :done
-            return
-          elsif @buffer.start_with?(CRLF)
-            @buffer = @buffer.byteslice(2..-1)
-            @state = :part_header
-          else
-            return
-          end
-        when :done
-          raise Error, "parsing should have been over by now"
-        end until @buffer.empty?
-      end
-
-      def get_filename(head)
-        filename = nil
-        case head
-        when RFC2183
-          params = Hash[*head.scan(DISPPARM).flat_map(&:compact)]
-
-          if (filename = params["filename"])
-            filename = Regexp.last_match(1) if filename =~ /^"(.*)"$/
-          elsif (filename = params["filename*"])
-            encoding, _, filename = filename.split("'", 3)
-          end
-        when BROKEN_QUOTED, BROKEN_UNQUOTED
-          filename = Regexp.last_match(1)
-        end
-
-        return unless filename
-
-        filename = URI::DEFAULT_PARSER.unescape(filename) if filename.scan(/%.?.?/).all? { |s| /%[0-9a-fA-F]{2}/.match?(s) }
-
-        filename.scrub!
-
-        filename = filename.gsub(/\\(.)/, '\1') unless /\\[^\\"]/.match?(filename)
-
-        filename.force_encoding ::Encoding.find(encoding) if encoding
-
-        filename
-      end
-    end
-  end
-end

data/lib/httpx/plugins/multipart.rb

@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-
-module HTTPX
-  module Plugins
-    #
-    # This plugin adds support for passing `http-form_data` objects (like file objects) as "multipart/form-data";
-    #
-    #   HTTPX.post(URL, form: form: { image: HTTP::FormData::File.new("path/to/file")})
-    #
-    # https://gitlab.com/honeyryderchuck/httpx/wikis/Multipart-Uploads
-    #
-    module Multipart
-      MULTIPART_VALUE_COND = lambda do |value|
-        value.respond_to?(:read) ||
-          (value.respond_to?(:to_hash) &&
-            value.key?(:body) &&
-            (value.key?(:filename) || value.key?(:content_type)))
-      end
-
-      class << self
-        def normalize_keys(key, value, &block)
-          Transcoder.normalize_keys(key, value, MULTIPART_VALUE_COND, &block)
-        end
-
-        def load_dependencies(*)
-          # :nocov:
-          begin
-            unless defined?(HTTP::FormData)
-              # in order not to break legacy code, we'll keep loading http/form_data for them.
-              require "http/form_data"
-              warn "httpx: http/form_data is no longer a requirement to use HTTPX :multipart plugin. See migration instructions under" \
-                   "https://honeyryderchuck.gitlab.io/httpx/wiki/Multipart-Uploads.html#notes. \n\n" \
-                   "If you'd like to stop seeing this message, require 'http/form_data' yourself."
-            end
-          rescue LoadError
-          end
-          # :nocov:
-          require "httpx/plugins/multipart/encoder"
-          require "httpx/plugins/multipart/decoder"
-          require "httpx/plugins/multipart/part"
-          require "httpx/plugins/multipart/mime_type_detector"
-        end
-
-        def configure(*)
-          Transcoder.register("form", FormTranscoder)
-        end
-      end
-
-      module FormTranscoder
-        module_function
-
-        def encode(form)
-          if multipart?(form)
-            Encoder.new(form)
-          else
-            Transcoder::Form::Encoder.new(form)
-          end
-        end
-
-        def decode(response)
-          content_type = response.content_type.mime_type
-
-          case content_type
-          when "application/x-www-form-urlencoded"
-            Transcoder::Form.decode(response)
-          when "multipart/form-data"
-            Decoder.new(response)
-          else
-            raise Error, "invalid form mime type (#{content_type})"
-          end
-        end
-
-        def multipart?(data)
-          data.any? do |_, v|
-            MULTIPART_VALUE_COND.call(v) ||
-              (v.respond_to?(:to_ary) && v.to_ary.any?(&MULTIPART_VALUE_COND)) ||
-              (v.respond_to?(:to_hash) && v.to_hash.any? { |_, e| MULTIPART_VALUE_COND.call(e) })
-          end
-        end
-      end
-    end
-    register_plugin :multipart, Multipart
-  end
-end

data/lib/httpx/registry.rb

@@ -1,85 +0,0 @@
-# frozen_string_literal: true
-
-module HTTPX
-  # Adds a general-purpose registry API to a class. It is designed to be a
-  # configuration-level API, i.e. the registry is global to the class and
-  # should be set on **boot time**.
-  #
-  # It is used internally to associate tags with handlers.
-  #
-  # ## Register/Fetch
-  #
-  # One is strongly advised to register handlers when creating the class.
-  #
-  # There is an instance-level method to retrieve from the registry based
-  # on the tag:
-  #
-  #     class Server
-  #       include HTTPX::Registry
-  #
-  #       register "tcp", TCPHandler
-  #       register "ssl", SSLHandlers
-  #       ...
-  #
-  #
-  #       def handle(uri)
-  #         scheme = uri.scheme
-  #         handler = registry(scheme) #=> TCPHandler
-  #         handler.handle
-  #       end
-  #     end
-  #
-  module Registry
-    # Base Registry Error
-    class Error < Error; end
-
-    def self.extended(klass)
-      super
-      klass.extend(ClassMethods)
-    end
-
-    def self.included(klass)
-      super
-      klass.extend(ClassMethods)
-      klass.__send__(:include, InstanceMethods)
-    end
-
-    # Class Methods
-    module ClassMethods
-      def inherited(klass)
-        super
-        klass.instance_variable_set(:@registry, @registry.dup)
-      end
-
-      # @param [Object] tag the handler identifier in the registry
-      # @return [Symbol, String, Object] the corresponding handler (if Symbol or String,
-      #   will assume it referes to an autoloaded module, and will load-and-return it).
-      #
-      def registry(tag = nil)
-        @registry ||= {}
-        return @registry if tag.nil?
-
-        handler = @registry[tag]
-        raise(Error, "#{tag} is not registered in #{self}") unless handler
-
-        handler
-      end
-
-      # @param [Object] tag the identifier for the handler in the registry
-      # @return [Symbol, String, Object] the handler (if Symbol or String, it is
-      #   assumed to be an autoloaded module, to be loaded later)
-      #
-      def register(tag, handler)
-        registry[tag] = handler
-      end
-    end
-
-    # Instance Methods
-    module InstanceMethods
-      # delegates to HTTPX::Registry#registry
-      def registry(tag)
-        self.class.registry(tag)
-      end
-    end
-  end
-end

data/sig/plugins/authentication.rbs

@@ -1,11 +0,0 @@
-module HTTPX
-  module Plugins
-    module Authentication
-      module InstanceMethods
-        def authentication: (string token) -> instance
-      end
-    end
-
-    type sessionAuthentication = Session & Authentication::InstanceMethods
-  end
-end

data/sig/plugins/compression/brotli.rbs

@@ -1,21 +0,0 @@
-module HTTPX
-  module Plugins
-    module Compression
-      module Brotli
-        def self.load_dependencies: (singleton(Session)) -> void
-        def self.configure: (singleton(Session)) -> void
-
-        def self?.deflater: () -> _Deflater
-        def self?.decoder: (Numeric bytesize) -> Inflater
-
-        module Deflater
-          extend _Deflater
-        end
-
-        class Inflater
-          include _Inflater
-        end
-      end
-    end
-  end
-end

data/sig/plugins/compression/deflate.rbs

@@ -1,17 +0,0 @@
-module HTTPX
-  module Plugins
-    module Compression
-      module Deflate
-        def self.load_dependencies: (singleton(Session)) -> void
-        def self.configure: (singleton(Session)) -> void
-
-        def self?.deflater: () -> _Deflater
-        def self?.inflater: (Numeric bytesize) -> GZIP::Inflater
-
-        module Deflater
-          extend _Deflater
-        end
-      end
-    end
-  end
-end

data/sig/plugins/compression/gzip.rbs

@@ -1,29 +0,0 @@
-module HTTPX
-  module Plugins
-    module Compression
-      module GZIP
-        def self.load_dependencies: (singleton(Session)) -> void
-        def self.configure: (singleton(Session)) -> void
-
-        def self?.deflater: () -> _Deflater
-        def self?.inflater: (Numeric bytesize) -> Inflater
-
-        class Deflater
-          include _Deflater
-
-          @compressed_chunk: String
-          
-          private
-          
-          def initialize: () -> untyped
-          def write: (string) -> void
-          def compressed_chunk: () -> String
-        end
-
-        class Inflater
-          include _Inflater
-        end
-      end
-    end
-  end
-end

data/sig/registry.rbs

@@ -1,12 +0,0 @@
-module HTTPX::Registry[T, V]
-  class Error < HTTPX::Error
-  end
-
-  # type registrable = Symbol | String | Class
-
-  def self.registry: (T tag) -> Class
-                   | () -> Hash[T, V]
-  def self.register: (T tag,  V handler) -> void
-
-  def registry: (?T tag) -> V
-end