requests_ruby 1.0.0

data/lib/requests/adapters.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'openssl'
+require 'uri'
+require 'zlib'
+require 'stringio'
+
+module Requests
+  class HTTPAdapter
+    METHS = {
+      'GET' => Net::HTTP::Get,
+      'POST' => Net::HTTP::Post,
+      'PUT' => Net::HTTP::Put,
+      'PATCH' => Net::HTTP::Patch,
+      'DELETE' => Net::HTTP::Delete,
+      'HEAD' => Net::HTTP::Head,
+      'OPTIONS' => Net::HTTP::Options}.freeze
+    attr_accessor :max_retries, :backoff_factor
+    def initialize(max_retries: 0, backoff_factor: 0)
+      @max_retries = max_retries
+      @backoff_factor = backoff_factor
+    end
+    def send_once(meth, url, hdrs, body, timeout, proxies, verify, cert, auth)
+      attempt = 0
+      begin
+        do_send(meth, url, hdrs, body, timeout, proxies, verify, cert, auth)
+      rescue Requests::ConnectionError, Requests::ConnectTimeout => e
+        attempt += 1
+        if attempt <= @max_retries && idempotent?(meth)
+          sleep(@backoff_factor * attempt) if @backoff_factor.to_f > 0
+          retry
+        end
+        raise e
+      end
+    end
+    def decode_body(net_resp)
+      raw = net_resp.body
+      return '' if raw.nil?
+      case net_resp['content-encoding'].to_s.downcase
+      when 'gzip', 'x-gzip'
+        Zlib::GzipReader.new(StringIO.new(raw)).read
+      when 'deflate'
+        begin
+          Zlib::Inflate.inflate(raw)
+        rescue Zlib::DataError
+          Zlib::Inflate.new(-Zlib::MAX_WBITS).inflate(raw)
+        end
+      else
+        raw
+      end
+    rescue Zlib::Error => e
+      raise Requests::ContentDecodingError, "couldn't decode response body: #{e.message}"
+    end
+    private
+    def idempotent?(meth)
+      %w[GET HEAD OPTIONS PUT DELETE].include?(meth.to_s.upcase)
+    end
+    def do_send(meth, url, hdrs, body, timeout, proxies, verify, cert, auth)
+      u = URI.parse(url)
+      auth.call(hdrs) if auth.respond_to?(:call) && !auth.is_a?(Requests::DigestAuth)
+      popt = proxy_opts(u, proxies)
+      open_t, read_t = split_timeout(timeout)
+      http = Net::HTTP.new(u.host, u.port, *popt)
+      configure_ssl(http, u, verify, cert)
+      http.open_timeout = open_t if open_t
+      http.read_timeout = read_t if read_t
+      begin
+        http.start do |h|
+          klass = METHS[meth] || Net::HTTP::Get
+          req = klass.new(u.request_uri)
+          hdrs.each { |k, v| req[k] = v }
+          req.body = body if body
+          h.request(req)
+        end
+      rescue Net::OpenTimeout
+        raise Requests::ConnectTimeout, "connect timeout: #{url}"
+      rescue Net::ReadTimeout
+        raise Requests::ReadTimeout, "read timeout: #{url}"
+      rescue OpenSSL::SSL::SSLError => e
+        raise Requests::SSLError, e.message
+      rescue SocketError, Errno::ECONNREFUSED, Errno::EHOSTUNREACH, Errno::ETIMEDOUT, Errno::ECONNRESET => e
+        raise Requests::ConnectionError, e.message
+      end
+    end
+    def configure_ssl(http, uri, verify, cert)
+      return unless uri.scheme == 'https'
+      http.use_ssl = true
+      if verify == false
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      else
+        http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        http.ca_file = verify.is_a?(String) ? verify : Requests::CA_FILE
+      end
+      return unless cert
+      http.cert = OpenSSL::X509::Certificate.new(File.read(cert[0]))
+      http.key = OpenSSL::PKey::RSA.new(File.read(cert[1]))
+    end
+    def proxy_opts(uri, proxies)
+      return [] unless proxies && !proxies.empty?
+      proxy_url = proxies[uri.scheme] || proxies[uri.scheme.to_sym]
+      return [] unless proxy_url
+      pu = URI.parse(proxy_url)
+      [pu.host, pu.port, pu.user, pu.password]
+    end
+    def split_timeout(t)
+      case t
+      when nil then [nil, nil]
+      when Array then [t[0], t[1]]
+      else [t, t]
+      end
+    end
+  end
+end

