dialed 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6d782b0da7b47eb1f23159a03c8ff84b96f619641586f4d4e63c344912d84d06
+  data.tar.gz: c83dc4502bb902e2d7dc0103d27c0dea56f32c2ec324b0eeb993bbe4744b28b9
+SHA512:
+  metadata.gz: cc6952bb3d6f5119b9e1c9288c7ad86b5f63db88e4a634749091c1473c33b9a762b9c8a7db5ed5b5b692f0acfcfbaf757362de9fc89837afc6c9141f79d39cb2
+  data.tar.gz: e90af846eabeebcdda0d820691faa64bf47fd6cfa4f35c83f275fa151f45855b50007a4f469777f811e1d5138f59d29956aa77d64ac0dd8be2f154cf25231e51

data/lib/dialed/http/client.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Dialed
+  module HTTP
+    class Client
+      def self.build(&block)
+        ExplicitClient.new create_connection_builder(&block)
+      end
+
+      def self.create_connection_builder(&block)
+        if block_given?
+          connection_builder = ConnectionBuilder.new
+          block.call(connection_builder)
+          return connection_builder
+        end
+        ConnectionBuilder.apply_defaults
+      end
+
+      def close
+        return if @closed
+
+        @closed = true
+        with_dialer(&:hangup!)
+      end
+
+      attr_accessor :waiter
+
+      def initialize(connection_builder = ConnectionBuilder.apply_defaults)
+        @connection_builder = connection_builder
+        @async_task_count = 0
+        @closed = false
+      end
+
+      def get(location, query: {}, **kwargs)
+        with_dialer do |dialer|
+          response = dialer.call('GET', location, **kwargs)
+          response
+        end
+      end
+
+      def async(&block)
+        Async do |task|
+          waiter = Async::Waiter.new(parent: task)
+          waiting_client = dup
+          waiting_client.waiter = waiter
+          arr = []
+          implicit = block.call(waiting_client, arr)
+          if arr.empty?
+            waiter.wait(waiter.instance_variable_get(:@done).count)
+            implicit
+          else
+            enum = Enumerator::Lazy.new(arr) do |yielder, *values|
+              if values.size == 1
+                value = values.first
+                value.wait
+                yielder << value.result
+              else
+                values.each(&:wait)
+                yielder << values.map(&:result)
+              end
+            end
+            enum
+          end
+        end
+      end
+
+      attr_reader :connection_builder
+
+      def with_dialer(&block)
+        if waiter
+          waiter.async do
+            fetch_dialer(&block)
+          end
+        elsif Async::Task.current?
+          fetch_dialer do |dialer|
+            block.call(dialer)
+          end
+        else
+          Sync do
+            fetch_dialer do |dialer|
+              dialer.start_session do |session|
+                block.call(session)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dialed/http/connection.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Dialed
+  module HTTP
+    class Connection
+      attr_reader :configuration
+
+      delegate :ssl_context, to: :configuration
+      delegate :uri, :version, to: :configuration, prefix: :remote
+      delegate :host, :port, to: :remote_host
+      delegate :authority, :scheme, to: :remote_uri
+
+      delegate :version, :http2?, :http1?, to: :internal_connection
+      delegate :call, to: :internal_connection
+
+      alias remote_host remote_uri
+
+      def initialize(configuration)
+        @semaphore = Async::Semaphore.new
+        # @semaphore2 = Async::Semaphore.new
+        @configuration = configuration
+      end
+
+      def ping
+        internal_connection.send_ping(SecureRandom.bytes(8))
+      end
+
+      def address
+        "#{host}:#{port}"
+      end
+
+      def closed?
+        internal_connection.closed?
+      end
+
+      def open?
+        !closed?
+      end
+
+      # def call(...)
+      #   Sync do
+      #     @semaphore2.acquire do
+      #       Sync do
+      #         reconnect! if closed?
+      #       end
+      #       internal_connection.call(...)
+      #     end
+      #   end
+      # end
+
+      def connect
+        open?
+        # !!internal_connection
+      rescue StandardError => e
+        @internal_connection = NilConnection.new
+        raise e
+      end
+
+      def nil_connection?
+        false
+      end
+
+      def reconnect!
+        @semaphore.acquire do
+          @internal_connection = create_internal_connection
+        end
+      end
+
+      def close
+        raise NotImplementedError, 'Subclasses must implement close'
+      end
+
+      protected
+
+      def create_internal_connection
+        raise NotImplementedError, 'Subclasses must implement create_internal_connection'
+      end
+
+      private
+
+      # A semaphore is used for now to prevent a stampede of opening new connections if multiple
+      # requests are being made concurrently and the connection does not yet exist. Unclear if this is needed
+      # after the connection has been created and/or if async-http handles its own isolation
+      def internal_connection
+        @semaphore.acquire do
+          __fetch_internal_connection
+        end
+      end
+
+      def __fetch_internal_connection
+        @internal_connection = create_internal_connection if needs_new_connection?
+        @internal_connection
+      end
+
+      # Instead, use the instance variable directly:
+      def needs_new_connection?
+        @internal_connection.nil? || @internal_connection.closed? # Correct - Checks raw state
+      end
+
+      def async_http_protocol
+        case remote_version
+        in :h2 then Async::HTTP::Protocol::HTTP2
+        in :http11 | :http10 | :http1 then Async::HTTP::Protocol::HTTP1
+        else raise "Unsupported protocol: #{remote_version}. Must be either :h2 or :http11 or :http1 or :http10"
+        end
+      end
+    end
+  end
+end

