mint_http 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: '091443e652f456b8bd3d867b48379610f5a0405272158921c8e92f7885483aa4'
+  data.tar.gz: 42b042095a6a3bad22c22d5cc4da0b004463b9e5a30918701a837ee480e46a80
+SHA512:
+  metadata.gz: fe2c2aa2bb1984f361d8cc695a5e2e26cfa3d4b1479d746ec4ccd2ae2f8c1df765a11280796cf81b8812d1b6fa68cccd789b432c0c0d26226c88b8877d4cff97
+  data.tar.gz: 9e58beac30df8cb862ce02440c2132fc88f24da196e703219443959d668e5715a24a29e5dfd9b311ebcf7c4ec3dd3f02664473f18042942c8edd814c800a845e

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2023-07-03
+
+- Initial release

data/Gemfile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in mint_http.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+gem "minitest", "~> 5.0"

data/Gemfile.lock

@@ -0,0 +1,34 @@
+PATH
+  remote: .
+  specs:
+    mint_http (0.1.0)
+      base64
+      json
+      net-http
+      openssl
+      uri
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    base64 (0.1.0)
+    ipaddr (1.2.4)
+    json (2.6.2)
+    minitest (5.18.0)
+    net-http (0.3.2)
+      uri
+    openssl (2.2.2)
+      ipaddr
+    rake (13.0.6)
+    uri (0.12.1)
+
+PLATFORMS
+  arm64-darwin-22
+
+DEPENDENCIES
+  minitest (~> 5.0)
+  mint_http!
+  rake (~> 13.0)
+
+BUNDLED WITH
+   2.2.33

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023 Ali Alhoshaiyan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,218 @@
+# MintHttp
+
+A simple and fluent HTTP client with connection pooling capability.
+
+MintHttp is built on top of Ruby's Net::HTTP library to provide you with the following features:
+
+- Fluent API to build requests
+- HTTP proxies support
+- Client certificate support
+- File uploads
+- Connection pooling
+- No DSLs or any other shenanigans
+
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+    $ bundle add mint_http
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+    $ gem install mint_http
+
+
+## Basic Usage
+
+Once you have installed the gem, require it into your Ruby code with:
+
+```ruby
+require 'mint_http'
+```
+
+Now perform a basic HTTP request:
+
+```ruby
+puts MintHttp.query(foo: 'bar').get('https://icanhazip.com').body
+```
+
+Note: when performing a request with MintHttp, you will get a [MintHttp::Response](/lib/mint_http/response.rb).
+
+
+## Post Requests
+
+MintHttp makes it easy to consume and interact with JSON APIs. You can simply make a post request as follows:
+
+```ruby
+MintHttp
+  .as_json
+  .accept_json
+  .post('https://dummyjson.com/products/add', {
+    title: 'Porsche Wallet'
+  })
+```
+
+The `as_json` and `accept_json` helper methods sets `Content-Type` and `Accept` headers to `application/json`. The above
+call can be re-written as:
+
+```ruby
+MintHttp
+  .header('Content-Type' => 'application/json')
+  .header('Accept' => 'application/json')
+  .post('https://dummyjson.com/products/add', {
+    title: 'Porsche Wallet'
+  })
+```
+
+Note: When no content type is set, `application/json` is set by default.
+
+
+## Put Requests
+
+Like a post request, you can easily make a `PUT` request as follows:
+
+```ruby
+MintHttp.put('https://dummyjson.com/products/1', {
+  title: 'Porsche Wallet'
+})
+```
+
+or make a `PATCH` request
+
+```ruby
+MintHttp.patch('https://dummyjson.com/products/1', {
+  title: 'Porsche Wallet'
+})
+```
+
+
+## Delete Requests
+
+To delete some resource, you can easily call:
+
+```ruby
+MintHttp.delete('https://dummyjson.com/products/1')
+```
+
+
+## Uploading Files
+
+MintHttp makes good use of the powerful Net::HTTP library to allow you to upload files:
+
+```ruby
+MintHttp
+  .as_multipart
+  .with_file('upload_field', File.open('/tmp/file.txt'), 'grocery-list.txt', 'text/plain')
+  .post('https://example.com/upload')
+```
+
+Note: `as_multipart` is required in order to upload files, this will set the content type to `multipart/form-data`.
+
+
+## Authentication
+
+MintHttp provides you with little helpers for common authentication schemes
+
+### Basic Auth
+
+```ruby
+MintHttp
+  .basic_auth('username', 'password')
+  .get('https://example.com/secret-door')
+``` 
+
+
+### Bearer Auth
+
+```ruby
+MintHttp
+  .bearer('super-string-token')
+  .get('https://example.com/secret-door')
+``` 
+
+
+## Using a Proxy
+
+Connecting through an HTTP proxy is as simple as chaining the following call:
+
+```ruby
+MintHttp
+  .via_proxy('proxy.example.com', 3128, 'optional-username', 'optional-password')
+  .get('https://icanhazip.com')
+``` 
+
+
+## Pooling Connections
+
+When your application is communicating with external services so often, it is a good idea to keep a couple of connections
+open if the target server supports that, this can save you time that is usually gone by TCP and TLS handshakes. This
+is especially true when the target server is in a faraway geographical region.
+
+MintHttp uses a pool to manage connections and make sure each connection is used by a single thread at a time. To create
+a pool, simply do the following:
+
+```ruby
+pool = MintHttp::Pool.new({
+  ttl: 30_000,
+  idle_ttl: 10_000,
+  size: 10,
+  usage_limit: 500,
+  timeout: 500,
+})
+```
+
+This will create a new pool with the following properties:
+
+- Allow a connection to be open for a maximum of 30 seconds defined by `ttl`.
+- If a connection is not used within 10 seconds of the last use then it is considered expired, defined by `idle_ttl`.
+- Only hold a maximum of 10 connections, if an 11th thread tries to acquire a connection, it will block until there is one available or timeout is reached.
+- A connection may be only used for 500 requests, then it should be closed. This is defined by `usage_limit`.
+
+Once you have created a pool, you can use it in your requests as following:
+
+```ruby
+MintHttp
+  .use_pool(pool)
+  .get('https://example.com')
+```
+
+A single pool can be used for multiple endpoints, as MintHttp will logically separate connections based on hostname, port,
+scheme, client certificate, proxy, and other variables.
+
+> Note: it is possible to use only a single pool for the entire application.
+
+> Note: The Pool object is thread-safe
+
+
+## The Response Object
+
+Each HTTP request will return a [response](/lib/mint_http/response.rb) object when a response is received from the server regardless of the status code.
+
+You can chain the `raise!` call after the request to make MintHttp throw an exception when a `4xx` ot `5xx` error is returned.
+Otherwise the same response object is returned. 
+
+```ruby
+MintHttp.get('https://example.com').raise!
+```
+
+
+## Missing Features
+
+There are a couple of features that are coming soon, these include:
+
+- Retrying Requests
+- Middlewares
+
+
+## Credit
+
+This library was inspired by Laravel's `Http` wrapper over `GuzzleHttp`.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/ahoshaiyan/mint_http.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/test_*.rb"]
+end
+
+task default: :test