data/lib/requests/api.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Requests
+  def self.request(method, url, **kw)
+    Session.new.request(method, url, **kw)
+  end
+  def self.get(url, **kw); request('GET', url, **kw); end
+  def self.post(url, **kw); request('POST', url, **kw); end
+  def self.put(url, **kw); request('PUT', url, **kw); end
+  def self.patch(url, **kw); request('PATCH', url, **kw); end
+  def self.delete(url, **kw); request('DELETE', url, **kw); end
+  def self.options(url, **kw); request('OPTIONS', url, **kw); end
+  def self.head(url, **kw)
+    kw[:allow_redirects] = kw.fetch(:allow_redirects, false)
+    request('HEAD', url, **kw)
+  end
+  def self.session
+    Session.new
+  end
+  def self.download(url, to:, **kw)
+    resp = get(url, **kw)
+    resp.raise_for_status
+    resp.save_to(to)
+  end
+end

data/lib/requests/auth.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'base64'
+require 'digest/md5'
+require 'securerandom'
+
+module Requests
+  module AuthBase
+    def call(_headers)
+      raise NotImplementedError, 'subclass must implement #call'
+    end
+  end
+  class BasicAuth
+    include AuthBase
+    def initialize(user, pass)
+      @user = user
+      @pass = pass
+    end
+    def call(hdrs)
+      hdrs['Authorization'] = 'Basic ' + Base64.strict_encode64("#{@user}:#{@pass}")
+    end
+  end
+  class BearerAuth
+    include AuthBase
+    def initialize(token)
+      @token = token
+    end
+    def call(hdrs)
+      hdrs['Authorization'] = "Bearer #{@token}"
+    end
+  end
+  class DigestAuth
+    include AuthBase
+    def initialize(user, pass)
+      @user = user
+      @pass = pass
+    end
+    def call(hdrs, meth: nil, url: nil, prev_resp: nil)
+      return unless prev_resp
+      wa = prev_resp.headers['www-authenticate']
+      return unless wa && wa =~ /\ADigest/
+      pr = parse_challenge(wa)
+      realm  = pr['realm']
+      nonce  = pr['nonce']
+      qop    = pr['qop']
+      path   = URI.parse(url).request_uri
+      ha1 = Digest::MD5.hexdigest("#{@user}:#{realm}:#{@pass}")
+      ha2 = Digest::MD5.hexdigest("#{meth}:#{path}")
+      if qop
+        nc = '00000001'
+        cnonce = SecureRandom.hex(8)
+        response = Digest::MD5.hexdigest("#{ha1}:#{nonce}:#{nc}:#{cnonce}:#{qop}:#{ha2}")
+        hdrs['Authorization'] =
+          "Digest username=\"#{@user}\", realm=\"#{realm}\", nonce=\"#{nonce}\", " \
+          "uri=\"#{path}\", qop=#{qop}, nc=#{nc}, cnonce=\"#{cnonce}\", response=\"#{response}\""
+      else
+        response = Digest::MD5.hexdigest("#{ha1}:#{nonce}:#{ha2}")
+        hdrs['Authorization'] =
+          "Digest username=\"#{@user}\", realm=\"#{realm}\", nonce=\"#{nonce}\", " \
+          "uri=\"#{path}\", response=\"#{response}\""
+      end
+    end
+    private
+    def parse_challenge(www_authenticate)
+      pr = {}
+      www_authenticate.sub(/\ADigest\s*/, '').split(',').each do |pair|
+        k, v = pair.strip.split('=', 2)
+        next unless k
+        pr[k] = v.to_s.gsub('"', '')
+      end
+      pr
+    end
+  end
+end

data/lib/requests/cookies.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Requests
+  class Jar
+    include Enumerable
+    def initialize
+      @c = {}
+    end
+    def [](n)
+      @c[n]
+    end
+    def []=(n, v)
+      @c[n] = v
+    end
+    def get(name, default = nil)
+      @c.fetch(name, default)
+    end
+    def set(name, value)
+      @c[name] = value
+      self
+    end
+    def delete(name)
+      @c.delete(name)
+    end
+    def clear
+      @c.clear
+    end
+    def to_h
+      @c.dup
+    end
+    def to_a
+      @c.to_a
+    end
+    def each(&b)
+      @c.each(&b)
+    end
+    def empty?
+      @c.empty?
+    end
+    def to_header
+      @c.map { |k, v| "#{k}=#{v}" }.join('; ')
+    end
+    def update(net_resp)
+      lines = net_resp.get_fields('set-cookie') || []
+      lines.each do |l|
+        kv = l.split(';').first
+        next unless kv
+        k, v = kv.split('=', 2)
+        next unless k
+        @c[k.strip] = v.to_s.strip
+      end
+    end
+  end
+  CookieJar = Jar
+end