data/lib/dialed/http/connection_builder.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+module Dialed
+  module HTTP
+    class ConnectionBuilder
+      DirectConnectionConfiguration = Data.define(:uri, :version, :ssl_context)
+      TunneledConnectionConfiguration = Data.define(:uri, :proxy_uri, :version, :ssl_context)
+      using Dialed::Refinements::Presence
+
+      attr_accessor :ssl_context
+      attr_reader :version, :scheme, :uri, :proxy_uri
+
+      delegate :host, :port, :scheme, to: :uri
+      delegate :host=, :port=, to: :uri
+
+      def self.apply_defaults
+        new.tap(&:apply_defaults!)
+      end
+
+      def initialize
+        @version = :h2
+        @proxy_uri = nil
+        @ssl_context = build_ssl_context
+        @uri = Addressable::URI.new
+        @uri_defaults = { scheme: 'https', port: 443 }
+      end
+
+      def build_ssl_context
+        OpenSSL::SSL::SSLContext.new.tap do |ssl_context|
+          ssl_context.alpn_protocols = %w[h2 http/1.1]
+          ssl_context.verify_hostname = true
+        end
+      end
+
+      def scheme=(scheme)
+        uri.scheme = scheme
+        case scheme
+        in 'http'
+          uri.port = 80
+        in 'https'
+          uri.port = 443
+        else
+          raise ArgumentError, "Unsupported scheme: #{scheme.inspect}"
+        end
+      end
+
+      def uri_valid?
+        uri.send(:validate).nil?
+      end
+
+      def valid?
+        uri_valid? && !ssl_context.nil? && version.present?
+      end
+
+      def build
+        apply_defaults!
+        raise Dialed::Error, 'Cannot build. Invalid' unless valid?
+
+        if proxy_uri
+          configuration = TunneledConnectionConfiguration.new(
+            uri:         uri,
+            version:     version,
+            ssl_context: ssl_context,
+            proxy_uri:   proxy_uri
+          )
+          TunneledConnection.new(configuration)
+        else
+          configuration = DirectConnectionConfiguration.new(
+            uri:         uri,
+            version:     version,
+            ssl_context: ssl_context
+          )
+          DirectConnection.new(configuration)
+        end
+      end
+
+      def cert_store
+        ssl_context.cert_store ||= OpenSSL::X509::Store.new
+      end
+
+      def alpn_protocols=(protocols)
+        ssl_context.alpn_protocols = protocols
+      end
+
+      def alpn_protocols
+        ssl_context.alpn_protocols
+      end
+
+      def cert_store=(cert_store)
+        ssl_context.cert_store = cert_store
+      end
+
+      def add_certificate(path)
+        pathname = Pathname(path)
+        pathname = Pathname(File.expand_path(path)) if pathname.relative?
+
+        certificate = OpenSSL::X509::Certificate.new(pathname.read)
+        cert_store.add_cert(certificate)
+        self
+      end
+
+      def version=(version)
+        version = version.to_s
+
+        case version
+        in '1.0' | '10' | 1 | 'http/1.0' | 'HTTP/1.0'
+          @version = :http10
+          self.alpn_protocols = ['http/1.0']
+        in '1.1' | '11' | 'http/1.1' | 'HTTP/1.1'
+          @version = :http11
+          self.alpn_protocols = ['http/1.1']
+        in '2.0' | '20' | 2 | 'http/2' | 'HTTP/2'
+          @version = :h2
+          self.alpn_protocols = ['h2']
+        else
+          raise ArgumentError, "Unsupported HTTP version: #{version.inspect}"
+        end
+      end
+
+      def verify_peer=(verify_peer)
+        ssl_context.verify_mode = (OpenSSL::SSL::VERIFY_PEER if verify_peer)
+      end
+
+      def verify_none=(verify_none)
+        ssl_context.verify_mode = (OpenSSL::SSL::VERIFY_NONE if verify_none)
+      end
+
+      alias insecure= verify_none=
+
+      def uri=(uri)
+        input = Addressable::URI.parse(uri)
+        input_no_path = input.dup
+        input_no_path.path = nil
+        input_no_path.query = nil
+        input_no_path.fragment = nil
+        @uri = input_no_path
+      end
+
+      def proxy(&block)
+        if block_given?
+          uri = ProxyUri.new.tap(&block)
+          uri.infer_scheme_if_missing!
+          raise ArgumentError, "Invalid proxy URI: #{uri.inspect}" unless uri.valid?
+
+          @proxy_uri = uri
+
+          self
+        else
+          @proxy_uri
+        end
+        self
+      end
+
+      def proxy=(proxy_uri)
+        parsed = Addressable::URI.parse(proxy_uri)
+        proxy do |self_proxy|
+          self_proxy.merge!(parsed)
+        end
+      end
+
+      alias proxy_uri= proxy=
+
+      def apply_defaults!
+        defaults_to_apply = @uri_defaults.select do |key, _value|
+          uri_value = uri.send(key)
+          next if uri_value.present?
+
+          true
+        end
+
+        uri.merge!(defaults_to_apply)
+        self
+      end
+    end
+  end
+end