data/lib/mint_http/errors/authentication_error.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class MintHttp::AuthenticationError < MintHttp::ClientError
+end

data/lib/mint_http/errors/authorization_error.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class MintHttp::AuthorizationError < MintHttp::ClientError
+end

data/lib/mint_http/errors/client_error.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class MintHttp::ClientError < MintHttp::ResponseError
+end

data/lib/mint_http/errors/not_found_error.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class MintHttp::NotFoundError < MintHttp::ClientError
+end

data/lib/mint_http/errors/response_error.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class MintHttp::ResponseError < StandardError
+  # @return [HTTP::Response]
+  attr_reader :response
+
+  def initialize(msg, response)
+    super(msg)
+    @response = response
+  end
+
+  def to_s
+    response.inspect
+  end
+end

data/lib/mint_http/errors/server_error.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class MintHttp::ServerError < MintHttp::ResponseError
+end

data/lib/mint_http/headers.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class MintHttp::Headers < Hash
+  def [](key)
+    super(key.downcase)
+  end
+
+  def []=(key, value)
+    super(key.downcase, value)
+  end
+end

data/lib/mint_http/net_http_factory.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+class MintHttp::NetHttpFactory
+  def defaults(options = {})
+    options[:open_timeout] = options[:open_timeout] || 5
+    options[:write_timeout] = options[:write_timeout] || 5
+    options[:read_timeout] = options[:read_timeout] || 20
+    options[:ssl_timeout] = options[:ssl_timeout] || 5
+    options[:verify_mode] = options[:verify_mode] || OpenSSL::SSL::VERIFY_PEER
+    options[:verify_hostname] = options[:verify_hostname] || true
+    options
+  end
+
+  def client_namespace(hostname, port, options = {})
+    options = defaults(options)
+
+    host_group = "#{hostname.downcase}_#{port.to_s.downcase}"
+    proxy_group = "#{options[:proxy_address]}_#{options[:proxy_port]}_#{options[:proxy_user]}"
+    timeout_group = "#{options[:open_timeout]}_#{options[:write_timeout]}_#{options[:read_timeout]}"
+
+    cert_signature = options[:cert]&.serial&.to_s
+    key_signature = OpenSSL::Digest::SHA1.new(options[:key]&.to_der || '').to_s
+    ssl_group = "#{options[:use_ssl]}_#{options[:ssl_timeout]}_#{options[:ca_file]}_#{cert_signature}_#{key_signature}_#{options[:verify_mode]}_#{options[:verify_hostname]}"
+
+    "#{host_group}_#{proxy_group}_#{timeout_group}_#{ssl_group}"
+  end
+
+  # Available options:
+  # proxy_address
+  # proxy_port
+  # proxy_user
+  # proxy_pass
+  # open_timeout
+  # write_timeout
+  # read_timeout
+  # ssl_timeout
+  # ca_file
+  # cert
+  # key
+  # verify_mode
+  # verify_hostname
+  def make_client(hostname, port, options = {})
+    options = defaults(options)
+
+    net_http = Net::HTTP.new(hostname, port, nil)
+
+    # Disable retries
+    net_http.max_retries = 0
+
+    # Set proxy options
+    net_http.proxy_address = options[:proxy_address]
+    net_http.proxy_port = options[:proxy_port]
+    net_http.proxy_user = options[:proxy_user]
+    net_http.proxy_pass = options[:proxy_pass]
+
+    # Timeout
+    net_http.open_timeout = options[:open_timeout]
+    net_http.write_timeout = options[:write_timeout]
+    net_http.read_timeout = options[:read_timeout]
+
+    # SSL options
+    net_http.use_ssl = options[:use_ssl]
+    net_http.ssl_timeout = options[:ssl_timeout]
+    net_http.cert = options[:cert]
+    net_http.key = options[:key]
+    net_http.verify_mode = options[:verify_mode]
+    net_http.verify_hostname = options[:verify_hostname]
+
+    if OpenSSL::X509::Store === options[:ca]
+      net_http.cert_store = options[:ca]
+    else
+      net_http.ca_file = options[:ca]
+    end
+
+    net_http
+  end
+end