data/lib/requests/exceptions.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Requests
+  module Timeoutable; end
+  class RequestException < StandardError
+    attr_reader :response, :request
+    def initialize(msg = nil, response: nil, request: nil)
+      @response = response
+      @request = request
+      super(msg || 'request error')
+    end
+  end
+
+  class InvalidJSONError < RequestException
+  end
+  class JSONDecodeError < InvalidJSONError
+  end
+  class HTTPError < RequestException
+  end
+  class ConnectionError < RequestException
+  end
+  class ProxyError < ConnectionError
+  end
+  class SSLError < ConnectionError
+  end
+  class Timeout < RequestException
+    include Timeoutable
+  end
+  class ConnectTimeout < ConnectionError
+    include Timeoutable
+  end
+  class ReadTimeout < Timeout
+  end
+  class URLRequired < RequestException
+  end
+  class TooManyRedirects < RequestException
+  end
+  class MissingSchema < RequestException
+  end
+  class InvalidSchema < RequestException
+  end
+  class InvalidURL < RequestException
+  end
+  class InvalidProxyURL < InvalidURL
+  end
+  class ChunkedEncodingError < RequestException
+  end
+  class ContentDecodingError < RequestException
+  end
+  class StreamConsumedError < RequestException
+  end
+  class InvalidHeader < RequestException
+  end
+  class RetryError < RequestException
+  end
+end

data/lib/requests/models.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Requests
+  class PreparedRequest
+    attr_reader :method, :url, :headers, :body
+    def initialize(method:, url:, headers: nil, body: nil)
+      @method = method
+      @url = url
+      @headers = headers
+      @body = body
+    end
+    def [](key)
+      case key.to_sym
+      when :method then @method
+      when :url then @url
+      when :headers then @headers
+      when :body then @body
+      end
+    end
+    def to_h
+      { method: @method, url: @url, headers: @headers, body: @body }
+    end
+  end
+  class Response
+    attr_accessor :status_code, :headers, :raw_body, :url, :history,
+                  :elapsed, :request, :cookies, :encoding, :reason
+    def initialize
+      @history = []
+    end
+    def ok?
+      status_code.to_i < 400
+    end
+    alias_method :ok, :ok?
+    def status
+      status_code
+    end
+    def redirect?
+      [301, 302, 303, 307, 308].include?(status_code)
+    end
+    alias_method :is_redirect?, :redirect?
+    def permanent_redirect?
+      [301, 308].include?(status_code)
+    end
+    alias_method :is_permanent_redirect?, :permanent_redirect?
+    def client_error?
+      status_code.to_i.between?(400, 499)
+    end
+    def server_error?
+      status_code.to_i >= 500
+    end
+    def content
+      raw_body
+    end
+    def text
+      enc = encoding || 'UTF-8'
+      s = raw_body.to_s.dup
+      begin
+        s.force_encoding(enc).encode('UTF-8', invalid: :replace, undef: :replace)
+      rescue ArgumentError, Encoding::ConverterNotFoundError
+        s.force_encoding('UTF-8')
+      end
+    end
+    def json(**kw)
+      JSON.parse(text, **kw)
+    rescue JSON::ParserError => e
+      raise Requests::JSONDecodeError.new(build_json_error_message(e), response: self)
+    end
+    def raise_for_status
+      return self if ok?
+      kind = status_code.to_i >= 500 ? 'Server' : 'Client'
+      msg = "#{status_code} #{kind} Error: #{reason} for url: #{url}"
+      raise Requests::HTTPError.new(msg, response: self)
+    end
+    alias_method :raise_for_status!, :raise_for_status
+
+    def iter_lines(chunk: nil)
+      return enum_for(:iter_lines, chunk: chunk) unless block_given?
+      text.each_line { |l| yield l.chomp }
+    end
+
+    def iter_content(chunk_size: 1024)
+      return enum_for(:iter_content, chunk_size: chunk_size) unless block_given?
+      s = content.to_s
+      i = 0
+      while i < s.bytesize
+        yield s.byteslice(i, chunk_size)
+        i += chunk_size
+      end
+    end
+    def save_to(path)
+      File.open(path, 'wb') { |f| f.write(raw_body.to_s.dup.force_encoding(Encoding::ASCII_8BIT)) }
+      path
+    end
+
+    def apparent_encoding
+      encoding
+    end
+    def links
+      Requests::Utils.parse_header_links(headers['link'])
+    end
+    private
+    def build_json_error_message(err)
+      body_preview = Requests::Utils.truncate(text, 200)
+      if Requests::Utils.looks_like_html?(text)
+        "expected JSON but got an HTML page back (status #{status_code} from #{url}). " \
+          "you probably hit an error page or got redirected somewhere unexpected, " \
+          "not the JSON endpoint you meant to call. body starts with: #{body_preview.inspect}"
+      elsif text.to_s.strip.empty?
+        "expected JSON but the response body was empty (status #{status_code} from #{url})"
+      else
+        "couldn't parse response body as JSON (status #{status_code} from #{url}): " \
+          "#{err.message}. body starts with: #{body_preview.inspect}"
+      end
+    end
+  end
+end

