x 0.10.0 → 0.12.0

data/sig/x.rbs

@@ -1,13 +1,19 @@
 module X
   VERSION: Gem::Version
 
-  class BearerTokenAuthenticator
+  class Authenticator
+    AUTHENTICATION_HEADER: String
+
+    def header: (Net::HTTPRequest? request) -> Hash[String, String]
+  end
+
+  class BearerTokenAuthenticator < Authenticator
     attr_accessor bearer_token: String
-    def initialize: (String bearer_token) -> void
-    def header: (Net::HTTPRequest _request) -> String
+    def initialize: (bearer_token: String) -> void
+    def header: (Net::HTTPRequest? request) -> Hash[String, String]
   end
 
-  class OauthAuthenticator
+  class OAuthAuthenticator < Authenticator
     OAUTH_VERSION: String
     OAUTH_SIGNATURE_METHOD: String
     OAUTH_SIGNATURE_ALGORITHM: String
@@ -16,8 +22,8 @@ module X
     attr_accessor api_key_secret: String
     attr_accessor access_token: String
     attr_accessor access_token_secret: String
-    def initialize: (String api_key, String api_key_secret, String access_token, String access_token_secret) -> void
-    def header: (Net::HTTPRequest request) -> String
+    def initialize: (api_key: String, api_key_secret: String, access_token: String, access_token_secret: String) -> void
+    def header: (Net::HTTPRequest request) -> Hash[String, String]
 
     private
     def parse_request: (Net::HTTPRequest request) -> [String, String, Hash[String, String]]
@@ -34,188 +40,203 @@ module X
   end
 
   class Error < StandardError
+  end
+
+  class ClientError < HTTPError
+  end
+
+  class BadGateway < ClientError
+  end
+
+  class BadRequest < ClientError
+  end
+
+  class ConnectionException < ClientError
+  end
+
+  class HTTPError < Error
     JSON_CONTENT_TYPE_REGEXP: Regexp
 
-    attr_reader object: untyped
-    def initialize: (String msg, response: Net::HTTPResponse?) -> void
+    attr_reader response : Net::HTTPResponse
+    attr_reader code : String
+
+    def initialize: (response: Net::HTTPResponse) -> void
 
     private
-    def json_response?: (Net::HTTPResponse response) -> bool
+    def error_message: (Net::HTTPResponse response) -> String
+    def message_from_json_response:  (Net::HTTPResponse response) -> String
+    def json?: (Net::HTTPResponse response) -> bool
   end
 
-  class ClientError < Error
+  class Forbidden < ClientError
   end
 
-  class BadRequestError < ClientError
+  class GatewayTimeout < ClientError
   end
 
-  class AuthenticationError < ClientError
+  class Gone < ClientError
   end
 
-  class ForbiddenError < ClientError
+  class InternalServerError < ServerError
   end
 
-  class InternalServerError < ServerError
+  class NetworkError < Error
   end
 
-  class NotFoundError < ClientError
+  class NotAcceptable < ClientError
   end
 
-  class PayloadTooLargeError < ClientError
+  class NotFound < ClientError
   end
 
-  class TooManyRedirectsError < ClientError
+  class PayloadTooLarge < ClientError
   end
 
-  class TooManyRequestsError < ClientError
+  class ServerError < HTTPError
+  end
+
+  class ServiceUnavailable < ServerError
+  end
+
+  class TooManyRedirects < Error
+  end
+
+  class TooManyRequests < ClientError
     @response: Net::HTTPResponse
 
-    def initialize: (String msg, response: Net::HTTPResponse) -> void
     def limit: -> Integer
     def remaining: -> Integer
     def reset_at: -> Time
     def reset_in: -> Integer?
   end
 
-  class ServerError < Error
-  end
-
-  class ServiceUnavailableError < ServerError
+  class Unauthorized < ClientError
   end
 
-  class NetworkError < Error
+  class UnprocessableEntity < ClientError
   end
 
   class Connection
-    DEFAULT_BASE_URL: String
     DEFAULT_HOST: String
     DEFAULT_PORT: Integer
     DEFAULT_OPEN_TIMEOUT: Integer
     DEFAULT_READ_TIMEOUT: Integer
     DEFAULT_WRITE_TIMEOUT: Integer
