httpx 0.0.1

data/lib/httpx/plugins/push_promise.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Plugins
+    module PushPromise
+      PUSH_OPTIONS = { http2_settings: { settings_enable_push: 1 },
+                       max_concurrent_requests: 1 }.freeze
+
+      module ResponseMethods
+        def pushed?
+          @__pushed
+        end
+
+        def mark_as_pushed!
+          @__pushed = true
+        end
+      end
+
+      module InstanceMethods
+        def initialize(opts = {})
+          super(PUSH_OPTIONS.merge(opts))
+          @promise_headers = {}
+        end
+
+        private
+
+        def on_promise(parser, stream)
+          stream.on(:promise_headers) do |h|
+            __on_promise_request(parser, stream, h)
+          end
+          stream.on(:headers) do |h|
+            __on_promise_response(parser, stream, h)
+          end
+        end
+
+        def __on_promise_request(parser, stream, h)
+          log(1, "#{stream.id}: ") do
+            h.map { |k, v| "-> PROMISE HEADER: #{k}: #{v}" }.join("\n")
+          end
+          headers = @options.headers_class.new(h)
+          path = headers[":path"]
+          authority = headers[":authority"]
+          request = parser.pending.find { |r| r.authority == authority && r.path == path }
+          if request
+            request.merge_headers(headers)
+            @promise_headers[stream] = request
+            parser.pending.delete(request)
+          else
+            stream.refuse
+          end
+        end
+
+        def __on_promise_response(parser, stream, h)
+          request = @promise_headers.delete(stream)
+          return unless request
+          parser.__send__(:on_stream_headers, stream, request, h)
+          request.transition(:done)
+          response = request.response
+          response.mark_as_pushed!
+          stream.on(:data, &parser.method(:on_stream_data).curry[stream, request])
+          stream.on(:close, &parser.method(:on_stream_close).curry[stream, request])
+        end
+      end
+    end
+    register_plugin(:push_promise, PushPromise)
+  end
+end

data/lib/httpx/plugins/stream.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Plugins
+    module Stream
+      module InstanceMethods
+        def stream
+          headers("accept" => "text/event-stream",
+                  "cache-control" => "no-cache")
+        end
+      end
+
+      module ResponseMethods
+        def complete?
+          super ||
+            stream? &&
+              @stream_complete
+        end
+
+        def stream?
+          @headers["content-type"].start_with?("text/event-stream")
+        end
+
+        def <<(data)
+          res = super
+          @stream_complete = true if String(data).end_with?("\n\n")
+          res
+        end
+      end
+    end
+    register_plugin :stream, Stream
+  end
+end

data/lib/httpx/registry.rb

@@ -0,0 +1,88 @@
+# 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
+    Error = Class.new(Error)
+
+    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.fetch(tag)
+        raise(Error, "#{tag} is not registered in #{self}") unless handler
+        case handler
+        when Symbol, String
+          const_get(handler)
+        else
+          handler
+        end
+      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/lib/httpx/request.rb

