amritk-scalar-test 0.1.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e330b5f75ddaf318457adb5e09460b061f0670bd47875eccd852f7ffb987124e
-  data.tar.gz: fb9185d3fb78a4c1c71cab4bfd9b6b0af4089b3fa58e87c96053b28d3fb841ce
+  metadata.gz: 57d60baeaab95d5b69bfb7398de111026485f80c908a76dd4939e383784fb200
+  data.tar.gz: 2853c8c957db2078b5f02d6ee64b0794f810d88a171aaee55c86f44b7c5edafc
 SHA512:
-  metadata.gz: a40597758f49453df975c6bfaa3f97873bf186898613d2ac1a3069a11da4aa0c6d5c30d8819605381cb7761b3c99d66e5f0e63d2737887357e1a2dfbcacba059
-  data.tar.gz: f787d4c7f6f2cd87c4595a89fa691f652bc883fa01223acde90548c4df591dcd1c20df5aa95da7d8d2445dd31f783f710e7f2b5ccc082cb10faf639faec4fcf6
+  metadata.gz: d451bbd651ef8d398070475c97f677ecada1a15b50abee623e048c5dc406a9881155c9ad0f00e5e5330e412974eb8dc3ad6c55f883fac752e2dd4956fa1c8387
+  data.tar.gz: c3fa8ff2f6698e9488e37ebd3b15e39baee966dced211edc97d07526295de3b9b11aac1c4cd79c9c810e3aae1cb4f24eab7a4ad9d542a79ab0c9cfaeca87cf10

data/LICENSE

@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright [yyyy] [name of copyright owner]
+   Copyright 2026 ScalarRubyTest
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

data/README.md

@@ -1,6 +1,6 @@
-# Scalar Ruby Test
+# ScalarRubyTest
 
-This library provides convenient access to the Scalar Ruby Test REST API from Ruby.
+This library provides convenient access to the ScalarRubyTest REST API from Ruby.
 
 The full API of this library can be found in [api.md](./api.md).
 
@@ -23,6 +23,14 @@ The full API of this library can be found in [api.md](./api.md).
 
 ## Installation
 
+Add the gem to your application's `Gemfile`:
+
+```ruby
+gem "amritk-scalar-test", "~> 0.3.0" # x-release-please-version
+```
+
+Or install it directly:
+
 ```sh
 gem install amritk-scalar-test
 ```
@@ -32,7 +40,12 @@ gem install amritk-scalar-test
 ## Usage
 
 ```ruby
+require "amritk-scalar-test"
+
+client = AmritkScalarTest::Client.new
+
 response = client.ping.ping
+
 puts response.inspect
 ```
 
@@ -55,10 +68,12 @@ Non-success responses throw generated API errors. Error objects expose status, h
 ```ruby
 begin
   response = client.ping.ping
+
   puts response.inspect
-rescue ScalarRubyTest::APIError => error
+rescue AmritkScalarTest::Errors::APIError => error
   puts "#{error.status}: #{error.message}"
   raise
+end
 ```
 
 <br />
@@ -70,7 +85,7 @@ Configure the generated client by setting any of these options when you create i
 ```ruby
 require "amritk-scalar-test"
 
-client = ScalarRubyTest::Client.new(
+client = AmritkScalarTest::Client.new(
   timeout: 60.0,
   max_retries: 2,
   logger: $stderr,
@@ -112,9 +127,9 @@ Generated clients support request timeouts and retry temporary failures such as
 
 ## Helpers
 
-- Use `with_raw_response` companions when you need status, headers, or unparsed response bodies.
-- Use `with_result` companions when you want success data or HTTP error bodies without raising status errors.
-- WebSocket helpers use Ruby stdlib sockets (`ws://` and `wss://`) and expose typed `serialize_send` / `deserialize_receive` helpers.
+- Every model is a `BaseModel`: pass a plain hash or a model instance, and read decoded values back as attributes.
+- Paginated methods return a page you can iterate directly, or walk with `auto_paging_each`.
+- The gem ships `rbi/` and `sig/` trees, so Sorbet and Steep type-check calls into the SDK.
 
 <br />
 

data/SKILL.md

@@ -1,11 +1,11 @@
 ---
 name: scalar-ruby-test-ruby-sdk
