x 0.10.0 → 0.12.0

data/lib/x/errors/payload_too_large.rb

@@ -0,0 +1,5 @@
+require_relative "client_error"
+
+module X
+  class PayloadTooLarge < ClientError; 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/service_unavailable.rb

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

data/lib/x/errors/too_many_redirects.rb

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

data/lib/x/errors/too_many_requests.rb

@@ -0,0 +1,24 @@
+require_relative "client_error"
+
+module X
+  # Rate limit error class
+  class TooManyRequests < ClientError
+    def limit
+      response["x-rate-limit-limit"].to_i
+    end
+
+    def remaining
+      response["x-rate-limit-remaining"].to_i
+    end
+
+    def reset_at
+      Time.at(response["x-rate-limit-reset"].to_i)
+    end
+
+    def reset_in
+      [(reset_at - Time.now).ceil, 0].max
+    end
+
+    alias_method :retry_after, :reset_in
+  end
+end

data/lib/x/errors/unauthorized.rb

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

data/lib/x/errors/unprocessable_entity.rb

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

data/lib/x/{media_upload.rb → media_uploader.rb}

@@ -2,7 +2,7 @@ require "securerandom"
 
 module X
   # Helper module for uploading images and videos
-  module MediaUpload
+  module MediaUploader
     extend self
 
     MAX_RETRIES = 3
@@ -15,28 +15,29 @@ module X
     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
 
-    def media_upload(client:, file_path:, media_category:, media_type: infer_media_type(file_path, media_category),
+    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_uri = "https://upload.twitter.com/1.1/" }
-      upload_body = construct_upload_body(file_path, media_type, boundary)
-      upload_client.content_type = "multipart/form-data, boundary=#{boundary}"
-      upload_client.post("media/upload.json?media_category=#{media_category}", upload_body)
+      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)
+      headers = {"Content-Type" => "multipart/form-data, boundary=#{boundary}"}
+      upload_client.post("media/upload.json?media_category=#{media_category}", upload_body, headers: headers)
     end
 
-    def chunked_media_upload(client:, file_path:, media_category:, media_type: infer_media_type(file_path,
+    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_uri = "https://upload.twitter.com/1.1/" }
-      media = init(upload_client, file_path, media_type, 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)
       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
 
     def await_processing(client:, media:)
-      upload_client = client.dup.tap { |c| c.base_uri = "https://upload.twitter.com/1.1/" }
+      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"]["state"] == "succeeded"
@@ -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,37 +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}"
-          upload_chunk(upload_client, query, upload_body, chunk_path, boundary)
+          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)
         end
       end
       threads.each(&:join)
     end
 
-    def upload_chunk(upload_client, query, upload_body, chunk_path, boundary)
-      # Initialize a new client to avoid shared connection issues
-      client = upload_client.dup
-      client.connection = Connection.new(**upload_client.connection.configuration.merge(base_url: "https://upload.twitter.com/1.1/"))
-      client.content_type = "multipart/form-data, boundary=#{boundary}"
-      client.post("media/upload.json?#{query}", upload_body)
+    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

@@ -1,20 +1,21 @@
 require "base64"
-require "cgi"
 require "json"
 require "openssl"
 require "securerandom"
 require "uri"
+require_relative "authenticator"
+require_relative "cgi"
 
 module X
   # Handles OAuth authentication
-  class OauthAuthenticator
+  class OAuthAuthenticator < Authenticator
     OAUTH_VERSION = "1.0".freeze
     OAUTH_SIGNATURE_METHOD = "HMAC-SHA1".freeze
     OAUTH_SIGNATURE_ALGORITHM = "sha1".freeze
 
     attr_accessor :api_key, :api_key_secret, :access_token, :access_token_secret
 
-    def initialize(api_key, api_key_secret, access_token, access_token_secret)
+    def initialize(api_key:, api_key_secret:, access_token:, access_token_secret:) # rubocop:disable Lint/MissingSuper
       @api_key = api_key
       @api_key_secret = api_key_secret
       @access_token = access_token
@@ -23,7 +24,7 @@ module X
 
     def header(request)
       method, url, query_params = parse_request(request)
-      build_oauth_header(method, url, query_params)
+      {AUTHENTICATION_HEADER => build_oauth_header(method, url, query_params)}
     end
 
     private
@@ -54,7 +55,7 @@ module X
         "oauth_consumer_key" => api_key,
         "oauth_nonce" => SecureRandom.hex,
         "oauth_signature_method" => OAUTH_SIGNATURE_METHOD,
-        "oauth_timestamp" => Time.now.utc.to_i.to_s,
+        "oauth_timestamp" => Integer(Time.now).to_s,
         "oauth_token" => access_token,
         "oauth_version" => OAUTH_VERSION
       }