@@ -0,0 +1,222 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module HTTPX
+  class Request
+    extend Forwardable
+
+    METHODS = [
+      # RFC 2616: Hypertext Transfer Protocol -- HTTP/1.1
+      :options, :get, :head, :post, :put, :delete, :trace, :connect,
+
+      # RFC 2518: HTTP Extensions for Distributed Authoring -- WEBDAV
+      :propfind, :proppatch, :mkcol, :copy, :move, :lock, :unlock,
+
+      # RFC 3648: WebDAV Ordered Collections Protocol
+      :orderpatch,
+
+      # RFC 3744: WebDAV Access Control Protocol
+      :acl,
+
+      # RFC 6352: vCard Extensions to WebDAV -- CardDAV
+      :report,
+
+      # RFC 5789: PATCH Method for HTTP
+      :patch,
+
+      # draft-reschke-webdav-search: WebDAV Search
+      :search
+    ].freeze
+
+    USER_AGENT = "httpx.rb/#{VERSION}"
+
+    attr_reader :verb, :uri, :headers, :body, :state
+
+    attr_accessor :response
+
+    def_delegator :@body, :<<
+
+    def_delegator :@body, :empty?
+
+    def_delegator :@body, :chunk!
+
+    def initialize(verb, uri, options = {})
+      @verb    = verb.to_s.downcase.to_sym
+      @uri     = URI(uri)
+      @options = Options.new(options)
+
+      raise(Error, "unknown method: #{verb}") unless METHODS.include?(@verb)
+
+      @headers = @options.headers_class.new(@options.headers)
+      @headers["user-agent"] ||= USER_AGENT
+      @headers["accept"]     ||= "*/*"
+
+      @body = @options.request_body_class.new(@headers, @options)
+      @state = :idle
+    end
+
+    def merge_headers(h)
+      @headers = @headers.merge(h)
+    end
+
+    def scheme
+      @uri.scheme
+    end
+
+    def path
+      path = uri.path
+      path << "/" if path.empty?
+      path << "?#{query}" unless query.empty?
+      path
+    end
+
+    def authority
+      host = @uri.host
+      port_string = @uri.port == @uri.default_port ? nil : ":#{@uri.port}"
+      "#{host}#{port_string}"
+    end
+
+    def query
+      return @query if defined?(@query)
+      query = []
+      if (q = @options.params)
+        query << URI.encode_www_form(q)
+      end
+      query << @uri.query if @uri.query
+      @query = query.join("&")
+    end
+
+    def drain_body
+      return nil if @body.nil?
+      @drainer ||= @body.each
+      chunk = @drainer.next
+      chunk.dup
+    rescue StopIteration
+      nil
+    end
+
+    def inspect
+      "#<Request #{@verb.to_s.upcase} #{path} @headers=#{@headers.to_hash} @body=#{@body}>"
+    end
+
+    class Body
+      class << self
+        def new(*, options)
+          return options.body if options.body.is_a?(self)
+          super
+        end
+      end
+
+      def initialize(headers, options)
+        @headers = headers
+        @body = if options.body
+          Transcoder.registry("body").encode(options.body)
+        elsif options.form
+          Transcoder.registry("form").encode(options.form)
+        elsif options.json
+          Transcoder.registry("json").encode(options.json)
+        end
+        return if @body.nil?
+        @headers["content-type"] ||= @body.content_type
+        @headers["content-length"] = @body.bytesize unless unbounded_body?
+      end
+
+      def each(&block)
+        return enum_for(__method__) unless block_given?
+        return if @body.nil?
+        body = stream(@body)
+        if body.respond_to?(:read)
+          ::IO.copy_stream(body, ProcIO.new(block))
+        elsif body.respond_to?(:each)
+          body.each(&block)
+        else
+          block[body.to_s]
+        end
+      end
+
+      def empty?
+        return true if @body.nil?
+        return false if chunked?
+        bytesize.zero?
+      end
+
+      def bytesize
+        return 0 if @body.nil?
+        if @body.respond_to?(:bytesize)
+          @body.bytesize
+        elsif @body.respond_to?(:size)
+          @body.size
+        else
+          raise Error, "cannot determine size of body: #{@body.inspect}"
+        end
+      end
+
+      def stream(body)
+        encoded = body
+        encoded = Transcoder.registry("chunker").encode(body) if chunked?
+        encoded
+      end
+
+      def unbounded_body?
+        chunked? || @body.bytesize == Float::INFINITY
+      end
+
+      def chunked?
+        @headers["transfer-encoding"] == "chunked"
+      end
+
+      def chunk!
+        @headers.add("transfer-encoding", "chunked")
+      end
+    end
+
+    def transition(nextstate)
+      case nextstate
+      when :idle
+        @response = nil
+      when :headers
+        return unless @state == :idle
+      when :body
+        return unless @state == :headers ||
+                      @state == :expect
+
+        if @headers.key?("expect")
+          unless @response
+            @state = :expect
+            return
+          end
+
+          case @response.status
+          when 100
+            # deallocate
+            @response = nil
+          when 417
+            @response = ErrorResponse.new("Expectation Failed", 0)
+            return
+          end
+        end
+      when :done
+        return if @state == :expect
+      end
+      @state = nextstate
+      nil
+    end
+
+    def expects?
+      @headers["expect"] == "100-continue" &&
+        @response && @response.status == 100
+    end
+
+    class ProcIO
+      def initialize(block)
+        @block = block
+      end
+
+      def write(data)
+        @block.call(data)
+        data.bytesize
+      end
+    end
+  end
+end

