httpx 0.0.1

data/lib/httpx/client.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+module HTTPX
+  class Client
+    include Loggable
+    include Chainable
+
+    def initialize(options = {})
+      @options = self.class.default_options.merge(options)
+      @connection = Connection.new(@options)
+      @responses = {}
+      return unless block_given?
+      begin
+        @keep_open = true
+        yield self
+      ensure
+        @keep_open = false
+        close
+      end
+    end
+
+    def close
+      @connection.close
+    end
+
+    def request(*args, keep_open: @keep_open, **options)
+      requests = __build_reqs(*args, **options)
+      responses = __send_reqs(*requests, **options)
+      return responses.first if responses.size == 1
+      responses
+    ensure
+      close unless keep_open
+    end
+
+    private
+
+    def on_response(request, response)
+      @responses[request] = response
+    end
+
+    def on_promise(_, stream)
+      log(2, "#{stream.id}: ") { "refusing stream!" }
+      stream.refuse
+      # TODO: policy for handling promises
+    end
+
+    def fetch_response(request)
+      response = @responses.delete(request)
+      if response.is_a?(ErrorResponse) && response.retryable?
+        channel = find_channel(request)
+        channel.send(request, retries: response.retries - 1)
+        return
+      end
+      response
+    end
+
+    def find_channel(request, **options)
+      uri = URI(request.uri)
+      @connection.find_channel(uri) || begin
+        channel = @connection.build_channel(uri, **options)
+        set_channel_callbacks(channel)
+        channel
+      end
+    end
+
+    def set_channel_callbacks(channel)
+      channel.on(:response, &method(:on_response))
+      channel.on(:promise, &method(:on_promise))
+    end
+
+    def __build_reqs(*args, **options)
+      case args.size
+      when 1
+        reqs = args.first
+        reqs.map do |verb, uri|
+          __build_req(verb, uri, options)
+        end
+      when 2, 3
+        verb, uris = args
+        if uris.respond_to?(:each)
+          uris.map do |uri|
+            __build_req(verb, uri, options)
+          end
+        else
+          [__build_req(verb, uris, options)]
+        end
+      else
+        raise ArgumentError, "unsupported number of arguments"
+      end
+    end
+
+    def __send_reqs(*requests, **options)
+      requests.each do |request|
+        channel = find_channel(request, **options)
+        channel.send(request)
+      end
+      responses = []
+
+      # guarantee ordered responses
+      loop do
+        begin
+          request = requests.first
+          @connection.next_tick until (response = fetch_response(request))
+
+          responses << response
+          requests.shift
+
+          break if requests.empty?
+        rescue TimeoutError => e
+          responses << ErrorResponse.new(e.message, 0) while requests.shift
+          @connection.reset
+          break
+        end
+      end
+      requests.size == 1 ? responses.first : responses
+    end
+
+    def __build_req(verb, uri, options = {})
+      rklass = @options.request_class
+      rklass.new(verb, uri, @options.merge(options))
+    end
+
+    @default_options = Options.new
+    @plugins = []
+
+    class << self
+      attr_reader :default_options
+
+      def inherited(klass)
+        super
+        klass.instance_variable_set(:@default_options, @default_options.dup)
+        klass.instance_variable_set(:@plugins, @plugins.dup)
+      end
+
+      def plugin(pl, *args, &block)
+        # raise Error, "Cannot add a plugin to a frozen config" if frozen?
+        pl = Plugins.load_plugin(pl) if pl.is_a?(Symbol)
+        unless @plugins.include?(pl)
+          @plugins << pl
+          pl.load_dependencies(self, *args, &block) if pl.respond_to?(:load_dependencies)
+          include(pl::InstanceMethods) if defined?(pl::InstanceMethods)
+          extend(pl::ClassMethods) if defined?(pl::ClassMethods)
+          if defined?(pl::OptionsMethods) || defined?(pl::OptionsClassMethods)
+            options_klass = Class.new(@default_options.class)
+            options_klass.extend(pl::OptionsClassMethods) if defined?(pl::OptionsClassMethods)
+            options_klass.__send__(:include, pl::OptionsMethods) if defined?(pl::OptionsMethods)
+            @default_options = options_klass.new
+          end
+          opts = default_options
+          opts.request_class.__send__(:include, pl::RequestMethods) if defined?(pl::RequestMethods)
+          opts.request_class.extend(pl::RequestClassMethods) if defined?(pl::RequestClassMethods)
+          opts.response_class.__send__(:include, pl::ResponseMethods) if defined?(pl::ResponseMethods)
+          opts.response_class.extend(pl::ResponseClassMethods) if defined?(pl::ResponseClassMethods)
+          opts.headers_class.__send__(:include, pl::HeadersMethods) if defined?(pl::HeadersMethods)
+          opts.headers_class.extend(pl::HeadersClassMethods) if defined?(pl::HeadersClassMethods)
+          opts.request_body_class.__send__(:include, pl::RequestBodyMethods) if defined?(pl::RequestBodyMethods)
+          opts.request_body_class.extend(pl::RequestBodyClassMethods) if defined?(pl::RequestBodyClassMethods)
+          opts.response_body_class.__send__(:include, pl::ResponseBodyMethods) if defined?(pl::ResponseBodyMethods)
+          opts.response_body_class.extend(pl::ResponseBodyClassMethods) if defined?(pl::ResponseBodyClassMethods)
+          pl.configure(self, *args, &block) if pl.respond_to?(:configure)
+        end
+        self
+      end
+
+      def plugins(pls)
+        pls.each do |pl, *args|
+          plugin(pl, *args)
+        end
+        self
+      end
+    end
+  end
+end