data/lib/dialed/http/dialer.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Dialed
+  module HTTP
+    class Dialer
+      attr_reader :connection
+
+      def initialize(builder = ConnectionBuilder.apply_defaults, lazy: true, &block)
+        @builder = builder
+        @connection = NilConnection.new
+        @lazy = lazy
+        start_session(&block) if block_given?
+      end
+
+      def connected?
+        connection.open?
+      end
+
+      def lazy?
+        @lazy
+      end
+
+      def disconnected?
+        connection.closed?
+      end
+
+      def current_host
+        return nil unless on_a_call?
+
+        connection.remote_host
+      end
+
+      def start_session(&block)
+        attempt_connection!
+        block.call(self)
+      ensure
+        hangup!
+      end
+
+      def call(verb, location, *args, proxy_uri: nil, **kwargs)
+        location_uri = Addressable::URI.parse(location)
+        request = Request.new(verb, location_uri.path, *args, **kwargs)
+        response = (
+          if connection.open?
+            response = request.call(connection)
+            Response.new(response)
+          elsif lazy?
+            @builder.uri = location_uri
+            @builder.proxy_uri = proxy_uri if proxy_uri
+            success = attempt_connection!
+            raise Dialed::Error, "Failed to connect to #{location}. connection status: #{connection.open?}" unless success
+
+            Response.new(request.call(connection))
+          else
+            success = attempt_connection!
+            raise Dialed::Error, "Failed to connect to #{location}. connection status: #{connection.open?}" unless success
+
+            Response.new(request.call(connection))
+          end
+
+        )
+
+        return response unless block_given?
+
+        begin
+          yield response
+        ensure
+          response.close
+        end
+      end
+
+      def hangup!
+        connection.close if connection.open?
+        @connection = NilConnection.new
+      end
+
+      def ready?
+        raise 'Expected connection not to be actually nil' if connection.nil?
+        return false if connection.nil_connection?
+        return false if connection.open?
+        return false unless @builder.valid?
+
+        true
+      end
+
+      private
+
+      def attempt_connection!
+        return true if ready?
+
+        @connection = @builder.build
+        connection.connect
+      end
+    end
+  end
+end

data/lib/dialed/http/direct_connection.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Dialed
+  module HTTP
+    class DirectConnection < Connection
+      def close
+        internal_connection.close
+      end
+
+      protected
+
+      def create_internal_connection
+        remote_endpoint = Async::HTTP::Endpoint.parse(
+          remote_uri.to_s,
+          protocol:       async_http_protocol,
+          ssl_context:    ssl_context,
+          alpn_protocols: ssl_context.alpn_protocols
+        )
+
+        remote_sock = remote_endpoint.connect
+        async_http_protocol.client(remote_sock)
+      end
+    end
+  end
+end

