t 4.2.0 → 5.0.0

data/lib/t/requestable_api/helpers.rb

@@ -0,0 +1,86 @@
+module T
+  module RequestableAPI
+    module Helpers
+    private
+
+      def normalize_id_list(ids)
+        Array(ids).flatten.compact.map(&:to_s)
+      end
+
+      def single_or_array(input, values)
+        input.is_a?(Array) ? values : values.first
+      end
+
+      def timeline_v2_params(opts)
+        params = {
+          "tweet.fields": V2_TWEET_FIELDS,
+          expansions: V2_TWEET_EXPANSIONS,
+          "user.fields": V2_USER_FIELDS,
+          "place.fields": V2_PLACE_FIELDS,
+        }
+        count = opts[:count] || DEFAULT_NUM_RESULTS
+        params[:max_results] = count.to_i.clamp(1, MAX_SEARCH_RESULTS).to_s
+        excludes = build_v2_excludes(opts)
+        params[:exclude] = excludes unless excludes.empty?
+        params[:until_id] = opts[:max_id].to_s if opts[:max_id]
+        params[:since_id] = opts[:since_id].to_s if opts[:since_id]
+        params
+      end
+
+      def build_v2_excludes(opts)
+        excludes = []
+        excludes << "replies" if opts[:exclude_replies]
+        excludes << "retweets" if opts.key?(:include_rts) && opts[:include_rts] == false
+        excludes.join(",")
+      end
+
+      def user_lookup_params
+        {
+          "user.fields": V2_USER_FIELDS,
+          expansions: V2_USER_EXPANSIONS,
+          "tweet.fields": V2_TWEET_FIELDS,
+        }
+      end
+
+      def list_lookup_params
+        {
+          "list.fields": V2_LIST_FIELDS,
+          expansions: "owner_id",
+          "user.fields": V2_USER_FIELDS,
+        }
+      end
+
+      def v2_tweet_params
+        {
+          "tweet.fields": V2_TWEET_FIELDS,
+          expansions: V2_TWEET_EXPANSIONS,
+          "user.fields": V2_USER_FIELDS,
+          "place.fields": V2_PLACE_FIELDS,
+        }
+      end
+
+      def entity_like?(obj)
+        obj.is_a?(Hash)
+      end
+
+      def value_id(value)
+        return nil unless entity_like?(value)
+
+        value["id_str"] || value["id"]&.to_s
+      end
+
+      def strip_at(value)
+        value.to_s.delete_prefix("@")
+      end
+
+      def slugify_list_name(value)
+        slug = value.to_s.downcase.gsub(/[^a-z0-9_]+/, "-")
+        slug.gsub(/\A-+|-+\z/, "")
+      end
+
+      def numeric_identifier?(value)
+        value.to_s.match?(/\A\d+\z/)
+      end
+    end
+  end
+end

data/lib/t/requestable_api/http.rb

