x 0.11.0 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e5af820e6e3cd8b04becf201ad7af96c8d95d9206112673888f91c5ecf923187
-  data.tar.gz: 6f0f561be192153eca2cc7356c823c87bd98f0987256875892c0a2e9ea12b82d
+  metadata.gz: 5c6252a6765246fe6ca0820e5ce96f9e66d9611e91b2d59753730fad6b87f67e
+  data.tar.gz: 7a7dc55ece60d848cde08c151e887a1cc86808408a864c05934c4be906b2021a
 SHA512:
-  metadata.gz: 8b208d5ba10604a34a57b0dd2ee5dc0992eb801cfbcc287a7f1b0d54444f214050a2c25b2ec6291868a8c35fff09260ad91a82641be830b87d3e6abf0207fc3e
-  data.tar.gz: 24c6a1083358b60065698320372d53404bab9c319aaad13b097508a7041653ac9d45aabd8e6f7a99204accddfc1beeeb2bce18bd67fa9ba816eb6282cbab4227
+  metadata.gz: 4216ad5a466dd1a714a638a45d9c0996f40c16247f7fc6eb0ff756d301c3cd63aac5ca95fd421940634e3661db5cb41e19300b73f8ef01056c14e21ad89edea1
+  data.tar.gz: a27036e7dd594f9b13b5cd66267c57b63679352ea3eeeaada13adbba838c6cdad5d8f841fe35b808950fc610808c219679e72334091b3d8de1dca5899ba386b5

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+## [0.12.0] - 2023-11-02
+* Ensure Authenticator is passed to RedirectHandler (fc8557b)
+* Add AUTHENTICATION_HEADER to X::Authenticator base class (85a2818)
+* Introduce X::HTTPError (90ae132)
+* Add `code` attribute to error classes (b003639)
+
 ## [0.11.0] - 2023-10-24
 
 * Add base Authenticator class (8c66ce2)

data/README.md