@@ -66,26 +67,20 @@ module X
     end
 
     def hmac_signature(base_string)
-      digest = OpenSSL::Digest.new(OAUTH_SIGNATURE_ALGORITHM)
-      hmac = OpenSSL::HMAC.digest(digest, signing_key, base_string)
+      hmac = OpenSSL::HMAC.digest(OAUTH_SIGNATURE_ALGORITHM, signing_key, base_string)
       Base64.strict_encode64(hmac)
     end
 
     def signature_base_string(method, url, params)
-      "#{method}&#{escape(url)}&#{escape(URI.encode_www_form(params.sort))}"
+      "#{method}&#{CGI.escape(url)}&#{CGI.escape(CGI.escape_params(params.sort))}"
     end
 
     def signing_key
-      "#{escape(api_key_secret)}&#{escape(access_token_secret)}"
+      "#{api_key_secret}&#{access_token_secret}"
     end
 
     def format_oauth_header(params)
-      "OAuth #{params.sort.map { |k, v| "#{k}=\"#{escape(v.to_s)}\"" }.join(", ")}"
-    end
-
-    def escape(value)
-      # TODO: Replace CGI.escape with CGI.escapeURIComponent when support for Ruby 3.1 is dropped
-      CGI.escape(value.to_s).gsub("+", "%20")
+      "OAuth #{params.sort.map { |k, v| "#{k}=\"#{CGI.escape(v)}\"" }.join(", ")}"
     end
   end
 end

data/lib/x/redirect_handler.rb

@@ -1,31 +1,35 @@
 require "net/http"
 require "uri"
+require_relative "authenticator"
 require_relative "connection"
-require_relative "errors/too_many_redirects_error"
+require_relative "errors/too_many_redirects"
+require_relative "request_builder"
 
 module X
   # Handles HTTP redirects
   class RedirectHandler
     DEFAULT_MAX_REDIRECTS = 10
 
-    attr_reader :authenticator, :connection, :request_builder, :max_redirects
+    attr_accessor :max_redirects
+    attr_reader :connection, :request_builder
 
-    def initialize(authenticator, connection, request_builder, max_redirects: DEFAULT_MAX_REDIRECTS)
-      @authenticator = authenticator
+    def initialize(connection: Connection.new, request_builder: RequestBuilder.new,
+      max_redirects: DEFAULT_MAX_REDIRECTS)
       @connection = connection
       @request_builder = request_builder
       @max_redirects = max_redirects
     end
 
-    def handle_redirects(response, original_request, original_base_url, redirect_count = 0)
+    def handle(response:, request:, base_url:, authenticator: Authenticator.new, redirect_count: 0)
       if response.is_a?(Net::HTTPRedirection)
-        raise TooManyRedirectsError.new("Too many redirects", response: response) if redirect_count >= max_redirects
+        raise TooManyRedirects, "Too many redirects" if redirect_count > max_redirects
 
-        new_uri = build_new_uri(response, original_base_url)
-        new_request = build_request(original_request, new_uri)
-        new_response = send_new_request(new_uri, new_request)
+        new_uri = build_new_uri(response, base_url)
 
-        handle_redirects(new_response, new_request, original_base_url, redirect_count + 1)
+        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)
       else
         response
       end
@@ -33,22 +37,21 @@ module X
 
     private
 
-    def build_new_uri(response, original_base_url)
-      location = response["location"].to_s
-      new_uri = URI.parse(location)
-      new_uri = URI.join(original_base_url.to_s, location) if new_uri.relative?
-      new_uri
+    def build_new_uri(response, base_url)
+      location = response.fetch("location")
+      # If location is relative, it will join with the original base URL, otherwise it will overwrite it
+      URI.join(base_url, location)
     end
 
-    def build_request(original_request, new_uri)
-      http_method = original_request.method.downcase.to_sym
-      body = original_request.body if original_request.body
-      request_builder.build(authenticator, http_method, new_uri, body: body)
-    end
+    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]
+      else
+        [:get, nil]
+      end
 
-    def send_new_request(new_uri, new_request)
-      @connection = Connection.new(**connection.configuration.merge(base_url: new_uri))
-      connection.send_request(new_request)
+      request_builder.build(http_method: http_method, uri: new_uri, body: body, authenticator: authenticator)
     end
   end
 end

data/lib/x/request_builder.rb

@@ -1,71 +1,58 @@
 require "net/http"
 require "uri"
+require_relative "authenticator"
+require_relative "cgi"
 require_relative "version"
 
 module X
   # Creates HTTP requests
   class RequestBuilder