+    DEFAULT_DEBUG_OUTPUT: IO
     NETWORK_ERRORS: Array[(singleton(Errno::ECONNREFUSED) | singleton(Errno::ECONNRESET) | singleton(Net::OpenTimeout) | singleton(Net::ReadTimeout) | singleton(OpenSSL::SSL::SSLError))]
 
     extend Forwardable
-    @http_client: Net::HTTP
 
-    attr_reader base_uri: URI::Generic
+    attr_accessor open_timeout : Float | Integer
+    attr_accessor read_timeout : Float | Integer
+    attr_accessor write_timeout : Float | Integer
+    attr_accessor debug_output : IO
+
     attr_reader proxy_uri: URI::Generic?
-    attr_reader open_timeout : Float | Integer
-    attr_reader read_timeout : Float | Integer
-    attr_reader write_timeout : Float | Integer
-    def initialize: (?base_url: URI::Generic | String, ?open_timeout: Float | Integer, ?read_timeout: Float | Integer, ?write_timeout: Float | Integer, ?proxy_url: URI::Generic? | String?, ?debug_output: IO?) -> void
-    def send_request: (Net::HTTPRequest request) -> Net::HTTPResponse
-    def base_uri=: (URI::Generic | String base_url) -> void
-    def debug_output: -> IO?
-    def configuration: -> Hash[Symbol, untyped]
+    attr_reader proxy_host : String?
+    attr_reader proxy_port : Integer?
+    attr_reader proxy_user : String?
+    attr_reader proxy_pass : String?
+
+    def initialize: (?open_timeout: Float | Integer, ?read_timeout: Float | Integer, ?write_timeout: Float | Integer, ?proxy_url: URI::Generic? | String?, ?debug_output: IO) -> void
+    def proxy_url=: (URI::Generic | String proxy_url) -> void
+    def perform: (request: Net::HTTPRequest) -> Net::HTTPResponse
 
     private
-    def apply_http_client_settings: (open_timeout: Float | Integer, read_timeout: Float | Integer, write_timeout: Float | Integer, debug_output: IO?) -> untyped
-    def current_http_client_settings: -> {open_timeout: Float | Integer, read_timeout: Float | Integer, write_timeout: Float | Integer, debug_output: IO?}
-    def update_http_client_settings: -> untyped
-    def build_http_client: (host: String, port: Integer) -> (Net::HTTP)
-    def conditionally_apply_http_client_settings: { -> untyped } -> untyped
+    def build_http_client: (?String host, ?Integer port) -> Net::HTTP
+    def configure_http_client: (Net::HTTP http_client) -> Net::HTTP
   end
 
   class RequestBuilder
-    HTTP_METHODS: Hash[::Symbol, (singleton(::Net::HTTP::Get) | singleton(::Net::HTTP::Post) | singleton(::Net::HTTP::Put) | singleton(::Net::HTTP::Delete))]
-    DEFAULT_CONTENT_TYPE: String
-    DEFAULT_USER_AGENT: String
-    AUTHORIZATION_HEADER: String
-    CONTENT_TYPE_HEADER: String
-    USER_AGENT_HEADER: String
-
-    attr_accessor content_type: String
-    attr_accessor user_agent: String
+    HTTP_METHODS: Hash[Symbol, (singleton(Net::HTTP::Get) | singleton(Net::HTTP::Post) | singleton(Net::HTTP::Put) | singleton(Net::HTTP::Delete))]
+    DEFAULT_HEADERS: Hash[String, String]
+
     def initialize: (?content_type: String, ?user_agent: String) -> void
-    def build: (BearerTokenAuthenticator | OauthAuthenticator authenticator, Symbol http_method, URI::Generic uri, ?body: String?) -> (Net::HTTPRequest)
-    def configuration: -> Hash[Symbol, untyped]
+    def build: (authenticator: Authenticator, http_method: Symbol, uri: URI::Generic, ?body: String?, ?headers: Hash[String, String]) -> (Net::HTTPRequest)
 
     private
