x 0.9.1 → 0.11.0

data/lib/x/media_uploader.rb

@@ -0,0 +1,122 @@
+require "securerandom"
+
+module X
+  # Helper module for uploading images and videos
+  module MediaUploader
+    extend self
+
+    MAX_RETRIES = 3
+    BYTES_PER_MB = 1_048_576
+    MEDIA_CATEGORIES = %w[dm_gif dm_image dm_video subtitles tweet_gif tweet_image tweet_video].freeze
+    DM_GIF, DM_IMAGE, DM_VIDEO, SUBTITLES, TWEET_GIF, TWEET_IMAGE, TWEET_VIDEO = MEDIA_CATEGORIES
+    DEFAULT_MIME_TYPE = "application/octet-stream".freeze
+    MIME_TYPES = %w[image/gif image/jpeg video/mp4 image/png application/x-subrip image/webp].freeze
+    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
+
+    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, 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)
+    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, file_path, media_type, 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)
+      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_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"
+
+        sleep status["processing_info"]["check_after_secs"].to_i
+      end
+    end
+
+    private
+
+    def validate!(file_path:, media_category:)
+      raise "File not found: #{file_path}" unless File.exist?(file_path)
+
+      return if MEDIA_CATEGORIES.include?(media_category.downcase)
+
+      raise ArgumentError, "Invalid media_category: #{media_category}. Valid values: #{MEDIA_CATEGORIES.join(", ")}"
+    end
+
+    def infer_media_type(file_path, media_category)
+      case media_category.downcase
+      when TWEET_GIF, DM_GIF then GIF_MIME_TYPE
+      when TWEET_VIDEO, DM_VIDEO then MP4_MIME_TYPE
+      when SUBTITLES then SUBRIP_MIME_TYPE
+      else MIME_TYPE_MAP[File.extname(file_path).delete(".").downcase] || DEFAULT_MIME_TYPE
+      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|
+        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.write(path, chunk)
+            end
+          end
+        end
+      end
+    end
+
+    def append(upload_client, chunk_paths, media, media_type, boundary = SecureRandom.hex)
+      threads = chunk_paths.map.with_index do |chunk_path, index|
+        Thread.new do
+          upload_body = construct_upload_body(chunk_path, media_type, 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)
+        end
+      end
+      threads.each(&:join)
+    end
+
+    def upload_chunk(upload_client, query, upload_body, chunk_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)
+    end
+
+    def cleanup_chunk(chunk_path)
+      dirname = File.dirname(chunk_path)
+      File.delete(chunk_path)
+      Dir.delete(dirname) if Dir.empty?(dirname)
+    end
+
+    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" \
+        "#{File.read(file_path)}\r\n" \
+        "--#{boundary}--\r\n"
+    end
+  end
+end

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)
+      {"Authorization" => 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,36 @@
 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 :authenticator, :connection, :request_builder
 
-    def initialize(authenticator, connection, request_builder, max_redirects: DEFAULT_MAX_REDIRECTS)
+    def initialize(authenticator: Authenticator.new, 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_redirects(response, original_request, original_base_url, redirect_count = 0)
+    def handle(response:, request:, base_url:, 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))
+        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,24 +38,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)
+      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(base_url: new_uri, open_timeout: connection.open_timeout,
-        read_timeout: connection.read_timeout, write_timeout: connection.write_timeout,
-        debug_output: connection.debug_output, proxy_url: connection.proxy_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,64 +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
 
     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,92 @@
+require "json"
+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/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_CLASSES = {
+      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/(problem\+|)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 success?(response)
+
+      JSON.parse(response.body, array_class: array_class, object_class: object_class) if json?(response)
+    end
+
+    private
+
+    def success?(response)
+      response.is_a?(Net::HTTPSuccess)
+    end
+
+    def error(response)
+      error_class(response).new(error_message(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
+    end
+
+    def json?(response)
+      response.body && 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.9.1")
+  VERSION = Gem::Version.create("0.11.0")
 end