data/lib/mint_http/pool.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+class MintHttp::Pool
+  attr_reader :ttl
+  attr_reader :idle_ttl
+  attr_reader :timeout
+  attr_reader :size
+  attr_reader :usage_limit
+
+  def initialize(options = {})
+    @mutex = Mutex.new
+
+    @ttl = options[:ttl] || 10000
+    @idle_ttl = options[:idle_ttl] || 5000
+    @timeout = options[:timeout] || 5000
+
+    @size = options[:size] || 10
+    @usage_limit = options[:usage_limit] || 100
+
+    @pool = []
+  end
+
+  def net_factory
+    @net_factory ||= MintHttp::NetHttpFactory.new
+  end
+
+  def acquire(hostname, port, options = {})
+    namespace = net_factory.client_namespace(hostname, port, options)
+    deadline = time_ms + @timeout
+
+    while time_ms < deadline
+      @mutex.synchronize do
+        if (entry = @pool.find { |e| e.namespace == namespace && e.available? })
+          entry.acquire!
+          return entry.client
+        end
+
+        if @pool.length > 0 && @pool.all? { |e| e.to_clean? }
+          clean_pool_unsafe!
+        end
+
+        if @pool.length < @size
+          client = net_factory.make_client(hostname, port, options)
+          entry = append(client, namespace)
+          entry.acquire!
+          return entry.client
+        end
+      end
+
+      sleep_time = (deadline - time_ms) / 2
+      sleep_time = [sleep_time, 100].max
+      sleep_time = sleep_time / 1000.0
+
+      sleep(sleep_time)
+    end
+
+    raise RuntimeError, "Cannot acquire lock after #{@timeout}ms."
+  end
+
+  def release(client)
+    raise ArgumentError, 'An client is required to be released.' unless client
+
+    @mutex.synchronize do
+      if (entry = @pool.find { |e| e.matches?(client) })
+        entry.release!
+      end
+
+      clean_pool_unsafe!
+    end
+  end
+
+  private
+
+  def append(client, namespace)
+    if @pool.any? { |e| e.matches?(client) }
+      raise RuntimeError, "client with id ##{client.object_id} already exists in the pool."
+    end
+
+    @pool << (entry = MintHttp::PoolEntry.new(self, client, namespace))
+    entry
+  end
+
+  def time_ms
+    Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond)
+  end
+
+  def elapsed(beginning)
+    time_ms - beginning
+  end
+
+  def clean_pool_unsafe!
+    to_clean = []
+
+    @pool.delete_if do |e|
+      to_clean << e if (should_clean = e.to_clean?)
+      should_clean
+    end
+
+    to_clean.each do |e|
+      e.client.finish rescue nil
+    end
+  end
+
+  def clean_pool!
+    @mutex.synchronize do
+      clean_pool_unsafe!
+    end
+  end
+end