@@ -0,0 +1,113 @@
+require "net/http"
+
+module T
+  module RequestableAPI
+    module HTTP
+    private
+
+      def v1_client
+        @v1_client ||= begin
+          client # ensure credentials are initialized
+          X::Client.new(**@requestable_api_credentials, base_url: BASE_URL_V1)
+        end
+      end
+
+      def upload_client
+        @upload_client ||= begin
+          client # ensure credentials are initialized
+          X::Client.new(**@requestable_api_credentials, base_url: BASE_URL_UPLOAD)
+        end
+      end
+
+      def bearer_client
+        @bearer_client ||= begin
+          client # ensure credentials are initialized
+          key = @requestable_api_credentials[:api_key]
+          secret = @requestable_api_credentials[:api_key_secret]
+          basic = Base64.strict_encode64("#{key}:#{secret}")
+          uri = URI("https://api.twitter.com/oauth2/token")
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = true
+          request = Net::HTTP::Post.new(uri)
+          request["Authorization"] = "Basic #{basic}"
+          request["Content-Type"] = "application/x-www-form-urlencoded;charset=UTF-8"
+          request.body = "grant_type=client_credentials"
+          response = http.request(request)
+          token = JSON.parse(response.body)["access_token"]
+          X::Client.new(bearer_token: token)
+        end
+      end
+
+      def upload_media(file)
+        binary = if file.respond_to?(:read)
+          file.rewind if file.respond_to?(:rewind)
+          file.read
+        else
+          File.binread(file.to_s)
+        end
+        response = t_post_v1_form("media/upload.json", {media_data: Base64.strict_encode64(binary)}, request_client: upload_client)
+        media_id = response["media_id_string"] || response["media_id"] || value_id(response)
+        raise X::Error.new("Media upload did not return a media_id") if media_id.to_s.empty?
+
+        media_id.to_s
+      end
+
+      def t_get_v2(path, params = {})
+        client.get(t_endpoint(path, params))
+      end
+
+      def t_get_v1(path, params = {})
+        v1_client.get(t_endpoint(path, params))
+      end
+
+      def t_post_v2_json(path, body = {})
+        client.post(t_normalize_path(path), JSON.generate(t_compact_hash(body)), headers: JSON_HEADERS)
+      end
+
+      def t_post_bearer_json(path, body = {})
+        bearer_client.post(t_normalize_path(path), JSON.generate(t_compact_hash(body)), headers: JSON_HEADERS)
+      end
+
+      def t_post_v1_form(path, params = {}, request_client: v1_client)
+        request_client.post(t_normalize_path(path), URI.encode_www_form(t_form_pairs(params)), headers: FORM_HEADERS)
+      end
+
+      def t_delete_v2(path, params = {})
+        client.delete(t_endpoint(path, params))
+      end
+
+      def t_endpoint(path, params)
+        query = URI.encode_www_form(t_form_pairs(params))
+        query.empty? ? t_normalize_path(path) : "#{t_normalize_path(path)}?#{query}"
+      end
+
+      def t_form_pairs(hash)
+        hash.each_with_object([]) do |(key, value), pairs|
+          next if value.nil?
+
+          pairs << [key.to_s, t_scalar_value(value)]
+        end
+      end
+
+      def t_scalar_value(value)
+        case value
+        when TrueClass then "true"
+        when FalseClass then "false"
+        else value.to_s
+        end
+      end
+
+      def t_compact_hash(hash)
+        hash.each_with_object({}) do |(key, value), memo|
+          next if value.nil?
+
+          memo[key] = value
+        end
+      end
+
+      def t_normalize_path(path)
+        path.to_s.sub(%r{\A/+}, "")
+      end
+    end
+  end
+end

data/lib/t/requestable_api/list_endpoints.rb

@@ -0,0 +1,70 @@
+module T
+  module RequestableAPI
+    module ListEndpoints
+      def x_lists(user = nil)
+        user_id = user.nil? ? current_user_id : resolve_user_id(user)
+        collect_owned_lists(user_id)
+      end
+
+      def x_list(owner_or_id, list_name = nil)
+        list_id = if list_name.nil?
+          numeric_identifier?(owner_or_id) ? owner_or_id.to_s : resolve_list_id(current_user_id, owner_or_id.to_s)
+        else
+          owner_id = numeric_identifier?(owner_or_id) ? owner_or_id.to_s : resolve_user_id(owner_or_id)
+          resolve_list_id(owner_id, list_name.to_s)
+        end
+        extract_lists(t_get_v2("lists/#{list_id}", list_lookup_params)).first || {}
+      end
+
+      def x_create_list(name, opts = {})
+        body = {
+          name: name.to_s,
+          description: opts[:description].to_s,
+          private: opts[:mode].to_s == "private",
+        }
+        extract_lists(t_post_v2_json("lists", body)).first || {}
+      end
+
+      def x_destroy_list(list)
+        list_id = entity_like?(list) ? value_id(list) : list.to_s
+        t_delete_v2("lists/#{list_id}")
+        true
+      end
+
+      def x_add_list_members(list_name, users)
+        list_id = resolve_list_id(current_user_id, list_name.to_s)
+        Array(users).flatten.each do |entry|
+          t_post_v2_json("lists/#{list_id}/members", user_id: resolve_user_id(entry))
+        end
+        true
+      end
+
+      def x_remove_list_members(list_name, users)
+        list_id = resolve_list_id(current_user_id, list_name.to_s)
+        Array(users).flatten.each do |entry|
+          t_delete_v2("lists/#{list_id}/members/#{resolve_user_id(entry)}")
+        end
+        true
+      end
+
+      def x_list_member?(owner, list_name, user)
+        owner_id = numeric_identifier?(owner) ? owner.to_s : resolve_user_id(owner)
+        list_id = resolve_list_id(owner_id, list_name.to_s)
+        user_id = resolve_user_id(user)
+        fetch_list_member_ids(list_id).include?(user_id.to_s)
+      end
+
+      def x_list_members(owner, list_name)
+        owner_id = numeric_identifier?(owner) ? owner.to_s : resolve_user_id(owner)
+        list_id = resolve_list_id(owner_id, list_name)
+        lookup_users_by_ids(fetch_list_member_ids(list_id))
+      end
+
+      def x_list_timeline(owner, list_name, opts = {})
+        owner_id = numeric_identifier?(owner) ? owner.to_s : resolve_user_id(owner)
+        list_id = resolve_list_id(owner_id, list_name)
+        extract_tweets(t_get_v2("lists/#{list_id}/tweets", timeline_v2_params(opts)))
+      end
+    end
+  end
+end