-description: "Ruby SDK for Scalar Ruby Test API. Use when writing Ruby code that calls Scalar Ruby Test API with the amritk-scalar-test package: installing it, constructing and authenticating the client, and calling API operations."
+description: "Ruby SDK for ScalarRubyTest API. Use when writing Ruby code that calls ScalarRubyTest API with the amritk-scalar-test package: installing it, constructing and authenticating the client, and calling API operations."
 ---
 
-# Scalar Ruby Test Ruby SDK
+# ScalarRubyTest Ruby SDK
 
-Generated Ruby client for Scalar Ruby Test API, published as `amritk-scalar-test`. Use the generated client instead of hand-writing HTTP requests.
+Generated Ruby client for ScalarRubyTest API, published as `amritk-scalar-test`. Use the generated client instead of hand-writing HTTP requests.
 
 ## Install
 
@@ -24,7 +24,12 @@ client = AmritkScalarTest::Client.new
 ## Calling operations
 
 ```ruby
+require "amritk-scalar-test"
+
+client = AmritkScalarTest::Client.new
+
 response = client.ping.ping
+
 puts response.inspect
 ```
 
@@ -37,10 +42,12 @@ Non-success responses throw generated API errors. Error objects expose status, h
 ```ruby
 begin
   response = client.ping.ping
+
   puts response.inspect
-rescue ScalarRubyTest::APIError => error
+rescue AmritkScalarTest::Errors::APIError => error
   puts "#{error.status}: #{error.message}"
   raise
+end
 ```
 
 ## Requirements
@@ -49,5 +56,5 @@ rescue ScalarRubyTest::APIError => error
 
 ## Reference files
 
-- [README.md](./README.md) — full feature tour: client options, request options, retries and timeouts, logging.
+- [README.md](./README.md) — full feature tour: client options, request options, retries and timeouts.
 - [api.md](./api.md) — complete catalogue of every operation with request and response types.

data/lib/amritk-scalar-test/client.rb

@@ -1,21 +1,67 @@
 # frozen_string_literal: true
 
-# Code generated by Scalar SDK Generator. DO NOT EDIT.
-require_relative "errors"
-require_relative "runtime"
-require_relative "models"
-
-module ScalarRubyTest
-  module Resources
-    autoload :Ping, File.expand_path("resources/ping", __dir__)
-  end
+module AmritkScalarTest
+  class Client < AmritkScalarTest::Internal::Transport::BaseClient
+    # Default max number of retries to attempt after a failed retryable request.
+    DEFAULT_MAX_RETRIES = 2
+
+    # Default per-request timeout.
+    DEFAULT_TIMEOUT_IN_SECONDS = 60.0
+
+    # Default initial retry delay in seconds.
+    # Overall delay is calculated using exponential backoff + jitter.
+    DEFAULT_INITIAL_RETRY_DELAY = 0.5
+
+    # Default max retry delay in seconds.
+    DEFAULT_MAX_RETRY_DELAY = 8.0
 
-  class Client < APIClient
+    # @return [AmritkScalarTest::Resources::Ping]
     attr_reader :ping
 
-    def initialize(base_url: ENV["SCALAR_RUBY_TEST_BASE_URL"] || "https://api.example.com", max_retries: 2, timeout: 60.0, initial_retry_delay: 0.5, max_retry_delay: 8.0, idempotency_header: "Idempotency-Key", logger: nil, default_headers: nil, default_query: nil)
-      super(base_url: base_url, max_retries: max_retries, timeout: timeout, initial_retry_delay: initial_retry_delay, max_retry_delay: max_retry_delay, idempotency_header: idempotency_header, logger: logger, default_headers: ({  }).merge(default_headers || {}), default_query: default_query || {})
-      @ping = Resources::Ping.new(self)
+    # Creates and returns a new client for interacting with the API.
+    #
+    # @param base_url [String, nil] Override the default base URL for the API, e.g.,
+    # `"https://api.example.com/v2/"`. Defaults to `ENV["SCALAR_RUBY_TEST_BASE_URL"]`
+    #
+    # @param max_retries [Integer] Max number of retries to attempt after a failed retryable request.
+    #
+    # @param timeout [Float]
+    #
+    # @param initial_retry_delay [Float]
+    #
+    # @param max_retry_delay [Float]
+    def initialize(
+      base_url: ENV["SCALAR_RUBY_TEST_BASE_URL"],
+      max_retries: self.class::DEFAULT_MAX_RETRIES,
+      timeout: self.class::DEFAULT_TIMEOUT_IN_SECONDS,
+      initial_retry_delay: self.class::DEFAULT_INITIAL_RETRY_DELAY,
+      max_retry_delay: self.class::DEFAULT_MAX_RETRY_DELAY
+    )
+      base_url ||= "https://api.example.com"
+
+      headers = {}
+      custom_headers_env = ENV["SCALAR_RUBY_TEST_CUSTOM_HEADERS"]
+      unless custom_headers_env.nil?
+        parsed = {}
+        custom_headers_env.split("\n").each do |line|
+          colon = line.index(":")
+          unless colon.nil?
+            parsed[line[0...colon].strip] = line[(colon + 1)..].strip
+          end
+        end
+        headers = parsed.merge(headers)
+      end
+
+      super(
+        base_url: base_url,
+        timeout: timeout,
+        max_retries: max_retries,
+        initial_retry_delay: initial_retry_delay,
+        max_retry_delay: max_retry_delay,
+        headers: headers
+      )
+
+      @ping = AmritkScalarTest::Resources::Ping.new(client: self)
     end
   end
 end