data/lib/mint_http/pool_entry.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+class MintHttp::PoolEntry
+  attr_reader :client
+  attr_reader :namespace
+  attr_reader :acquired
+  attr_reader :last_used
+  attr_reader :usage
+  attr_reader :unhealthy
+
+  def initialize(pool, client, namespace)
+    @pool = pool
+    @client = client
+    @namespace = namespace
+    @acquired = false
+    @birth_time = time_ms
+    @last_used = time_ms
+    @usage = 0
+    @unhealthy = false
+  end
+
+  def matches?(other)
+    @client.object_id == other.object_id
+  end
+
+  def ttl_reached?
+    (time_ms - @birth_time) > @pool.ttl
+  end
+
+  def idle_ttl_reached?
+    (time_ms - @last_used) > @pool.idle_ttl
+  end
+
+  def usage_reached?
+    @usage >= @pool.usage_limit
+  end
+
+  def expired?
+    idle_ttl_reached? || ttl_reached? || usage_reached?
+  end
+
+  def acquire!
+    @acquired = true
+    @last_used = time_ms
+    @usage += 1
+  end
+
+  def release!
+    @acquired = false
+  end
+
+  def available?
+    !@acquired && !expired? && !@unhealthy
+  end
+
+  def healthy?
+    # TODO: add health check
+    healthy = true
+    @unhealthy = !healthy
+    healthy
+  end
+
+  def to_clean?
+    (expired? || @unhealthy) && !@acquired
+  end
+
+  private
+
+  def time_ms
+    Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond)
+  end
+end