-    def create_request: (Symbol http_method, URI::Generic uri, String? body) -> (Net::HTTPRequest)
-    def add_authorization: (Net::HTTPRequest request, BearerTokenAuthenticator | OauthAuthenticator authenticator) -> void
-    def add_content_type: (Net::HTTPRequest request) -> void
-    def add_user_agent: (Net::HTTPRequest request) -> void
+    def create_request: (http_method: Symbol, uri: URI::Generic, body: String?) -> (Net::HTTPRequest)
+    def add_authentication: (request: Net::HTTPRequest, authenticator: Authenticator) -> void
+    def add_headers: (request: Net::HTTPRequest, headers: Hash[String, String]) -> void
     def escape_query_params: (URI::Generic uri) -> URI::Generic
   end
 
   class RedirectHandler
     DEFAULT_MAX_REDIRECTS: Integer
 
-    attr_reader authenticator: BearerTokenAuthenticator | OauthAuthenticator
+    attr_reader authenticator: Authenticator
     attr_reader connection: Connection
     attr_reader request_builder: RequestBuilder
     attr_reader max_redirects: Integer
-    def initialize: (BearerTokenAuthenticator | OauthAuthenticator authenticator, Connection connection, RequestBuilder request_builder, ?max_redirects: Integer) -> void
-    def handle_redirects: (Net::HTTPResponse response, Net::HTTPRequest original_request, URI::Generic | String original_base_url, ?Integer redirect_count) -> Net::HTTPResponse
+    def initialize: (connection: Connection, request_builder: RequestBuilder, ?max_redirects: Integer) -> void
+    def handle: (response: Net::HTTPResponse, request: Net::HTTPRequest, base_url: String, ?authenticator: Authenticator, ?redirect_count: Integer) -> Net::HTTPResponse
 
     private
-    def build_new_uri: (Net::HTTPResponse response, URI::Generic | String original_base_url) -> URI::Generic
-    def build_request: (Net::HTTPRequest original_request, URI::Generic new_uri) -> Net::HTTPRequest
+    def build_new_uri: (Net::HTTPResponse response, String base_url) -> URI::Generic
+    def build_request: (Net::HTTPRequest request, URI::Generic new_uri, Integer response_code, Authenticator authenticator) -> Net::HTTPRequest
     def send_new_request: (URI::Generic new_uri, Net::HTTPRequest new_request) -> Net::HTTPResponse
   end
 
-  class ResponseHandler
+  class ResponseParser
     DEFAULT_ARRAY_CLASS: Class
     DEFAULT_OBJECT_CLASS: Class
-    ERROR_CLASSES: Hash[Integer, singleton(AuthenticationError) | singleton(BadRequestError) | singleton(ForbiddenError) | singleton(InternalServerError) | singleton(NotFoundError) | singleton(PayloadTooLargeError) | singleton(ServiceUnavailableError) | singleton(TooManyRequestsError)]
+    ERROR_MAP: Hash[Integer, singleton(Unauthorized) | singleton(BadRequest) | singleton(Forbidden) | singleton(InternalServerError) | singleton(NotFound) | singleton(PayloadTooLarge) | singleton(ServiceUnavailable) | singleton(TooManyRequests)]
     JSON_CONTENT_TYPE_REGEXP: Regexp
 
     attr_accessor array_class: Class
     attr_accessor object_class: Class
     def initialize: (?array_class: Class, ?object_class: Class) -> void
-    def handle: (Net::HTTPResponse response) -> untyped
-    def configuration: -> Hash[Symbol, Class]
+    def parse: (response: Net::HTTPResponse) -> untyped
 
     private
-    def success?: (Net::HTTPResponse response) -> bool
+    def error: (Net::HTTPResponse response) -> (Unauthorized | BadRequest | Forbidden | InternalServerError | NotFound | PayloadTooLarge | ServiceUnavailable | TooManyRequests)
+    def error_class: (Net::HTTPResponse response) -> (singleton(Unauthorized) | singleton(BadRequest) | singleton(Forbidden) | singleton(InternalServerError) | singleton(NotFound) | singleton(PayloadTooLarge) | singleton(ServiceUnavailable) | singleton(TooManyRequests))
     def json?: (Net::HTTPResponse response) -> bool
   end
 
   class Client