data/lib/amritk-scalar-test/errors.rb

@@ -1,89 +1,228 @@
 # frozen_string_literal: true
 
-# Code generated by Scalar SDK Generator. DO NOT EDIT.
-require_relative "models"
-module ScalarRubyTest
-  ProblemDetails = Struct.new(:type, :title, :status, :detail, :instance, :extensions, keyword_init: true)
-
+module AmritkScalarTest
   module Errors
-    class Error < StandardError; end
-    class ConversionError < Error; end
+    class Error < StandardError
+      # @!attribute cause
+      #
+      #   @return [StandardError, nil]
+    end
+
+    class ConversionError < AmritkScalarTest::Errors::Error
+      # @return [StandardError, nil]
+      def cause = @cause.nil? ? super : @cause
 
-    class APIError < Error
-      attr_reader :status, :body, :headers, :request_id, :raw_body, :problem_details
+      # @api private
+      #
+      # @param on [Class<StandardError>]
+      # @param method [Symbol]
+      # @param target [Object]
+      # @param value [Object]
+      # @param cause [StandardError, nil]
+      def initialize(on:, method:, target:, value:, cause: nil)
+        cls = on.name.split("::").last
 
-      def initialize(message, status: nil, body: nil, headers: nil, request_id: nil, raw_body: nil)
+        message = [
+          "Failed to parse #{cls}.#{method} from #{value.class} to #{target.inspect}.",
+          "To get the unparsed API response, use #{cls}[#{method.inspect}].",
+          cause && "Cause: #{cause.message}"
+        ].filter(&:itself).join(" ")
+
+        @cause = cause
         super(message)
+      end
+    end
+
+    class APIError < AmritkScalarTest::Errors::Error
+      # @return [URI::Generic]
+      attr_accessor :url
+
+      # @return [Integer, nil]
+      attr_accessor :status
+
+      # @return [Hash{String=>String}, nil]
+      attr_accessor :headers
+
+      # @return [Object, nil]
+      attr_accessor :body
+
+      # @api private
+      #
+      # @param url [URI::Generic]
+      # @param status [Integer, nil]
+      # @param headers [Hash{String=>String}, nil]
+      # @param body [Object, nil]
+      # @param request [nil]
+      # @param response [nil]
+      # @param message [String, nil]
+      def initialize(url:, status: nil, headers: nil, body: nil, request: nil, response: nil, message: nil)
+        @url = url
         @status = status
-        @body = body
         @headers = headers
-        @request_id = request_id
-        @raw_body = raw_body
-        @problem_details = self.class.parse_problem_details(body)
+        @body = body
+        @request = request
+        @response = response
+        super(message)
       end
+    end
 
-      alias problem problem_details
-
-      def self.from_response(response, body)
-        klass = case response.code.to_i
-                when 400 then BadRequestError
-                when 401 then AuthenticationError
-                when 403 then PermissionDeniedError
-                when 404 then NotFoundError
-                when 409 then ConflictError
-                when 422 then UnprocessableEntityError
-                when 429 then RateLimitError
-                else response.code.to_i >= 500 ? InternalServerError : APIStatusError
-                end
-        headers = response.to_hash
-        request_id = headers["x-request-id"]&.first || headers["request-id"]&.first
-        klass.new(error_message(response.code.to_i, body), status: response.code.to_i, body: body, headers: headers, request_id: request_id, raw_body: response.body)
-      end
+    class APIConnectionError < AmritkScalarTest::Errors::APIError
+      # @!attribute status
+      #
+      #   @return [nil]
+
+      # @!attribute body
+      #
+      #   @return [nil]
 
