finch-api 0.1.0.pre.alpha.3 → 0.1.0.pre.alpha.5

data/lib/finch-api/base_page.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-module FinchAPI
-  # @example
-  #   if page.has_next?
-  #     page = page.next_page
-  #   end
-  #
-  # @example
-  #   page.auto_paging_each do |access_token|
-  #     puts(access_token)
-  #   end
-  #
-  # @example
-  #   access_tokens =
-  #     page
-  #     .to_enum
-  #     .lazy
-  #     .select { _1.object_id.even? }
-  #     .map(&:itself)
-  #     .take(2)
-  #     .to_a
-  #
-  #   access_tokens => Array
-  module BasePage
-    # rubocop:disable Lint/UnusedMethodArgument
-
-    # @return [Boolean]
-    def next_page? = (raise NotImplementedError)
-
-    # @raise [FinchAPI::APIError]
-    # @return [FinchAPI::BasePage]
-    def next_page = (raise NotImplementedError)
-
-    # @param blk [Proc]
-    #
-    # @return [void]
-    def auto_paging_each(&) = (raise NotImplementedError)
-
-    # @return [Enumerable]
-    def to_enum = super(:auto_paging_each)
-
-    alias_method :enum_for, :to_enum
-
-    # @api private
-    #
-    # @param client [FinchAPI::BaseClient]
-    # @param req [Hash{Symbol=>Object}]
-    # @param headers [Hash{String=>String}, Net::HTTPHeader]
-    # @param page_data [Object]
-    def initialize(client:, req:, headers:, page_data:)
-      @client = client
-      @req = req
-      super()
-    end
-
-    # rubocop:enable Lint/UnusedMethodArgument
-  end
-end

data/lib/finch-api/extern.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-module FinchAPI
-  # @api private
-  module Extern
-  end
-end

data/lib/finch-api/pooled_net_requester.rb

