httpx 0.0.1

data/lib/httpx/selector.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+class HTTPX::Selector
+  #
+  # I/O monitor
+  #
+  class Monitor
+    attr_accessor :value, :interests, :readiness
+
+    def initialize(io, interests, reactor)
+      @io = io
+      @interests = interests
+      @reactor = reactor
+      @closed = false
+    end
+
+    def readable?
+      @interests == :rw || @interests == :r
+    end
+
+    def writable?
+      @interests == :rw || @interests == :w
+    end
+
+    # closes +@io+, deregisters from reactor (unless +deregister+ is false)
+    def close(deregister = true)
+      return if @closed
+      @closed = true
+      @reactor.deregister(@io) if deregister
+    end
+
+    def closed?
+      @closed
+    end
+
+    # :nocov:
+    def to_s
+      "#<#{self.class}: #{@io}(closed:#{@closed}) #{@interests} #{object_id.to_s(16)}>"
+    end
+    # :nocov:
+  end
+
+  def initialize
+    @readers = {}
+    @writers = {}
+    @lock = Mutex.new
+    @__r__, @__w__ = IO.pipe
+    @closed = false
+  end
+
+  def empty?
+    @readers.empty? && @writers.empty?
+  end
+
+  # deregisters +io+ from selectables.
+  def deregister(io)
+    @lock.synchronize do
+      rmonitor = @readers.delete(io)
+      wmonitor = @writers.delete(io)
+      monitor = rmonitor || wmonitor
+      monitor.close(false) if monitor
+    end
+  end
+
+  # register +io+ for +interests+ events.
+  def register(io, interests)
+    readable = interests == :r || interests == :rw
+    writable = interests == :w || interests == :rw
+    @lock.synchronize do
+      if readable
+        monitor = @readers[io]
+        if monitor
+          monitor.interests = interests
+        else
+          monitor = Monitor.new(io, interests, self)
+        end
+        @readers[io] = monitor
+        @writers.delete(io) unless writable
+      end
+      if writable
+        monitor = @writers[io]
+        if monitor
+          monitor.interests = interests
+        else
+          # reuse object
+          monitor = readable ? @readers[io] : Monitor.new(io, interests, self)
+        end
+        @writers[io] = monitor
+        @readers.delete(io) unless readable
+      end
+      monitor
+    end
+  end
+
+  # waits for read/write events for +interval+. Yields for monitors of
+  # selected IO objects.
+  #
+  def select(interval)
+    begin
+      r = nil
+      w = nil
+      @lock.synchronize do
+        r = @readers.keys
+        w = @writers.keys
+      end
+      r.unshift(@__r__)
+
+      readers, writers = IO.select(r, w, nil, interval)
+
+      raise HTTPX::TimeoutError, "timed out while waiting on select" if readers.nil? && writers.nil?
+    rescue IOError, SystemCallError
+      @lock.synchronize do
+        @readers.reject! { |io, _| io.closed? }
+        @writers.reject! { |io, _| io.closed? }
+      end
+      retry
+    end
+
+    readers.each do |io|
+      if io == @__r__
+        # clean up wakeups
+        @__r__.read(@__r__.stat.size)
+      else
+        monitor = io.closed? ? @readers.delete(io) : @readers[io]
+        next unless monitor
+        monitor.readiness = writers.delete(io) ? :rw : :r
+        yield monitor
+      end
+    end if readers
+
+    writers.each do |io|
+      monitor = io.closed? ? @writers.delete(io) : @writers[io]
+      next unless monitor
+      # don't double run this, the last iteration might have run this task already
+      monitor.readiness = :w
+      yield monitor
+    end if writers
+  end
+
+  # Closes the selector.
+  #
+  def close
+    return if @closed
+    @__r__.close
+    @__w__.close
+  rescue IOError
+  ensure
+    @closed = true
+  end
+
+  # interrupts the select call.
+  def wakeup
+    @__w__.write_nonblock("\0", exception: false)
+  end
+end

