x 0.14.1 → 0.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d12a0c6ddac3958b996b0bb5fc2a0a9893d0c85fa456d9d3a95bb5a9b4a39291
-  data.tar.gz: 771bc16ba8c1b1492268be7e83a9a69a3291d45863dd309fbdc083969a58d5da
+  metadata.gz: 546b7411941d44ee91c52d183794a25c0335df8bc86606a6eb6464a2e45222b6
+  data.tar.gz: 17d533d29594706aef376c5970269ea634d5c8eb67216b6b4b9b78c3d3861db1
 SHA512:
-  metadata.gz: c0c951541a6a4fdcb6eb7cf68135ecc8177a91af6beb1b823cd80495c54fd7bff8571b1644ff66553e65a4f386fb4e1ef5acc0984621d2f68e1c8960505d1708
-  data.tar.gz: 6de5b4c4c7350dad50704727c1947705c590adc0729acb91c63b219b35b5ea51feba448d799b74ec4c0102fdac0896b91eafe79e9ecfa42ebae40efa55873ae5
+  metadata.gz: fd1be4aa484b43ac51d0a6ef04375b9de9c5f3f132ae3d8b33f108838710ef4ea5303ddf8fc89c334639383da5986d5ca16b90be3ae6e9f3b26cc929de091276
+  data.tar.gz: a0c0335a499edc77b0c6c260f16d35a0ffcc9de485b546e0f8477c2eb92426796d7c2588b006926718bcc8b989c06c0c15c20cde177582ede998cfbcf20b1910

data/CHANGELOG.md

@@ -1,3 +1,6 @@
+## [0.15.0] - 2025-02-06
+* Change media upload to use the API v2 endpoints (eca2b88)
+
 ## [0.14.1] - 2023-12-20
 * Fix infinite loop when an upload fails (5dfc604)
 

data/README.md