@@ -1,180 +0,0 @@
-# frozen_string_literal: true
-
-module FinchAPI
-  # @api private
-  class PooledNetRequester
-    # from the golang stdlib
-    #   https://github.com/golang/go/blob/c8eced8580028328fde7c03cbfcb720ce15b2358/src/net/http/transport.go#L49
-    KEEP_ALIVE_TIMEOUT = 30
-
-    class << self
-      # @api private
-      #
-      # @param url [URI::Generic]
-      #
-      # @return [Net::HTTP]
-      def connect(url)
-        port =
-          case [url.port, url.scheme]
-          in [Integer, _]
-            url.port
-          in [nil, "http" | "ws"]
-            Net::HTTP.http_default_port
-          in [nil, "https" | "wss"]
-            Net::HTTP.https_default_port
-          end
-
-        Net::HTTP.new(url.host, port).tap do
-          _1.use_ssl = %w[https wss].include?(url.scheme)
-          _1.max_retries = 0
-        end
-      end
-
-      # @api private
-      #
-      # @param conn [Net::HTTP]
-      # @param deadline [Float]
-      def calibrate_socket_timeout(conn, deadline)
-        timeout = deadline - FinchAPI::Util.monotonic_secs
-        conn.open_timeout = conn.read_timeout = conn.write_timeout = conn.continue_timeout = timeout
-      end
-
-      # @api private
-      #
-      # @param request [Hash{Symbol=>Object}] .
-      #
-      #   @option request [Symbol] :method
-      #
-      #   @option request [URI::Generic] :url
-      #
-      #   @option request [Hash{String=>String}] :headers
-      #
-      # @param blk [Proc]
-      #
-      # @yieldparam [String]
-      # @return [Net::HTTPGenericRequest]
-      def build_request(request, &)
-        method, url, headers, body = request.fetch_values(:method, :url, :headers, :body)
-        req = Net::HTTPGenericRequest.new(
-          method.to_s.upcase,
-          !body.nil?,
-          method != :head,
-          url.to_s
-        )
-
-        headers.each { req[_1] = _2 }
-
-        case body
-        in nil
-          nil
-        in String
-          req["content-length"] ||= body.bytesize.to_s unless req["transfer-encoding"]
-          req.body_stream = FinchAPI::Util::ReadIOAdapter.new(body, &)
-        in StringIO
-          req["content-length"] ||= body.size.to_s unless req["transfer-encoding"]
-          req.body_stream = FinchAPI::Util::ReadIOAdapter.new(body, &)
-        in IO | Enumerator
-          req["transfer-encoding"] ||= "chunked" unless req["content-length"]
-          req.body_stream = FinchAPI::Util::ReadIOAdapter.new(body, &)
-        end
-
-        req
-      end
-    end
-
-    # @api private
-    #
-    # @param url [URI::Generic]
-    # @param deadline [Float]
-    # @param blk [Proc]
-    #
-    # @raise [Timeout::Error]
-    # @yieldparam [Net::HTTP]
-    private def with_pool(url, deadline:, &blk)
-      origin = FinchAPI::Util.uri_origin(url)
-      timeout = deadline - FinchAPI::Util.monotonic_secs
-      pool =
-        @mutex.synchronize do
-          @pools[origin] ||= ConnectionPool.new(size: @size) do
-            self.class.connect(url)
-          end
-        end
-
-      pool.with(timeout: timeout, &blk)
-    end
-
-    # @api private
-    #
-    # @param request [Hash{Symbol=>Object}] .
-    #
-    #   @option request [Symbol] :method
-    #
-    #   @option request [URI::Generic] :url
-    #
-    #   @option request [Hash{String=>String}] :headers
-    #
-    #   @option request [Object] :body
-    #
-    #   @option request [Float] :deadline
-    #
-    # @return [Array(Integer, Net::HTTPResponse, Enumerable)]
-    def execute(request)
-      url, deadline = request.fetch_values(:url, :deadline)
-
-      eof = false
-      finished = false
-      enum = Enumerator.new do |y|
-        with_pool(url, deadline: deadline) do |conn|
-          next if finished
-
-          req = self.class.build_request(request) do
-            self.class.calibrate_socket_timeout(conn, deadline)
-          end
-
-          self.class.calibrate_socket_timeout(conn, deadline)
-          unless conn.started?
-            conn.keep_alive_timeout = self.class::KEEP_ALIVE_TIMEOUT
-            conn.start
-          end
-
-          self.class.calibrate_socket_timeout(conn, deadline)
-          conn.request(req) do |rsp|
-            y << [conn, req, rsp]
-            break if finished
-
-            rsp.read_body do |bytes|
-              y << bytes
-              break if finished
-
-              self.class.calibrate_socket_timeout(conn, deadline)
-            end
-            eof = true
-          end
-        end
-      rescue Timeout::Error
-        raise FinchAPI::APITimeoutError
-      end
-
-      conn, _, response = enum.next
-      body = FinchAPI::Util.fused_enum(enum, external: true) do
-        finished = true
-        tap do
-          enum.next
-        rescue StopIteration
-          nil
-        end
-        conn.finish if !eof && conn&.started?
-      end
-      [Integer(response.code), response, (response.body = body)]
-    end
-
-    # @api private
-    #
-    # @param size [Integer]
-    def initialize(size: Etc.nprocessors)
-      @mutex = Mutex.new
-      @size = size
-      @pools = {}
-    end
-  end
-end

data/rbi/lib/finch-api/base_client.rbi