data/lib/httpx/timeout.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "timeout"
+
+module HTTPX
+  class Timeout
+    LOOP_TIMEOUT = 5
+
+    def self.new(opts = {})
+      return opts if opts.is_a?(Timeout)
+      super
+    end
+
+    def initialize(loop_timeout: 5, total_timeout: nil)
+      @loop_timeout = loop_timeout
+      @total_timeout = total_timeout
+      reset_counter
+    end
+
+    def timeout
+      @loop_timeout || @total_timeout
+    ensure
+      log_time
+    end
+
+    def ==(other)
+      if other.is_a?(Timeout)
+        @loop_timeout == other.instance_variable_get(:@loop_timeout) &&
+          @total_timeout == other.instance_variable_get(:@total_timeout)
+      else
+        super
+      end
+    end
+
+    def merge(other)
+      case other
+      when Hash
+        timeout = Timeout.new(other)
+        merge(timeout)
+      when Timeout
+        loop_timeout = other.instance_variable_get(:@loop_timeout) || @loop_timeout
+        total_timeout = other.instance_variable_get(:@total_timeout) || @total_timeout
+        Timeout.new(loop_timeout: loop_timeout, total_timeout: total_timeout)
+      else
+        raise ArgumentError, "can't merge with #{other.class}"
+      end
+    end
+
+    private
+
+    def reset_counter
+      @time_left = @total_timeout
+    end
+
+    def reset_timer
+      @started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+
+    def log_time
+      return unless @time_left
+      return reset_timer unless @started
+      @time_left -= (Process.clock_gettime(Process::CLOCK_MONOTONIC) - @started)
+      raise TimeoutError, "Timed out after #{@total_timeout} seconds" if @time_left <= 0
+
+      reset_timer
+    end
+  end
+end

data/lib/httpx/transcoder.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Transcoder
+    extend Registry
+  end
+end
+
+require "httpx/transcoder/body"
+require "httpx/transcoder/form"
+require "httpx/transcoder/json"
+require "httpx/transcoder/chunker"

data/lib/httpx/transcoder/body.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module HTTPX::Transcoder
+  module Body
+    module_function
+
+    class Encoder
+      extend Forwardable
+
+      def_delegator :@raw, :to_s
+
+      def initialize(body)
+        @raw = body
+      end
+
+      def bytesize
+        if @raw.respond_to?(:bytesize)
+          @raw.bytesize
+        elsif @raw.respond_to?(:to_ary)
+          @raw.map(&:bytesize).reduce(0, :+)
+        elsif @raw.respond_to?(:size)
+          @raw.size || Float::INFINITY
+        elsif @raw.respond_to?(:each)
+          Float::INFINITY
+        else
+          raise Error, "cannot determine size of body: #{@raw.inspect}"
+        end
+      end
+
+      def content_type
+        "application/octet-stream"
+      end
+
+      private
+
+      def respond_to_missing?(meth, *args)
+        @raw.respond_to?(meth, *args) || super
+      end
+
+      def method_missing(meth, *args, &block)
+        if @raw.respond_to?(meth)
+          @raw.__send__(meth, *args, &block)
+        else
+          super
+        end
+      end
+    end
+
+    def encode(body)
+      Encoder.new(body)
+    end
+  end
+  register "body", Body
+end

data/lib/httpx/transcoder/chunker.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module HTTPX::Transcoder
+  module Chunker
+    module_function
+
+    class Encoder
+      extend Forwardable
+
+      def_delegator :@raw, :readpartial
+
+      CRLF = "\r\n"
+
+      def initialize(body)
+        @raw = body
+      end
+
+      def each
+        return enum_for(__method__) unless block_given?
+        @raw.each do |chunk|
+          yield "#{chunk.bytesize.to_s(16)}#{CRLF}#{chunk}#{CRLF}"
+        end
+        yield "0#{CRLF}#{CRLF}"
+      end
+
+      def respond_to_missing?(meth, *args)
+        @raw.respond_to?(meth, *args) || super
+      end
+    end
+
+    def encode(chunks)
+      Encoder.new(chunks)
+    end
+  end
+  register "chunker", Chunker
+end