data/lib/mint_http/request.rb

@@ -0,0 +1,322 @@
+# frozen_string_literal: true
+
+require 'base64'
+require 'net/http'
+require 'uri'
+require 'openssl'
+require 'json'
+
+module MintHttp
+  class Request
+    attr_reader :base_url
+    attr_reader :headers
+    attr_reader :body_type
+    attr_reader :body
+    attr_reader :query
+    attr_reader :open_timeout
+    attr_reader :write_timeout
+    attr_reader :read_timeout
+    attr_reader :ca
+    attr_reader :cert
+    attr_reader :proxy_address
+    attr_reader :proxy_port
+
+    def initialize
+      @pool = nil
+      @base_url = nil
+      @headers = {}
+      @body_type = nil
+      @body = nil
+      @query = {}
+      @files = []
+      @open_timeout = 5
+      @write_timeout = 5
+      @read_timeout = 20
+      @ca = nil
+      @cert = nil
+      @key = nil
+      @proxy_address = nil
+      @proxy_port = nil
+      @proxy_user = nil
+      @proxy_pass = nil
+
+      header('User-Agent' => 'Mint Http')
+      as_json
+    end
+
+    def use_pool(pool)
+      raise ArgumentError, 'Expected a MintHttp::Pool' unless Pool === pool
+
+      @pool = pool
+      self
+    end
+
+    def timeout(open, write, read)
+      @open_timeout = open
+      @write_timeout = write
+      @read_timeout = read
+    end
+
+    def base_url(url)
+      @base_url = URI.parse(url)
+      self
+    end
+
+    def use_ca(ca)
+      @ca = ca
+      self
+    end
+
+    def use_cert(cert, key)
+      unless OpenSSL::X509::Certificate === cert
+        raise ArgumentError, 'Expected an OpenSSL::X509::Certificate'
+      end
+
+      unless OpenSSL::PKey::PKey === key
+        raise ArgumentError, 'Expected an OpenSSL::PKey::PKey'
+      end
+
+      @cert = cert
+      @key = key
+
+      self
+    end
+
+    def via_proxy(proxy_address, proxy_port = 3128, proxy_user = nil, proxy_pass = nil)
+      @proxy_address = proxy_address
+      @proxy_port = proxy_port
+      @proxy_user = proxy_user
+      @proxy_pass = proxy_pass
+
+      self
+    end
+
+    def query(queries = {})
+      queries.each do |k, v|
+        k = k.to_s
+
+        if v.nil?
+          @query.delete(k)
+          next
+        end
+
+        @query[k] = v.to_s
+      end
+
+      self
+    end
+
+    def header(headers = {})
+      headers.each do |k, v|
+        k = k.downcase.to_s
+
+        if v.nil?
+          @headers.delete(k)
+          next
+        end
+
+        v = v.join(' ;') if Array === v
+        @headers[k] = v
+      end
+
+      self
+    end
+
+    def basic_auth(username, password = '')
+      header('Authorization' => 'Basic ' + Base64.strict_encode64("#{username}:#{password}"))
+    end
+
+    def token_auth(type, token)
+      header('Authorization' => "#{type} #{token}")
+    end
+
+    def bearer(token)
+      token_auth('Bearer', token)
+    end
+
+    def accept(type)
+      header('Accept' => type)
+    end
+
+    def accept_json
+      accept('application/json')
+    end
+
+    def content_type(type)
+      header('Content-Type' => type)
+    end
+
+    def with_body(raw)
+      @body_type = :raw
+      @body = raw
+      content_type(nil)
+      self
+    end
+
+    def as_json
+      @body_type = :json
+      content_type('application/json')
+    end
+
+    def as_form
+      @body_type = :form
+      content_type('application/x-www-form-urlencoded')
+    end
+
+    def as_multipart
+      @body_type = :multipart
+      content_type('multipart/form-data')
+    end
+
+    def with_file(name, file, filename = nil, content_type = nil)
+      unless file.respond_to?(:read)
+        raise ArgumentError, "File must be an IO or IO like"
+      end
+
+      @files << [
+        name,
+        file,
+        { filename: filename, content_type: content_type }.compact
+      ]
+
+      self
+    end
+
+    def get(url, params = {})
+      query(params).send_request('get', url)
+    end
+
+    def head(url, params = {})
+      query(params).send_request('head', url)
+    end
+
+    def post(url, data = nil)
+      @body = data if data
+      send_request('post', url)
+    end
+
+    def put(url, data = nil)
+      @body = data if data
+      send_request('put', url)
+    end
+
+    def patch(url, data = nil)
+      @body = data if data
+      send_request('patch', url)
+    end
+
+    def delete(url, data = nil)
+      @body = data if data
+      send_request('delete', url)
+    end
+
+    def send_request(method, url)
+      url, net_request, options = build_request(method, url)
+
+      res = with_client(url.hostname, url.port, options) do |http|
+        http.request(net_request)
+      end
+
+      Response.new(res)
+    end
+
+    private
+
+    def build_request(method, url)
+      url = URI.parse(url)
+      url = @base_url + url if @base_url
+
+      unless %w[http https].include?(url.scheme)
+        raise ArgumentError, "Only HTTP and HTTPS URLs are allowed"
+      end
+
+      url.query = URI.encode_www_form(@query)
+
+      net_request = case method.to_s
+        when 'get'
+          @body_type = nil
+          Net::HTTP::Get.new(url)
+        when 'head'
+          @body_type = nil
+          Net::HTTP::Head.new(url)
+        when 'post'
+          Net::HTTP::Post.new(url)
+        when 'put'
+          Net::HTTP::Put.new(url)
+        when 'patch'
+          Net::HTTP::Patch.new(url)
+        when 'delete'
+          Net::HTTP::Delete.new(url)
+        else
+          raise ArgumentError, "Unsupported HTTP method #{method}"
+      end
+
+      # add body
+      case @body_type
+        when nil
+          # Ignore body
+        when :raw
+          net_request.body = @body
+        when :json
+          net_request.body = @body.to_json if @body
+        when :form
+          net_request.body = URI.encode_www_form(@body) if @body
+        when :multipart
+          params = []
+          params.concat(@body.map { |k, v| [k.to_s, v.to_s] }) if Hash === @body
+          params.concat(@files)
+          net_request.set_form(params, 'multipart/form-data')
+        else
+          raise ArgumentError, "Invalid body type #{@body_type}"
+      end
+
+      # add headers
+      @headers.each do |k, v|
+        net_request.send(:set_field, k, v)
+      end
+
+      options = {
+        use_ssl: url.scheme == 'https',
+        open_timeout: @open_timeout,
+        write_timeout: @write_timeout,
+        read_timeout: @read_timeout,
+        ca: @ca,
+        cert: @cert,
+        key: @key,
+        proxy_address: @proxy_address,
+        proxy_port: @proxy_port,
+        proxy_user: @proxy_user,
+        proxy_pass: @proxy_pass,
+      }
+
+      [url, net_request, options]
+    end
+
+    def with_client(hostname, port, options = {})
+      raise ArgumentError, 'Block is required' unless block_given?
+
+      # Get client from pool
+      net_http = @pool&.acquire(hostname, port, options)
+
+      # make a new client if there is no pool
+      unless net_http
+        net_http = net_factory.make_client(hostname, port, options)
+      end
+
+      begin
+        net_http.start unless net_http.started?
+        yield(net_http)
+      ensure
+        if @pool
+          @pool.release(net_http)
+        else
+          net_http.finish
+        end
+      end
+    end
+
+    def net_factory
+      @net_factory ||= NetHttpFactory.new
+    end
+  end
+end