@@ -1,196 +0,0 @@
-# typed: strong
-
-module FinchAPI
-  # @api private
-  class BaseClient
-    abstract!
-
-    RequestComponentsShape =
-      T.type_alias do
-        {
-          method: Symbol,
-          path: T.any(String, T::Array[String]),
-          query: T.nilable(T::Hash[String, T.nilable(T.any(T::Array[String], String))]),
-          headers: T.nilable(
-            T::Hash[String,
-                    T.nilable(
-                      T.any(
-                        String,
-                        Integer,
-                        T::Array[T.nilable(T.any(String, Integer))]
-                      )
-                    )]
-          ),
-          body: T.nilable(T.anything),
-          unwrap: T.nilable(Symbol),
-          page: T.nilable(T::Class[FinchAPI::BasePage[FinchAPI::BaseModel]]),
-          stream: T.nilable(T::Class[T.anything]),
-          model: T.nilable(FinchAPI::Converter::Input),
-          options: T.nilable(T.any(FinchAPI::RequestOptions, FinchAPI::Util::AnyHash))
-        }
-      end
-
-    RequestInputShape =
-      T.type_alias do
-        {
-          method: Symbol,
-          url: URI::Generic,
-          headers: T::Hash[String, String],
-          body: T.anything,
-          max_retries: Integer,
-          timeout: Float
-        }
-      end
-
-    # from whatwg fetch spec
-    MAX_REDIRECTS = 20
-
-    PLATFORM_HEADERS = T::Hash[String, String]
-
-    class << self
-      # @api private
-      sig { params(req: FinchAPI::BaseClient::RequestComponentsShape).void }
-      def validate!(req)
-      end
-
-      # @api private
-      sig do
-        params(status: Integer, headers: T.any(T::Hash[String, String], Net::HTTPHeader)).returns(T::Boolean)
-      end
-      def should_retry?(status, headers:)
-      end
-
-      # @api private
-      sig do
-        params(
-          request: FinchAPI::BaseClient::RequestInputShape,
-          status: Integer,
-          response_headers: T.any(T::Hash[String, String], Net::HTTPHeader)
-        )
-          .returns(FinchAPI::BaseClient::RequestInputShape)
-      end
-      def follow_redirect(request, status:, response_headers:)
-      end
-
-      # @api private
-      sig do
-        params(
-          status: T.any(Integer, FinchAPI::APIConnectionError),
-          stream: T.nilable(T::Enumerable[String])
-        ).void
-      end
-      def reap_connection!(status, stream:)
-      end
-    end
-
-    # @api private
-    sig { returns(T.anything) }
-    attr_accessor :requester
-
-    # @api private
-    sig do
-      params(
-        base_url: String,
-        timeout: Float,
-        max_retries: Integer,
-        initial_retry_delay: Float,
-        max_retry_delay: Float,
-        headers: T::Hash[String,
-                         T.nilable(T.any(String, Integer, T::Array[T.nilable(T.any(String, Integer))]))],
-        idempotency_header: T.nilable(String)
-      )
-        .returns(T.attached_class)
-    end
-    def self.new(
-      base_url:,
-      timeout: 0.0,
-      max_retries: 0,
-      initial_retry_delay: 0.0,
-      max_retry_delay: 0.0,
-      headers: {},
-      idempotency_header: nil
-    )
-    end
-
-    # @api private
-    sig { overridable.returns(T::Hash[String, String]) }
-    private def auth_headers
-    end
-
-    # @api private
-    sig { returns(String) }
-    private def generate_idempotency_key
-    end
-
-    # @api private
-    sig do
-      overridable
-        .params(req: FinchAPI::BaseClient::RequestComponentsShape, opts: FinchAPI::Util::AnyHash)
-        .returns(FinchAPI::BaseClient::RequestInputShape)
-    end
-    private def build_request(req, opts)
-    end
-
-    # @api private
-    sig { params(headers: T::Hash[String, String], retry_count: Integer).returns(Float) }
-    private def retry_delay(headers, retry_count:)
-    end
-
-    # @api private
-    sig do
-      params(
-        request: FinchAPI::BaseClient::RequestInputShape,
-        redirect_count: Integer,
-        retry_count: Integer,
-        send_retry_header: T::Boolean
-      )
-        .returns([Integer, Net::HTTPResponse, T::Enumerable[String]])
-    end
-    private def send_request(request, redirect_count:, retry_count:, send_retry_header:)
-    end
-
-    # Execute the request specified by `req`. This is the method that all resource
-    #   methods call into.
-    sig do
-      params(
-        method: Symbol,
-        path: T.any(String, T::Array[String]),
-        query: T.nilable(T::Hash[String, T.nilable(T.any(T::Array[String], String))]),
-        headers: T.nilable(
-          T::Hash[String,
-                  T.nilable(
-                    T.any(
-                      String,
-                      Integer,
-                      T::Array[T.nilable(T.any(String, Integer))]
-                    )
-                  )]
-        ),
-        body: T.nilable(T.anything),
-        unwrap: T.nilable(Symbol),
-        page: T.nilable(T::Class[FinchAPI::BasePage[FinchAPI::BaseModel]]),
-        stream: T.nilable(T::Class[T.anything]),
-        model: T.nilable(FinchAPI::Converter::Input),
-        options: T.nilable(T.any(FinchAPI::RequestOptions, FinchAPI::Util::AnyHash))
-      )
-        .returns(T.anything)
-    end
-    def request(
-      method,
-      path,
-      query: {},
-      headers: {},
-      body: nil,
-      unwrap: nil,
-      page: nil,
-      stream: nil,
-      model: FinchAPI::Unknown,
-      options: {}
-    )
-    end
-
-    sig { returns(String) }
-    def inspect
-    end
-  end
-end