data/lib/dialed/http/explicit_client.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Dialed
+  module HTTP
+    class ExplicitClient < Client
+      def initialize(connection_builder)
+        super
+        @dialer = Dialer.new(connection_builder, lazy: false)
+      end
+
+      protected
+
+      def fetch_dialer(&block)
+        block.call(@dialer)
+      end
+    end
+  end
+end

data/lib/dialed/http/nil_connection.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Dialed
+  module HTTP
+    class NilConnection < Connection
+      def initialize
+        super(uri: nil, version: nil, ssl_context: nil)
+      end
+
+      def remote_host
+        nil
+      end
+
+      def remote_uri
+        nil
+      end
+
+      def ssl_context
+        nil
+      end
+
+      def http2?
+        false
+      end
+
+      def http1?
+        false
+      end
+
+      def open?
+        false
+      end
+
+      def nil_connection?
+        true
+      end
+
+      def closed?
+        true
+      end
+
+      private
+
+      def internal_connection
+        Class.new do
+          def call(...)
+            raise Dialed::Net::HTTP::ConnectionError, 'Tried to call a nil connection'
+          end
+        end.new
+      end
+    end
+  end
+end

data/lib/dialed/http/operator.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Dialed
+  module HTTP
+    class Operator
+      include Singleton
+
+      def initialize
+        @dialers = {}
+      end
+
+      def request_call(&block)
+        connection_builder = block.call(ConnectionBuilder.new) if block_given?
+        connection_builder ||= ConnectionBuilder.apply_defaults
+      end
+
+      def singleplex_dialers
+        @dialers
+          .reject { |_, dialer| dialer.disconnected? }
+          .select { |_, dialer| dialer.singleplex? }
+      end
+
+      def multiplex_dialers
+        @dialers.reject { |_, dialer| dialer.disconnected? }
+          .select { |_, dialer| dialer.multiplex? }
+      end
+
+      def checkout_dialer(connection_builder, &block)
+        full_connection_uri = connection_builder.full_connection_uri
+        plex_type = connection_builder.plex_type
+        case [full_connection_uri, plex_type, registry.keys]
+        in [URI => uri, :h2, [*, ^uri, *]]
+          block.call multiplex_dialers.fetch(uri)
+        in [URI => uri, :h1 | :h11, [*, ^uri, *]]
+          # not thread safe. Use async gem as it is not implemented with threads
+          dialer = remove_dialer(uri)
+          raise Dialed::Error, 'Dialer not found when it was expected to be. Is it possible you are using multiple threads?' unless dialer
+
+          block.call dialer
+          register_dialer dialer
+        in [URI => uri, Symbol, Array]
+          register_dialer dialer
+          block.call dialer
+        else
+          raise Dialed::Error, "Unknown Dialer type: #{full_connection_uri}, #{plex_type}"
+        end
+      end
+
+      def fetch_dialer(_uri, &)
+        Dialer.new(connection_builder, &)
+      end
+
+      def remove_dialer(dialer)
+        @dialers.delete(dialer.full_connection_uri)
+      end
+
+      def register_dialer(dialer)
+        @dialers[dialer.full_connection_uri] = dialer
+      end
+    end
+  end
+end

data/lib/dialed/http/proxy_uri.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Dialed
+  module HTTP
+    class ProxyUri < SimpleDelegator
+      using Dialed::Refinements::Presence
+
+      def self.parse(string)
+        new(Addressable::URI.parse(string))
+      end
+
+      def initialize(uri = Addressable::URI.parse('http://invalid.invalid'))
+        super
+      end
+
+      def infer_scheme_if_missing!
+        self.scheme ||= 'http'
+      end
+
+      def valid?
+        host.present? &&
+          port.present? &&
+          scheme.present?
+      end
+    end
+  end
+end

data/lib/dialed/http/request.rb

@@ -0,0 +1,39 @@
+module Dialed
+  module HTTP
+    class Request
+      attr_reader :verb, :path, :args, :options
+
+      def initialize(verb, path, *args, **options)
+        @verb = verb
+        @path = path
+        @args = args
+        @options = options
+      end
+
+      def call(connection)
+        # protocol_request = Protocol::HTTP::Request[
+        #   verb,
+        #   path,
+        #   *args,
+        #   version: connection.version,
+        #   headers: options[:headers],
+        #   method: verb.upcase,
+        #   authority: connection.authority,
+        #   scheme:    connection.scheme,
+        # ]
+        protocol_request = Protocol::HTTP::Request.new.tap do |r|
+          r.path = path
+          r.method = verb.upcase
+          r.headers = options[:headers] if options[:headers]
+          r.version = connection.version
+          r.authority = connection.authority
+          r.scheme = connection.scheme
+          r.body = options[:body]
+          r.protocol = options[:protocol] if options[:protocol]
+        end
+
+        protocol_request.call(connection)
+      end
+    end
+  end
+end