data/lib/t/requestable_api/list_normalization.rb

@@ -0,0 +1,74 @@
+module T
+  module RequestableAPI
+    module ListNormalization
+    private
+
+      def extract_lists(value)
+        return value if value.is_a?(Array)
+        return value.fetch("lists", []) if value["lists"].is_a?(Array)
+
+        users_by_id = index_items_by_id(value.dig("includes", "users"))
+        data = value["data"]
+        return [] unless data.is_a?(Array)
+
+        data.map { |list| normalize_v2_list(list, users_by_id) }
+      end
+
+      def normalize_v2_list(list, users_by_id)
+        return list if list.key?("slug") || list.key?("full_name")
+
+        object = build_v2_list_core(list)
+        apply_v2_list_mode(object, list)
+        apply_v2_list_owner(object, list, users_by_id)
+        object
+      end
+
+      def build_v2_list_core(list)
+        object = {}
+        apply_v2_id(object, list)
+        apply_v2_list_slug(object, list)
+        %w[created_at description].each { |f| object[f] = list[f] if list[f] }
+        object["member_count"] = list["member_count"] if list.key?("member_count")
+        object["subscriber_count"] = list["subscriber_count"] || list["follower_count"]
+        object
+      end
+
+      def apply_v2_id(object, source)
+        id = value_id(source)
+        return unless id
+
+        object["id"] = id.to_i
+        object["id_str"] = id.to_s
+      end
+
+      def apply_v2_list_slug(object, list)
+        slug = list["slug"] || list["name"]
+        return unless slug
+
+        object["slug"] = slug
+        object["name"] = slug
+      end
+
+      def apply_v2_list_mode(object, list)
+        if list.key?("mode")
+          object["mode"] = list["mode"]
+        elsif list.key?("private")
+          object["mode"] = list["private"] ? "private" : "public"
+        end
+      end
+
+      def apply_v2_list_owner(object, list, users_by_id)
+        id = value_id(list)
+        slug = object["slug"]
+        owner_id = list["owner_id"]
+        if owner_id && users_by_id[owner_id]
+          owner = normalize_v2_user(users_by_id[owner_id])
+          object["user"] = owner
+          owner_name = owner["screen_name"]
+          object["full_name"] = "@#{owner_name}/#{slug}" if owner_name && slug
+        end
+        object["uri"] = "https://x.com/i/lists/#{id}" if id
+      end
+    end
+  end
+end

data/lib/t/requestable_api/mutations.rb

