onebusaway-sdk 0.1.0.pre.alpha.207 → 0.1.0.pre.alpha.208

data/rbi/lib/onebusaway-sdk/pooled_net_requester.rbi

@@ -1,51 +0,0 @@
-# typed: strong
-
-module OnebusawaySDK
-  # @api private
-  class PooledNetRequester
-    RequestShape = T.type_alias do
-      {method: Symbol, url: URI::Generic, headers: T::Hash[String, String], body: T.anything, deadline: Float}
-    end
-
-    class << self
-      # @api private
-      sig { params(url: URI::Generic).returns(Net::HTTP) }
-      def connect(url)
-      end
-
-      # @api private
-      sig { params(conn: Net::HTTP, deadline: Float).void }
-      def calibrate_socket_timeout(conn, deadline)
-      end
-
-      # @api private
-      sig do
-        params(
-          request: OnebusawaySDK::PooledNetRequester::RequestShape,
-          blk: T.proc.params(arg0: String).void
-        )
-          .returns(Net::HTTPGenericRequest)
-      end
-      def build_request(request, &blk)
-      end
-    end
-
-    # @api private
-    sig { params(url: URI::Generic, deadline: Float, blk: T.proc.params(arg0: Net::HTTP).void).void }
-    private def with_pool(url, deadline:, &blk)
-    end
-
-    # @api private
-    sig do
-      params(request: OnebusawaySDK::PooledNetRequester::RequestShape)
-        .returns([Integer, Net::HTTPResponse, T::Enumerable[String]])
-    end
-    def execute(request)
-    end
-
-    # @api private
-    sig { params(size: Integer).returns(T.attached_class) }
-    def self.new(size: Etc.nprocessors)
-    end
-  end
-end

data/rbi/lib/onebusaway-sdk/request_options.rbi

@@ -1,107 +0,0 @@
-# typed: strong
-
-module OnebusawaySDK
-  # @api private
-  module RequestParameters
-    # Options to specify HTTP behaviour for this request.
-    sig { returns(T.any(OnebusawaySDK::RequestOptions, T::Hash[Symbol, T.anything])) }
-    def request_options
-    end
-
-    sig do
-      params(_: T.any(OnebusawaySDK::RequestOptions, T::Hash[Symbol, T.anything]))
-        .returns(T.any(OnebusawaySDK::RequestOptions, T::Hash[Symbol, T.anything]))
-    end
-    def request_options=(_)
-    end
-
-    # @api private
-    module Converter
-      # @api private
-      sig { params(params: T.anything).returns([T.anything, T::Hash[Symbol, T.anything]]) }
-      def dump_request(params)
-      end
-    end
-  end
-
-  # Specify HTTP behaviour to use for a specific request. These options supplement
-  #   or override those provided at the client level.
-  #
-  #   When making a request, you can pass an actual {RequestOptions} instance, or
-  #   simply pass a Hash with symbol keys matching the attributes on this class.
-  class RequestOptions < OnebusawaySDK::BaseModel
-    # @api private
-    sig { params(opts: T.any(T.self_type, T::Hash[Symbol, T.anything])).void }
-    def self.validate!(opts)
-    end
-
-    # Idempotency key to send with request and all associated retries. Will only be
-    #   sent for write requests.
-    sig { returns(T.nilable(String)) }
-    def idempotency_key
-    end
-
-    sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-    def idempotency_key=(_)
-    end
-
-    # Extra query params to send with the request. These are `.merge`’d into any
-    #   `query` given at the client level.
-    sig { returns(T.nilable(T::Hash[String, T.nilable(T.any(T::Array[String], String))])) }
-    def extra_query
-    end
-
-    sig do
-      params(_: T.nilable(T::Hash[String, T.nilable(T.any(T::Array[String], String))]))
-        .returns(T.nilable(T::Hash[String, T.nilable(T.any(T::Array[String], String))]))
-    end
-    def extra_query=(_)
-    end
-
-    # Extra headers to send with the request. These are `.merged`’d into any
-    #   `extra_headers` given at the client level.
-    sig { returns(T.nilable(T::Hash[String, T.nilable(String)])) }
-    def extra_headers
-    end
-
-    sig do
-      params(_: T.nilable(T::Hash[String, T.nilable(String)]))
-        .returns(T.nilable(T::Hash[String, T.nilable(String)]))
-    end
-    def extra_headers=(_)
-    end
-
-    # Extra data to send with the request. These are deep merged into any data
-    #   generated as part of the normal request.
-    sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
-    def extra_body
-    end
-
-    sig { params(_: T.nilable(T::Hash[Symbol, T.anything])).returns(T.nilable(T::Hash[Symbol, T.anything])) }
-    def extra_body=(_)
-    end
-
-    # Maximum number of retries to attempt after a failed initial request.
-    sig { returns(T.nilable(Integer)) }
-    def max_retries
-    end
-
-    sig { params(_: T.nilable(Integer)).returns(T.nilable(Integer)) }
-    def max_retries=(_)
-    end
-
-    # Request timeout in seconds.
-    sig { returns(T.nilable(Float)) }
-    def timeout
-    end
-
-    sig { params(_: T.nilable(Float)).returns(T.nilable(Float)) }
-    def timeout=(_)
-    end
-
-    # Returns a new instance of RequestOptions.
-    sig { params(values: T::Hash[Symbol, T.anything]).returns(T.attached_class) }
-    def self.new(values = {})
-    end
-  end
-end