-      def self.error_message(status, body)
-        detail = Runtime.extract_error_message(body)
-        detail.nil? || detail.empty? ? "HTTP #{status}" : "#{status} #{detail}"
+      # @api private
+      #
+      # @param url [URI::Generic]
+      # @param status [nil]
+      # @param headers [Hash{String=>String}, nil]
+      # @param body [nil]
+      # @param request [nil]
+      # @param response [nil]
+      # @param message [String, nil]
+      def initialize(
+        url:,
+        status: nil,
+        headers: nil,
+        body: nil,
+        request: nil,
+        response: nil,
+        message: "Connection error."
+      )
+        super
       end
+    end
 
-      def self.parse_problem_details(body)
-        return nil unless body.is_a?(Hash)
-        known = %w[type title status detail instance]
-        return nil unless known.any? { |key| body.key?(key) }
-        return nil if %w[type title detail instance].any? { |key| body.key?(key) && !body[key].is_a?(String) }
-        return nil if body.key?("status") && !body["status"].is_a?(Integer)
-        ProblemDetails.new(type: body["type"], title: body["title"], status: body["status"], detail: body["detail"], instance: body["instance"], extensions: body.reject { |key, _| known.include?(key) })
+    class APITimeoutError < AmritkScalarTest::Errors::APIConnectionError
+      # @api private
+      #
+      # @param url [URI::Generic]
+      # @param status [nil]
+      # @param headers [Hash{String=>String}, nil]
+      # @param body [nil]
+      # @param request [nil]
+      # @param response [nil]
+      # @param message [String, nil]
+      def initialize(
+        url:,
+        status: nil,
+        headers: nil,
+        body: nil,
+        request: nil,
+        response: nil,
+        message: "Request timed out."
+      )
+        super
       end
     end
 
-    class APIStatusError < APIError; end
-    class BadRequestError < APIStatusError; end
-    class AuthenticationError < APIStatusError; end
-    class PermissionDeniedError < APIStatusError; end
-    class NotFoundError < APIStatusError; end
-    class ConflictError < APIStatusError; end
-    class UnprocessableEntityError < APIStatusError; end
-    class RateLimitError < APIStatusError; end
-    class InternalServerError < APIStatusError; end
-    class APIConnectionError < APIError; end
-    class APITimeoutError < APIConnectionError; end
-    class MissingDependencyError < Error
-      def initialize(gem_name:, feature:)
-        super("The #{gem_name} gem is required to use #{feature}. Install it with: gem install #{gem_name}")
+    class APIStatusError < AmritkScalarTest::Errors::APIError
+      # @api private
+      #
+      # @param url [URI::Generic]
+      # @param status [Integer]
+      # @param headers [Hash{String=>String}, nil]
+      # @param body [Object, nil]
+      # @param request [nil]
+      # @param response [nil]
+      # @param message [String, nil]
+      #
+      # @return [self]
+      def self.for(url:, status:, headers:, body:, request:, response:, message: nil)
+        kwargs =
+          {
+            url: url,
+            status: status,
+            headers: headers,
+            body: body,
+            request: request,
+            response: response,
+            message: message
+          }
+
+        case status
+        in 400
+          AmritkScalarTest::Errors::BadRequestError.new(**kwargs)
+        in 401
+          AmritkScalarTest::Errors::AuthenticationError.new(**kwargs)
+        in 403
+          AmritkScalarTest::Errors::PermissionDeniedError.new(**kwargs)
+        in 404
+          AmritkScalarTest::Errors::NotFoundError.new(**kwargs)
+        in 409
+          AmritkScalarTest::Errors::ConflictError.new(**kwargs)
+        in 422
+          AmritkScalarTest::Errors::UnprocessableEntityError.new(**kwargs)
+        in 429
+          AmritkScalarTest::Errors::RateLimitError.new(**kwargs)
+        in (500..)
+          AmritkScalarTest::Errors::InternalServerError.new(**kwargs)
+        else
+          AmritkScalarTest::Errors::APIStatusError.new(**kwargs)
+        end
+      end
+
+      # @!parse
+      #   # @return [Integer]
+      #   attr_accessor :status
+
+      # @api private
+      #
+      # @param url [URI::Generic]
+      # @param status [Integer]
+      # @param headers [Hash{String=>String}, nil]
+      # @param body [Object, nil]
+      # @param request [nil]
+      # @param response [nil]
+      # @param message [String, nil]
+      def initialize(url:, status:, headers:, body:, request:, response:, message: nil)
+        message ||= {url: url.to_s, status: status, body: body}
+        super(
+          url: url,
+          status: status,
+          headers: headers,
+          body: body,
+          request: request,
+          response: response,
+          message: message&.to_s
+        )
       end
     end