@@ -0,0 +1,88 @@
+module T
+  module RequestableAPI
+    module Mutations
+      def x_block(users)
+        mutate_users(users) { |target_id, me_id| t_post_v2_json("users/#{me_id}/blocking", target_user_id: target_id) }
+      end
+
+      def x_unblock(users)
+        mutate_users(users) { |target_id, me_id| t_delete_v2("users/#{me_id}/blocking/#{target_id}") }
+      end
+
+      def x_mute(users)
+        mutate_users(users) { |target_id, me_id| t_post_v2_json("users/#{me_id}/muting", target_user_id: target_id) }
+      end
+
+      def x_unmute(users)
+        mutate_users(users) { |target_id, me_id| t_delete_v2("users/#{me_id}/muting/#{target_id}") }
+      end
+
+      def x_follow(users)
+        mutate_users(users) { |target_id, me_id| t_post_v2_json("users/#{me_id}/following", target_user_id: target_id) }
+      end
+
+      def x_unfollow(users)
+        mutate_users(users) { |target_id, me_id| t_delete_v2("users/#{me_id}/following/#{target_id}") }
+      end
+
+      def x_report_spam(users)
+        Array(users).flatten.map do |entry|
+          resolved_user = resolve_user(entry)
+          key = numeric_identifier?(entry) ? :user_id : :screen_name
+          t_post_v1_form("users/report_spam.json", {key => (key == :user_id ? resolved_user["id"] : resolved_user["screen_name"])})
+          resolved_user
+        end
+      end
+
+      def x_muted_ids
+        ids = []
+        params = {max_results: "1000", "user.fields": "id,username"}
+        me_id = current_user_id
+        MAX_PAGE.times do
+          response = t_get_v2("users/#{me_id}/muting", params)
+          ids.concat(extract_ids(response))
+          token = response.dig("meta", "next_token")
+          break if token.nil?
+
+          params = params.merge(pagination_token: token)
+        end
+        ids
+      end
+
+      def x_favorite(status_ids)
+        me_id = current_user_id
+        tweets = normalize_id_list(status_ids).map do |id|
+          t_post_v2_json("users/#{me_id}/likes", tweet_id: id)
+          {"id" => id.to_i, "id_str" => id.to_s}
+        end
+        single_or_array(status_ids, tweets)
+      end
+
+      def x_unfavorite(status_ids)
+        me_id = current_user_id
+        tweets = normalize_id_list(status_ids).map do |id|
+          t_delete_v2("users/#{me_id}/likes/#{id}")
+          {"id" => id.to_i, "id_str" => id.to_s}
+        end
+        single_or_array(status_ids, tweets)
+      end
+
+      def x_retweet(status_ids)
+        me_id = current_user_id
+        tweets = normalize_id_list(status_ids).map do |id|
+          t_post_v2_json("users/#{me_id}/retweets", tweet_id: id)
+          {"id" => id.to_i, "id_str" => id.to_s}
+        end
+        single_or_array(status_ids, tweets)
+      end
+
+      def x_destroy_status(status_ids)
+        statuses = normalize_id_list(status_ids).map do |id|
+          t_delete_v2("tweets/#{id}")
+          {"id" => id.to_i, "id_str" => id.to_s}
+        end
+        single_or_array(status_ids, statuses)
+      end
+    end
+  end
+end

data/lib/t/requestable_api/resolution.rb

@@ -0,0 +1,108 @@
+module T
+  module RequestableAPI
+    module Resolution
+    private
+
+      def mutate_users(users)
+        me_id = current_user_id
+        Array(users).flatten.map do |entry|
+          resolved_user = resolve_user(entry)
+          yield resolved_user["id"].to_s, me_id
+          resolved_user
+        end
+      end
+
+      def current_user
+        @current_user ||= x_verify_credentials
+      end
+
+      def current_user_id
+        value_id(current_user).to_s
+      end
+
+      def resolve_user(entry)
+        return current_user if entry.nil?
+        return entry if entity_like?(entry)
+        return x_user(entry.to_s) if numeric_identifier?(entry)
+
+        x_user(strip_at(entry.to_s))
+      end
+
+      def resolve_user_id(entry)
+        return current_user_id if entry.nil?
+        return value_id(entry).to_s if entity_like?(entry)
+
+        numeric_identifier?(entry) ? entry.to_s : value_id(x_user(strip_at(entry.to_s))).to_s
+      end
+
+      def resolve_list_id(owner_id, list_name)
+        desired = slugify_list_name(list_name)
+        lists = collect_owned_lists(owner_id)
+        matched = lists.find do |list|
+          slug = (list["slug"] || list["name"]).to_s
+          slug.casecmp?(list_name.to_s) || slugify_list_name(slug) == desired
+        end
+        (value_id(matched) || list_name).to_s
+      end
+
+      def fetch_relationship_ids(user_id, relationship)
+        endpoint = relationship == "followers" ? "users/#{user_id}/followers" : "users/#{user_id}/following"
+        params = {max_results: "1000", "user.fields": "id,username"}
+        ids = []
+        MAX_PAGE.times do
+          response = t_get_v2(endpoint, params)
+          ids.concat(extract_ids(response))
+          token = response.dig("meta", "next_token")
+          break if token.nil?
+
+          params = params.merge(pagination_token: token)
+        end
+        ids
+      end
+
+      def fetch_list_member_ids(list_id)
+        params = {max_results: "100", "user.fields": "id,username"}
+        ids = []
+        MAX_PAGE.times do
+          response = t_get_v2("lists/#{list_id}/members", params)
+          ids.concat(extract_ids(response))
+          token = response.dig("meta", "next_token")
+          break if token.nil?
+
+          params = params.merge(pagination_token: token)
+        end
+        ids
+      end
+
+      def collect_owned_lists(user_id)
+        params = {
+          max_results: "100",
+          "list.fields": V2_LIST_FIELDS,
+          expansions: "owner_id",
+          "user.fields": V2_USER_FIELDS,
+        }
+        lists = []
+        MAX_PAGE.times do
+          response = t_get_v2("users/#{user_id}/owned_lists", params)
+          lists.concat(extract_lists(response))
+          token = response.dig("meta", "next_token")
+          break if token.nil?
+
+          params = params.merge(pagination_token: token)
+        end
+        lists
+      end
+
+      def lookup_users_by_ids(ids)
+        ids = Array(ids).compact
+        return [] if ids.empty?
+
+        users = []
+        ids.each_slice(100) do |chunk|
+          users.concat(extract_users(t_get_v2("users", user_lookup_params.merge(ids: chunk.join(",")))))
+        end
+        users
+      end
+    end
+  end
+end