data/lib/httpx/response.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+require "stringio"
+require "tempfile"
+require "fileutils"
+require "forwardable"
+
+module HTTPX
+  class Response
+    extend Forwardable
+
+    attr_reader :status, :headers, :body, :version
+
+    def_delegator :@body, :to_s
+
+    def_delegator :@body, :read
+
+    def_delegator :@body, :copy_to
+
+    def_delegator :@body, :close
+
+    def_delegator :@request, :uri
+
+    def initialize(request, status, version, headers, options = {})
+      @options = Options.new(options)
+      @version = version
+      @request = request
+      @status = Integer(status)
+      @headers = @options.headers_class.new(headers)
+      @body = @options.response_body_class.new(self, threshold_size: @options.body_threshold_size,
+                                                     window_size: @options.window_size)
+    end
+
+    def merge_headers(h)
+      @headers = @headers.merge(h)
+    end
+
+    def <<(data)
+      @body.write(data)
+    end
+
+    def bodyless?
+      @request.verb == :head ||
+        @status < 200 ||
+        @status == 201 ||
+        @status == 204 ||
+        @status == 205 ||
+        @status == 304
+    end
+
+    def content_type
+      ContentType.parse(@headers["content-type"])
+    end
+
+    def complete?
+      bodyless? || (@request.verb == :connect && @status == 200)
+    end
+
+    def inspect
+      "#<Response:#{object_id} @status=#{@status} @headers=#{@headers}>"
+    end
+
+    class Body
+      def initialize(response, threshold_size:, window_size: 1 << 14)
+        @response = response
+        @headers = response.headers
+        @threshold_size = threshold_size
+        @window_size = window_size
+        @encoding = response.content_type.charset || Encoding::BINARY
+        @length = 0
+        @buffer = nil
+        @state = :idle
+      end
+
+      def write(chunk)
+        @length += chunk.bytesize
+        transition
+        @buffer.write(chunk)
+      end
+
+      def read(*args)
+        return unless @buffer
+        @buffer.read(*args)
+      end
+
+      def bytesize
+        @length
+      end
+
+      def each
+        return enum_for(__method__) unless block_given?
+        begin
+          unless @state == :idle
+            rewind
+            while (chunk = @buffer.read(@window_size))
+              yield(chunk)
+            end
+          end
+        ensure
+          close
+        end
+      end
+
+      def to_s
+        rewind
+        return @buffer.read.force_encoding(@encoding) if @buffer
+        ""
+      ensure
+        close
+      end
+      alias_method :to_str, :to_s
+
+      def empty?
+        @length.zero?
+      end
+
+      def copy_to(dest)
+        return unless @buffer
+        if dest.respond_to?(:path) && @buffer.respond_to?(:path)
+          FileUtils.mv(@buffer.path, dest.path)
+        else
+          @buffer.rewind
+          ::IO.copy_stream(@buffer, dest)
+        end
+      end
+
+      # closes/cleans the buffer, resets everything
+      def close
+        return if @state == :idle
+        @buffer.close
+        @buffer.unlink if @buffer.respond_to?(:unlink)
+        @buffer = nil
+        @length = 0
+        @state = :idle
+      end
+
+      def ==(other)
+        to_s == other.to_s
+      end
+
+      private
+
+      def rewind
+        return if @state == :idle
+        @buffer.rewind
+      end
+
+      def transition
+        case @state
+        when :idle
+          if @length > @threshold_size
+            @state = :buffer
+            @buffer = Tempfile.new("httpx", encoding: @encoding, mode: File::RDWR)
+          else
+            @state = :memory
+            @buffer = StringIO.new("".b, File::RDWR)
+          end
+        when :memory
+          if @length > @threshold_size
+            aux = @buffer
+            @buffer = Tempfile.new("palanca", encoding: @encoding, mode: File::RDWR)
+            aux.rewind
+            ::IO.copy_stream(aux, @buffer)
+            # TODO: remove this if/when minor ruby is 2.3
+            # (this looks like a bug from older versions)
+            @buffer.pos = aux.pos #######################
+            #############################################
+            aux.close
+            @state = :buffer
+          end
+        end
+
+        return unless %i[memory buffer].include?(@state)
+      end
+    end
+  end
+
+  class ContentType
+    MIME_TYPE_RE = %r{^([^/]+/[^;]+)(?:$|;)}
+    CHARSET_RE   = /;\s*charset=([^;]+)/i
+
+    attr_reader :mime_type, :charset
+
+    def initialize(mime_type, charset)
+      @mime_type = mime_type
+      @charset = charset
+    end
+
+    class << self
+      # Parse string and return ContentType struct
+      def parse(str)
+        new(mime_type(str), charset(str))
+      end
+
+      private
+
+      # :nodoc:
+      def mime_type(str)
+        m = str.to_s[MIME_TYPE_RE, 1]
+        m && m.strip.downcase
+      end
+
+      # :nodoc:
+      def charset(str)
+        m = str.to_s[CHARSET_RE, 1]
+        m && m.strip.delete('"')
+      end
+    end
+  end
+
+  class ErrorResponse
+    attr_reader :error, :retries
+
+    alias_method :status, :error
+
+    def initialize(error, retries)
+      @error = error
+      @retries = retries
+    end
+
+    def retryable?
+      @retries.positive?
+    end
+  end
+end