+    DEFAULT_BASE_URL: String
+
     extend Forwardable
-    @authenticator: BearerTokenAuthenticator | OauthAuthenticator
+    @authenticator: Authenticator
     @connection: Connection
     @request_builder: RequestBuilder
     @redirect_handler: RedirectHandler
-    @response_handler: ResponseHandler
+    @response_parser: ResponseParser
 
     attr_accessor access_token: String
     attr_accessor access_token_secret: String
     attr_accessor api_key: String
     attr_accessor api_key_secret: String
     attr_accessor bearer_token: String
-    attr_accessor base_uri: URI::Generic | String
+    attr_accessor base_url: String
     attr_accessor open_timeout: Float | Integer
     attr_accessor read_timeout: Float | Integer
     attr_accessor write_timeout: Float | Integer
     attr_accessor proxy_url: String
-    attr_accessor content_type: String
-    attr_accessor user_agent: String
-    attr_accessor debug_output: IO?
+    attr_accessor debug_output: IO
     attr_accessor array_class: Class
     attr_accessor object_class: Class
     attr_accessor max_redirects: Integer
-    attr_accessor authenticator: BearerTokenAuthenticator | OauthAuthenticator
+    attr_accessor authenticator: Authenticator
     attr_accessor connection: Connection
     attr_accessor request_builder: RequestBuilder
     attr_accessor redirect_handler: RedirectHandler
-    attr_accessor response_handler: ResponseHandler
-    alias base_url base_uri
-
+    attr_accessor response_parser: ResponseParser
 
-    def initialize: (?bearer_token: String?, ?api_key: String?, ?api_key_secret: String?, ?access_token: String?, ?access_token_secret: String?, ?base_url: URI::Generic | String, ?content_type: String, ?user_agent: String, ?open_timeout: Float | Integer, ?read_timeout: Float | Integer, ?write_timeout: Float | Integer, ?proxy_url: URI::Generic? | String?, ?debug_output: IO?, ?array_class: Class, ?object_class: Class, ?max_redirects: Integer) -> void
-    def get: (String endpoint) -> untyped
-    def post: (String endpoint, ?String? body) -> untyped
-    def put: (String endpoint, ?String? body) -> untyped
-    def delete: (String endpoint) -> untyped
+    def initialize: (?api_key: String?, ?api_key_secret: String?, ?access_token: String?, ?access_token_secret: String?, ?bearer_token: String?, ?base_url: String, ?open_timeout: Float | Integer, ?read_timeout: Float | Integer, ?write_timeout: Float | Integer, ?proxy_url: URI::Generic? | String?, ?debug_output: IO, ?array_class: Class, ?object_class: Class, ?max_redirects: Integer) -> void
+    def get: (String endpoint, ?headers: Hash[String, String]) -> untyped
+    def post: (String endpoint, ?String? body, ?headers: Hash[String, String]) -> untyped
+    def put: (String endpoint, ?String? body, ?headers: Hash[String, String]) -> untyped
+    def delete: (String endpoint, ?headers: Hash[String, String]) -> untyped
 
     private
-    def initialize_authenticator: (String? bearer_token, String? api_key, String? api_key_secret, String? access_token, String? access_token_secret) -> (BearerTokenAuthenticator | OauthAuthenticator)
-    def send_request: (Symbol http_method, String endpoint, ?String? body) -> untyped
+    def initialize_oauth: (String? api_key, String? api_key_secret, String? access_token, String? access_token_secret) -> void
+    def initialize_authenticator: -> Authenticator
+    def execute_request: (Symbol http_method, String endpoint, headers: Hash[String, String], ?body: String?) -> untyped
   end
 
-  module MediaUpload
+  module MediaUploader
     MAX_RETRIES: Integer
     BYTES_PER_MB: Integer
     MEDIA_CATEGORIES: Array[String]
@@ -235,22 +256,27 @@ module X
     SUBRIP_MIME_TYPE: String
     WEBP_MIME_TYPE: String
     MIME_TYPE_MAP: Hash[String, String]