data/lib/httpx/connection.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "httpx/selector"
+require "httpx/channel"
+
+module HTTPX
+  class Connection
+    def initialize(options)
+      @options = Options.new(options)
+      @timeout = options.timeout
+      @selector = Selector.new
+      @channels = []
+    end
+
+    def running?
+      !@channels.empty?
+    end
+
+    def next_tick(timeout: @timeout.timeout)
+      @selector.select(timeout) do |monitor|
+        if (channel = monitor.value)
+          consume(channel)
+        end
+        monitor.interests = channel.interests
+      end
+    end
+
+    def close(channel = nil)
+      if channel
+        channel.close
+      else
+        @channels.each(&:close)
+        next_tick until @selector.empty?
+      end
+    end
+
+    def reset
+      @channels.each(&:reset)
+    end
+
+    def build_channel(uri, **options)
+      channel = Channel.by(uri, @options.merge(options))
+      register_channel(channel)
+      channel
+    end
+
+    # opens a channel to the IP reachable through +uri+.
+    # Many hostnames are reachable through the same IP, so we try to
+    # maximize pipelining by opening as few channels as possible.
+    #
+    def find_channel(uri)
+      @channels.find do |channel|
+        channel.match?(uri)
+      end
+    end
+
+    private
+
+    def register_channel(channel)
+      monitor = @selector.register(channel, :w)
+      monitor.value = channel
+      channel.on(:close) do
+        @channels.delete(channel)
+        @selector.deregister(channel)
+      end
+      @channels << channel
+    end
+
+    def consume(channel)
+      ch = catch(:close) { channel.call }
+      close(ch) if ch
+    end
+  end
+end

data/lib/httpx/errors.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module HTTPX
+  Error = Class.new(StandardError)
+
+  TimeoutError = Class.new(Error)
+end

data/lib/httpx/extensions.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+unless Method.method_defined?(:curry)
+
+  # Backport
+  #
+  # Ruby 2.1 and lower implement curry only for Procs.
+  #
+  # Why not using Refinements? Because they don't work for Method (tested with ruby 2.1.9).
+  #
+  module CurryMethods # :nodoc:
+    # Backport for the Method#curry method, which is part of ruby core since 2.2 .
+    #
+    def curry(*args)
+      to_proc.curry(*args)
+    end
+  end
+  Method.__send__(:include, CurryMethods)
+end
+
+unless String.method_defined?(:+@)
+  # Backport for +"", to initialize unfrozen strings from the string literal.
+  #
+  module LiteralStringExtensions
+    def +@
+      frozen? ? dup : self
+    end
+  end
+  String.__send__(:include, LiteralStringExtensions)
+end
+
+unless Numeric.method_defined?(:positive?)
+  # Ruby 2.3 Backport (Numeric#positive?)
+  #
+  module PosMethods
+    def positive?
+      self > 0
+    end
+  end
+  Numeric.__send__(:include, PosMethods)
+end
+
+unless Numeric.method_defined?(:negative?)
+  # Ruby 2.3 Backport (Numeric#negative?)
+  #
+  module NegMethods
+    def negative?
+      self < 0
+    end
+  end
+  Numeric.__send__(:include, NegMethods)
+end