data/lib/dialed/http/response/body.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Dialed
+  module HTTP
+    class Response::Body
+      def initialize(internal_body)
+        @internal_body = internal_body
+        @file = nil
+      end
+
+      def read
+        raise NotImplementedError
+      end
+
+      def to_io
+        @to_io ||= begin
+                     file = nil
+                     begin
+                       file = ::Tempfile.create(anonymous: true)
+                       internal_body.each do |chunk|
+                         file.write(chunk)
+                       end
+                       file.rewind
+                       file
+                     rescue => e
+                       file.close
+                       raise e
+                     end
+                   end
+      end
+
+      def http2?; end
+
+      private
+
+      def buffered_internal_body
+        @buffered_internal_body ||= begin
+                                      if @file
+                                        return to_io.tap(&:rewind)
+                                                    .read
+                                      end
+                                      internal_body.read
+                                    end
+      end
+
+      def internal_body
+        if @internal_body.respond_to?(:rewindable?) && @internal_body.rewindable?
+          @internal_body
+            .rewind
+          # elsif @internal_body.is_a?(Async::HTTP::Protocol::HTTP2::Input)
+        elsif @internal_body.is_a?(Protocol::HTTP::Body::Buffered)
+          @internal_body.rewind
+          # buffered_body = @internal_body.finish
+          # buffered_body.rewind
+        end
+        @internal_body
+      end
+    end
+  end
+end

data/lib/dialed/http/response/every_body.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Dialed
+  module HTTP
+    class Response::EveryBody < Response::Body
+    end
+  end
+end

data/lib/dialed/http/response/json_body.rb

@@ -0,0 +1,28 @@
+module Dialed
+  module HTTP
+    class Response::JsonBody < Response::Body
+      alias to_json to_s
+
+      def read
+        # already memoized
+        buffered_internal_body
+      end
+
+      def to_s
+        read.to_s
+      end
+
+      def to_h
+        @__to_h ||= JSON.parse(read, symbolize_names: true)
+      end
+
+      def as_json
+        @__as_json ||= JSON.parse(read, symbolize_names: false)
+      end
+
+      def deconstruct_keys(keys)
+        keys ? to_h.slice(*keys) : to_h
+      end
+    end
+  end
+end

data/lib/dialed/http/response.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'async/http'
+::Async::HTTP::Body::Reader.module_eval do
+  def buffered!
+    if @body
+      @body = @body.finish
+    end
+
+    return self
+  end
+end
+
+module Dialed
+  module HTTP
+    class Response
+      delegate :to_io, :read, :to_h, :to_s, to: :body
+
+      def initialize(internal_response)
+        @internal_response = internal_response
+        @notifier = Async::Notification.new
+        buffer!
+      end
+
+      def body
+        @body ||= body_klass.new(internal_response.body)
+      end
+
+      def body_klass
+        case headers
+        in { 'content-type': 'application/json' }
+          JsonBody
+        else
+          EveryBody
+        end
+      end
+
+      def buffer!
+        @internal_response.buffered!
+      end
+
+      def http2?
+        internal_response.version == 'HTTP/2'
+      end
+
+      def http11?
+        internal_response.version == 'HTTP/1.1'
+      end
+
+      def headers
+        @headers ||= internal_response
+                       &.headers
+                       &.to_h
+                       &.transform_keys(&:to_sym)
+      end
+
+      private
+
+      attr_reader :internal_response
+    end
+  end
+end

data/lib/dialed/http/tunneled_connection.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Dialed
+  module HTTP
+    class TunneledConnection < Connection
+      ProxyConnectError = Class.new(StandardError)
+
+      delegate :proxy_uri, to: :configuration
+
+      def close
+        internal_connection.close
+      end
+
+      protected
+
+      def create_internal_connection
+        proxy_connection = create_proxy_connection
+        remote_endpoint = Async::HTTP::Endpoint.parse(
+          remote_uri.to_s,
+          protocol:       async_http_protocol,
+          ssl_context:    ssl_context,
+          alpn_protocols: ssl_context.alpn_protocols
+        )
+
+        proxy = Async::HTTP::Proxy.new(proxy_connection, address)
+        proxied_endpoint = proxy.wrap_endpoint(remote_endpoint)
+
+        proxied_sock = (
+          begin
+            proxied_endpoint.connect
+          rescue Errno::ECONNRESET => e
+            proxy_connection.close
+            raise ProxyConnectError, e
+          end
+        )
+        async_http_protocol.client(proxied_sock)
+      end
+
+      private
+
+      def create_proxy_connection
+        proxy_endpoint = Async::HTTP::Endpoint.parse(proxy_uri.to_s)
+        Async::HTTP::Client.new(proxy_endpoint)
+      end
+    end
+  end
+end