+    DEFAULT_HEADERS = {
+      "Content-Type" => "application/json; charset=utf-8",
+      "User-Agent" => "X-Client/#{VERSION} #{RUBY_ENGINE}/#{RUBY_VERSION} (#{RUBY_PLATFORM})"
+    }.freeze
     HTTP_METHODS = {
       get: Net::HTTP::Get,
       post: Net::HTTP::Post,
       put: Net::HTTP::Put,
       delete: Net::HTTP::Delete
     }.freeze
-    DEFAULT_CONTENT_TYPE = "application/json; charset=utf-8".freeze
-    DEFAULT_USER_AGENT = "X-Client/#{VERSION} #{RUBY_ENGINE}/#{RUBY_VERSION} (#{RUBY_PLATFORM})".freeze
-    AUTHORIZATION_HEADER = "Authorization".freeze
-    CONTENT_TYPE_HEADER = "Content-Type".freeze
-    USER_AGENT_HEADER = "User-Agent".freeze
-
-    attr_accessor :content_type, :user_agent
-
-    def initialize(content_type: DEFAULT_CONTENT_TYPE, user_agent: DEFAULT_USER_AGENT)
-      @content_type = content_type
-      @user_agent = user_agent
-    end
 
-    def build(authenticator, http_method, uri, body: nil)
-      request = create_request(http_method, uri, body)
-      add_authorization(request, authenticator)
-      add_content_type(request)
-      add_user_agent(request)
+    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
     end
 
-    def configuration
-      {
-        content_type: content_type,
-        user_agent: user_agent
-      }
-    end
-
     private
 
-    def create_request(http_method, uri, body)
+    def create_request(http_method:, uri:, body:)
       http_method_class = HTTP_METHODS[http_method]
 
       raise ArgumentError, "Unsupported HTTP method: #{http_method}" unless http_method_class
 
       escaped_uri = escape_query_params(uri)
       request = http_method_class.new(escaped_uri)
-      request.body = body if body && http_method != :get
+      request.body = body
       request
     end
 
-    def add_authorization(request, authenticator)
-      request.add_field(AUTHORIZATION_HEADER, authenticator.header(request))
-    end
-
-    def add_content_type(request)
-      request.add_field(CONTENT_TYPE_HEADER, content_type) if content_type
+    def add_authentication(request:, authenticator:)
+      authenticator.header(request).each do |key, value|
+        request.add_field(key, value)
+      end
     end
 
-    def add_user_agent(request)
-      request.add_field(USER_AGENT_HEADER, user_agent) if user_agent
+    def add_headers(request:, headers:)
+      DEFAULT_HEADERS.merge(headers).each do |key, value|
+        request.delete(key)
+        request.add_field(key, value)
+      end
     end
 
     def escape_query_params(uri)
-      URI(uri).tap { |u| u.query = URI.encode_www_form(URI.decode_www_form(uri.query)) if uri.query }
+      URI(uri).tap { |u| u.query = CGI.escape_params(URI.decode_www_form(u.query)) if u.query }
     end
   end
 end

data/lib/x/response_parser.rb

@@ -0,0 +1,69 @@
+require "json"
+require "net/http"
+require_relative "errors/bad_gateway"
+require_relative "errors/bad_request"
+require_relative "errors/connection_exception"
+require_relative "errors/http_error"
+require_relative "errors/forbidden"
+require_relative "errors/gateway_timeout"
+require_relative "errors/gone"
+require_relative "errors/internal_server_error"
+require_relative "errors/not_acceptable"
+require_relative "errors/not_found"
+require_relative "errors/payload_too_large"
+require_relative "errors/service_unavailable"
+require_relative "errors/too_many_requests"
+require_relative "errors/unauthorized"
+require_relative "errors/unprocessable_entity"
+
+module X
+  # Process HTTP responses
+  class ResponseParser
+    ERROR_MAP = {
+      400 => BadRequest,
+      401 => Unauthorized,
+      403 => Forbidden,
+      404 => NotFound,
+      406 => NotAcceptable,
+      409 => ConnectionException,
+      410 => Gone,
+      413 => PayloadTooLarge,
+      422 => UnprocessableEntity,
+      429 => TooManyRequests,
+      500 => InternalServerError,
+      502 => BadGateway,
+      503 => ServiceUnavailable,
+      504 => GatewayTimeout
+    }.freeze
+    JSON_CONTENT_TYPE_REGEXP = %r{application/json}
+
+    attr_accessor :array_class, :object_class
+
+    def initialize(array_class: nil, object_class: nil)
+      @array_class = array_class
+      @object_class = object_class
+    end
+
+    def parse(response:)
+      raise error(response) unless response.is_a?(Net::HTTPSuccess)
+
+      return unless json?(response)
+
+      JSON.parse(response.body, array_class: array_class, object_class: object_class)
+    end
+
+    private
+
+    def error(response)
+      error_class(response).new(response: 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.10.0")
+  VERSION = Gem::Version.create("0.12.0")
 end