-  end
 
-  APIError = Errors::APIError
-  APIStatusError = Errors::APIStatusError
-  BadRequestError = Errors::BadRequestError
-  AuthenticationError = Errors::AuthenticationError
-  PermissionDeniedError = Errors::PermissionDeniedError
-  NotFoundError = Errors::NotFoundError
-  ConflictError = Errors::ConflictError
-  UnprocessableEntityError = Errors::UnprocessableEntityError
-  RateLimitError = Errors::RateLimitError
-  InternalServerError = Errors::InternalServerError
-  APIConnectionError = Errors::APIConnectionError
-  APIConnectionTimeoutError = Errors::APITimeoutError
-  MissingDependencyError = Errors::MissingDependencyError
+    class BadRequestError < AmritkScalarTest::Errors::APIStatusError
+      HTTP_STATUS = 400
+    end
+
+    class AuthenticationError < AmritkScalarTest::Errors::APIStatusError
+      HTTP_STATUS = 401
+    end
+
+    class PermissionDeniedError < AmritkScalarTest::Errors::APIStatusError
+      HTTP_STATUS = 403
+    end
+
+    class NotFoundError < AmritkScalarTest::Errors::APIStatusError
+      HTTP_STATUS = 404
+    end
+
+    class ConflictError < AmritkScalarTest::Errors::APIStatusError
+      HTTP_STATUS = 409
+    end
+
+    class UnprocessableEntityError < AmritkScalarTest::Errors::APIStatusError
+      HTTP_STATUS = 422
+    end
+
+    class RateLimitError < AmritkScalarTest::Errors::APIStatusError
+      HTTP_STATUS = 429
+    end
+
+    class InternalServerError < AmritkScalarTest::Errors::APIStatusError
+      HTTP_STATUS = (500..)
+    end
+  end
 end

data/lib/amritk-scalar-test/file_part.rb

@@ -1,14 +1,58 @@
 # frozen_string_literal: true
 
-# Code generated by Scalar SDK Generator. DO NOT EDIT.
-module ScalarRubyTest
+module AmritkScalarTest
   class FilePart
-    attr_reader :io, :filename, :content_type
+    # @return [Pathname, StringIO, IO, String]
+    attr_reader :content
 
-    def initialize(io:, filename: nil, content_type: nil)
-      @io = io
-      @filename = filename
+    # @return [String, nil]
+    attr_reader :content_type
+
+    # @return [String, nil]
+    attr_reader :filename
+
+    # @api private
+    #
+    # @return [String]
+    private def read
+      case content
+      in Pathname
+        content.read(binmode: true)
+      in StringIO
+        content.string
+      in IO
+        content.read
+      in String
+        content
+      end
+    end
+
+    # @param a [Object]
+    #
+    # @return [String]
+    def to_json(*a) = read.to_json(*a)
+
+    # @param a [Object]
+    #
+    # @return [String]
+    def to_yaml(*a) = read.to_yaml(*a)
+
+    # @param content [Pathname, StringIO, IO, String]
+    # @param filename [Pathname, String, nil]
+    # @param content_type [String, nil]
+    def initialize(content, filename: nil, content_type: nil)
       @content_type = content_type
+      @filename =
+        case [filename, (@content = content)]
+        in [String | Pathname, _]
+          ::File.basename(filename)
+        in [nil, Pathname]
+          content.basename.to_path
+        in [nil, IO]
+          content.to_path
+        else
+          filename
+        end
     end
   end
 end