data/lib/dialed/refinements/presence.rb

@@ -0,0 +1,59 @@
+module Dialed
+  module Refinements
+    module PresenceMethods
+      def present?
+        !nil? && !empty?
+      end
+
+      def presence
+        self if present?
+      end
+    end
+
+    module Presence
+      refine NilClass do
+        def present?
+          false
+        end
+      end
+
+      refine String do
+        def present?
+          !nil? && !empty?
+        end
+      end
+
+      refine Integer do
+        def present?
+          !nil?
+        end
+      end
+
+      refine Array do
+        def present?
+          !nil? && !empty?
+        end
+
+        def presence
+          self if present?
+        end
+      end
+
+      refine Hash do
+        def present?
+          !nil? && !empty?
+        end
+
+        def presence
+          self if present?
+        end
+      end
+
+      refine Symbol do
+        def present?
+          !nil? && !empty?
+        end
+      end
+    end
+  end
+end

data/lib/dialed/version.rb

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

data/lib/dialed.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'backports/3.2.0/data'
+require 'zeitwerk'
+
+
+autoload :Pathname, 'pathname'
+autoload :Async, 'async'
+autoload :Tempfile, 'tempfile'
+autoload :Open3, 'open3'
+autoload :OpenSSL, 'openssl'
+autoload :Benchmark, 'benchmark'
+autoload :Base64, 'base64'
+autoload :SimpleDelegator, 'delegate'
+
+require 'active_support/core_ext/module/delegation'
+
+module Addressable
+  autoload :URI, 'addressable/uri'
+end
+
+module Async
+  autoload :Barrier, 'async/barrier'
+  autoload :Semaphore, 'async/semaphore'
+  autoload :HTTP, 'async/http'
+  autoload :Waiter, 'async/waiter'
+
+  module HTTP
+    autoload :Client, 'async/http/client.rb'
+    autoload :Proxy, 'async/http/proxy.rb'
+    autoload :Endpoint, 'async/http/endpoint.rb'
+  end
+end
+
+loader = Zeitwerk::Loader.for_gem
+loader.inflector.inflect(
+  'io' => 'IO',
+  'http' => 'HTTP'
+)
+loader.ignore('test/**/*')
+loader.ignore('bin/**/*')
+loader.setup
+
+module Dialed
+  class Error < StandardError; end
+
+  Client = HTTP::Client
+end

metadata

@@ -0,0 +1,132 @@
+--- !ruby/object:Gem::Specification
+name: dialed
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- " David Gillis"
+bindir: bin
+cert_chain: []
+date: 2025-02-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  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: addressable
+  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: async-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: bundler
+  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: zeitwerk
+  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: Supports HTTP/2, HTTP/1.X, HTTP proxying, connection pooling, concurrent
+  requests, and lots more
+email:
+- david@flipmine.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/dialed.rb
+- lib/dialed/http/client.rb
+- lib/dialed/http/connection.rb
+- lib/dialed/http/connection_builder.rb
+- lib/dialed/http/dialer.rb
+- lib/dialed/http/direct_connection.rb
+- lib/dialed/http/explicit_client.rb
+- lib/dialed/http/nil_connection.rb
+- lib/dialed/http/operator.rb
+- lib/dialed/http/proxy_uri.rb
+- lib/dialed/http/request.rb
+- lib/dialed/http/response.rb
+- lib/dialed/http/response/body.rb
+- lib/dialed/http/response/every_body.rb
+- lib/dialed/http/response/json_body.rb
+- lib/dialed/http/tunneled_connection.rb
+- lib/dialed/refinements/presence.rb
+- lib/dialed/version.rb
+homepage: https://github.com/gillisd/dialed
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/gillisd/dialed
+  source_code_uri: https://github.com/gillisd/dialed
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.5
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.5
+specification_version: 4
+summary: A modern, ergonomic HTTP client built on top of async-http
+test_files: []