x 0.15.4 → 0.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 731556dfa3e6417d5e0ea9305d6a6b87cc87bd360d71277df0b3dd1c5c8400b5
-  data.tar.gz: a1170fee36003355b65fe7a6a2732eb750ab0681bae74539d3f1eb17bfd96f65
+  metadata.gz: cc174269cbe283b3f360fee2c9a443272d0c1d3aab08cf609d552f22323dabc7
+  data.tar.gz: a2f50383c52f0e499f8afe275ce100cd9ca6f8231bd5fdd1f18c1bfdd7bf5191
 SHA512:
-  metadata.gz: ec96213eaf3a727ba153c9df7f4f92649b45d3089944d3c02bf6c56960a593845818b7e9e4c947b0317dc6ec4325c7563652d9bcebd911c677171ba1d397fd21
-  data.tar.gz: dc3d6fb361ec7de40ac47d065c3840dd4972f7a32ebb17ed3969b56fc6257272d82c66d035b298956ac1209548c54e46530c75dbea3d23b8ebcd341480670a41
+  metadata.gz: d9d9d70a98d38037f5a9606ec4770bc1fb79b7201a4c6f0a3d6a8a7e9360d360730d42606059fe40365ef008bab229cafe14feef5c3558518528afe2c15f6676
+  data.tar.gz: bceff542ee42df84cc8b96df31e311db88bafb7ecec138c2caf7c07d2c106c535750c1cdc603d22e1743586798f79f9d624c9073dee282093f89dc305e886286

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+## [0.16.0] - 2025-06-24
+* Remove media_type parameter from non-chunked upload and append methods (f1f38b5)
+* Fix media upload (dcb418a)
+* Add await_processing! method to handle media upload failures (6cfc973)
+* Move media_category in body for media upload (b790636)
+
 ## [0.15.4] - 2025-05-02
 * Use dedicated endpoints for chunked media upload (d54d0d0)
 

data/README.md

@@ -23,7 +23,7 @@ Or, if Bundler is not being used to manage dependencies:
 
 ## Usage
 