-    extend MediaUpload
+    extend MediaUploader
 
-    def media_upload: (client: Client, file_path: String, media_category: String, ?media_type: String, ?boundary: String) -> untyped
-    def chunked_media_upload: (client: Client, file_path: String, media_category: String, ?media_type: String, ?boundary: String, ?chunk_size_mb: Integer) -> untyped
+    def upload: (client: Client, file_path: String, media_category: String, ?media_type: String, ?boundary: String) -> untyped
+    def chunked_upload: (client: Client, file_path: String, media_category: String, ?media_type: String, ?boundary: String, ?chunk_size_mb: Integer) -> untyped
     def await_processing: (client: Client, media: untyped) -> untyped
 
     private
     def validate!: (file_path: String, media_category: String) -> nil
     def infer_media_type: (String file_path, String media_category) -> String
-    def init: (Client upload_client, String file_path, String media_type, String media_category) -> untyped
     def split: (String file_path, Integer chunk_size) -> Array[String]
-    def append: (Client upload_client, Array[String] chunk_paths, untyped media, String media_type, ?String boundary) -> Array[String]
-    def upload_chunk: (Client upload_client, String query, String chunk_path, String media_type, String boundary) -> Integer?
-    def cleanup_chunk: (String chunk_path) -> Integer?
-    def finalize: (Client upload_client, untyped media) -> untyped
-    def construct_upload_body: (String file_path, String media_type, ?String boundary) -> String
+    def init: (upload_client: Client, file_path: String, media_type: String, media_category: String) -> untyped
+    def append: (upload_client: Client, file_paths: Array[String], media: untyped, media_type: String, ?boundary: String) -> Array[String]
+    def upload_chunk: (upload_client: Client, query: String, upload_body: String, file_path: String, ?headers: Hash[String, String]) -> Integer?
+    def cleanup_file: (String file_path) -> Integer?
+    def finalize: (upload_client: Client, media: untyped) -> untyped
+    def construct_upload_body: (file_path: String, media_type: String, ?boundary: String) -> String
+  end
+
+  class CGI
+    def self.escape: (String value) -> String
+    def self.escape_params: (Hash[String, String] | Array[[String, String]] params) -> String
   end
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: x
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.12.0
 platform: ruby
 authors:
 - Erik Berlin
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-10-08 00:00:00.000000000 Z
+date: 2023-11-02 00:00:00.000000000 Z
 dependencies: []
 description:
 email:
@@ -23,27 +23,36 @@ files:
 - bin/console
 - bin/setup
 - lib/x.rb
+- lib/x/authenticator.rb
 - lib/x/bearer_token_authenticator.rb
+- lib/x/cgi.rb
 - lib/x/client.rb
 - lib/x/connection.rb
-- lib/x/errors/authentication_error.rb
-- lib/x/errors/bad_request_error.rb
+- lib/x/errors/bad_gateway.rb
+- lib/x/errors/bad_request.rb
 - lib/x/errors/client_error.rb
+- lib/x/errors/connection_exception.rb
 - lib/x/errors/error.rb
-- lib/x/errors/forbidden_error.rb
+- lib/x/errors/forbidden.rb
+- lib/x/errors/gateway_timeout.rb
+- lib/x/errors/gone.rb
+- lib/x/errors/http_error.rb
 - lib/x/errors/internal_server_error.rb
 - lib/x/errors/network_error.rb
-- lib/x/errors/not_found_error.rb
-- lib/x/errors/payload_too_large_error.rb
+- lib/x/errors/not_acceptable.rb
+- lib/x/errors/not_found.rb
+- lib/x/errors/payload_too_large.rb
 - lib/x/errors/server_error.rb
-- lib/x/errors/service_unavailable_error.rb
-- lib/x/errors/too_many_redirects_error.rb
-- lib/x/errors/too_many_requests_error.rb
-- lib/x/media_upload.rb
+- lib/x/errors/service_unavailable.rb
+- lib/x/errors/too_many_redirects.rb
+- lib/x/errors/too_many_requests.rb
+- lib/x/errors/unauthorized.rb
+- lib/x/errors/unprocessable_entity.rb
+- lib/x/media_uploader.rb
 - lib/x/oauth_authenticator.rb
 - lib/x/redirect_handler.rb
 - lib/x/request_builder.rb