data/rbi/lib/onebusaway-sdk/util.rbi

@@ -1,270 +0,0 @@
-# typed: strong
-
-module OnebusawaySDK
-  # @api private
-  module Util
-    # @api private
-    sig { returns(Float) }
-    def self.monotonic_secs
-    end
-
-    class << self
-      # @api private
-      sig { returns(String) }
-      def arch
-      end
-
-      # @api private
-      sig { returns(String) }
-      def os
-      end
-    end
-
-    class << self
-      # @api private
-      sig { params(input: T.anything).returns(T::Boolean) }
-      def primitive?(input)
-      end
-
-      # @api private
-      sig { params(input: T.anything).returns(T.any(T::Boolean, T.anything)) }
-      def coerce_boolean(input)
-      end
-
-      # @api private
-      sig { params(input: T.anything).returns(T.nilable(T::Boolean)) }
-      def coerce_boolean!(input)
-      end
-
-      # @api private
-      sig { params(input: T.anything).returns(T.any(Integer, T.anything)) }
-      def coerce_integer(input)
-      end
-
-      # @api private
-      sig { params(input: T.anything).returns(T.any(Float, T.anything)) }
-      def coerce_float(input)
-      end
-
-      # @api private
-      sig { params(input: T.anything).returns(T.any(T::Hash[T.anything, T.anything], T.anything)) }
-      def coerce_hash(input)
-      end
-    end
-
-    OMIT = T.let(T.anything, T.anything)
-
-    class << self
-      # @api private
-      sig { params(lhs: T.anything, rhs: T.anything, concat: T::Boolean).returns(T.anything) }
-      private def deep_merge_lr(lhs, rhs, concat: false)
-      end
-
-      # @api private
-      #
-      # Recursively merge one hash with another. If the values at a given key are not
-      #   both hashes, just take the new value.
-      sig do
-        params(values: T::Array[T.anything], sentinel: T.nilable(T.anything), concat: T::Boolean)
-          .returns(T.anything)
-      end
-      def deep_merge(
-        *values,
-        # the value to return if no values are provided.
-        sentinel: nil,
-        # whether to merge sequences by concatenation.
-        concat: false
-      )
-      end
-
-      # @api private
-      sig do
-        params(
-          data: T.any(T::Hash[Symbol, T.anything], T::Array[T.anything], T.anything),
-          pick: T.nilable(T.any(Symbol, Integer, T::Array[T.any(Symbol, Integer)])),
-          sentinel: T.nilable(T.anything),
-          blk: T.nilable(T.proc.returns(T.anything))
-        )
-          .returns(T.nilable(T.anything))
-      end
-      def dig(data, pick, sentinel = nil, &blk)
-      end
-    end
-
-    class << self
-      # @api private
-      sig { params(uri: URI::Generic).returns(String) }
-      def uri_origin(uri)
-      end
-
-      # @api private
-      sig { params(path: T.any(String, T::Array[String])).returns(String) }
-      def interpolate_path(path)
-      end
-    end
-
-    class << self
-      # @api private
-      sig { params(query: T.nilable(String)).returns(T::Hash[String, T::Array[String]]) }
-      def decode_query(query)
-      end
-
-      # @api private
-      sig do
-        params(query: T.nilable(T::Hash[String, T.nilable(T.any(T::Array[String], String))]))
-          .returns(T.nilable(String))
-      end
-      def encode_query(query)
-      end
-    end
-
-    ParsedUriShape = T.type_alias do
-      {
-        scheme: T.nilable(String),
-        host: T.nilable(String),
-        port: T.nilable(Integer),
-        path: T.nilable(String),
-        query: T::Hash[String, T::Array[String]]
-      }
-    end
-
-    class << self
-      # @api private
-      sig { params(url: T.any(URI::Generic, String)).returns(OnebusawaySDK::Util::ParsedUriShape) }
-      def parse_uri(url)
-      end
-
-      # @api private
-      sig { params(parsed: OnebusawaySDK::Util::ParsedUriShape).returns(URI::Generic) }
-      def unparse_uri(parsed)
-      end
-
-      # @api private
-      sig do
-        params(lhs: OnebusawaySDK::Util::ParsedUriShape, rhs: OnebusawaySDK::Util::ParsedUriShape)
-          .returns(URI::Generic)
-      end
-      def join_parsed_uri(lhs, rhs)
-      end
-    end
-
-    class << self
-      # @api private
-      sig do
-        params(
-          headers: T::Hash[String,
-                           T.nilable(T.any(String, Integer, T::Array[T.nilable(T.any(String, Integer))]))]
-        )
-          .returns(T::Hash[String, String])
-      end
-      def normalized_headers(*headers)
-      end
-    end
-
-    # @api private
-    #
-    # An adapter that satisfies the IO interface required by `::IO.copy_stream`
-    class ReadIOAdapter
-      # @api private
-      sig { params(max_len: T.nilable(Integer)).returns(String) }
-      private def read_enum(max_len)
-      end
-
-      # @api private
-      sig { params(max_len: T.nilable(Integer), out_string: T.nilable(String)).returns(T.nilable(String)) }
-      def read(max_len = nil, out_string = nil)
-      end
-
-      # @api private
-      sig do
-        params(
-          stream: T.any(String, IO, StringIO, T::Enumerable[String]),
-          blk: T.proc.params(arg0: String).void
-        )
-          .returns(T.attached_class)
-      end
-      def self.new(stream, &blk)
-      end
-    end
-
-    class << self
-      sig { params(blk: T.proc.params(y: Enumerator::Yielder).void).returns(T::Enumerable[String]) }
-      def string_io(&blk)
-      end
-    end
-
-    class << self
-      # @api private
-      sig do
-        params(y: Enumerator::Yielder, boundary: String, key: T.any(Symbol, String), val: T.anything).void
-      end
-      private def encode_multipart_formdata(y, boundary:, key:, val:)
-      end
-
-      # @api private
-      sig { params(body: T.anything).returns([String, T::Enumerable[String]]) }
-      private def encode_multipart_streaming(body)
-      end
-
-      # @api private
-      sig { params(headers: T::Hash[String, String], body: T.anything).returns(T.anything) }
-      def encode_content(headers, body)
-      end
-
-      # @api private
-      sig do
-        params(
-          headers: T.any(T::Hash[String, String], Net::HTTPHeader),
-          stream: T::Enumerable[String],
-          suppress_error: T::Boolean
-        )
-          .returns(T.anything)
-      end
-      def decode_content(headers, stream:, suppress_error: false)
-      end
-    end
-
-    class << self
-      # @api private
-      #
-      # https://doc.rust-lang.org/std/iter/trait.FusedIterator.html
-      sig do
-        params(enum: T::Enumerable[T.anything], external: T::Boolean, close: T.proc.void)
-          .returns(T::Enumerable[T.anything])
-      end
-      def fused_enum(enum, external: false, &close)
-      end
-
-      # @api private
-      sig { params(enum: T.nilable(T::Enumerable[T.anything])).void }
-      def close_fused!(enum)
-      end
-
-      # @api private
-      sig do
-        params(enum: T.nilable(T::Enumerable[T.anything]), blk: T.proc.params(arg0: Enumerator::Yielder).void)
-          .returns(T::Enumerable[T.anything])
-      end
-      def chain_fused(enum, &blk)
-      end
-    end
-
-    ServerSentEvent = T.type_alias do
-      {event: T.nilable(String), data: T.nilable(String), id: T.nilable(String), retry: T.nilable(Integer)}
-    end
-
-    class << self
-      # @api private
-      sig { params(enum: T::Enumerable[String]).returns(T::Enumerable[String]) }
-      def decode_lines(enum)
-      end
-
-      # @api private
-      #
-      # https://html.spec.whatwg.org/multipage/server-sent-events.html#parsing-an-event-stream
-      sig { params(lines: T::Enumerable[String]).returns(OnebusawaySDK::Util::ServerSentEvent) }
-      def decode_sse(lines)
-      end
-    end
-  end
-end

