ruby-gems-publish-test 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ac8bd8ba7b57798389ba503764caa99a0c1b3f6b7af024861292d3fde5e57f28
+  data.tar.gz: 49cde772617f5d22f632b07428cd5e12cddc1acaaf1ba129b0bda0f696900ef2
+SHA512:
+  metadata.gz: 4ff4ecd518225a2d57e82db5d7f793b5ecce32e2ce8eae5b4dee7709e1001bf85ac19e578a840c2553a0298972f31659b0d8f1ac89faab144e41d1f43030d140
+  data.tar.gz: 7ba25bde4bc48d3e2459cf0f6d57fc3dec5b07b979264da6184f7a9fd076d6987438e1714fdd11a8663d33d304ba9a2853820868b659eaf75c117003d2745b18

data/README.md

@@ -0,0 +1,233 @@
+# RubyGemsPublishTest Ruby SDK 0.1.0
+
+
+Welcome to the RubyGemsPublishTest SDK documentation. This guide will help you get started with integrating and using the RubyGemsPublishTest SDK in your project.
+
+## Versions
+
+- API version: `1.0.0`
+- SDK version: `0.1.0`
+
+## About the API
+
+This is a sample Pet Store Server based on the OpenAPI 3.0 specification.  You can find out more about
+Swagger at [https://swagger.io](https://swagger.io). In the third iteration of the pet store, we've switched to the design first approach!
+You can now help us improve the API whether it's by making changes to the definition itself or to the code.
+That way, with time, we can improve the API in general, and expose some of the new features in OAS3.
+
+Some useful links:
+- [The Pet Store repository](https://github.com/swagger-api/swagger-petstore)
+- [The source API definition for the Pet Store](https://github.com/swagger-api/swagger-petstore/blob/master/src/main/resources/openapi.yaml)
+
+## Table of Contents
+- [Setup & Configuration](#setup--configuration)
+	- [Supported Language Versions](#supported-language-versions)
+	- [Installation](#installation)
+- [Authentication](#authentication)
+	- [Access Token Authentication](#access-token-authentication)
+	- [API Key Authentication](#api-key-authentication)
+- [Sample Usage](#sample-usage)
+- [Services](#services)
+- [Models](#models)
+- [License](#license)
+
+# Setup & Configuration
+
+## Supported Language Versions
+
+This SDK is compatible with the following versions: `Ruby >= 3.3`
+
+## Installation
+
+### Using RubyGems
+
+If the gem is published to RubyGems or a private gem server, install it directly:
+
+```bash
+gem install ruby_gems_publish_test
+```
+
+### Using Bundler (recommended)
+
+Add the gem to your application's `Gemfile`:
+
+```ruby
+gem 'ruby_gems_publish_test'
+```
+
+Then run:
+
+```bash
+bundle install
+```
+
+## Verifying the SDK setup
+
+To verify the SDK works correctly, you can run the included example:
+
+1. Install dependencies:
+
+```bash
+bundle install
+```
+
+2. Run the example:
+
+```bash
+bundle exec ruby example/example.rb
+```
+
+## Configuration Scopes
+
+The SDK supports three nested configuration scopes. The most-specific scope always wins; changes made at a narrower scope do not persist beyond that scope.
+
+### SDK-level (default)
+
+Set once at initialization and applied to every request unless overridden.
+
+```ruby
+require 'ruby_gems_publish_test'
+
+sdk = RubyGemsPublishTest::Client.new(
+  base_url: 'https://api.example.com',
+  timeout: 30,
+  # auth credentials are also set here — see the Authentication section below
+)
+```
+
+### Service-level
+
+Override config for all requests made through a particular service instance. The original client and other services are not affected.
+
+```ruby
+override = RubyGemsPublishTest::Config.new(token: 'SERVICE_TOKEN')
+service = sdk.pet(config: override)
+response = service.some_method
+```
+
+### Per-request
+
+Override config for a single call only. The next call automatically reverts to the enclosing scope.
+
+```ruby
+response = sdk.pet.some_method(
+  config: RubyGemsPublishTest::Config.new(token: 'REQUEST_TOKEN'),
+)
+
+# The next call uses the original SDK-level config automatically
+response = sdk.pet.some_method
+```
+
+Passing `config: nil` explicitly bypasses any service-level override for that single call, falling back directly to the SDK-level (connection) defaults.
+
+
+## Authentication
+
+### Access Token Authentication
+The RubyGemsPublishTest API uses an Access Token for authentication.
+
+This token must be provided to authenticate your requests to the API.
+
+#### Setting the Access Token
+
+When you initialize the SDK, you can set the access token as follows:
+
+```ruby
+require 'ruby_gems_publish_test'
+
+sdk = RubyGemsPublishTest::Client.new(token: 'YOUR_TOKEN')
+```
+
+If you need to set or update the access token after initializing the SDK, you can use:
+
+```ruby
+require 'ruby_gems_publish_test'
+
+sdk = RubyGemsPublishTest::Client.new
+
+sdk.token = 'YOUR_TOKEN'
+```
+### API Key Authentication
+The RubyGemsPublishTest API uses API keys as a form of authentication. An API key is a unique identifier used to authenticate a user, developer, or a program that is calling the API.
+
+#### Setting the API key
+
+When you initialize the SDK, you can set the API key as follows:
+
+```ruby
+require 'ruby_gems_publish_test'
+
+sdk = RubyGemsPublishTest::Client.new(api_key: 'YOUR_API_KEY')
+```
+
+If you need to set or update the API key after initializing the SDK, you can use:
+
+```ruby
+require 'ruby_gems_publish_test'
+
+sdk = RubyGemsPublishTest::Client.new
+
+sdk.api_key = 'YOUR_API_KEY'
+```
+
+
+
+
+# Sample Usage
+
+Below is a comprehensive example demonstrating how to authenticate and call a simple endpoint:
+
+```ruby
+require 'ruby_gems_publish_test'
+
+sdk = RubyGemsPublishTest::Client.new(api_key: 'YOUR_API_KEY')
+
+response = sdk.store.get_inventory
+
+puts response
+
+```
+
+## Services
+
+The SDK provides various services to interact with the API.
+
+
+<details>
+<summary>Below is a list of all available services with links to their detailed documentation:</summary>
+
+| Name |
+| :--- |
+| [Pet](documentation/services/pet.md) |
+| [Store](documentation/services/store.md) |
+| [User](documentation/services/user.md) |
+</details>
+
+
+## Models
+
+The SDK includes several models that represent the data structures used in API requests and responses. These models help in organizing and managing the data efficiently.
+
+
+<details>
+<summary>Below is a list of all available models with links to their detailed documentation:</summary>
+
+| Name       | Description |
+| :--------- | :---------- |
+| [Pet](documentation/models/pet.md) |  |
+| [Category](documentation/models/category.md) |  |
+| [Tag](documentation/models/tag.md) |  |
+| [FindPetsByStatusStatus](documentation/models/find_pets_by_status_status.md) |  |
+| [ApiResponse](documentation/models/api_response.md) |  |
+| [Order](documentation/models/order.md) |  |
+| [User](documentation/models/user.md) |  |
+</details>
+
+
+## License
+
+This SDK is licensed under the MIT License.
+
+See the [LICENSE](LICENSE) file for more details.
+
+

data/lib/ruby_gems_publish_test/async/services/pet.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'concurrent'
+
+module RubyGemsPublishTest
+  module Async
+    # Async variant of ::RubyGemsPublishTest::Pet. Each method returns a
+    # +Concurrent::Promises::Future+ that runs the corresponding synchronous call on a
+    # background thread; resolve it with +#value!+ (re-raises the SDK's typed errors) or
+    # +#value+ (returns nil on failure).
+    class Pet
+      def initialize(connection_factory, config = nil)
+        @connection_factory = connection_factory
+        @config = config
+      end
+
+      # Async variant of #add_pet; returns a Concurrent::Promises::Future.
+      def add_pet(*args, **kwargs, &block)
+        Concurrent::Promises.future { service.add_pet(*args, **kwargs, &block) }
+      end
+
+      # Async variant of #update_pet; returns a Concurrent::Promises::Future.
+      def update_pet(*args, **kwargs, &block)
+        Concurrent::Promises.future { service.update_pet(*args, **kwargs, &block) }
+      end
+
+      # Async variant of #find_pets_by_status; returns a Concurrent::Promises::Future.
+      def find_pets_by_status(*args, **kwargs, &block)
+        Concurrent::Promises.future { service.find_pets_by_status(*args, **kwargs, &block) }
+      end
+
+      # Async variant of #find_pets_by_tags; returns a Concurrent::Promises::Future.
+      def find_pets_by_tags(*args, **kwargs, &block)
+        Concurrent::Promises.future { service.find_pets_by_tags(*args, **kwargs, &block) }
+      end
+
+      # Async variant of #get_pet_by_id; returns a Concurrent::Promises::Future.
+      def get_pet_by_id(*args, **kwargs, &block)
+        Concurrent::Promises.future { service.get_pet_by_id(*args, **kwargs, &block) }
+      end
+
+      # Async variant of #update_pet_with_form; returns a Concurrent::Promises::Future.
+      def update_pet_with_form(*args, **kwargs, &block)
+        Concurrent::Promises.future { service.update_pet_with_form(*args, **kwargs, &block) }
+      end
+
+      # Async variant of #delete_pet; returns a Concurrent::Promises::Future.
+      def delete_pet(*args, **kwargs, &block)
+        Concurrent::Promises.future { service.delete_pet(*args, **kwargs, &block) }
+      end
+
+      # Async variant of #upload_file; returns a Concurrent::Promises::Future.
+      def upload_file(*args, **kwargs, &block)
+        Concurrent::Promises.future { service.upload_file(*args, **kwargs, &block) }
+      end
+
+      private
+
+      def service
+        ::RubyGemsPublishTest::Pet.new(@connection_factory.call, @config)
+      end
+    end
+  end
+end

data/lib/ruby_gems_publish_test/async/services/store.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'concurrent'
+
+module RubyGemsPublishTest
+  module Async
+    # Async variant of ::RubyGemsPublishTest::Store. Each method returns a
+    # +Concurrent::Promises::Future+ that runs the corresponding synchronous call on a
+    # background thread; resolve it with +#value!+ (re-raises the SDK's typed errors) or
+    # +#value+ (returns nil on failure).
+    class Store
+      def initialize(connection_factory, config = nil)
+        @connection_factory = connection_factory
+        @config = config
+      end
+
+      # Async variant of #get_inventory; returns a Concurrent::Promises::Future.
+      def get_inventory(*args, **kwargs, &block)
+        Concurrent::Promises.future { service.get_inventory(*args, **kwargs, &block) }
+      end
+
+      # Async variant of #place_order; returns a Concurrent::Promises::Future.
+      def place_order(*args, **kwargs, &block)
+        Concurrent::Promises.future { service.place_order(*args, **kwargs, &block) }
+      end
+
+      # Async variant of #get_order_by_id; returns a Concurrent::Promises::Future.
+      def get_order_by_id(*args, **kwargs, &block)
+        Concurrent::Promises.future { service.get_order_by_id(*args, **kwargs, &block) }
+      end
+
+      # Async variant of #delete_order; returns a Concurrent::Promises::Future.
+      def delete_order(*args, **kwargs, &block)
+        Concurrent::Promises.future { service.delete_order(*args, **kwargs, &block) }
+      end
+
+      private
+
+      def service
+        ::RubyGemsPublishTest::Store.new(@connection_factory.call, @config)
+      end
+    end
+  end
+end

data/lib/ruby_gems_publish_test/async/services/user.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'concurrent'
+
+module RubyGemsPublishTest
+  module Async
+    # Async variant of ::RubyGemsPublishTest::User. Each method returns a
+    # +Concurrent::Promises::Future+ that runs the corresponding synchronous call on a
+    # background thread; resolve it with +#value!+ (re-raises the SDK's typed errors) or
+    # +#value+ (returns nil on failure).
+    class User
+      def initialize(connection_factory, config = nil)
+        @connection_factory = connection_factory
+        @config = config
+      end
+
+      # Async variant of #create_user; returns a Concurrent::Promises::Future.
+      def create_user(*args, **kwargs, &block)
+        Concurrent::Promises.future { service.create_user(*args, **kwargs, &block) }
+      end
+
+      # Async variant of #create_users_with_list_input; returns a Concurrent::Promises::Future.
+      def create_users_with_list_input(*args, **kwargs, &block)
+        Concurrent::Promises.future { service.create_users_with_list_input(*args, **kwargs, &block) }
+      end
+
+      # Async variant of #login_user; returns a Concurrent::Promises::Future.
+      def login_user(*args, **kwargs, &block)
+        Concurrent::Promises.future { service.login_user(*args, **kwargs, &block) }
+      end
+
+      # Async variant of #logout_user; returns a Concurrent::Promises::Future.
+      def logout_user(*args, **kwargs, &block)
+        Concurrent::Promises.future { service.logout_user(*args, **kwargs, &block) }
+      end
+
+      # Async variant of #get_user_by_name; returns a Concurrent::Promises::Future.
+      def get_user_by_name(*args, **kwargs, &block)
+        Concurrent::Promises.future { service.get_user_by_name(*args, **kwargs, &block) }
+      end
+
+      # Async variant of #update_user; returns a Concurrent::Promises::Future.
+      def update_user(*args, **kwargs, &block)
+        Concurrent::Promises.future { service.update_user(*args, **kwargs, &block) }
+      end
+
+      # Async variant of #delete_user; returns a Concurrent::Promises::Future.
+      def delete_user(*args, **kwargs, &block)
+        Concurrent::Promises.future { service.delete_user(*args, **kwargs, &block) }
+      end
+
+      private
+
+      def service
+        ::RubyGemsPublishTest::User.new(@connection_factory.call, @config)
+      end
+    end
+  end
+end

data/lib/ruby_gems_publish_test/async_client.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module RubyGemsPublishTest
+  class AsyncClient
+    DEFAULT_BASE_URL = Environment::DEFAULT
+
+    def initialize(base_url: DEFAULT_BASE_URL, timeout: nil, timeout_ms: nil, token: nil, api_key: nil)
+      unless timeout_ms.nil?
+        warn '[DEPRECATION] `timeout_ms` is deprecated; use `timeout` (seconds) instead.', uplevel: 1
+        timeout = timeout_ms / 1000.0 if timeout.nil?
+      end
+      @token = token
+      @api_key = api_key
+      @base_url = base_url
+      @timeout = timeout
+      factory = method(:build_connection)
+      @pet = Async::Pet.new(factory)
+      @store = Async::Store.new(factory)
+      @user = Async::User.new(factory)
+    end
+
+    def pet(config: nil)
+      return @pet unless config
+
+      Async::Pet.new(method(:build_connection), config)
+    end
+
+    def store(config: nil)
+      return @store unless config
+
+      Async::Store.new(method(:build_connection), config)
+    end
+
+    def user(config: nil)
+      return @user unless config
+
+      Async::User.new(method(:build_connection), config)
+    end
+
+    attr_writer :token, :api_key, :base_url
+
+    def environment=(env)
+      self.base_url = Environment.const_get(env.to_s.upcase)
+    rescue NameError
+      raise ArgumentError, "Unknown environment: #{env.inspect}"
+    end
+
+    private
+
+    def build_connection
+      HTTP::Connection.new(@base_url, HTTP::Auth.new(token: @token, api_key: @api_key).headers, timeout: @timeout)
+    end
+  end
+end

data/lib/ruby_gems_publish_test/client.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module RubyGemsPublishTest
+  class Client
+    DEFAULT_BASE_URL = Environment::DEFAULT
+
+    def initialize(base_url: DEFAULT_BASE_URL, timeout: nil, timeout_ms: nil, token: nil, api_key: nil, http_client: nil)
+      unless timeout_ms.nil?
+        warn '[DEPRECATION] `timeout_ms` is deprecated; use `timeout` (seconds) instead.', uplevel: 1
+        timeout = timeout_ms / 1000.0 if timeout.nil?
+      end
+      @token = token
+      @api_key = api_key
+      @connection = HTTP::Connection.new(
+        base_url,
+        HTTP::Auth.new(token: @token, api_key: @api_key).headers,
+        timeout: timeout,
+        http_client: http_client,
+      )
+      @pet = Pet.new(@connection)
+      @store = Store.new(@connection)
+      @user = User.new(@connection)
+    end
+
+    def pet(config: nil)
+      return @pet unless config
+
+      Pet.new(@connection, config)
+    end
+
+    def store(config: nil)
+      return @store unless config
+
+      Store.new(@connection, config)
+    end
+
+    def user(config: nil)
+      return @user unless config
+
+      User.new(@connection, config)
+    end
+
+    def token=(token)
+      @token = token
+      @connection.default_headers = HTTP::Auth.new(token: @token, api_key: @api_key).headers
+    end
+
+    def api_key=(api_key)
+      @api_key = api_key
+      @connection.default_headers = HTTP::Auth.new(token: @token, api_key: @api_key).headers
+    end
+
+    def environment=(env)
+      self.base_url = Environment.const_get(env.to_s.upcase)
+    rescue NameError
+      raise ArgumentError, "Unknown environment: #{env.inspect}"
+    end
+
+    def base_url=(url)
+      @connection.base_url = url
+    end
+  end
+end

data/lib/ruby_gems_publish_test/config.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module RubyGemsPublishTest
+  class Config
+    attr_reader :base_url, :timeout, :enable_response_validation, :return_raw, :additional_headers, :additional_query_parameters, :retry_config, :token, :api_key
+
+    def initialize(
+      base_url: nil,
+      timeout: nil,
+      timeout_ms: nil,
+      enable_response_validation: false,
+      return_raw: false,
+      additional_headers: nil,
+      additional_query_parameters: nil,
+      retry_config: nil,
+      token: nil,
+      api_key: nil
+    )
+      unless timeout_ms.nil?
+        warn '[DEPRECATION] `timeout_ms` is deprecated; use `timeout` (seconds) instead.', uplevel: 1
+        timeout = timeout_ms / 1000.0 if timeout.nil?
+      end
+      @base_url = base_url
+      @timeout = timeout
+      @enable_response_validation = enable_response_validation
+      @return_raw = return_raw
+      @additional_headers = additional_headers
+      @additional_query_parameters = additional_query_parameters
+      @retry_config = retry_config
+      @token = token
+      @api_key = api_key
+    end
+
+    def with(**overrides)
+      base = to_h
+      base.delete(:timeout) if overrides.key?(:timeout_ms) && !overrides.key?(:timeout)
+      self.class.new(**base, **overrides)
+    end
+
+    def to_h
+      {
+        base_url: @base_url,
+        timeout: @timeout,
+        enable_response_validation: @enable_response_validation,
+        return_raw: @return_raw,
+        additional_headers: @additional_headers,
+        additional_query_parameters: @additional_query_parameters,
+        retry_config: @retry_config,
+        token: @token,
+        api_key: @api_key,
+      }
+    end
+  end
+end

data/lib/ruby_gems_publish_test/environment.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module RubyGemsPublishTest
+  module Environment
+    DEFAULT = 'https://petstore3.swagger.io/api/v3'
+  end
+end

data/lib/ruby_gems_publish_test/error.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RubyGemsPublishTest
+  class Error < StandardError; end
+
+  class APIError < Error
+    attr_reader :status, :body, :headers
+
+    def initialize(status, body, headers = {})
+      @status  = status
+      @body    = body
+      @headers = headers || {}
+      super("HTTP #{status}: #{body}")
+    end
+  end
+
+  class TimeoutError < Error
+    def initialize(msg = 'Request timed out')
+      super
+    end
+  end
+
+  class ValidationError < Error
+    attr_reader :field, :validation_message
+
+    def initialize(field, message)
+      @field              = field
+      @validation_message = message
+      super("Validation failed for #{field}: #{message}")
+    end
+  end
+end

data/lib/ruby_gems_publish_test/http/auth.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module RubyGemsPublishTest
+  module HTTP
+    class Auth
+      def initialize(token: nil, api_key: nil)
+        @token = token
+        @api_key = api_key
+      end
+
+      def headers
+        result = {}
+        result['Authorization'] = "Bearer #{@token}" unless @token.nil?
+        result['api_key'] = @api_key unless @api_key.nil?
+        result
+      end
+    end
+  end
+end