test-test-sink-test-test2 0.0.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3c0f9378f1675d98710fa5ec56bd73650d25ca22789e0916102b29c485a47c28
+  data.tar.gz: 3051b450c74b423e9ba5561f1c15748619e819d4ee871b024122d8f7331772d4
+SHA512:
+  metadata.gz: 420b8a6a0e53b0b8f4604b9c1d72eb0b03ddac8998a49fd7aefe34d4c8ecfa00dda11487ecfe25e3b1946058a4fa28a769b053fb37801f992733fd9ee7662062
+  data.tar.gz: f3a704f7fcd330785b1cea5d2c74ff80e12eecc472f4e1427f64635e5ee6553de922ef3a7c223e0d4d2a1331c936e9fc4ef009c2e5f280d14ccd96fe63d30e82

data/README.md

@@ -0,0 +1,151 @@
+# Sink Ruby API library
+
+The Sink Ruby library provides convenient access to the Sink REST API from any Ruby 3.0+
+application.
+
+It is generated with [Stainless](https://www.stainlessapi.com/).
+
+## Documentation
+
+Documentation for the most recent version of this gem can be found [on RubyDoc](https://rubydoc.info/github/stainless-sdks/sink-ruby-public).
+
+The underlying REST API documentation can be found on [stainlessapi.com](https://stainlessapi.com).
+
+## Installation
+
+To use this gem during the beta, install directly from GitHub with Bundler by
+adding the following to your application's `Gemfile`:
+
+```ruby
+gem "sink", git: "https://github.com/stainless-sdks/sink-ruby-public", branch: "main"
+```
+
+To fetch an initial copy of the gem:
+
+```sh
+bundle install
+```
+
+To update the version used by your application when updates are pushed to
+GitHub:
+
+```sh
+bundle update sink
+```
+
+## Usage
+
+```ruby
+require "sink"
+
+sink = Sink::Client.new(
+  user_token: "My User Token", # defaults to ENV["SINK_CUSTOM_API_KEY_ENV"]
+  environment: "sandbox", # defaults to "production"
+  username: "Robert",
+  some_number_arg_required_no_default: 0,
+  some_number_arg_required_no_default_no_env: 0,
+  required_arg_no_env: "<example>"
+)
+
+card = sink.cards.create(
+  type: "SINGLE_USE",
+  exp_month: "08",
+  not_: "TEST",
+  shipping_address: {
+    "address1" => "180 Varick St",
+    "city" => "New York",
+    "country" => "USA",
+    "first_name" => "Jason",
+    "last_name" => "Mimosa",
+    "state" => "NY",
+    "postal_code" => "H0H0H0"
+  }
+)
+
+puts(card.token)
+```
+
+### Errors
+
+When the library is unable to connect to the API, or if the API returns a
+non-success status code (i.e., 4xx or 5xx response), a subclass of
+`Sink::HTTP::Error` will be thrown:
+
+```ruby
+begin
+  sink.cards.create(type: "an_incorrect_type")
+rescue Sink::HTTP::Error => e
+  puts(e.code) # 400
+end
+```
+
+Error codes are as followed:
+
+| Cause            | Error Type                 |
+| ---------------- | -------------------------- |
+| HTTP 400         | `BadRequestError`          |
+| HTTP 401         | `AuthenticationError`      |
+| HTTP 403         | `PermissionDeniedError`    |
+| HTTP 404         | `NotFoundError`            |
+| HTTP 409         | `ConflictError`            |
+| HTTP 422         | `UnprocessableEntityError` |
+| HTTP 429         | `RateLimitError`           |
+| HTTP >=500       | `InternalServerError`      |
+| Other HTTP error | `APIStatusError`           |
+| Timeout          | `APITimeoutError`          |
+| Network error    | `APIConnectionError`       |
+
+### Retries
+
+Certain errors will be automatically retried 1 times by default, with a short
+exponential backoff. Connection errors (for example, due to a network
+connectivity problem), 408 Request Timeout, 409 Conflict, 429 Rate Limit, >=500 Internal errors,
+and timeouts will all be retried by default.
+
+You can use the `max_retries` option to configure or disable this:
+
+```ruby
+# Configure the default for all requests:
+sink = Sink::Client.new(
+  max_retries: 0, # default is 1
+  username: "Robert",
+  some_number_arg_required_no_default: 0,
+  some_number_arg_required_no_default_no_env: 0,
+  required_arg_no_env: "<example>"
+)
+
+# Or, configure per-request:
+sink.cards.provision_foo("my card token", digital_wallet: "GOOGLE_PAY", max_retries: 5)
+```
+
+### Timeouts
+
+By default, requests will time out after 60 seconds.
+Timeouts are applied separately to the initial connection and the overall request time,
+so in some cases a request could wait 2\*timeout seconds before it fails.
+
+You can use the `timeout` option to configure or disable this:
+
+```ruby
+# Configure the default for all requests:
+sink = Sink::Client.new(
+  timeout: nil, # default is 60
+  username: "Robert",
+  some_number_arg_required_no_default: 0,
+  some_number_arg_required_no_default_no_env: 0,
+  required_arg_no_env: "<example>"
+)
+
+# Or, configure per-request:
+sink.cards.create(type: "DIGITAL", timeout: 5)
+```
+
+## Versioning
+
+This package follows [SemVer](https://semver.org/spec/v2.0.0.html) conventions. As the
+library is in initial development and has a major version of `0`, APIs may change
+at any time.
+
+## Requirements
+
+Ruby 3.0 or higher.

data/lib/sink/base_client.rb

@@ -0,0 +1,404 @@
+# frozen_string_literal: true
+
+module Sink
+  # @!visibility private
+  class BaseClient
+    attr_accessor :requester
+
+    # @param base_url [String]
+    # @param timeout [Integer, nil]
+    # @param headers [Hash{String => String}]
+    # @param max_retries [Integer]
+    # @param idempotency_header [String, nil]
+    def initialize(
+      base_url:,
+      timeout: nil,
+      headers: {},
+      max_retries: 0,
+      idempotency_header: nil
+    )
+      self.requester = PooledNetRequester.new
+      base_url_parsed = URI.parse(base_url)
+      @headers = Util.normalized_headers(
+        {
+          "X-Stainless-Lang" => "ruby",
+          "X-Stainless-Package-Version" => Sink::VERSION,
+          "X-Stainless-Runtime" => RUBY_ENGINE,
+          "X-Stainless-Runtime-Version" => RUBY_ENGINE_VERSION,
+          "Accept" => "application/json"
+        },
+        headers
+      )
+      @host = base_url_parsed.host
+      @scheme = base_url_parsed.scheme
+      @port = base_url_parsed.port
+      @base_path = self.class.normalize_path(base_url_parsed.path)
+      @max_retries = max_retries
+      @timeout = timeout
+      @idempotency_header = idempotency_header
+    end
+
+    # @return [Hash{String => String}]
+    def auth_headers
+      {}
+    end
+
+    def validate_request(req, opts)
+      if (body = req[:body])
+        # Body can be at least a Hash or Array, just check for Hash shape for now.
+        if body.is_a?(Hash)
+          body.each_key do |k|
+            unless k.is_a?(Symbol)
+              raise ArgumentError, "Request body keys must be Symbols, got #{k.inspect}"
+            end
+          end
+        end
+      end
+
+      unless opts.is_a?(Hash) || opts.is_a?(Sink::RequestOption)
+        raise ArgumentError, "Request `opts` must be a Hash or RequestOptions, got #{opts.inspect}"
+      end
+      opts.to_h.each_key do |k|
+        unless k.is_a?(Symbol)
+          raise ArgumentError, "Request `opts` keys must be Symbols, got #{k.inspect}"
+        end
+        unless (valid_keys = Sink::RequestOptions.options).include?(k)
+          raise ArgumentError, "Request `opts` keys must be one of #{valid_keys}, got #{k.inspect}"
+        end
+      end
+    end
+
+    def self.normalize_path(path)
+      path.gsub(/\/+/, "/")
+    end
+
+    def resolve_uri_elements(req)
+      from_args =
+        if req[:url]
+          uri = req[:url].is_a?(URI::Generic) ? req[:url] : URI.parse(req[:url])
+          {
+            host: uri.host,
+            scheme: uri.scheme,
+            path: uri.path,
+            query: CGI.parse(uri.query || ""),
+            port: uri.port
+          }
+        else
+          from_req = req.slice(:host, :scheme, :path, :port, :query)
+          from_req[:path] = self.class.normalize_path("/#{@base_path}/#{from_req[:path]}")
+          from_req
+        end
+
+      uri_components = {host: @host, scheme: @scheme, port: @port}.merge(from_args)
+
+      if req[:extra_query]
+        uri_components[:query] = Util.deep_merge(uri_components[:query], req[:extra_query], concat: true)
+      end
+
+      uri_components
+    end
+
+    def prep_request(options)
+      method = options.fetch(:method)
+
+      headers = Util.normalized_headers(@headers, auth_headers, options[:headers], options[:extra_headers])
+      if @idempotency_header && !headers[@idempotency_header] && ![:get, :head, :options].include?(method)
+        headers[@idempotency_header.to_s.downcase] = options[:idempotency_key] || generate_idempotency_key
+      end
+      if !headers.key?("x-stainless-retry-count")
+        headers["x-stainless-retry-count"] = "0"
+      end
+      headers.compact!
+      headers.transform_values!(&:to_s)
+
+      body =
+        case method
+        when :post, :put, :patch, :delete
+          body = options[:body]
+          if body
+            if headers["content-type"] == "application/json"
+              JSON.dump(body)
+            else
+              body
+            end
+          end
+        else
+          nil
+        end
+      if options[:extra_body]
+        body = Util.deep_merge(body, options[:extra_body])
+      end
+
+      url_elements = resolve_uri_elements(options)
+
+      {method: method, headers: headers, body: body}.merge(url_elements)
+    end
+
+    def generate_idempotency_key
+      "stainless-ruby-retry-#{SecureRandom.uuid}"
+    end
+
+    def should_retry?(response)
+      should_retry_header = response["x-should-retry"]
+
+      case should_retry_header
+      when "true"
+        true
+      when "false"
+        false
+      else
+        response_code = response.code.to_i
+        # retry on:
+        # 408: timeouts
+        # 409: locks
+        # 429: rate limits
+        # 500+: unknown errors
+        [408, 409, 429].include?(response_code) || response_code >= 500
+      end
+    end
+
+    def make_status_error(message:, body:, response:)
+      raise NotImplementedError
+    end
+
+    def make_status_error_from_response(response)
+      err_body =
+        begin
+          JSON.parse(response.body)
+        rescue StandardError
+          response
+        end
+
+      # We include the body in the error message as well as returning it
+      # since logging error messages is a common and quick way to assess what's
+      # wrong with a response.
+      message = "Error code: #{response.code}; Response: #{response.body}"
+
+      make_status_error(message: message, body: err_body, response: response)
+    end
+
+    def header_based_retry(response)
+      # Note the `retry-after-ms` header may not be standard, but is a good idea and we'd like proactive support for it.
+      retry_after_millis = Float(response["retry-after-ms"], exception: false)
+      if retry_after_millis
+        retry_after = retry_after_millis / 1000.0
+      elsif response["retry-after"]
+        retry_after = Float(response["retry-after"], exception: false)
+        if retry_after.nil?
+          begin
+            base = Time.now
+            if response["x-stainless-mock-sleep-base"]
+              base = Time.httpdate(response["x-stainless-mock-sleep-base"])
+            end
+            retry_after = Time.httpdate(response["retry-after"]) - base
+          rescue StandardError # rubocop:disable Lint/SuppressedException
+          end
+        end
+      end
+      retry_after
+    rescue StandardError # rubocop:disable Lint/SuppressedException
+    end
+
+    def send_request(request, max_retries:, timeout:, redirect_count:)
+      delay = 0.6
+      max_delay = 8.0
+      # Don't send the current retry count in the headers if the caller modified the header defaults.
+      should_send_retry_count = request[:headers]["x-stainless-retry-count"] == "0"
+      retries = 0
+      loop do # rubocop:disable Metrics/BlockLength
+        if should_send_retry_count
+          request[:headers]["x-stainless-retry-count"] = retries.to_s
+        end
+
+        begin
+          response = @requester.execute(request, timeout: timeout)
+          status = response.code.to_i
+
+          if status < 300
+            return response
+          elsif status < 400
+            begin
+              prev_uri = URI.parse(Util.uri_from_req(request, absolute: true))
+              location = URI.join(prev_uri, response["location"])
+            rescue ArgumentError
+              message = "server responded with status #{status} but no valid location header"
+              raise HTTP::APIConnectionError.new(message: message, request: request)
+            end
+            # from whatwg fetch spec
+            if redirect_count == 20
+              message = "failed to complete the request within 20 redirects"
+              raise HTTP::APIConnectionError.new(message: message, request: request)
+            end
+            if location.scheme != "http" && location.scheme != "https"
+              message = "tried to redirect to a non-http URL"
+              raise HTTP::APIConnectionError.new(message: message, request: request)
+            end
+            request = request.merge(resolve_uri_elements({url: location}))
+            # from whatwg fetch spec
+            if ([301, 302].include?(status) && request[:method] == :post) || (status == 303)
+              request[:method] = request[:method] == :head ? :head : :get
+              request[:body] = nil
+              request[:headers] = request[:headers].reject do |k|
+                %w[content-encoding content-language content-location content-type content-length].include?(k)
+              end
+            end
+            # from undici
+            if Sink::Util.uri_origin(prev_uri) != Sink::Util.uri_origin(location)
+              request[:headers] = request[:headers].reject do |k|
+                %w[authorization cookie proxy-authorization host].include?(k)
+              end
+            end
+            return send_request(
+              request,
+              max_retries: max_retries,
+              timeout: timeout,
+              redirect_count: redirect_count + 1
+            )
+          end
+        rescue Net::HTTPBadResponse
+          if retries >= max_retries
+            message = "failed to complete the request within #{max_retries} retries"
+            raise HTTP::APIConnectionError.new(message: message, request: request)
+          end
+        rescue Timeout::Error
+          if retries >= max_retries
+            message = "failed to complete the request within #{max_retries} retries"
+            raise HTTP::APITimeoutError.new(message: message, request: request)
+          end
+        end
+
+        if (response && !should_retry?(response)) || retries >= max_retries
+          raise make_status_error_from_response(response)
+        end
+
+        retries += 1
+        base_delay = header_based_retry(response)
+        if base_delay
+          delay = base_delay
+        else
+          base_delay = (delay * (2**retries))
+          jitter_factor = 1 - (0.25 * rand)
+          delay = (base_delay * jitter_factor).clamp(0, max_delay)
+        end
+
+        if response&.key?("x-stainless-mock-sleep")
+          request[:headers]["x-stainless-mock-slept"] = delay
+        else
+          sleep(delay)
+        end
+      end
+    end
+
+    # Execute the request specified by req + opts. This is the method that all
+    # resource methods call into.
+    # Params req & opts are kept separate up until this point so that we can
+    # validate opts as it was given to us by the user.
+    def request(req, opts)
+      validate_request(req, opts)
+      options = Util.deep_merge(req, opts)
+      request_args = prep_request(options)
+      response = send_request(
+        request_args,
+        max_retries: opts.fetch(:max_retries, @max_retries),
+        timeout: opts.fetch(:timeout, @timeout),
+        redirect_count: 0
+      )
+      raw_data =
+        case response.content_type
+        when "application/json"
+          begin
+            data = JSON.parse(response.body, symbolize_names: true)
+            req[:unwrap] ? data[req[:unwrap]] : data
+          rescue JSON::ParserError
+            response.body
+          end
+          # TODO: parsing other response types
+        else
+          response.body
+        end
+
+      if (page = req[:page])
+        model = req.fetch(:model)
+        page.new(model, raw_data, response, self, req, opts)
+      elsif (model = req[:model])
+        Converter.convert(model, raw_data)
+      else
+        raw_data
+      end
+    end
+
+    # @return [String]
+    def inspect
+      base_url = Util.uri_from_req(
+        {host: @host, scheme: @scheme, port: @port, path: @base_path},
+        absolute: true
+      )
+      "#<#{self.class.name}:0x#{object_id.to_s(16)} base_url=#{base_url.inspect} max_retries=#{@max_retries.inspect} timeout=#{@timeout.inspect}>"
+    end
+  end
+
+  class Error < StandardError
+  end
+
+  module HTTP
+    class Error < Sink::Error
+    end
+
+    class ResponseError < Error
+      attr_reader :response, :body
+
+      # @!attribute [r] code
+      #   @return [Integer]
+      attr_reader :code
+
+      def initialize(message:, response:, body:)
+        super(message)
+        @response = response
+        @body = body
+        @code = response.code.to_i
+      end
+    end
+
+    class RequestError < Error
+      attr_reader :request
+
+      def initialize(message:, request:)
+        super(message)
+        @request = request
+      end
+    end
+
+    class BadRequestError < ResponseError
+    end
+
+    class AuthenticationError < ResponseError
+    end
+
+    class PermissionDeniedError < ResponseError
+    end
+
+    class NotFoundError < ResponseError
+    end
+
+    class ConflictError < ResponseError
+    end
+
+    class UnprocessableEntityError < ResponseError
+    end
+
+    class RateLimitError < ResponseError
+    end
+
+    class InternalServerError < ResponseError
+    end
+
+    class APIStatusError < ResponseError
+    end
+
+    class APIConnectionError < RequestError
+    end
+
+    class APITimeoutError < RequestError
+    end
+  end
+end

data/lib/sink/base_model.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+module Sink
+  # @!visibility private
+  module Converter
+    # Based on `value`, returns a value that conforms to `type`, to the extent possible:
+    # - If the given `value` conforms to `type` already, the given `value`.
+    # - If it's possible and safe to convert the given `value` to `type`, such a converted value.
+    # - Otherwise, the given `value` unaltered.
+    def self.convert(type, value)
+      # If `type.is_a?(Converter)`, `type` is an instance of a class that mixes
+      # in `Converter`, indicating that the type should define `#convert` on this
+      # instance. This is used for Enums and ArrayOfs, which are parameterized.
+      # If `type.include?(Converter)`, `type` is a class that mixes in `Converter`
+      # which we use to signal that the class should define `.convert`. This is
+      # used where the class itself fully specifies the type, like model classes.
+      # We don't monkey-patch Ruby-native types, so those need to be handled
+      # directly.
+      if type.is_a?(Converter) || type.include?(Converter)
+        type.convert(value)
+      elsif type == Date
+        Date.parse(value)
+      elsif type == Time
+        Time.parse(value)
+      elsif type == NilClass
+        nil
+      elsif type == Float
+        value.is_a?(Numeric) ? value.to_f : value
+      elsif [Object, Integer, String, Hash].include?(type)
+        value
+      else
+        raise StandardError, "Unexpected type #{type}"
+      end
+    end
+  end
+
+  # When we don't know what to expect for the value.
+  # @!visibility private
+  class Unknown
+    include Converter
+
+    def self.convert(value)
+      value
+    end
+  end
+
+  # Ruby has no Boolean class; this is something for models to refer to.
+  # @!visibility private
+  class BooleanModel
+    include Converter
+
+    def self.convert(value)
+      value
+    end
+  end
+
+  # A value from among a specified list of options. OpenAPI enum values map to
+  # Ruby values in the SDK as follows:
+  # boolean => true|false
+  # integer => Integer
+  # float => Float
+  # string => Symbol
+  # We can therefore convert string values to Symbols, but can't convert other
+  # values safely.
+  # @!visibility private
+  class Enum
+    include Converter
+
+    def self.convert(value)
+      if value.is_a?(String)
+        value.to_sym
+      else
+        value
+      end
+    end
+
+    # @return [Array<Symbol>] All of the valid Symbol values for this enum.
+    def self.values
+      @values ||= constants.map { |c| const_get(c) }
+    end
+  end
+
+  # Array of items of a given type.
+  # @!visibility private
+  class ArrayOf
+    include Converter
+
+    def initialize(items_type_info = nil, enum: nil)
+      @items_type_fn = enum || (items_type_info.is_a?(Proc) ? items_type_info : -> { items_type_info })
+    end
+
+    def convert(value)
+      items_type = @items_type_fn.call
+      value.map { |item| Converter.convert(items_type, item) }
+    end
+  end
+
+  class BaseModel
+    include Converter
+
+    # @!visibility private
+    # Assumes superclass fields are totally defined before fields are accessed / defined on subclasses.
+    # @return [Hash{Symbol => Hash{Symbol => Object}}]
+    def self.fields
+      @fields ||= (superclass == BaseModel ? {} : superclass.fields.dup)
+    end
+
+    # @!visibility private
+    # @param name_sym [Symbol]
+    # @param api_name [Symbol, nil]
+    # @param type_info [Proc, Object]
+    # @param mode [Symbol]
+    # @return [void]
+    def self.add_field(name_sym, api_name:, type_info:, mode:)
+      type_fn = type_info.is_a?(Proc) ? type_info : -> { type_info }
+      key = api_name || name_sym
+      fields[name_sym] = {type_fn: type_fn, mode: mode, key: key}
+
+      define_method(name_sym) do
+        field_type = type_fn.call
+        Converter.convert(field_type, @data[key])
+      rescue StandardError
+        name = self.class.name.split("::").last
+        raise ConversionError,
+              "Failed to parse #{name}.#{name_sym} as #{field_type.inspect}. " \
+              "To get the unparsed API response, use #{name}[:#{key}]."
+      end
+      define_method("#{name_sym}=") { |val| @data[key] = val }
+    end
+
+    # @!visibility private
+    # NB `required` is just a signal to the reader. We don't do runtime validation anyway.
+    def self.required(name_sym, type_info = nil, mode = :rw, api_name: nil, enum: nil)
+      add_field(name_sym, api_name: api_name, type_info: enum || type_info, mode: mode)
+    end
+
+    # @!visibility private
+    # NB `optional` is just a signal to the reader. We don't do runtime validation anyway.
+    def self.optional(name_sym, type_info = nil, mode = :rw, api_name: nil, enum: nil)
+      add_field(name_sym, api_name: api_name, type_info: enum || type_info, mode: mode)
+    end
+
+    # @!visibility private
+    def self.convert(data)
+      new(data)
+    end
+
+    # Create a new instance of a model.
+    # @param data [Hash{Symbol => Object}] Raw data to initialize the model with.
+    def initialize(data = {})
+      @data = {}
+      # TODO: what if data isn't a hash?
+      data.each do |field_name, value|
+        next if value.nil?
+
+        field = self.class.fields[field_name.to_sym]
+        if field
+          next if field[:mode] == :w
+        end
+        @data[field_name.to_sym] = value
+      end
+    end
+
+    # Returns a Hash of the data underlying this object.
+    # Keys are Symbols and values are the raw values from the response.
+    # The return value indicates which values were ever set on the object -
+    # i.e. there will be a key in this hash if they ever were, even if the
+    # set value was nil.
+    # This method is not recursive.
+    # The returned value is shared by the object, so it should not be mutated.
+    #
+    # @return [Hash{Symbol => Object}] Data for this object.
+    def to_h
+      @data
+    end
+
+    alias_method :to_hash, :to_h
+
+    # Returns the raw value associated with the given key, if found. Otherwise, nil is returned.
+    # It is valid to lookup keys that are not in the API spec, for example to access
+    # undocumented features.
+    # This method does not parse response data into higher-level types.
+    # Lookup by anything other than a Symbol is an ArgumentError.
+    #
+    # @param key [Symbol] Key to look up by.
+    #
+    # @return [Object, nil] The raw value at the given key.
+    def [](key)
+      if !key.instance_of?(Symbol)
+        raise ArgumentError, "Expected symbol key for lookup, got #{key.inspect}"
+      end
+      @data[key]
+    end
+
+    # @param keys [Array<Symbol>, nil]
+    # @return [Hash{Symbol => Object}]
+    def deconstruct_keys(keys)
+      (keys || self.class.fields.keys).to_h do |k|
+        if !k.instance_of?(Symbol)
+          raise ArgumentError, "Expected symbol key for lookup, got #{k.inspect}"
+        end
+
+        if !self.class.fields.key?(k)
+          raise KeyError, "Expected one of #{self.class.fields.keys}, got #{k.inspect}"
+        end
+
+        [k, method(k).call]
+      end
+    end
+
+    # @return [String]
+    def inspect
+      "#<#{self.class.name}:0x#{object_id.to_s(16)} #{deconstruct_keys(nil).map do |k, v|
+        "#{k}=#{v.inspect}"
+      end.join(' ')}>"
+    end
+
+    # @return [String]
+    def to_s
+      @data.to_s
+    end
+  end
+
+  class ConversionError < Error
+  end
+end

data/lib/sink/client.rb

@@ -0,0 +1,391 @@
+# frozen_string_literal: true
+
+module Sink
+  class Client < BaseClient
+    # Default max number of retries to attempt after a failed retryable request.
+    DEFAULT_MAX_RETRIES = 1
+
+    # Client option
+    # @return [String]
+    attr_reader :user_token
+
+    # Client option
+    # @return [String]
+    attr_reader :api_key_header
+
+    # Client option
+    # @return [String]
+    attr_reader :api_key_query
+
+    # Client option
+    # @return [String]
+    attr_reader :username
+
+    # Client option
+    # @return [String]
+    attr_reader :client_id
+
+    # Client option
+    # @return [String]
+    attr_reader :client_secret
+
+    # Client option
+    # @return [Boolean]
+    attr_reader :some_boolean_arg
+
+    # Client option
+    # @return [Integer]
+    attr_reader :some_integer_arg
+
+    # Client option
+    # @return [Float]
+    attr_reader :some_number_arg
+
+    # Client option
+    # @return [Float]
+    attr_reader :some_number_arg_required
+
+    # Client option
+    # @return [Float]
+    attr_reader :some_number_arg_required_no_default
+
+    # Client option
+    # @return [Float]
+    attr_reader :some_number_arg_required_no_default_no_env
+
+    # Client option
+    # @return [String]
+    attr_reader :required_arg_no_env
+
+    # Client option
+    # @return [String]
+    attr_reader :required_arg_no_env_with_default
+
+    # Client option
+    # @return [String]
+    attr_reader :client_path_param
+
+    # Client option
+    # @return [String]
+    attr_reader :camel_case_path
+
+    # Client option
+    # @return [String]
+    attr_reader :client_query_param
+
+    # Client option
+    # @return [String]
+    attr_reader :client_path_or_query_param
+
+    # @return [Sink::Resources::Testing]
+    attr_reader :testing
+
+    # @return [Sink::Resources::ComplexQueries]
+    attr_reader :complex_queries
+
+    # @return [Sink::Resources::Casing]
+    attr_reader :casing
+
+    # @return [Sink::Resources::Tools]
+    attr_reader :tools
+
+    # @return [Sink::Resources::UndocumentedResource]
+    attr_reader :undocumented_resource
+
+    # @return [Sink::Resources::MethodConfig]
+    attr_reader :method_config
+
+    # @return [Sink::Resources::Streaming]
+    attr_reader :streaming
+
+    # @return [Sink::Resources::PaginationTests]
+    attr_reader :pagination_tests
+
+    # @return [Sink::Resources::Docstrings]
+    attr_reader :docstrings
+
+    # @return [Sink::Resources::InvalidSchemas]
+    attr_reader :invalid_schemas
+
+    # @return [Sink::Resources::ResourceRefs]
+    attr_reader :resource_refs
+
+    # @return [Sink::Resources::Cards]
+    attr_reader :cards
+
+    # @return [Sink::Resources::Files]
+    attr_reader :files
+
+    # @return [Sink::Resources::Resources]
+    attr_reader :resources
+
+    # @return [Sink::Resources::ConfigTools]
+    attr_reader :config_tools
+
+    # Stainless API company
+    # @return [Sink::Resources::Company]
+    attr_reader :company
+
+    # @return [Sink::Resources::OpenAPIFormats]
+    attr_reader :openapi_formats
+
+    # @return [Sink::Resources::Parent]
+    attr_reader :parent
+
+    # @return [Sink::Resources::Envelopes]
+    attr_reader :envelopes
+
+    # @return [Sink::Resources::Types]
+    attr_reader :types
+
+    # @return [Sink::Resources::Clients]
+    attr_reader :clients
+
+    # @return [Sink::Resources::Names]
+    attr_reader :names
+
+    # Widget is love
+    # Widget is life
+    # @return [Sink::Resources::Widgets]
+    attr_reader :widgets
+
+    # @return [Sink::Resources::Responses]
+    attr_reader :responses
+
+    # @return [Sink::Resources::PathParams]
+    attr_reader :path_params
+
+    # @return [Sink::Resources::PositionalParams]
+    attr_reader :positional_params
+
+    # @return [Sink::Resources::EmptyBody]
+    attr_reader :empty_body
+
+    # @return [Sink::Resources::QueryParams]
+    attr_reader :query_params
+
+    # @return [Sink::Resources::BodyParams]
+    attr_reader :body_params
+
+    # @return [Sink::Resources::HeaderParams]
+    attr_reader :header_params
+
+    # @return [Sink::Resources::MixedParams]
+    attr_reader :mixed_params
+
+    # @return [Sink::Resources::MakeAmbiguousSchemasLooser]
+    attr_reader :make_ambiguous_schemas_looser
+
+    # @return [Sink::Resources::MakeAmbiguousSchemasExplicit]
+    attr_reader :make_ambiguous_schemas_explicit
+
+    # @return [Sink::Resources::DecoratorTests]
+    attr_reader :decorator_tests
+
+    # @return [Sink::Resources::Tests]
+    attr_reader :tests
+
+    # @return [Sink::Resources::DeeplyNested]
+    attr_reader :deeply_nested
+
+    # @return [Sink::Resources::Version1_30Names]
+    attr_reader :version_1_30_names
+
+    # @return [Sink::Resources::Recursion]
+    attr_reader :recursion
+
+    # @return [Sink::Resources::SharedQueryParams]
+    attr_reader :shared_query_params
+
+    # @return [Sink::Resources::ModelReferencedInParentAndChild]
+    attr_reader :model_referenced_in_parent_and_child
+
+    # Creates and returns a new client for interacting with the API.
+    #
+    # @param environment ["production", "sandbox", nil] Specifies the environment to use for the API.
+    #
+    #   Each environment maps to a different base URL:
+    #
+    #   - `production` corresponds to `https://demo.stainlessapi.com/`
+    #   - `sandbox` corresponds to `https://demo-sanbox.stainlessapi.com/`
+    # @param base_url [String, nil] Override the default base URL for the API, e.g., `"https://api.example.com/v2/"`
+    # @param user_token [String, nil] The API Key for the SINK API, sent as a bearer token Defaults to
+    #   `ENV["SINK_CUSTOM_API_KEY_ENV"]`
+    # @param api_key_header [String, nil] The API Key for the SINK API, sent as an api key header Defaults to
+    #   `ENV["SINK_CUSTOM_API_KEY_HEADER_ENV"]`
+    # @param api_key_query [String, nil] The API Key for the SINK API, sent as an api key query Defaults to
+    #   `ENV["SINK_CUSTOM_API_KEY_QUERY_ENV"]`
+    # @param username [String, nil] Defaults to `ENV["SINK_USER"]`
+    # @param client_id [String, nil] Defaults to `ENV["SINK_CLIENT_ID"]`
+    # @param client_secret [String, nil] Defaults to `ENV["SINK_CLIENT_SECRET"]`
+    # @param some_boolean_arg [Boolean, nil] Defaults to `ENV["SINK_SOME_BOOLEAN_ARG"]`
+    # @param some_integer_arg [Integer, nil] Defaults to `ENV["SINK_SOME_INTEGER_ARG"]`
+    # @param some_number_arg [Float, nil] Defaults to `ENV["SINK_SOME_NUMBER_ARG"]`
+    # @param some_number_arg_required [Float, nil] Defaults to `ENV["SINK_SOME_NUMBER_ARG"]`
+    # @param some_number_arg_required_no_default [Float, nil] Defaults to `ENV["SINK_SOME_NUMBER_ARG"]`
+    # @param some_number_arg_required_no_default_no_env [Float, nil]
+    # @param required_arg_no_env [String, nil]
+    # @param required_arg_no_env_with_default [String, nil]
+    # @param client_path_param [String, nil]
+    # @param camel_case_path [String, nil]
+    # @param client_query_param [String, nil]
+    # @param client_path_or_query_param [String, nil]
+    # @param max_retries [Integer] Max number of retries to attempt after a failed retryable request.
+    #
+    # @return [Sink::Client]
+    def initialize(
+      environment: nil,
+      base_url: nil,
+      user_token: nil,
+      api_key_header: nil,
+      api_key_query: nil,
+      username: nil,
+      client_id: nil,
+      client_secret: nil,
+      some_boolean_arg: nil,
+      some_integer_arg: nil,
+      some_number_arg: nil,
+      some_number_arg_required: nil,
+      some_number_arg_required_no_default: nil,
+      some_number_arg_required_no_default_no_env: nil,
+      required_arg_no_env: nil,
+      required_arg_no_env_with_default: nil,
+      client_path_param: nil,
+      camel_case_path: nil,
+      client_query_param: nil,
+      client_path_or_query_param: nil,
+      max_retries: DEFAULT_MAX_RETRIES,
+      timeout: 60
+    )
+      environments = {"production" => "https://demo.stainlessapi.com/", "sandbox" => "https://demo-sanbox.stainlessapi.com/"}
+      if environment && base_url
+        raise ArgumentError, "both environment and base_url given, expected only one"
+      elsif environment
+        if !environments.key?(environment.to_s)
+          raise ArgumentError, "environment must be one of #{environments.keys}, got #{environment}"
+        end
+        base_url = environments[environment.to_s]
+      elsif !base_url
+        base_url = "https://demo.stainlessapi.com/"
+      end
+
+      username_header = [username, ENV["SINK_USER"]].find { |v| !v.nil? }
+      if username_header.nil?
+        raise ArgumentError, "username is required"
+      end
+      client_secret_header = [client_secret, ENV["SINK_CLIENT_SECRET"], "hellosecret"].find { |v| !v.nil? }
+      some_integer_arg_header = [some_integer_arg, ENV["SINK_SOME_INTEGER_ARG"], 123].find { |v| !v.nil? }
+      headers = {
+        "My-Api-Version" => "11",
+        "X-Enable-Metrics" => "1",
+        "X-Client-UserName" => username_header,
+        "X-Client-Secret" => client_secret_header,
+        "X-Integer" => some_integer_arg_header
+      }
+
+      idempotency_header = "Idempotency-Key"
+
+      @user_token = [user_token, ENV["SINK_CUSTOM_API_KEY_ENV"]].find { |v| !v.nil? }
+      @api_key_header = [api_key_header, ENV["SINK_CUSTOM_API_KEY_HEADER_ENV"]].find { |v| !v.nil? }
+      @api_key_query = [api_key_query, ENV["SINK_CUSTOM_API_KEY_QUERY_ENV"]].find { |v| !v.nil? }
+      @client_id = [client_id, ENV["SINK_CLIENT_ID"]].find { |v| !v.nil? }
+      @some_boolean_arg = [some_boolean_arg, ENV["SINK_SOME_BOOLEAN_ARG"], true].find { |v| !v.nil? }
+      @some_number_arg = [some_number_arg, ENV["SINK_SOME_NUMBER_ARG"], 1.2].find { |v| !v.nil? }
+      @some_number_arg_required = [some_number_arg_required, ENV["SINK_SOME_NUMBER_ARG"], 1.2].find do |v|
+        !v.nil?
+      end
+      @some_number_arg_required_no_default = [
+        some_number_arg_required_no_default,
+        ENV["SINK_SOME_NUMBER_ARG"]
+      ].find do |v|
+        !v.nil?
+      end
+      if @some_number_arg_required_no_default.nil?
+        raise ArgumentError, "some_number_arg_required_no_default is required"
+      end
+      @some_number_arg_required_no_default_no_env = some_number_arg_required_no_default_no_env
+      if @some_number_arg_required_no_default_no_env.nil?
+        raise ArgumentError, "some_number_arg_required_no_default_no_env is required"
+      end
+      @required_arg_no_env = required_arg_no_env
+      if @required_arg_no_env.nil?
+        raise ArgumentError, "required_arg_no_env is required"
+      end
+      @required_arg_no_env_with_default = [required_arg_no_env_with_default, "hi!"].find { |v| !v.nil? }
+      @client_query_param = client_query_param
+
+      super(
+        base_url: base_url,
+        max_retries: max_retries,
+        timeout: timeout,
+        headers: headers,
+        idempotency_header: idempotency_header
+      )
+
+      @testing = Sink::Resources::Testing.new(client: self)
+      @complex_queries = Sink::Resources::ComplexQueries.new(client: self)
+      @casing = Sink::Resources::Casing.new(client: self)
+      @tools = Sink::Resources::Tools.new(client: self)
+      @undocumented_resource = Sink::Resources::UndocumentedResource.new(client: self)
+      @method_config = Sink::Resources::MethodConfig.new(client: self)
+      @streaming = Sink::Resources::Streaming.new(client: self)
+      @pagination_tests = Sink::Resources::PaginationTests.new(client: self)
+      @docstrings = Sink::Resources::Docstrings.new(client: self)
+      @invalid_schemas = Sink::Resources::InvalidSchemas.new(client: self)
+      @resource_refs = Sink::Resources::ResourceRefs.new(client: self)
+      @cards = Sink::Resources::Cards.new(client: self)
+      @files = Sink::Resources::Files.new(client: self)
+      @resources = Sink::Resources::Resources.new(client: self)
+      @config_tools = Sink::Resources::ConfigTools.new(client: self)
+      @company = Sink::Resources::Company.new(client: self)
+      @openapi_formats = Sink::Resources::OpenAPIFormats.new(client: self)
+      @parent = Sink::Resources::Parent.new(client: self)
+      @envelopes = Sink::Resources::Envelopes.new(client: self)
+      @types = Sink::Resources::Types.new(client: self)
+      @clients = Sink::Resources::Clients.new(client: self)
+      @names = Sink::Resources::Names.new(client: self)
+      @widgets = Sink::Resources::Widgets.new(client: self)
+      @responses = Sink::Resources::Responses.new(client: self)
+      @path_params = Sink::Resources::PathParams.new(client: self)
+      @positional_params = Sink::Resources::PositionalParams.new(client: self)
+      @empty_body = Sink::Resources::EmptyBody.new(client: self)
+      @query_params = Sink::Resources::QueryParams.new(client: self)
+      @body_params = Sink::Resources::BodyParams.new(client: self)
+      @header_params = Sink::Resources::HeaderParams.new(client: self)
+      @mixed_params = Sink::Resources::MixedParams.new(client: self)
+      @make_ambiguous_schemas_looser = Sink::Resources::MakeAmbiguousSchemasLooser.new(client: self)
+      @make_ambiguous_schemas_explicit = Sink::Resources::MakeAmbiguousSchemasExplicit.new(client: self)
+      @decorator_tests = Sink::Resources::DecoratorTests.new(client: self)
+      @tests = Sink::Resources::Tests.new(client: self)
+      @deeply_nested = Sink::Resources::DeeplyNested.new(client: self)
+      @version_1_30_names = Sink::Resources::Version1_30Names.new(client: self)
+      @recursion = Sink::Resources::Recursion.new(client: self)
+      @shared_query_params = Sink::Resources::SharedQueryParams.new(client: self)
+      @model_referenced_in_parent_and_child = Sink::Resources::ModelReferencedInParentAndChild.new(client: self)
+    end
+
+    # @!visibility private
+    def make_status_error(message:, body:, response:)
+      case response.code.to_i
+      when 400
+        Sink::HTTP::BadRequestError.new(message: message, response: response, body: body)
+      when 401
+        Sink::HTTP::AuthenticationError.new(message: message, response: response, body: body)
+      when 403
+        Sink::HTTP::PermissionDeniedError.new(message: message, response: response, body: body)
+      when 404
+        Sink::HTTP::NotFoundError.new(message: message, response: response, body: body)
+      when 409
+        Sink::HTTP::ConflictError.new(message: message, response: response, body: body)
+      when 422
+        Sink::HTTP::UnprocessableEntityError.new(message: message, response: response, body: body)
+      when 429
+        Sink::HTTP::RateLimitError.new(message: message, response: response, body: body)
+      when 500..599
+        Sink::HTTP::InternalServerError.new(message: message, response: response, body: body)
+      else
+        Sink::HTTP::APIStatusError.new(message: message, response: response, body: body)
+      end
+    end
+  end
+end

data/lib/sink/util.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Sink
+  # @!visibility private
+  class Util
+    # Use this to indicate that a value should be explicitly removed from a data structure
+    # when using `Sink::Util.deep_merge`.
+    # E.g. merging `{a: 1}` and `{a: OMIT}` should produce `{}`, where merging `{a: 1}` and
+    # `{}` would produce `{a: 1}`.
+    OMIT = Object.new.freeze
+
+    # Recursively merge one hash with another.
+    # If the values at a given key are not both hashes, just take the new value.
+    # @param concat [true, false] whether to merge sequences by concatenation
+    def self.deep_merge(left, right, concat: false)
+      right_cleaned = if right.is_a?(Hash)
+        right.reject { |_, value| value == OMIT }
+      else
+        right
+      end
+
+      if left.is_a?(Hash) && right_cleaned.is_a?(Hash)
+        left
+          .reject { |key, _| right[key] == OMIT }
+          .merge(right_cleaned) do |_k, old_val, new_val|
+            deep_merge(old_val, new_val, concat: concat)
+          end
+      elsif left.is_a?(Array) && right_cleaned.is_a?(Array) && concat
+        left.concat(right_cleaned)
+      else
+        right_cleaned
+      end
+    end
+
+    def self.coerce_integer(str)
+      Integer(str, exception: false) || str
+    end
+
+    def self.coerce_float(str)
+      Float(str, exception: false) || str
+    end
+
+    def self.coerce_boolean(input)
+      case input
+      in "true"
+        true
+      in "false"
+        false
+      else
+        input
+      end
+    end
+
+    def self.uri_from_req(req, absolute:)
+      query_string = ("?#{URI.encode_www_form(req[:query])}" if req[:query])
+      uri = String.new
+      if absolute
+        uri << "#{req[:scheme]}://#{req[:host]}"
+        if req[:port] && !(req[:scheme] == "https" && req[:port] == 443) && !(req[:scheme] == "http" && req[:port] == 80)
+          uri << ":#{req[:port]}"
+        end
+      end
+      uri << ((req[:path] || "/") + (query_string || ""))
+    end
+
+    def self.uri_origin(uri)
+      if uri.respond_to?(:origin)
+        uri.origin
+      else
+        "#{uri.scheme}://#{uri.host}#{uri.port == uri.default_port ? '' : ":#{uri.port}"}"
+      end
+    end
+
+    def self.normalized_headers(*headers)
+      {}.merge(*headers.compact).transform_keys(&:downcase)
+    end
+  end
+end

data/lib/sink/version.rb

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

data/lib/sink.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+# Standard libraries.
+require "cgi"
+require "date"
+require "json"
+require "net/http"
+require "securerandom"
+require "time"
+require "uri"
+
+# Gems.
+require "connection_pool"

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: test-test-sink-test-test2
+version: !ruby/object:Gem::Version
+  version: 0.0.5
+platform: ruby
+authors:
+- Sink
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2024-11-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: connection_pool
+  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: 
+email: dev@stainlessapi.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- README.md
+- lib/sink.rb
+- lib/sink/base_client.rb
+- lib/sink/base_model.rb
+- lib/sink/client.rb
+- lib/sink/util.rb
+- lib/sink/version.rb
+homepage: https://rubydoc.info/github/ms-jpq/test-publishing-yard
+licenses: []
+metadata:
+  homepage_uri: https://rubydoc.info/github/ms-jpq/test-publishing-yard
+  source_code_uri: https://github.com/ms-jpq/test-publishing-yard
+  rubygems_mfa_required: 'true'
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.27
+signing_key: 
+specification_version: 4
+summary: Ruby library to access the Sink API
+test_files: []