data/sig/onebusaway-sdk/base_client.rbs

@@ -1,108 +0,0 @@
-module OnebusawaySDK
-  class BaseClient
-    type request_components =
-      {
-        method: Symbol,
-        path: String | ::Array[String],
-        query: ::Hash[String, (::Array[String] | String)?]?,
-        headers: ::Hash[String, (String
-        | Integer
-        | ::Array[(String | Integer)?])?]?,
-        body: top?,
-        unwrap: Symbol?,
-        page: Class?,
-        stream: Class?,
-        model: OnebusawaySDK::Converter::input?,
-        options: OnebusawaySDK::request_opts?
-      }
-
-    type request_input =
-      {
-        method: Symbol,
-        url: URI::Generic,
-        headers: ::Hash[String, String],
-        body: top,
-        max_retries: Integer,
-        timeout: Float
-      }
-
-    MAX_REDIRECTS: 20
-
-    PLATFORM_HEADERS: ::Hash[String, String]
-
-    def self.validate!: (
-      OnebusawaySDK::BaseClient::request_components req
-    ) -> void
-
-    def self.should_retry?: (
-      Integer status,
-      headers: ::Hash[String, String]
-    ) -> bool
-
-    def self.follow_redirect: (
-      OnebusawaySDK::BaseClient::request_input request,
-      status: Integer,
-      response_headers: ::Hash[String, String]
-    ) -> OnebusawaySDK::BaseClient::request_input
-
-    def self.reap_connection!: (
-      Integer | OnebusawaySDK::APIConnectionError status,
-      stream: Enumerable[String]?
-    ) -> void
-
-    # @api private
-    attr_accessor requester: top
-
-    def initialize: (
-      base_url: String,
-      timeout: Float,
-      max_retries: Integer,
-      initial_retry_delay: Float,
-      max_retry_delay: Float,
-      headers: ::Hash[String, (String
-      | Integer
-      | ::Array[(String | Integer)?])?],
-      idempotency_header: String?
-    ) -> void
-
-    private def auth_query: -> ::Hash[String, String]
-
-    private def generate_idempotency_key: -> String
-
-    private def build_request: (
-      OnebusawaySDK::BaseClient::request_components req,
-      OnebusawaySDK::request_options opts
-    ) -> OnebusawaySDK::BaseClient::request_input
-
-    private def retry_delay: (
-      ::Hash[String, String] headers,
-      retry_count: Integer
-    ) -> Float
-
-    private def send_request: (
-      OnebusawaySDK::BaseClient::request_input request,
-      redirect_count: Integer,
-      retry_count: Integer,
-      send_retry_header: bool
-    ) -> [Integer, top, Enumerable[String]]
-
-    def request:
-      (
-        Symbol method,
-        String | ::Array[String] path,
-        query: ::Hash[String, (::Array[String] | String)?]?,
-        headers: ::Hash[String, (String
-        | Integer
-        | ::Array[(String | Integer)?])?]?,
-        body: top?,
-        unwrap: Symbol?,
-        page: Class?,
-        stream: Class?,
-        model: OnebusawaySDK::Converter::input?,
-        options: OnebusawaySDK::request_opts?
-      ) -> top
-      | (OnebusawaySDK::BaseClient::request_components req) -> top
-
-    def inspect: -> String
-  end
-end