data/lib/mint_http/response.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module MintHttp
+  class Response
+    attr_reader :net_response
+    attr_reader :version
+    attr_reader :status_code
+    attr_reader :status_text
+    attr_reader :headers
+
+    def initialize(net_response)
+      @net_response = net_response
+      @version = net_response.http_version
+      @status_code = net_response.code.to_i
+      @status_text = net_response.message
+      @headers = Headers.new.merge(net_response.each_header.to_h)
+    end
+
+    def success?
+      (200..299).include?(@status_code)
+    end
+
+    def redirect?
+      (300..399).include?(@status_code)
+    end
+
+    def client_error?
+      (400..499).include?(@status_code)
+    end
+
+    def unauthenticated?
+      @status_code == 401
+    end
+
+    def unauthorized?
+      @status_code == 403
+    end
+
+    def not_found?
+      @status_code == 404
+    end
+
+    def server_error?
+      (500..599).include?(@status_code)
+    end
+
+    def raise!
+      case @status_code
+        when 401
+          raise Errors::AuthenticationError.new('Unauthenticated', self)
+        when 403
+          raise Errors::AuthorizationError.new('Forbidden', self)
+        when 404
+          raise Errors::NotFoundError.new('Not Found', self)
+        when 400..499
+          raise Errors::ClientError.new('Client Error', self)
+        when 500..599
+          raise Errors::ClientError.new('Server Error', self)
+        else
+          self
+      end
+    end
+
+    def body
+      net_response.body
+    end
+
+    def json
+      @json ||= JSON.parse(body)
+    end
+
+    def inspect
+      "#<#{self.class}/#{@version} #{@status_code} #{@status_text} #{@headers.inspect}>"
+    end
+  end
+end