-First, obtain X credentails from <https://developer.x.com>.
+First, obtain X credentials from <https://developer.x.com>.
 
 ```ruby
 require "x"
@@ -131,9 +131,9 @@ Many thanks to our sponsors (listed in order of when they sponsored this project
 
 ## Development
 
-1. Checkout and repo:
+1. Clone the repo:
 
-       git checkout git@github.com:sferik/x-ruby.git
+       git clone git@github.com:sferik/x-ruby.git
 
 2. Enter the repo’s directory:
 

data/lib/x/media_uploader.rb

@@ -1,3 +1,4 @@
+require "json"
 require "securerandom"
 require "tmpdir"
 
@@ -16,32 +17,38 @@ module X
                      "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)
+    def upload(client:, file_path:, media_category:, boundary: SecureRandom.hex)
       validate!(file_path:, media_category:)
-      upload_body = construct_upload_body(file_path:, media_type:, boundary:)
-      headers = {"Content-Type" => "multipart/form-data, boundary=#{boundary}"}
-      client.post("media/upload?media_category=#{media_category}", upload_body, headers:)
+      upload_body = construct_upload_body(file_path:, media_category:, boundary:)
+      headers = {"Content-Type" => "multipart/form-data; boundary=#{boundary}"}
+      client.post("media/upload", upload_body, headers:)&.fetch("data")
     end
 
-    def chunked_upload(client:, file_path:, media_category:, media_type: infer_media_type(file_path,
-      media_category), boundary: SecureRandom.hex, chunk_size_mb: 1)
+    def chunked_upload(client:, file_path:, media_category:, media_type: infer_media_type(file_path, 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(client:, file_paths: split(file_path, chunk_size), media:, media_type:, boundary:)
+      append(client:, file_paths: split(file_path, chunk_size), media:, boundary:)
       client.post("media/upload/#{media["id"]}/finalize")&.fetch("data")
     end
 
     def await_processing(client:, media:)
       loop do
         status = client.get("media/upload?command=STATUS&media_id=#{media["id"]}")&.fetch("data")
-        return status if !status["processing_info"] || PROCESSING_INFO_STATES.include?(status["processing_info"]["state"])
+        return status if status.nil? || !status["processing_info"] || PROCESSING_INFO_STATES.include?(status["processing_info"]["state"])
 
         sleep status["processing_info"]["check_after_secs"].to_i
       end
     end
 
+    def await_processing!(client:, media:)
+      status = await_processing(client:, media:)
+      raise "Media processing failed" if status&.dig("processing_info", "state") == "failed"
+
+      status
+    end
+
     private
 
     def validate!(file_path:, media_category:)
@@ -57,22 +64,18 @@ module X
       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
+      else MIME_TYPE_MAP.fetch(File.extname(file_path).delete(".").downcase, DEFAULT_MIME_TYPE)
       end
     end
 
     def split(file_path, chunk_size)
-      file_number = -1
-      file_paths = [] # @type var file_paths: Array[String]
-
-      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
+      file_size = File.size(file_path)
+      segment_count = (file_size.to_f / chunk_size).ceil
+      (0...segment_count).map do |segment_index|
+        segment_path = "#{Dir.mktmpdir}/x#{format("%03d", segment_index + 1)}"
+        File.binwrite(segment_path, File.binread(file_path, chunk_size, segment_index * chunk_size))
+        segment_path
       end
-      file_paths
     end
 
     def init(client:, file_path:, media_type:, media_category:)
@@ -81,11 +84,11 @@ module X
       client.post("media/upload/initialize", data)&.fetch("data")
     end
 
-    def append(client:, file_paths:, media:, media_type:, boundary: SecureRandom.hex)
+    def append(client:, file_paths:, media:, boundary: SecureRandom.hex)
       threads = file_paths.map.with_index do |file_path, index|
         Thread.new do
-          upload_body = construct_upload_body(file_path:, media_type:, segment_index: index, boundary:)
-          headers = {"Content-Type" => "multipart/form-data, boundary=#{boundary}"}
+          upload_body = construct_upload_body(file_path:, segment_index: index, boundary:)
+          headers = {"Content-Type" => "multipart/form-data; boundary=#{boundary}"}
           upload_chunk(client:, media_id: media["id"], upload_body:, file_path:, headers:)
         end
       end
@@ -107,12 +110,13 @@ module X
       Dir.delete(dirname) if Dir.empty?(dirname)
     end
 
-    def construct_upload_body(file_path:, media_type:, segment_index: nil, boundary: SecureRandom.hex)
+    def construct_upload_body(file_path:, media_category: nil, segment_index: nil, boundary: SecureRandom.hex)
       body = ""
       body += "--#{boundary}\r\nContent-Disposition: form-data; name=\"segment_index\"\r\n\r\n#{segment_index}\r\n" if segment_index
+      body += "--#{boundary}\r\nContent-Disposition: form-data; name=\"media_category\"\r\n\r\n#{media_category}\r\n" if media_category
       "#{body}--#{boundary}\r\n" \
         "Content-Disposition: form-data; name=\"media\"; filename=\"#{File.basename(file_path)}\"\r\n" \
-        "Content-Type: #{media_type}\r\n\r\n" \
+        "Content-Type: #{DEFAULT_MIME_TYPE}\r\n\r\n" \
         "#{File.binread(file_path)}\r\n" \
         "--#{boundary}--\r\n"
     end

data/lib/x/version.rb

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

data/sig/x.rbs

@@ -265,19 +265,20 @@ module X
     PROCESSING_INFO_STATES: Array[String]
     extend MediaUploader
 
-    def upload: (client: Client, file_path: String, media_category: String, ?media_type: String, ?boundary: String) -> untyped
+    def upload: (client: Client, file_path: String, media_category: String, ?boundary: String) -> untyped
     def chunked_upload: (client: Client, file_path: String, media_category: String, ?media_type: String, ?boundary: String, ?chunk_size_mb: Integer) -> untyped
     def await_processing: (client: Client, media: untyped) -> untyped
+    def await_processing!: (client: Client, media: untyped) -> untyped
 
     private
     def validate!: (file_path: String, media_category: String) -> nil
     def infer_media_type: (String file_path, String media_category) -> String
     def split: (String file_path, Integer chunk_size) -> Array[String]
     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 append: (client: Client, file_paths: Array[String], media: untyped, ?boundary: String) -> Array[String]
     def upload_chunk: (client: Client, media_id: String, upload_body: String, file_path: String, ?headers: Hash[String, String]) -> Integer?
     def cleanup_file: (String file_path) -> Integer?
     def finalize: (client: Client, media: untyped) -> untyped
-    def construct_upload_body: (file_path: String, media_type: String, ?segment_index: Integer, ?boundary: String) -> String
+    def construct_upload_body: (file_path: String, ?media_category: String, ?segment_index: Integer, ?boundary: String) -> String
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: x
 version: !ruby/object:Gem::Version
-  version: 0.15.4
+  version: 0.16.0
 platform: ruby
 authors:
 - Erik Berlin
@@ -93,7 +93,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.8
+rubygems_version: 3.6.9
 specification_version: 4
 summary: A Ruby interface to the X API.
 test_files: []