data/lib/httpx/headers.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module HTTPX
+  class Headers
+    EMPTY = [].freeze # :nodoc:
+
+    class << self
+      def new(h = nil)
+        return h if h.is_a?(self)
+        super
+      end
+    end
+
+    def initialize(h = nil)
+      @headers = {}
+      return unless h
+      h.each do |field, value|
+        array_value(value).each do |v|
+          add(downcased(field), v)
+        end
+      end
+    end
+
+    # cloned initialization
+    def initialize_clone(orig)
+      super
+      @headers = orig.instance_variable_get(:@headers).clone
+    end
+
+    # dupped initialization
+    def initialize_dup(orig)
+      super
+      @headers = orig.instance_variable_get(:@headers).dup
+    end
+
+    # freezes the headers hash
+    def freeze
+      @headers.freeze
+      super
+    end
+
+    # merges headers with another header-quack.
+    # the merge rule is, if the header already exists,
+    # ignore what the +other+ headers has. Otherwise, set
+    #
+    def merge(other)
+      # TODO: deep-copy
+      headers = dup
+      other.each do |field, value|
+        headers[field] = value
+      end
+      headers
+    end
+
+    # returns the comma-separated values of the header field
+    # identified by +field+, or nil otherwise.
+    #
+    def [](field)
+      a = @headers[downcased(field)] || return
+      a.join(",")
+    end
+
+    # sets +value+ (if not nil) as single value for the +field+ header.
+    #
+    def []=(field, value)
+      return unless value
+      @headers[downcased(field)] = array_value(value)
+    end
+
+    # deletes all values associated with +field+ header.
+    #
+    def delete(field)
+      canonical = downcased(field)
+      @headers.delete(canonical) if @headers.key?(canonical)
+    end
+
+    # adds additional +value+ to the existing, for header +field+.
+    #
+    def add(field, value)
+      (@headers[downcased(field)] ||= []) << String(value)
+    end
+
+    # helper to be used when adding an header field as a value to another field
+    #
+    #     h2_headers.add_header("vary", "accept-encoding")
+    #     h2_headers["vary"] #=> "accept-encoding"
+    #     h1_headers.add_header("vary", "accept-encoding")
+    #     h1_headers["vary"] #=> "Accept-Encoding"
+    #
+    alias_method :add_header, :add
+
+    # returns the enumerable headers store in pairs of header field + the values in
+    # the comma-separated string format
+    #
+    def each
+      return enum_for(__method__) { @headers.size } unless block_given?
+      @headers.each do |field, value|
+        yield(field, value.join(", ")) unless value.empty?
+      end
+    end
+
+    def ==(other)
+      to_hash == Headers.new(other).to_hash
+    end
+
+    # the headers store in Hash format
+    def to_hash
+      Hash[to_a]
+    end
+
+    # the headers store in array of pairs format
+    def to_a
+      Array(each)
+    end
+
+    # headers as string
+    def to_s
+      @headers.to_s
+    end
+
+    # this is internal API and doesn't abide to other public API
+    # guarantees, like downcasing strings.
+    # Please do not use this outside of core!
+    #
+    def key?(downcased_key)
+      @headers.key?(downcased_key)
+    end
+
+    # returns the values for the +field+ header in array format.
+    # This method is more internal, and for this reason doesn't try
+    # to "correct" the user input, i.e. it doesn't downcase the key.
+    #
+    def get(field)
+      @headers[field] || EMPTY
+    end
+
+    private
+
+    def array_value(value)
+      case value
+      when Array
+        value.map { |val| String(val) }
+      else
+        [String(value)]
+      end
+    end
+
+    def downcased(field)
+      String(field).downcase
+    end
+  end
+end