data/lib/mint_http/version.rb

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

data/lib/mint_http.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative 'mint_http/version'
+require_relative 'mint_http/pool_entry'
+require_relative 'mint_http/pool'
+require_relative 'mint_http/headers'
+require_relative 'mint_http/errors/response_error'
+require_relative 'mint_http/errors/server_error'
+require_relative 'mint_http/errors/client_error'
+require_relative 'mint_http/errors/authorization_error'
+require_relative 'mint_http/errors/authentication_error'
+require_relative 'mint_http/errors/not_found_error'
+require_relative 'mint_http/net_http_factory'
+require_relative 'mint_http/response'
+require_relative 'mint_http/request'
+
+module MintHttp
+  class << self
+    # @return [::MintHttp::Request]
+    def method_missing(method, *args)
+      request = Request.new
+      request.send(method, *args)
+    end
+  end
+end

data/sig/mint_http.rbs

@@ -0,0 +1,4 @@
+module MintHttp
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,137 @@
+--- !ruby/object:Gem::Specification
+name: mint_http
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ali Alhoshaiyan
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2023-07-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: net-http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: openssl
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: uri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: base64
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Like a mint breeze, MintHttp allows you to write simple HTTP requests
+  while giving you the full power of Net::HTTP.
+email:
+- ahoshaiyan@fastmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/mint_http.rb
+- lib/mint_http/errors/authentication_error.rb
+- lib/mint_http/errors/authorization_error.rb
+- lib/mint_http/errors/client_error.rb
+- lib/mint_http/errors/not_found_error.rb
+- lib/mint_http/errors/response_error.rb
+- lib/mint_http/errors/server_error.rb
+- lib/mint_http/headers.rb
+- lib/mint_http/net_http_factory.rb
+- lib/mint_http/pool.rb
+- lib/mint_http/pool_entry.rb
+- lib/mint_http/request.rb
+- lib/mint_http/response.rb
+- lib/mint_http/version.rb
+- sig/mint_http.rbs
+homepage: https://github.com/ahoshaiyan/mint_http
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/ahoshaiyan/mint_http
+  source_code_uri: https://github.com/ahoshaiyan/mint_http
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.6
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.33
+signing_key:
+specification_version: 4
+summary: A small fluent HTTP client.
+test_files: []