-- lib/x/response_handler.rb
+- lib/x/response_parser.rb
 - lib/x/version.rb
 - sig/x.rbs
 homepage: https://sferik.github.io/x-ruby
@@ -72,7 +81,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.20
+rubygems_version: 3.4.21
 signing_key:
 specification_version: 4
 summary: A Ruby interface to the X API.

data/lib/x/errors/authentication_error.rb

@@ -1,5 +0,0 @@
-require_relative "client_error"
-
-module X
-  class AuthenticationError < ClientError; end
-end

data/lib/x/errors/payload_too_large_error.rb

@@ -1,5 +0,0 @@
-require_relative "client_error"
-
-module X
-  class PayloadTooLargeError < ClientError; end
-end

data/lib/x/errors/service_unavailable_error.rb

@@ -1,5 +0,0 @@
-require_relative "server_error"
-
-module X
-  class ServiceUnavailableError < ServerError; end
-end

data/lib/x/errors/too_many_redirects_error.rb

@@ -1,5 +0,0 @@
-require_relative "client_error"
-
-module X
-  class TooManyRedirectsError < ClientError; end
-end

data/lib/x/errors/too_many_requests_error.rb

@@ -1,29 +0,0 @@
-require_relative "client_error"
-
-module X
-  # Rate limit error
-  class TooManyRequestsError < ClientError
-    def initialize(msg, response:)
-      @response = response
-      super
-    end
-
-    def limit
-      @response.fetch("x-rate-limit-limit", 0).to_i
-    end
-
-    def remaining
-      @response.fetch("x-rate-limit-remaining", 0).to_i
-    end
-
-    def reset_at
-      Time.at(@response.fetch("x-rate-limit-reset", 0).to_i).utc
-    end
-
-    def reset_in
-      [(reset_at - Time.now).ceil, 0].max if reset_at
-    end
-
-    alias_method :retry_after, :reset_in
-  end
-end

data/lib/x/response_handler.rb

@@ -1,63 +0,0 @@
-require "json"
-require "net/http"
-require_relative "errors/authentication_error"
-require_relative "errors/bad_request_error"
-require_relative "errors/forbidden_error"
-require_relative "errors/not_found_error"
-require_relative "errors/payload_too_large_error"
-require_relative "errors/internal_server_error"
-require_relative "errors/service_unavailable_error"
-require_relative "errors/too_many_requests_error"
-
-module X
-  # Process HTTP responses
-  class ResponseHandler
-    DEFAULT_ARRAY_CLASS = Array
-    DEFAULT_OBJECT_CLASS = Hash
-    ERROR_CLASSES = {
-      400 => BadRequestError,
-      401 => AuthenticationError,
-      403 => ForbiddenError,
-      404 => NotFoundError,
-      413 => PayloadTooLargeError,
-      429 => TooManyRequestsError,
-      500 => InternalServerError,
-      503 => ServiceUnavailableError
-    }.freeze
-    JSON_CONTENT_TYPE_REGEXP = %r{application/(problem\+|)json}
-
-    attr_accessor :array_class, :object_class
-
-    def initialize(array_class: DEFAULT_ARRAY_CLASS, object_class: DEFAULT_OBJECT_CLASS)
-      @array_class = array_class
-      @object_class = object_class
-    end
-
-    def handle(response)
-      if success?(response)
-        JSON.parse(response.body, array_class: array_class, object_class: object_class) if json?(response)
-      else
-        error_class = ERROR_CLASSES[response.code.to_i] || Error
-        error_message = "#{response.code} #{response.message}"
-        raise error_class.new(error_message, response: response)
-      end
-    end
-
-    def configuration
-      {
-        array_class: array_class,
-        object_class: object_class
-      }
-    end
-
-    private
-
-    def success?(response)
-      response.is_a?(Net::HTTPSuccess)
-    end
-
-    def json?(response)
-      response.body && JSON_CONTENT_TYPE_REGEXP.match?(response["content-type"])
-    end
-  end
-end