@@ -1,8 +1,9 @@
-[![Tests](https://github.com/sferik/x-ruby/actions/workflows/test.yml/badge.svg)](https://github.com/sferik/x-ruby/actions/workflows/test.yml)
-[![Linter](https://github.com/sferik/x-ruby/actions/workflows/lint.yml/badge.svg)](https://github.com/sferik/x-ruby/actions/workflows/lint.yml)
-[![Mutant](https://github.com/sferik/x-ruby/actions/workflows/mutant.yml/badge.svg)](https://github.com/sferik/x-ruby/actions/workflows/mutant.yml)
-[![Typer Checker](https://github.com/sferik/x-ruby/actions/workflows/steep.yml/badge.svg)](https://github.com/sferik/x-ruby/actions/workflows/steep.yml)
-[![Gem Version](https://badge.fury.io/rb/x.svg)](https://rubygems.org/gems/x)
+[![tests](https://github.com/sferik/x-ruby/actions/workflows/test.yml/badge.svg)](https://github.com/sferik/x-ruby/actions/workflows/test.yml)
+[![mutation tests](https://github.com/sferik/x-ruby/actions/workflows/mutant.yml/badge.svg)](https://github.com/sferik/x-ruby/actions/workflows/mutant.yml)
+[![linter](https://github.com/sferik/x-ruby/actions/workflows/lint.yml/badge.svg)](https://github.com/sferik/x-ruby/actions/workflows/lint.yml)
+[![typer checker](https://github.com/sferik/x-ruby/actions/workflows/steep.yml/badge.svg)](https://github.com/sferik/x-ruby/actions/workflows/steep.yml)
+[![maintainability](https://api.codeclimate.com/v1/badges/40bbddf2c9170742ca9e/maintainability)](https://codeclimate.com/github/sferik/x-ruby/maintainability)
+[![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)
 

data/lib/x/client.rb

@@ -33,35 +33,30 @@ module X
       default_array_class: DEFAULT_ARRAY_CLASS,
       default_object_class: DEFAULT_OBJECT_CLASS,
       max_redirects: RedirectHandler::DEFAULT_MAX_REDIRECTS)
-
       initialize_oauth(api_key, api_key_secret, access_token, access_token_secret, bearer_token)
       initialize_authenticator
       @base_url = base_url
       initialize_default_classes(default_array_class, default_object_class)
-      @connection = Connection.new(open_timeout: open_timeout, read_timeout: read_timeout,
-        write_timeout: write_timeout, debug_output: debug_output, proxy_url: proxy_url)
+      @connection = Connection.new(open_timeout:, read_timeout:, write_timeout:, debug_output:, proxy_url:)
       @request_builder = RequestBuilder.new
-      @redirect_handler = RedirectHandler.new(connection: @connection, request_builder: @request_builder,
-        max_redirects: max_redirects)
+      @redirect_handler = RedirectHandler.new(connection: @connection, request_builder: @request_builder, max_redirects:)
       @response_parser = ResponseParser.new
     end
 
     def get(endpoint, headers: {}, array_class: default_array_class, object_class: default_object_class)
-      execute_request(:get, endpoint, headers: headers, array_class: array_class, object_class: object_class)
+      execute_request(:get, endpoint, headers:, array_class:, object_class:)
     end
 
     def post(endpoint, body = nil, headers: {}, array_class: default_array_class, object_class: default_object_class)
-      execute_request(:post, endpoint, body: body, headers: headers, array_class: array_class,
-        object_class: object_class)
+      execute_request(:post, endpoint, body:, headers:, array_class:, object_class:)
     end
 
     def put(endpoint, body = nil, headers: {}, array_class: default_array_class, object_class: default_object_class)
-      execute_request(:put, endpoint, body: body, headers: headers, array_class: array_class,
-        object_class: object_class)
+      execute_request(:put, endpoint, body:, headers:, array_class:, object_class:)
     end
 
     def delete(endpoint, headers: {}, array_class: default_array_class, object_class: default_object_class)
-      execute_request(:delete, endpoint, headers: headers, array_class: array_class, object_class: object_class)
+      execute_request(:delete, endpoint, headers:, array_class:, object_class:)
     end
 
     def api_key=(api_key)
@@ -106,10 +101,9 @@ module X
 
     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)
+        OAuthAuthenticator.new(api_key:, api_key_secret:, access_token:, access_token_secret:)
       elsif bearer_token
-        BearerTokenAuthenticator.new(bearer_token: bearer_token)
+        BearerTokenAuthenticator.new(bearer_token:)
       elsif @authenticator.nil?
         Authenticator.new
       else
@@ -119,12 +113,10 @@ module X
 
     def execute_request(http_method, endpoint, body: nil, headers: {}, array_class: default_array_class, object_class: default_object_class)
       uri = URI.join(base_url, endpoint)
-      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,
-        authenticator: @authenticator)
-      @response_parser.parse(response: response, array_class: array_class, object_class: object_class)
+      request = @request_builder.build(http_method:, uri:, body:, headers:, authenticator: @authenticator)
+      response = @connection.perform(request:)
+      response = @redirect_handler.handle(response:, request:, base_url:, authenticator: @authenticator)
+      @response_parser.parse(response:, array_class:, object_class:)
     end
   end
 end

data/lib/x/errors/http_error.rb

@@ -35,7 +35,7 @@ module X
     end
 
     def json?(response)
-      JSON_CONTENT_TYPE_REGEXP.match?(response["content-type"])
+      JSON_CONTENT_TYPE_REGEXP === response["content-type"]
     end
   end
 end

data/lib/x/errors/too_many_requests.rb

@@ -9,7 +9,7 @@ module X
 
     def rate_limits
       @rate_limits ||= RateLimit::TYPES.filter_map do |type|
-        RateLimit.new(type: type, response: response) if response["x-#{type}-remaining"].eql?("0")
+        RateLimit.new(type:, response:) if response["x-#{type}-remaining"].eql?("0")
       end
     end
 

data/lib/x/media_uploader.rb

@@ -14,33 +14,29 @@ module X
     GIF_MIME_TYPE, JPEG_MIME_TYPE, MP4_MIME_TYPE, PNG_MIME_TYPE, SUBRIP_MIME_TYPE, WEBP_MIME_TYPE = MIME_TYPES
     MIME_TYPE_MAP = {"gif" => GIF_MIME_TYPE, "jpg" => JPEG_MIME_TYPE, "jpeg" => JPEG_MIME_TYPE, "mp4" => MP4_MIME_TYPE,
                      "png" => PNG_MIME_TYPE, "srt" => SUBRIP_MIME_TYPE, "webp" => WEBP_MIME_TYPE}.freeze
+    PROCESSING_INFO_STATES = %w[failed succeeded].freeze
 
     def upload(client:, file_path:, media_category:, media_type: infer_media_type(file_path, media_category),
       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: file_path, media_type: media_type, boundary: boundary)
+      validate!(file_path:, media_category:)
+      upload_body = construct_upload_body(file_path:, media_type:, boundary:)
       headers = {"Content-Type" => "multipart/form-data, boundary=#{boundary}"}
-      upload_client.post("media/upload.json?media_category=#{media_category}", upload_body, headers: headers)
+      client.post("media/upload?media_category=#{media_category}", upload_body, headers:)
     end
 
     def chunked_upload(client:, file_path:, media_category:, media_type: infer_media_type(file_path,
-      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: upload_client, file_path: file_path, media_type: media_type,
-        media_category: media_category)
+      media_category), boundary: SecureRandom.hex, chunk_size_mb: 1)
+      validate!(file_path:, media_category:)
+      media = init(client:, file_path:, media_type:, media_category:)
       chunk_size = chunk_size_mb * BYTES_PER_MB
-      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"]}")
+      append(client:, file_paths: split(file_path, chunk_size), media:, media_type:, boundary:)
+      client.post("media/upload?command=FINALIZE&media_key=#{media["media_key"]}")&.fetch("data")
     end
 
     def await_processing(client:, media:)
-      upload_client = client.dup.tap { |c| c.base_url = "https://upload.twitter.com/1.1/" }
       loop do
-        status = upload_client.get("media/upload.json?command=STATUS&media_id=#{media["media_id"]}")
-        return status if !status["processing_info"] || %w[failed succeeded].include?(status["processing_info"]["state"])
+        status = client.get("media/upload?command=STATUS&media_key=#{media["media_key"]}")&.fetch("data")
+        return status if !status["processing_info"] || PROCESSING_INFO_STATES.include?(status["processing_info"]["state"])
 
         sleep status["processing_info"]["check_after_secs"].to_i
       end
@@ -67,39 +63,38 @@ module X
 
     def split(file_path, chunk_size)
       file_number = -1
+      file_paths = [] # @type var file_paths: Array[String]
 
-      [].tap do |file_paths|
-        File.open(file_path, "rb") do |f|
-          while (chunk = f.read(chunk_size))
-            file_paths << "#{Dir.mktmpdir}/x#{format("%03d", file_number += 1)}".tap do |path|
-              File.binwrite(path, chunk)
-            end
-          end
+      File.open(file_path, "rb") do |f|
+        while (chunk = f.read(chunk_size))
+          path = "#{Dir.mktmpdir}/x#{format("%03d", file_number += 1)}"
+          File.binwrite(path, chunk)
+          file_paths << path
         end
       end
+      file_paths
     end
 
-    def init(upload_client:, file_path:, media_type:, media_category:)
+    def init(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}")
+      client.post("media/upload?#{query}")&.fetch("data")
     end
 
-    def append(upload_client:, file_paths:, media:, media_type:, boundary: SecureRandom.hex)
+    def append(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(file_path: file_path, media_type: media_type, boundary: boundary)
-          query = "command=APPEND&media_id=#{media["media_id"]}&segment_index=#{index}"
+          upload_body = construct_upload_body(file_path:, media_type:, boundary:)
+          query = "command=APPEND&media_key=#{media["media_key"]}&segment_index=#{index}"
           headers = {"Content-Type" => "multipart/form-data, boundary=#{boundary}"}
-          upload_chunk(upload_client: upload_client, query: query, upload_body: upload_body, file_path: file_path,
-            headers: headers)
+          upload_chunk(client:, query:, upload_body:, file_path:, headers:)
         end
       end
       threads.each(&:join)
     end
 
-    def upload_chunk(upload_client:, query:, upload_body:, file_path:, headers: {})
-      upload_client.post("media/upload.json?#{query}", upload_body, headers: headers)
+    def upload_chunk(client:, query:, upload_body:, file_path:, headers: {})
+      client.post("media/upload?#{query}", upload_body, headers:)
     rescue NetworkError, ServerError
       retries ||= 0
       ((retries += 1) < MAX_RETRIES) ? retry : raise

data/lib/x/oauth_authenticator.rb

@@ -1,10 +1,10 @@
 require "base64"
+require "cgi"
 require "json"
 require "openssl"
 require "securerandom"
 require "uri"
 require_relative "authenticator"
-require_relative "cgi"
 
 module X
   class OAuthAuthenticator < Authenticator
@@ -39,7 +39,7 @@ module X
     end
 
     def uri_without_query(uri)
-      uri.to_s.chomp("?#{uri.query}")
+      "#{uri.scheme}://#{uri.host}#{uri.path}"
     end
 
     def build_oauth_header(method, url, query_params)
@@ -71,7 +71,7 @@ module X
     end
 
     def signature_base_string(method, url, params)
-      "#{method}&#{CGI.escape(url)}&#{CGI.escape(CGI.escape_params(params.sort))}"
+      "#{method}&#{CGI.escapeURIComponent(url)}&#{CGI.escapeURIComponent(URI.encode_www_form(params.sort))}"
     end
 
     def signing_key
@@ -79,7 +79,7 @@ module X
     end
 
     def format_oauth_header(params)
-      "OAuth #{params.sort.map { |k, v| "#{k}=\"#{CGI.escape(v)}\"" }.join(", ")}"
+      "OAuth #{params.sort.map { |k, v| "#{k}=\"#{CGI.escapeURIComponent(v)}\"" }.join(", ")}"
     end
   end
 end

data/lib/x/redirect_handler.rb

@@ -28,7 +28,7 @@ module X
         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)
+        handle(response: new_response, request: new_request, base_url:, redirect_count: redirect_count + 1)
       else
         response
       end
@@ -42,7 +42,7 @@ module X
       URI.join(base_url, location)
     end
 
-    def build_request(request, new_uri, response_code, authenticator)
+    def build_request(request, uri, response_code, authenticator)
       http_method, body = case response_code
       in 307 | 308
         [request.method.downcase.to_sym, request.body]
@@ -50,7 +50,7 @@ module X
         [:get, nil]
       end
 
-      request_builder.build(http_method: http_method, uri: new_uri, body: body, authenticator: authenticator)
+      request_builder.build(http_method:, uri:, body:, authenticator:)
     end
   end
 end

data/lib/x/request_builder.rb

@@ -1,7 +1,6 @@
 require "net/http"
 require "uri"
 require_relative "authenticator"
-require_relative "cgi"
 require_relative "version"
 
 module X
@@ -18,9 +17,9 @@ module X
     }.freeze
 
     def build(http_method:, uri:, body: nil, headers: {}, authenticator: Authenticator.new)
-      request = create_request(http_method: http_method, uri: uri, body: body)
-      add_headers(request: request, headers: headers)
-      add_authentication(request: request, authenticator: authenticator)
+      request = create_request(http_method:, uri:, body:)
+      add_headers(request:, headers:)
+      add_authentication(request:, authenticator:)
       request
     end
 
@@ -51,7 +50,7 @@ module X
     end
 
     def escape_query_params(uri)
-      URI(uri).tap { |u| u.query = CGI.escape_params(URI.decode_www_form(u.query)) if u.query }
+      URI(uri).tap { |u| u.query = URI.encode_www_form(URI.decode_www_form(u.query)) if u.query }
     end
   end
 end

data/lib/x/response_parser.rb

@@ -34,28 +34,27 @@ module X
       503 => ServiceUnavailable,
       504 => GatewayTimeout
     }.freeze
-    JSON_CONTENT_TYPE_REGEXP = %r{application/json}
 
     def parse(response:, array_class: nil, object_class: nil)
       raise error(response) unless response.is_a?(Net::HTTPSuccess)
 
-      return unless json?(response)
+      return if response.instance_of?(Net::HTTPNoContent)
 
-      JSON.parse(response.body, array_class: array_class, object_class: object_class)
+      begin
+        JSON.parse(response.body, array_class:, object_class:)
+      rescue JSON::ParserError
+        nil
+      end
     end
 
     private
 
     def error(response)
-      error_class(response).new(response: response)
+      error_class(response).new(response:)
     end
 
     def error_class(response)
       ERROR_MAP[Integer(response.code)] || HTTPError
     end
-
-    def json?(response)
-      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.14.1")
+  VERSION = Gem::Version.create("0.15.0")
 end

data/sig/x.rbs

@@ -125,6 +125,8 @@ module X
     DEFAULT_DEBUG_OUTPUT: IO
     NETWORK_ERRORS: Array[(singleton(Errno::ECONNREFUSED) | singleton(Errno::ECONNRESET) | singleton(Net::OpenTimeout) | singleton(Net::ReadTimeout) | singleton(OpenSSL::SSL::SSLError))]
 
+    @proxy_url: URI::Generic | String
+
     extend Forwardable
 
     attr_accessor open_timeout : Float | Integer
@@ -151,7 +153,7 @@ module X
     RATE_LIMIT_TYPE: String
     APP_LIMIT_TYPE: String
     USER_LIMIT_TYPE: String
-    TYPES: [String, String, String]
+    TYPES: Array[String]
 
     attr_accessor type: String
     attr_accessor response: Net::HTTPResponse
@@ -167,7 +169,7 @@ module X
     DEFAULT_HEADERS: Hash[String, String]
 
     def initialize: (?content_type: String, ?user_agent: String) -> void
-    def build: (authenticator: Authenticator, http_method: Symbol, uri: URI::Generic, ?body: String?, ?headers: Hash[String, String]) -> (Net::HTTPRequest)
+    def build: (http_method: Symbol, uri: URI::Generic, ?body: String?, ?headers: Hash[String, String], ?authenticator: Authenticator) -> (Net::HTTPRequest)
 
     private
     def create_request: (http_method: Symbol, uri: URI::Generic, body: String?) -> (Net::HTTPRequest)
@@ -183,7 +185,7 @@ module X
     attr_reader connection: Connection
     attr_reader request_builder: RequestBuilder
     attr_reader max_redirects: Integer
-    def initialize: (connection: Connection, request_builder: RequestBuilder, ?max_redirects: Integer) -> void
+    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
@@ -193,60 +195,51 @@ module X
   end
 
   class ResponseParser
-    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
+    ERROR_MAP: Hash[Integer, singleton(BadGateway) | singleton(BadRequest) | singleton(ConnectionException) | singleton(Forbidden) | singleton(GatewayTimeout) | singleton(Gone) | singleton(InternalServerError) | singleton(NotAcceptable) | singleton(NotFound) | singleton(PayloadTooLarge) | singleton(ServiceUnavailable) | singleton(TooManyRequests) | singleton(Unauthorized) | singleton(UnprocessableEntity)]
 
     def parse: (response: Net::HTTPResponse, ?array_class: Class?, ?object_class: Class?) -> untyped
 
     private
-    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: (Net::HTTPResponse response) -> HTTPError
+    def error_class: (Net::HTTPResponse response) -> (singleton(BadGateway) | singleton(BadRequest) | singleton(ConnectionException) | singleton(Forbidden) | singleton(GatewayTimeout) | singleton(Gone) | singleton(InternalServerError) | singleton(NotAcceptable) | singleton(NotFound) | singleton(PayloadTooLarge) | singleton(ServiceUnavailable) | singleton(TooManyRequests) | singleton(Unauthorized) | singleton(UnprocessableEntity))
     def json?: (Net::HTTPResponse response) -> bool
   end
 
   class Client
     DEFAULT_BASE_URL: String
-    DEFAULT_ARRAY_CLASS: Class
-    DEFAULT_OBJECT_CLASS: Class
-
+    DEFAULT_ARRAY_CLASS: singleton(Array)
+    DEFAULT_OBJECT_CLASS: singleton(Hash)
     extend Forwardable
-    @authenticator: Authenticator
+    @authenticator: Authenticator | BearerTokenAuthenticator | OAuthAuthenticator
     @connection: Connection
     @request_builder: RequestBuilder
     @redirect_handler: RedirectHandler
     @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_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 debug_output: IO
-    attr_accessor default_array_class: Class
-    attr_accessor default_object_class: Class
-    attr_accessor max_redirects: Integer
-    attr_accessor authenticator: Authenticator
-    attr_accessor connection: Connection
-    attr_accessor request_builder: RequestBuilder
-    attr_accessor redirect_handler: RedirectHandler
-    attr_accessor response_parser: ResponseParser
-
-    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, ?default_array_class: Class, ?default_object_class: Class, ?max_redirects: Integer) -> void
+    attr_accessor default_array_class: singleton(Array)
+    attr_accessor default_object_class: singleton(Hash)
+    attr_reader api_key: String?
+    attr_reader api_key_secret: String?
+    attr_reader access_token: String?
+    attr_reader access_token_secret: String?
+    attr_reader bearer_token: String?
+    def initialize: (?api_key: nil, ?api_key_secret: nil, ?access_token: nil, ?access_token_secret: nil, ?bearer_token: nil, ?base_url: String, ?open_timeout: Integer, ?read_timeout: Integer, ?write_timeout: Integer, ?debug_output: untyped, ?proxy_url: nil, ?default_array_class: singleton(Array), ?default_object_class: singleton(Hash), ?max_redirects: Integer) -> void
     def get: (String endpoint, ?headers: Hash[String, String], ?array_class: Class, ?object_class: Class) -> untyped
     def post: (String endpoint, ?String? body, ?headers: Hash[String, String], ?array_class: Class, ?object_class: Class) -> untyped
     def put: (String endpoint, ?String? body, ?headers: Hash[String, String], ?array_class: Class, ?object_class: Class) -> untyped
     def delete: (String endpoint, ?headers: Hash[String, String], ?array_class: Class, ?object_class: Class) -> untyped
+    def api_key=: (String api_key) -> void
+    def api_key_secret=: (String api_key_secret) -> void
+    def access_token=: (String access_token) -> void
+    def access_token_secret=: (String access_token_secret) -> void
+    def bearer_token=: (String bearer_token) -> void
 
     private
     def initialize_oauth: (String? api_key, String? api_key_secret, String? access_token, String? access_token_secret, String? bearer_token) -> void
-    def initialize_default_classes: (Class? default_array_class, Class? default_object_class) -> void
-    def initialize_authenticator: -> Authenticator
-    def execute_request: (Symbol http_method, String endpoint, ?body: String?, ?headers: Hash[String, String], ?array_class: Class?, ?object_class: Class?) -> untyped
+    def initialize_default_classes: (singleton(Array) default_array_class, singleton(Hash) default_object_class) -> singleton(Hash)
+    def initialize_authenticator: -> (Authenticator | BearerTokenAuthenticator | OAuthAuthenticator)
+    def execute_request: (:delete | :get | :post | :put http_method, String endpoint, ?body: String?, ?headers: Hash[String, String], ?array_class: Class, ?object_class: Class) -> nil
   end
 
   module MediaUploader
@@ -269,6 +262,7 @@ module X
     SUBRIP_MIME_TYPE: String
     WEBP_MIME_TYPE: String
     MIME_TYPE_MAP: Hash[String, String]
+    PROCESSING_INFO_STATES: Array[String]
     extend MediaUploader
 
     def upload: (client: Client, file_path: String, media_category: String, ?media_type: String, ?boundary: String) -> untyped
@@ -279,16 +273,11 @@ module X
     def validate!: (file_path: String, media_category: String) -> nil
     def infer_media_type: (String file_path, String media_category) -> String
     def split: (String file_path, Integer chunk_size) -> Array[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 init: (client: Client, file_path: String, media_type: String, media_category: String) -> untyped
+    def append: (client: Client, file_paths: Array[String], media: untyped, media_type: String, ?boundary: String) -> Array[String]
+    def upload_chunk: (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 finalize: (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,16 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: x
 version: !ruby/object:Gem::Version
-  version: 0.14.1
+  version: 0.15.0
 platform: ruby
 authors:
 - Erik Berlin
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-12-20 00:00:00.000000000 Z
+date: 2025-02-06 00:00:00.000000000 Z
 dependencies: []
-description:
 email:
 - sferik@gmail.com
 executables: []
@@ -25,7 +23,6 @@ files:
 - 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/bad_gateway.rb
@@ -67,7 +64,6 @@ metadata:
   changelog_uri: https://github.com/sferik/x-ruby/blob/master/CHANGELOG.md
   bug_tracker_uri: https://github.com/sferik/x-ruby/issues
   documentation_uri: https://rubydoc.info/gems/x/
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -75,15 +71,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.0'
+      version: '3.2'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.1
-signing_key:
+rubygems_version: 3.6.3
 specification_version: 4
 summary: A Ruby interface to the X API.
 test_files: []

data/lib/x/cgi.rb

@@ -1,14 +0,0 @@
-require "cgi"
-
-module X
-  class CGI
-    # TODO: Replace CGI.escape with CGI.escapeURIComponent when support for Ruby 3.1 is dropped
-    def self.escape(value)
-      ::CGI.escape(value).gsub("+", "%20")
-    end
-
-    def self.escape_params(params)
-      params.map { |k, v| "#{k}=#{escape(v)}" }.join("&")
-    end
-  end
-end