data/lib/t/requestable_api/tweet_endpoints.rb

@@ -0,0 +1,85 @@
+module T
+  module RequestableAPI
+    module TweetEndpoints
+      def x_retweets_of_me(opts = {})
+        extract_tweets(t_get_v2("users/reposts_of_me", timeline_v2_params(opts)))
+      end
+
+      def x_retweeted_by_me(opts = {})
+        x_retweets_of_me(opts)
+      end
+
+      def x_retweeted_by_user(user, opts = {})
+        x_user_timeline(user, opts).select { |tweet| tweet["full_text"].to_s.start_with?("RT @") }
+      end
+
+      def x_retweeters_ids(tweet_id)
+        ids = []
+        params = {"user.fields": "id,username", max_results: "100"}
+        MAX_PAGE.times do
+          response = t_get_v2("tweets/#{tweet_id}/retweeted_by", params)
+          ids.concat(extract_ids(response))
+          token = response.dig("meta", "next_token")
+          break if token.nil?
+
+          params = params.merge(pagination_token: token)
+        end
+        ids
+      end
+
+      def x_status(status_id, _opts = {})
+        extract_tweets(t_get_v2("tweets/#{status_id}", v2_tweet_params)).first || {}
+      end
+
+      def x_home_timeline(opts = {})
+        me_id = current_user_id
+        extract_tweets(t_get_v2("users/#{me_id}/timelines/reverse_chronological", timeline_v2_params(opts)))
+      end
+
+      def x_user_timeline(user, opts = {})
+        user_id = resolve_user_id(user)
+        extract_tweets(t_get_v2("users/#{user_id}/tweets", timeline_v2_params(opts)))
+      end
+
+      def x_mentions(opts = {})
+        me_id = current_user_id
+        extract_tweets(t_get_v2("users/#{me_id}/mentions", timeline_v2_params(opts)))
+      end
+
+      def x_favorites(user = nil, opts = {})
+        if user.is_a?(Hash) && opts.empty?
+          opts = user
+          user = nil
+        end
+        user_id = user.nil? ? current_user_id : resolve_user_id(user)
+        extract_tweets(t_get_v2("users/#{user_id}/liked_tweets", timeline_v2_params(opts)))
+      end
+
+      def x_search(query, opts = {})
+        count = [opts.fetch(:count, MAX_SEARCH_RESULTS).to_i, MAX_SEARCH_RESULTS].min
+        params = {
+          query: query.to_s,
+          max_results: count.to_s,
+        }.merge(v2_tweet_params)
+        params[:until_id] = opts[:max_id].to_s if opts[:max_id]
+        params[:since_id] = opts[:since_id].to_s if opts[:since_id]
+        extract_tweets(t_get_v2("tweets/search/recent", params))
+      end
+
+      def x_update(status, opts = {})
+        body = {text: status.to_s}
+        body[:reply] = {in_reply_to_tweet_id: opts[:in_reply_to_status_id].to_s} if opts[:in_reply_to_status_id]
+        body[:media] = {media_ids: Array(opts[:media_ids]).map(&:to_s)} if opts[:media_ids]
+        response = t_post_v2_json("tweets", body)
+        id = value_id(response) || value_id(response["data"])
+        {"id" => id.to_i, "id_str" => id.to_s, "text" => status.to_s,
+         "full_text" => status.to_s, "user" => current_user}
+      end
+
+      def x_update_with_media(status, file, opts = {})
+        media_id = upload_media(file)
+        x_update(status, opts.merge(media_ids: [media_id]))
+      end
+    end
+  end
+end