data/lib/httpx/transcoder/form.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "forwardable"
+require "http/form_data"
+
+module HTTPX::Transcoder
+  module Form
+    module_function
+
+    class Encoder
+      extend Forwardable
+
+      def_delegator :@raw, :content_type
+
+      def_delegator :@raw, :to_s
+
+      def_delegator :@raw, :read
+
+      def initialize(form)
+        @raw = HTTP::FormData.create(form)
+      end
+
+      def bytesize
+        @raw.content_length
+      end
+
+      def force_encoding(*args)
+        @raw.to_s.force_encoding(*args)
+      end
+
+      def to_str
+        @raw.to_s
+      end
+    end
+
+    def encode(form)
+      Encoder.new(form)
+    end
+  end
+  register "form", Form
+end

data/lib/httpx/transcoder/json.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "forwardable"
+require "json"
+
+module HTTPX::Transcoder
+  module JSON
+    module_function
+
+    class Encoder
+      extend Forwardable
+
+      def_delegator :@raw, :to_str
+
+      def_delegator :@raw, :to_s
+
+      def_delegator :@raw, :bytesize
+
+      def_delegator :@raw, :force_encoding
+
+      def initialize(json)
+        @raw = ::JSON.dump(json)
+        @charset = @raw.encoding.name.downcase
+      end
+
+      def content_type
+        "application/json; charset=#{@charset}"
+      end
+    end
+
+    def encode(json)
+      Encoder.new(json)
+    end
+  end
+  register "json", JSON
+end

data/lib/httpx/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module HTTPX
+  VERSION = "0.0.1"
+end

metadata

@@ -0,0 +1,150 @@
+--- !ruby/object:Gem::Specification
+name: httpx
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Tiago Cardoso
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-02-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: http-2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+- !ruby/object:Gem::Dependency
+  name: http-form_data
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: http_parser.rb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+- !ruby/object:Gem::Dependency
+  name: http-cookie
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: A client library for making HTTP requests from Ruby.
+email:
+- cardoso_tiago@hotmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/httpx.rb
+- lib/httpx/buffer.rb
+- lib/httpx/callbacks.rb
+- lib/httpx/chainable.rb
+- lib/httpx/channel.rb
+- lib/httpx/channel/http1.rb
+- lib/httpx/channel/http2.rb
+- lib/httpx/client.rb
+- lib/httpx/connection.rb
+- lib/httpx/errors.rb
+- lib/httpx/extensions.rb
+- lib/httpx/headers.rb
+- lib/httpx/io.rb
+- lib/httpx/loggable.rb
+- lib/httpx/options.rb
+- lib/httpx/plugins/authentication.rb
+- lib/httpx/plugins/basic_authentication.rb
+- lib/httpx/plugins/compression.rb
+- lib/httpx/plugins/compression/brotli.rb
+- lib/httpx/plugins/compression/deflate.rb
+- lib/httpx/plugins/compression/gzip.rb
+- lib/httpx/plugins/cookies.rb
+- lib/httpx/plugins/digest_authentication.rb
+- lib/httpx/plugins/follow_redirects.rb
+- lib/httpx/plugins/h2c.rb
+- lib/httpx/plugins/proxy.rb
+- lib/httpx/plugins/proxy/http.rb
+- lib/httpx/plugins/proxy/socks4.rb
+- lib/httpx/plugins/proxy/socks5.rb
+- lib/httpx/plugins/push_promise.rb
+- lib/httpx/plugins/stream.rb
+- lib/httpx/registry.rb
+- lib/httpx/request.rb
+- lib/httpx/response.rb
+- lib/httpx/selector.rb
+- lib/httpx/timeout.rb
+- lib/httpx/transcoder.rb
+- lib/httpx/transcoder/body.rb
+- lib/httpx/transcoder/chunker.rb
+- lib/httpx/transcoder/form.rb
+- lib/httpx/transcoder/json.rb
+- lib/httpx/version.rb
+homepage: https://gitlab.com/honeyryderchuck/httpx
+licenses:
+- Apache 2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: HTTPX, to the future, and beyond
+test_files: []