data/lib/requests/sessions.rb

@@ -0,0 +1,222 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+require 'time'
+
+module Requests
+  class Session
+    attr_accessor :headers, :cookies, :auth, :params, :proxies, :verify,
+                  :cert, :max_redirects, :timeout, :retries, :backoff_factor
+    def initialize
+      @headers = Requests::Utils.default_headers
+      @cookies = Jar.new
+      @auth = nil
+      @params = nil
+      @proxies = {}
+      @verify = true
+      @cert = nil
+      @max_redirects = 30
+      @timeout = nil
+      @retries = 0
+      @backoff_factor = 0
+      @hooks = { response: [] }
+      @adapters = { 'https://' => HTTPAdapter.new, 'http://' => HTTPAdapter.new }
+    end
+    def hooks
+      @hooks
+    end
+    def mount(prefix, adapter)
+      @adapters[prefix] = adapter
+      self
+    end
+    def get(url, **kw); request('GET', url, **kw); end
+    def post(url, **kw); request('POST', url, **kw); end
+    def put(url, **kw); request('PUT', url, **kw); end
+    def patch(url, **kw); request('PATCH', url, **kw); end
+    def delete(url, **kw); request('DELETE', url, **kw); end
+    def options(url, **kw); request('OPTIONS', url, **kw); end
+    def head(url, **kw)
+      kw[:allow_redirects] = kw.fetch(:allow_redirects, false)
+      request('HEAD', url, **kw)
+    end
+    def get!(url, **kw); get(url, **kw).raise_for_status; end
+    def post!(url, **kw); post(url, **kw).raise_for_status; end
+    def close
+      true
+    end
+    def request(method, url, params: nil, data: nil, json: nil, headers: nil, cookies: nil, files: nil,
+                auth: nil, timeout: nil, allow_redirects: true, proxies: nil, verify: nil, stream: false,
+                cert: nil, hooks: nil, retries: nil)
+      validate_url!(url)
+      use_auth = auth || @auth
+      merged_params = merge_hash(@params, params)
+      original_url = build_url(url, merged_params)
+      original_host = URI.parse(original_url).host
+      cur_url = original_url
+      cur_method = method.to_s.upcase
+      hist = []
+      redirs = 0
+      body, content_type = build_body(data: data, json: json, files: files)
+      loop do
+        hdrs = CIHash.new(@headers.to_h)
+        hdrs.merge!(headers)
+        hdrs['Content-Type'] = content_type if content_type && !hdrs.key?('content-type')
+        hdrs.delete('Authorization') if redirs > 0 && URI.parse(cur_url).host != original_host
+        jar = merge_jar(@cookies, cookies)
+        hdrs['Cookie'] = jar.to_header unless jar.empty?
+        adapter = adapter_for(cur_url)
+        adapter.max_retries = retries.nil? ? @retries : retries
+        adapter.backoff_factor = @backoff_factor
+        t0 = Time.now
+        net_resp = adapter.send_once(cur_method, cur_url, hdrs, body, timeout || @timeout,proxies || @proxies, verify.nil? ? @verify : verify,cert || @cert, use_auth)
+        elapsed = Time.now - t0
+        resp = to_response(adapter, net_resp, cur_url, elapsed, cur_method, hdrs, body)
+        @cookies.update(net_resp)
+        resp.cookies = @cookies
+        if use_auth.is_a?(DigestAuth) && resp.status_code == 401 && redirs.zero? && hist.empty?
+          use_auth.call(hdrs, meth: cur_method, url: cur_url, prev_resp: resp)
+          t1 = Time.now
+          net_resp = adapter.send_once(cur_method, cur_url, hdrs, body, timeout || @timeout,proxies || @proxies, verify.nil? ? @verify : verify,cert || @cert, nil)
+          resp = to_response(adapter, net_resp, cur_url, Time.now - t1, cur_method, hdrs, body)
+          @cookies.update(net_resp)
+          resp.cookies = @cookies
+        end
+        hist << resp
+        if allow_redirects && resp.redirect? && resp.headers['location']
+          redirs += 1
+          raise Requests::TooManyRedirects, "too many redirects: #{url}" if redirs > @max_redirects
+          cur_url = URI.join(cur_url, resp.headers['location']).to_s
+          if resp.status_code == 303 || ([301, 302].include?(resp.status_code) && cur_method == 'POST')
+            cur_method = 'GET'
+            body = nil
+          end
+          next
+        end
+        resp.history = hist[0..-2]
+        run_hooks(resp, hooks)
+        return resp
+      end
+    end
+    private
+    def run_hooks(resp, per_request_hooks)
+      all = Array(@hooks[:response]) + Array(per_request_hooks && per_request_hooks[:response])
+      all.each { |h| h.call(resp) }
+    end
+    def validate_url!(url)
+      s = url.to_s
+      raise Requests::MissingSchema, "invalid url, no scheme: #{url}" unless s.include?('://')
+      raise Requests::InvalidSchema, "unsupported scheme: #{url}" unless s =~ %r{\Ahttps?://}
+    end
+    def adapter_for(url)
+      match = @adapters.keys.select { |prefix| url.start_with?(prefix) }.max_by(&:length)
+      match ? @adapters[match] : @adapters['https://']
+    end
+    def merge_hash(a, b)
+      return b unless a
+      return a unless b
+      a.merge(b)
+    end
+    def merge_jar(session_jar, extra)
+      j = Jar.new
+      session_jar.each { |k, v| j[k] = v }
+      extra&.each { |k, v| j[k] = v }
+      j
+    end
+    def build_url(base, params)
+      return base if params.nil? || (params.respond_to?(:empty?) && params.empty?)
+      qs = build_qs(params)
+      return base if qs.nil? || qs.empty?
+      sep = base.include?('?') ? '&' : '?'
+      base + sep + qs
+    end
+
+    def build_qs(p)
+      case p
+      when String then p
+      when Hash
+        parts = []
+        p.each do |k, v|
+          next if v.nil?
+          if v.is_a?(Array)
+            v.each { |vv| parts << "#{esc(k)}=#{esc(vv)}" }
+          else
+            parts << "#{esc(k)}=#{esc(v)}"
+          end
+        end
+        parts.join('&')
+      when Array
+        p.map { |k, v| "#{esc(k)}=#{esc(v)}" }.join('&')
+      else
+        ''
+      end
+    end
+
+    def esc(v)
+      URI.encode_www_form_component(v.to_s)
+    end
+    def build_body(data: nil, json: nil, files: nil)
+      if files
+        build_multipart(data, files)
+      elsif json
+        [JSON.generate(json), 'application/json']
+      elsif data.is_a?(Hash) || data.is_a?(Array)
+        [build_qs(data), 'application/x-www-form-urlencoded']
+      elsif data.is_a?(String)
+        [data, nil]
+      elsif data.respond_to?(:read)
+        [data.read, nil]
+      else
+        [nil, nil]
+      end
+    end
+
+    def build_multipart(data, files)
+      boundary = "----RubyReq#{SecureRandom.hex(10)}"
+      out = String.new(encoding: Encoding::ASCII_8BIT)
+      (data || {}).each do |k, v|
+        out << "--#{boundary}\r\n"
+        out << "Content-Disposition: form-data; name=\"#{k}\"\r\n\r\n"
+        out << v.to_s.dup.force_encoding(Encoding::ASCII_8BIT)
+        out << "\r\n"
+      end
+      files.each do |field, val|
+        fname, content, ctype = extract_file(field, val)
+        out << "--#{boundary}\r\n"
+        out << "Content-Disposition: form-data; name=\"#{field}\"; filename=\"#{fname}\"\r\n"
+        out << "Content-Type: #{ctype}\r\n\r\n"
+        out << content.to_s.dup.force_encoding(Encoding::ASCII_8BIT)
+        out << "\r\n"
+      end
+      out << "--#{boundary}--\r\n"
+      [out, "multipart/form-data; boundary=#{boundary}"]
+    end
+
+    def extract_file(field, val)
+      if val.is_a?(Array)
+        fname = val[0]
+        content = val[1].respond_to?(:read) ? val[1].read : val[1].to_s
+        ctype = val[2] || 'application/octet-stream'
+        [fname, content, ctype]
+      elsif val.respond_to?(:read)
+        [Requests::Utils.guess_filename(val, field), val.read, 'application/octet-stream']
+      else
+        [field.to_s, val.to_s, 'application/octet-stream']
+      end
+    end
+
+    def to_response(adapter, net_resp, url, elapsed, method, req_headers, req_body)
+      r = Response.new
+      r.status_code = net_resp.code.to_i
+      rh = CIHash.new
+      net_resp.each_header { |k, v| rh[k] = v }
+      r.headers = rh
+      r.raw_body = adapter.decode_body(net_resp)
+      r.url = url
+      r.elapsed = elapsed
+      r.encoding = Requests::Utils.encoding_from_headers(rh)
+      r.reason = net_resp.message
+      r.request = PreparedRequest.new(method: method, url: url, headers: req_headers.to_h, body: req_body)
+      r
+    end
+  end
+end

data/lib/requests/status_codes.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Requests
+  STATUS_CODES = {100 => :continue,101 => :switching_protocols,102 => :processing,103 => :early_hints,200 => :ok,201 => :created,202 => :accepted,203 => :non_authoritative_info,204 => :no_content,205 => :reset_content,206 => :partial_content,207 => :multi_status,208 => :already_reported,226 => :im_used,300 => :multiple_choices,301 => :moved_permanently,302 => :found,303 => :see_other,304 => :not_modified,305 => :use_proxy,307 => :temporary_redirect,308 => :permanent_redirect,400 => :bad_request,401 => :unauthorized,402 => :payment_required,403 => :forbidden,404 => :not_found,405 => :method_not_allowed,406 => :not_acceptable,407 => :proxy_authentication_required,408 => :request_timeout,409 => :conflict,410 => :gone,411 => :length_required,412 => :precondition_failed,413 => :payload_too_large,414 => :uri_too_long,415 => :unsupported_media_type,416 => :range_not_satisfiable,417 => :expectation_failed,418 => :im_a_teapot,421 => :misdirected_request,422 => :unprocessable_entity,423 => :locked,424 => :failed_dependency,425 => :too_early,426 => :upgrade_required,428 => :precondition_required,429 => :too_many_requests,431 => :request_header_fields_too_large,451 => :unavailable_for_legal_reasons,500 => :internal_server_error,501 => :not_implemented,502 => :bad_gateway,503 => :service_unavailable,504 => :gateway_timeout,505 => :http_version_not_supported,506 => :variant_also_negotiates,507 => :insufficient_storage,508 => :loop_detected,509 => :bandwidth_limit_exceeded,510 => :not_extended,511 => :network_authentication_required}.freeze
+  STATUS_ALIASES = {okay: 200,all_ok: 200,all_good: 200,request_uri_too_long: 414,unprocessable: 422,server_error: 500,unauthorised: 401}.freeze
+  class LookupDict
+    def initialize(code_map, aliases = {})
+      @by_name = {}
+      code_map.each { |code, name| @by_name[name] = code }
+      aliases.each { |name, code| @by_name[name] ||= code }
+    end
+    def method_missing(name, *_args)
+      @by_name.key?(name) ? @by_name[name] : super
+    end
+    def respond_to_missing?(name, include_private = false)
+      @by_name.key?(name) || super
+    end
+    def [](name)
+      @by_name[name.to_sym]
+    end
+    def name_for(code)
+      STATUS_CODES[code]
+    end
+  end
+
+  CODES = LookupDict.new(STATUS_CODES, STATUS_ALIASES)
+
+  def self.codes
+    CODES
+  end
+end