@@ -1,3 +1,9 @@
+![Tests](https://github.com/sferik/x-ruby/actions/workflows/test.yml/badge.svg)
+![Linter](https://github.com/sferik/x-ruby/actions/workflows/lint.yml/badge.svg)
+![Mutant](https://github.com/sferik/x-ruby/actions/workflows/mutant.yml/badge.svg)
+![Typer Checker](https://github.com/sferik/x-ruby/actions/workflows/type_check.yml/badge.svg)
+[![Gem Version](https://badge.fury.io/rb/x.svg)](https://rubygems.org/gems/x)
+
 # A [Ruby](https://www.ruby-lang.org) interface to the [X API](https://developer.x.com)
 
 ## Follow

data/lib/x/authenticator.rb

@@ -1,8 +1,10 @@
 module X
   # Base Authenticator class
   class Authenticator
+    AUTHENTICATION_HEADER = "Authorization".freeze
+
     def header(_request)
-      {"Authorization" => ""}
+      {AUTHENTICATION_HEADER => ""}
     end
   end
 end

data/lib/x/bearer_token_authenticator.rb

@@ -10,7 +10,7 @@ module X
     end
 
     def header(_request)
-      {"Authorization" => "Bearer #{bearer_token}"}
+      {AUTHENTICATION_HEADER => "Bearer #{bearer_token}"}
     end
   end
 end

data/lib/x/client.rb

@@ -14,9 +14,8 @@ module X
     DEFAULT_BASE_URL = "https://api.twitter.com/2/".freeze
 
     attr_accessor :base_url
+    attr_reader :api_key, :api_key_secret, :access_token, :access_token_secret, :bearer_token
 
-    def_delegators :@authenticator, :bearer_token, :api_key, :api_key_secret, :access_token, :access_token_secret
-    def_delegators :@authenticator, :bearer_token=, :api_key=, :api_key_secret=, :access_token=, :access_token_secret=
     def_delegators :@connection, :open_timeout, :read_timeout, :write_timeout, :proxy_url, :debug_output
     def_delegators :@connection, :open_timeout=, :read_timeout=, :write_timeout=, :proxy_url=, :debug_output=
     def_delegators :@redirect_handler, :max_redirects
@@ -24,25 +23,27 @@ module X
     def_delegators :@response_parser, :array_class, :object_class
     def_delegators :@response_parser, :array_class=, :object_class=
 
-    def initialize(bearer_token: nil,
-      api_key: nil, api_key_secret: nil, access_token: nil, access_token_secret: nil,
+    def initialize(api_key: nil, api_key_secret: nil, access_token: nil, access_token_secret: nil,
+      bearer_token: nil,
       base_url: DEFAULT_BASE_URL,
       open_timeout: Connection::DEFAULT_OPEN_TIMEOUT,
       read_timeout: Connection::DEFAULT_READ_TIMEOUT,
       write_timeout: Connection::DEFAULT_WRITE_TIMEOUT,
+      debug_output: Connection::DEFAULT_DEBUG_OUTPUT,
       proxy_url: nil,
-      debug_output: nil,
       array_class: nil,
       object_class: nil,
       max_redirects: RedirectHandler::DEFAULT_MAX_REDIRECTS)
 
+      initialize_oauth(api_key, api_key_secret, access_token, access_token_secret)
+      @bearer_token = bearer_token
+      initialize_authenticator
       @base_url = base_url
-      initialize_authenticator(bearer_token, api_key, api_key_secret, access_token, access_token_secret)
       @connection = Connection.new(open_timeout: open_timeout, read_timeout: read_timeout,
         write_timeout: write_timeout, debug_output: debug_output, proxy_url: proxy_url)
       @request_builder = RequestBuilder.new
-      @redirect_handler = RedirectHandler.new(authenticator: @authenticator, connection: @connection,
-        request_builder: @request_builder, max_redirects: max_redirects)
+      @redirect_handler = RedirectHandler.new(connection: @connection, request_builder: @request_builder,
+        max_redirects: max_redirects)
       @response_parser = ResponseParser.new(array_class: array_class, object_class: object_class)
     end
 
@@ -62,25 +63,60 @@ module X
       execute_request(:delete, endpoint, headers: headers)
     end
 
+    def api_key=(api_key)
+      @api_key = api_key
+      initialize_authenticator
+    end
+
+    def api_key_secret=(api_key_secret)
+      @api_key_secret = api_key_secret
+      initialize_authenticator
+    end
+
+    def access_token=(access_token)
+      @access_token = access_token
+      initialize_authenticator
+    end
+
+    def access_token_secret=(access_token_secret)
+      @access_token_secret = access_token_secret
+      initialize_authenticator
+    end
+
+    def bearer_token=(bearer_token)
+      @bearer_token = bearer_token
+      initialize_authenticator
+    end
+
     private
 
-    def initialize_authenticator(bearer_token, api_key, api_key_secret, access_token, access_token_secret)
-      @authenticator = if bearer_token
-        BearerTokenAuthenticator.new(bearer_token: bearer_token)
-      elsif api_key && api_key_secret && access_token && access_token_secret
+    def initialize_oauth(api_key, api_key_secret, access_token, access_token_secret)
+      @api_key = api_key
+      @api_key_secret = api_key_secret
+      @access_token = access_token
+      @access_token_secret = access_token_secret
+    end
+
+    def initialize_authenticator
+      @authenticator = if api_key && api_key_secret && access_token && access_token_secret
         OAuthAuthenticator.new(api_key: api_key, api_key_secret: api_key_secret, access_token: access_token,
           access_token_secret: access_token_secret)
-      else
+      elsif bearer_token
+        BearerTokenAuthenticator.new(bearer_token: bearer_token)
+      elsif @authenticator.nil?
         Authenticator.new
+      else
+        @authenticator
       end
     end
 
     def execute_request(http_method, endpoint, headers:, body: nil)
       uri = URI.join(base_url, endpoint)
-      request = @request_builder.build(authenticator: @authenticator, http_method: http_method, uri: uri, body: body,
-        headers: headers)
+      request = @request_builder.build(http_method: http_method, uri: uri, body: body, headers: headers,
+        authenticator: @authenticator)
       response = @connection.perform(request: request)
-      response = @redirect_handler.handle(response: response, request: request, base_url: base_url)
+      response = @redirect_handler.handle(response: response, request: request, base_url: base_url,
+        authenticator: @authenticator)
       @response_parser.parse(response: response)
     end
   end

data/lib/x/errors/client_error.rb

@@ -1,5 +1,5 @@
-require_relative "error"
+require_relative "http_error"
 
 module X
-  class ClientError < Error; end
+  class ClientError < HTTPError; end
 end

data/lib/x/errors/error.rb

@@ -1,8 +1,3 @@
 module X
-  # Base error class
-  class Error < ::StandardError
-    def initialize(msg, _response = nil)
-      super(msg)
-    end
-  end
+  class Error < StandardError; end
 end

data/lib/x/errors/http_error.rb

@@ -0,0 +1,42 @@
+require "json"
+require_relative "error"
+
+module X
+  # Base HTTP error class
+  class HTTPError < Error
+    JSON_CONTENT_TYPE_REGEXP = %r{application/(problem\+|)json}
+
+    attr_reader :response, :code
+
+    def initialize(response:)
+      super(error_message(response))
+      @response = response
+      @code = response.code
+    end
+
+    def error_message(response)
+      if json?(response)
+        message_from_json_response(response)
+      else
+        response.message
+      end
+    end
+
+    def message_from_json_response(response)
+      response_object = JSON.parse(response.body)
+      if response_object.key?("title") && response_object.key?("detail")
+        "#{response_object.fetch("title")}: #{response_object.fetch("detail")}"
+      elsif response_object.key?("error")
+        response_object.fetch("error")
+      elsif response_object["errors"].instance_of?(Array)
+        response_object.fetch("errors").map { |error| error.fetch("message") }.join(", ")
+      else
+        response.message
+      end
+    end
+
+    def json?(response)
+      JSON_CONTENT_TYPE_REGEXP.match?(response["content-type"])
+    end
+  end
+end

data/lib/x/errors/server_error.rb

@@ -1,5 +1,5 @@
-require_relative "error"
+require_relative "http_error"
 
 module X
-  class ServerError < Error; end
+  class ServerError < HTTPError; end
 end

data/lib/x/errors/too_many_redirects.rb

@@ -1,5 +1,5 @@
-require_relative "client_error"
+require_relative "error"
 
 module X
-  class TooManyRedirects < ClientError; end
+  class TooManyRedirects < Error; end
 end

data/lib/x/errors/too_many_requests.rb

@@ -1,23 +1,18 @@
 require_relative "client_error"
 
 module X
-  # Rate limit error
+  # Rate limit error class
   class TooManyRequests < ClientError
-    def initialize(msg, response)
-      @response = response
-      super(msg)
-    end
-
     def limit
-      @response["x-rate-limit-limit"].to_i
+      response["x-rate-limit-limit"].to_i
     end
 
     def remaining
-      @response["x-rate-limit-remaining"].to_i
+      response["x-rate-limit-remaining"].to_i
     end
 
     def reset_at
-      Time.at(@response["x-rate-limit-reset"].to_i)
+      Time.at(response["x-rate-limit-reset"].to_i)
     end
 
     def reset_in

data/lib/x/media_uploader.rb

@@ -19,7 +19,7 @@ module X
       boundary: SecureRandom.hex)
       validate!(file_path: file_path, media_category: media_category)
       upload_client = client.dup.tap { |c| c.base_url = "https://upload.twitter.com/1.1/" }
-      upload_body = construct_upload_body(file_path, media_type, boundary)
+      upload_body = construct_upload_body(file_path: file_path, media_type: media_type, boundary: boundary)
       headers = {"Content-Type" => "multipart/form-data, boundary=#{boundary}"}
       upload_client.post("media/upload.json?media_category=#{media_category}", upload_body, headers: headers)
     end
@@ -28,10 +28,11 @@ module X
       media_category), boundary: SecureRandom.hex, chunk_size_mb: 8)
       validate!(file_path: file_path, media_category: media_category)
       upload_client = client.dup.tap { |c| c.base_url = "https://upload.twitter.com/1.1/" }
-      media = init(upload_client, file_path, media_type, media_category)
+      media = init(upload_client: upload_client, file_path: file_path, media_type: media_type,
+        media_category: media_category)
       chunk_size = chunk_size_mb * BYTES_PER_MB
-      chunk_paths = split(file_path, chunk_size)
-      append(upload_client, chunk_paths, media, media_type, boundary)
+      append(upload_client: upload_client, file_paths: split(file_path, chunk_size), media: media,
+        media_type: media_type, boundary: boundary)
       upload_client.post("media/upload.json?command=FINALIZE&media_id=#{media["media_id"]}")
     end
 
@@ -64,19 +65,13 @@ module X
       end
     end
 
-    def init(upload_client, file_path, media_type, media_category)
-      total_bytes = File.size(file_path)
-      query = "command=INIT&media_type=#{media_type}&media_category=#{media_category}&total_bytes=#{total_bytes}"
-      upload_client.post("media/upload.json?#{query}")
-    end
-
     def split(file_path, chunk_size)
       file_number = -1
 
-      [].tap do |chunk_paths|
+      [].tap do |file_paths|
         File.open(file_path, "rb") do |f|
           while (chunk = f.read(chunk_size))
-            chunk_paths << "#{Dir.mktmpdir}/x#{format("%03d", file_number += 1)}".tap do |path|
+            file_paths << "#{Dir.mktmpdir}/x#{format("%03d", file_number += 1)}".tap do |path|
               File.write(path, chunk)
             end
           end
@@ -84,34 +79,41 @@ module X
       end
     end
 
-    def append(upload_client, chunk_paths, media, media_type, boundary = SecureRandom.hex)
-      threads = chunk_paths.map.with_index do |chunk_path, index|
+    def init(upload_client:, file_path:, media_type:, media_category:)
+      total_bytes = File.size(file_path)
+      query = "command=INIT&media_type=#{media_type}&media_category=#{media_category}&total_bytes=#{total_bytes}"
+      upload_client.post("media/upload.json?#{query}")
+    end
+
+    def append(upload_client:, file_paths:, media:, media_type:, boundary: SecureRandom.hex)
+      threads = file_paths.map.with_index do |file_path, index|
         Thread.new do
-          upload_body = construct_upload_body(chunk_path, media_type, boundary)
+          upload_body = construct_upload_body(file_path: file_path, media_type: media_type, boundary: boundary)
           query = "command=APPEND&media_id=#{media["media_id"]}&segment_index=#{index}"
           headers = {"Content-Type" => "multipart/form-data, boundary=#{boundary}"}
-          upload_chunk(upload_client, query, upload_body, chunk_path, headers)
+          upload_chunk(upload_client: upload_client, query: query, upload_body: upload_body, file_path: file_path,
+            headers: headers)
         end
       end
       threads.each(&:join)
     end
 
-    def upload_chunk(upload_client, query, upload_body, chunk_path, headers = {})
+    def upload_chunk(upload_client:, query:, upload_body:, file_path:, headers: {})
       upload_client.post("media/upload.json?#{query}", upload_body, headers: headers)
     rescue NetworkError, ServerError
       retries ||= 0
       ((retries += 1) < MAX_RETRIES) ? retry : raise
     ensure
-      cleanup_chunk(chunk_path)
+      cleanup_file(file_path)
     end
 
-    def cleanup_chunk(chunk_path)
-      dirname = File.dirname(chunk_path)
-      File.delete(chunk_path)
+    def cleanup_file(file_path)
+      dirname = File.dirname(file_path)
+      File.delete(file_path)
       Dir.delete(dirname) if Dir.empty?(dirname)
     end
 
-    def construct_upload_body(file_path, media_type, boundary = SecureRandom.hex)
+    def construct_upload_body(file_path:, media_type:, boundary: SecureRandom.hex)
       "--#{boundary}\r\n" \
         "Content-Disposition: form-data; name=\"media\"; filename=\"#{File.basename(file_path)}\"\r\n" \
         "Content-Type: #{media_type}\r\n\r\n" \

data/lib/x/oauth_authenticator.rb

@@ -24,7 +24,7 @@ module X
 
     def header(request)
       method, url, query_params = parse_request(request)
-      {"Authorization" => build_oauth_header(method, url, query_params)}
+      {AUTHENTICATION_HEADER => build_oauth_header(method, url, query_params)}
     end
 
     private

data/lib/x/redirect_handler.rb

@@ -11,23 +11,22 @@ module X
     DEFAULT_MAX_REDIRECTS = 10
 
     attr_accessor :max_redirects
-    attr_reader :authenticator, :connection, :request_builder
+    attr_reader :connection, :request_builder
 
-    def initialize(authenticator: Authenticator.new, connection: Connection.new, request_builder: RequestBuilder.new,
+    def initialize(connection: Connection.new, request_builder: RequestBuilder.new,
       max_redirects: DEFAULT_MAX_REDIRECTS)
-      @authenticator = authenticator
       @connection = connection
       @request_builder = request_builder
       @max_redirects = max_redirects
     end
 
-    def handle(response:, request:, base_url:, redirect_count: 0)
+    def handle(response:, request:, base_url:, authenticator: Authenticator.new, redirect_count: 0)
       if response.is_a?(Net::HTTPRedirection)
         raise TooManyRedirects, "Too many redirects" if redirect_count > max_redirects
 
         new_uri = build_new_uri(response, base_url)
 
-        new_request = build_request(request, new_uri, Integer(response.code))
+        new_request = build_request(request, new_uri, Integer(response.code), authenticator)
         new_response = connection.perform(request: new_request)
 
         handle(response: new_response, request: new_request, base_url: base_url, redirect_count: redirect_count + 1)
@@ -44,7 +43,7 @@ module X
       URI.join(base_url, location)
     end
 
-    def build_request(request, new_uri, response_code)
+    def build_request(request, new_uri, response_code, authenticator)
       http_method, body = case response_code
       in 307 | 308
         [request.method.downcase.to_sym, request.body]

data/lib/x/response_parser.rb

@@ -3,7 +3,7 @@ require "net/http"
 require_relative "errors/bad_gateway"
 require_relative "errors/bad_request"
 require_relative "errors/connection_exception"
-require_relative "errors/error"
+require_relative "errors/http_error"
 require_relative "errors/forbidden"
 require_relative "errors/gateway_timeout"
 require_relative "errors/gone"
@@ -19,7 +19,7 @@ require_relative "errors/unprocessable_entity"
 module X
   # Process HTTP responses
   class ResponseParser
-    ERROR_CLASSES = {
+    ERROR_MAP = {
       400 => BadRequest,
       401 => Unauthorized,
       403 => Forbidden,
@@ -35,7 +35,7 @@ module X
       503 => ServiceUnavailable,
       504 => GatewayTimeout
     }.freeze
-    JSON_CONTENT_TYPE_REGEXP = %r{application/(problem\+|)json}
+    JSON_CONTENT_TYPE_REGEXP = %r{application/json}
 
     attr_accessor :array_class, :object_class
 
@@ -45,48 +45,25 @@ module X
     end
 
     def parse(response:)
-      raise error(response) unless success?(response)
+      raise error(response) unless response.is_a?(Net::HTTPSuccess)
 
-      JSON.parse(response.body, array_class: array_class, object_class: object_class) if json?(response)
+      return unless json?(response)
+
+      JSON.parse(response.body, array_class: array_class, object_class: object_class)
     end
 
     private
 
-    def success?(response)
-      response.is_a?(Net::HTTPSuccess)
-    end
-
     def error(response)
-      error_class(response).new(error_message(response), response)
+      error_class(response).new(response: response)
     end
 
     def error_class(response)
-      ERROR_CLASSES[Integer(response.code)] || Error
-    end
-
-    def error_message(response)
-      if json?(response)
-        message_from_json_response(response)
-      else
-        response.message
-      end
-    end
-
-    def message_from_json_response(response)
-      response_object = JSON.parse(response.body)
-      if response_object.key?("title") && response_object.key?("detail")
-        "#{response_object.fetch("title")}: #{response_object.fetch("detail")}"
-      elsif response_object.key?("error")
-        response_object.fetch("error")
-      elsif response_object["errors"].instance_of?(Array)
-        response_object.fetch("errors").map { |error| error.fetch("message") }.join(", ")
-      else
-        response.message
-      end
+      ERROR_MAP[Integer(response.code)] || HTTPError
     end
 
     def json?(response)
-      response.body && JSON_CONTENT_TYPE_REGEXP.match?(response["content-type"])
+      JSON_CONTENT_TYPE_REGEXP.match?(response["content-type"])
     end
   end
 end

data/lib/x/version.rb

@@ -1,5 +1,5 @@
 require "rubygems/version"
 
 module X
-  VERSION = Gem::Version.create("0.11.0")
+  VERSION = Gem::Version.create("0.12.0")
 end

data/sig/x.rbs

@@ -2,16 +2,18 @@ module X
   VERSION: Gem::Version
 
   class Authenticator
+    AUTHENTICATION_HEADER: String
+
     def header: (Net::HTTPRequest? request) -> Hash[String, String]
   end
 
-  class BearerTokenAuthenticator
+  class BearerTokenAuthenticator < Authenticator
     attr_accessor bearer_token: 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
@@ -37,7 +39,10 @@ module X
     def escape: (String value) -> String
   end
 
-  class ClientError < Error
+  class Error < StandardError
+  end
+
+  class ClientError < HTTPError
   end
 
   class BadGateway < ClientError
@@ -49,8 +54,18 @@ module X
   class ConnectionException < ClientError
   end
 
-  class Error < StandardError
-    def initialize: (String msg, ?Net::HTTPResponse? response) -> void
+  class HTTPError < Error
+    JSON_CONTENT_TYPE_REGEXP: Regexp
+
+    attr_reader response : Net::HTTPResponse
+    attr_reader code : String
+
+    def initialize: (response: Net::HTTPResponse) -> void
+
+    private
+    def error_message: (Net::HTTPResponse response) -> String
+    def message_from_json_response:  (Net::HTTPResponse response) -> String
+    def json?: (Net::HTTPResponse response) -> bool
   end
 
   class Forbidden < ClientError
@@ -77,19 +92,18 @@ module X
   class PayloadTooLarge < ClientError
   end
 
-  class ServerError < Error
+  class ServerError < HTTPError
   end
 
   class ServiceUnavailable < ServerError
   end
 
-  class TooManyRedirects < ClientError
+  class TooManyRedirects < Error
   end
 
   class TooManyRequests < ClientError
     @response: Net::HTTPResponse
 
-    def initialize: (String msg, Net::HTTPResponse response) -> void
     def limit: -> Integer
     def remaining: -> Integer
     def reset_at: -> Time
@@ -154,19 +168,19 @@ module X
     attr_reader connection: Connection
     attr_reader request_builder: RequestBuilder
     attr_reader max_redirects: Integer
-    def initialize: (authenticator: Authenticator, connection: Connection, request_builder: RequestBuilder, ?max_redirects: Integer) -> void
-    def handle: (response: Net::HTTPResponse, request: Net::HTTPRequest, base_url: String, ?redirect_count: Integer) -> 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, String base_url) -> URI::Generic
-    def build_request: (Net::HTTPRequest request, URI::Generic new_uri, Integer response_code) -> Net::HTTPRequest
+    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 ResponseParser
     DEFAULT_ARRAY_CLASS: Class
     DEFAULT_OBJECT_CLASS: Class
-    ERROR_CLASSES: Hash[Integer, singleton(Unauthorized) | singleton(BadRequest) | singleton(Forbidden) | singleton(InternalServerError) | singleton(NotFound) | singleton(PayloadTooLarge) | singleton(ServiceUnavailable) | singleton(TooManyRequests)]
+    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
@@ -175,11 +189,8 @@ module X
     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 error_message: (Net::HTTPResponse response) -> String
-    def message_from_json_response:  (Net::HTTPResponse response) -> String
     def json?: (Net::HTTPResponse response) -> bool
   end
 
@@ -213,14 +224,15 @@ module X
     attr_accessor redirect_handler: RedirectHandler
     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: 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 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 | Authenticator)
+    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
 
@@ -253,13 +265,13 @@ module X
     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, ?Hash[String, String] headers) -> 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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: x
 version: !ruby/object:Gem::Version
-  version: 0.11.0
+  version: 0.12.0
 platform: ruby
 authors:
 - Erik Berlin
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-10-24 00:00:00.000000000 Z
+date: 2023-11-02 00:00:00.000000000 Z
 dependencies: []
 description:
 email:
@@ -36,6 +36,7 @@ files:
 - 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_acceptable.rb