t 4.1.1 → 5.0.0

data/lib/t/requestable_api/tweet_normalization.rb

@@ -0,0 +1,87 @@
+module T
+  module RequestableAPI
+    module TweetNormalization
+    private
+
+      def extract_tweets(value)
+        return value if value.is_a?(Array)
+        return value.fetch("statuses", []) if value["statuses"].is_a?(Array)
+
+        users_by_id = index_items_by_id(value.dig("includes", "users"))
+        places_by_id = index_items_by_id(value.dig("includes", "places"))
+        return value["data"].map { |tweet| normalize_v2_tweet(tweet, users_by_id, places_by_id) } if value["data"].is_a?(Array)
+        return [normalize_v2_tweet(value["data"], users_by_id, places_by_id)] if value["data"].is_a?(Hash)
+
+        []
+      end
+
+      def normalize_v2_tweet(tweet, users_by_id, places_by_id)
+        return tweet if tweet.is_a?(Hash) && tweet.key?("user")
+
+        object = build_v2_tweet_core(tweet)
+        apply_v2_tweet_entities(object, tweet)
+        apply_v2_tweet_metrics(object, tweet)
+        apply_v2_tweet_author(object, tweet, users_by_id)
+        apply_v2_tweet_geo(object, tweet, places_by_id)
+        object
+      end
+
+      def build_v2_tweet_core(tweet)
+        object = {}
+        apply_v2_id(object, tweet)
+        text = tweet["full_text"] || tweet["text"]
+        if text
+          object["text"] = text
+          object["full_text"] = text
+        end
+        object["created_at"] = tweet["created_at"] if tweet["created_at"]
+        object["source"] = tweet["source"] if tweet["source"]
+        object
+      end
+
+      def apply_v2_tweet_entities(object, tweet)
+        return unless tweet["entities"]
+
+        object["entities"] = tweet["entities"]
+        object["uris"] = tweet.dig("entities", "urls") if tweet.dig("entities", "urls")
+      end
+
+      def apply_v2_tweet_metrics(object, tweet)
+        return unless tweet["public_metrics"].is_a?(Hash)
+
+        metrics = tweet["public_metrics"]
+        object["retweet_count"] = metrics["retweet_count"] if metrics.key?("retweet_count")
+        object["favorite_count"] = metrics["like_count"] if metrics.key?("like_count")
+      end
+
+      def apply_v2_tweet_author(object, tweet, users_by_id)
+        author_id = tweet["author_id"]
+        object["user"] = normalize_v2_user(users_by_id[author_id] || {"id" => author_id, "username" => author_id}) if author_id
+      end
+
+      def apply_v2_tweet_geo(object, tweet, places_by_id)
+        geo = tweet["geo"]
+        return unless geo.is_a?(Hash)
+
+        place_id = geo["place_id"]
+        object["place"] = places_by_id[place_id] if place_id && places_by_id[place_id]
+        coords = geo.dig("coordinates", "coordinates")
+        object["geo"] = {"type" => "Point", "coordinates" => coords} if coords.is_a?(Array) && coords.size == 2 && !place_id
+      end
+
+      def extract_ids(response)
+        data = response["data"]
+        return [] unless data.is_a?(Array)
+
+        data.filter_map { |entry| value_id(entry) }
+      end
+
+      def index_items_by_id(values)
+        Array(values).each_with_object({}) do |entry, memo|
+          id = value_id(entry)
+          memo[id] = entry if id
+        end
+      end
+    end
+  end
+end

data/lib/t/requestable_api/user_endpoints.rb

@@ -0,0 +1,82 @@
+module T
+  module RequestableAPI
+    module UserEndpoints
+      def x_verify_credentials
+        extract_users(t_get_v2("users/me", user_lookup_params)).first || {}
+      rescue X::Error
+        t_get_v1("account/verify_credentials.json")
+      end
+
+      def x_user(user = nil, _opts = {}, &)
+        if block_given? && user.nil?
+          @requestable_api_before_request&.call
+          x_home_timeline(count: 100).each(&)
+          return
+        end
+
+        fetch_single_user(user)
+      rescue X::ServiceUnavailable
+        t_get_v1("users/show.json", screen_name: strip_at(user.to_s))
+      end
+
+      def x_users(users)
+        users = Array(users).flatten.compact
+        return [] if users.empty?
+
+        ids, names = users.partition { |entry| numeric_identifier?(entry) }
+        results = []
+        ids.each_slice(100) do |chunk|
+          results.concat(extract_users(t_get_v2("users", user_lookup_params.merge(ids: chunk.join(",")))))
+        end
+        names.each_slice(100) do |chunk|
+          results.concat(extract_users(t_get_v2("users/by", user_lookup_params.merge(usernames: chunk.map { |name| strip_at(name) }.join(",")))))
+        end
+        results
+      end
+
+      def x_user_search(query, page:)
+        page = page.to_i
+        return [] if page > 1 && @requestable_api_user_search_tokens[[query, page - 1]].to_s.empty?
+
+        params = {
+          query: query.to_s,
+          max_results: "100",
+          "user.fields": V2_USER_FIELDS,
+          expansions: V2_USER_EXPANSIONS,
+          "tweet.fields": V2_TWEET_FIELDS,
+        }
+        params[:next_token] = @requestable_api_user_search_tokens[[query, page - 1]] if page > 1
+        response = t_get_v2("users/search", params)
+        @requestable_api_user_search_tokens[[query, page]] = response.dig("meta", "next_token")
+        extract_users(response)
+      end
+
+      def x_friendship?(user1, user2)
+        user1_id = resolve_user_id(user1)
+        user2_id = resolve_user_id(user2)
+        fetch_relationship_ids(user1_id, "following").include?(user2_id.to_s)
+      end
+
+      def x_friend_ids(user = nil)
+        user_id = user.nil? ? current_user_id : resolve_user_id(user)
+        fetch_relationship_ids(user_id, "following")
+      end
+
+      def x_follower_ids(user = nil)
+        user_id = user.nil? ? current_user_id : resolve_user_id(user)
+        fetch_relationship_ids(user_id, "followers")
+      end
+
+    private
+
+      def fetch_single_user(user)
+        response = if numeric_identifier?(user)
+          t_get_v2("users/#{user}", user_lookup_params)
+        else
+          t_get_v2("users/by/username/#{strip_at(user)}", user_lookup_params)
+        end
+        extract_users(response).first || {}
+      end
+    end
+  end
+end

data/lib/t/requestable_api/user_normalization.rb

@@ -0,0 +1,68 @@
+module T
+  module RequestableAPI
+    module UserNormalization
+    private
+
+      def extract_users(value)
+        return value if value.is_a?(Array)
+        return value.fetch("users", []) if value["users"].is_a?(Array)
+
+        users = value["data"]
+        includes_tweets = index_items_by_id(value.dig("includes", "tweets"))
+        return users.map { |user| normalize_user_with_pinned_status(user, includes_tweets) } if users.is_a?(Array)
+        return [normalize_user_with_pinned_status(users, includes_tweets)] if users.is_a?(Hash)
+
+        extract_bare_v1_user(value)
+      end
+
+      def extract_bare_v1_user(value)
+        return [value] if value.is_a?(Hash) && (value.key?("screen_name") || value.key?("id"))
+
+        []
+      end
+
+      def normalize_user_with_pinned_status(user, includes_tweets)
+        normalized = normalize_v2_user(user || {})
+        pinned_id = user["pinned_tweet_id"]
+        normalized["status"] = normalize_v2_tweet(includes_tweets[pinned_id], {}, {}) if pinned_id && includes_tweets[pinned_id]
+        normalized
+      end
+
+      def normalize_v2_user(user)
+        return user if user.is_a?(Hash) && user.key?("screen_name")
+
+        object = build_v2_user_core(user)
+        apply_v2_user_metrics(object, user)
+        object
+      end
+
+      def build_v2_user_core(user)
+        object = {}
+        apply_v2_id(object, user)
+        username = user["username"] || user["screen_name"]
+        if username
+          object["screen_name"] = username
+          object["username"] = username
+        end
+        %w[created_at name verified protected description location url].each do |field|
+          object[field] = user[field] if user.key?(field)
+        end
+        object
+      end
+
+      def apply_v2_user_metrics(object, user)
+        return unless user["public_metrics"].is_a?(Hash)
+
+        metrics = user["public_metrics"]
+        object["statuses_count"] = metrics["tweet_count"] if metrics.key?("tweet_count")
+        if metrics.key?("like_count")
+          object["favourites_count"] = metrics["like_count"]
+          object["favorites_count"] = metrics["like_count"]
+        end
+        object["listed_count"] = metrics["listed_count"] if metrics.key?("listed_count")
+        object["friends_count"] = metrics["following_count"] if metrics.key?("following_count")
+        object["followers_count"] = metrics["followers_count"] if metrics.key?("followers_count")
+      end
+    end
+  end
+end

data/lib/t/requestable_api.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "base64"
+require "json"
+require "time"
+require "uri"
+
+require_relative "requestable_api/helpers"
+require_relative "requestable_api/http"
+require_relative "requestable_api/tweet_normalization"
+require_relative "requestable_api/user_normalization"
+require_relative "requestable_api/list_normalization"
+require_relative "requestable_api/resolution"
+require_relative "requestable_api/dm_parsing"
+require_relative "requestable_api/dm_helpers"
+require_relative "requestable_api/user_endpoints"
+require_relative "requestable_api/tweet_endpoints"
+require_relative "requestable_api/mutations"
+require_relative "requestable_api/dm_endpoints"
+require_relative "requestable_api/list_endpoints"
+require_relative "requestable_api/account_endpoints"
+
+module T
+  module RequestableAPI
+    include Helpers
+    include HTTP
+    include TweetNormalization
+    include UserNormalization
+    include ListNormalization
+    include Resolution
+    include DMParsing
+    include DMHelpers
+    include UserEndpoints
+    include TweetEndpoints
+    include Mutations
+    include DMEndpoints
+    include ListEndpoints
+    include AccountEndpoints
+
+    BASE_URL = "https://api.twitter.com"
+    BASE_URL_V1 = "#{BASE_URL}/1.1/".freeze
+    BASE_URL_UPLOAD = "https://upload.twitter.com/1.1/"
+
+    DEFAULT_NUM_RESULTS = 20
+    MAX_SEARCH_RESULTS = 100
+    MAX_PAGE = 51
+
+    V2_TWEET_FIELDS = "author_id,created_at,entities,geo,id,in_reply_to_user_id,public_metrics,source,text"
+    V2_USER_FIELDS = "created_at,description,id,location,name,protected,public_metrics,url,username,verified"
+    V2_LIST_FIELDS = "created_at,description,follower_count,id,member_count,name,owner_id,private"
+    V2_TWEET_EXPANSIONS = "author_id,geo.place_id"
+    V2_USER_EXPANSIONS = "pinned_tweet_id"
+    V2_PLACE_FIELDS = "contained_within,country,country_code,full_name,geo,id,name,place_type"
+
+    FORM_HEADERS = {"Content-Type" => "application/x-www-form-urlencoded; charset=utf-8"}.freeze
+    JSON_HEADERS = {"Content-Type" => "application/json; charset=utf-8"}.freeze
+
+    def setup_requestable_api!(credentials)
+      return if defined?(@requestable_api_setup) && @requestable_api_setup
+
+      @requestable_api_setup = true
+      @requestable_api_credentials = credentials
+      @v1_client = X::Client.new(**credentials, base_url: BASE_URL_V1)
+      @upload_client = X::Client.new(**credentials, base_url: BASE_URL_UPLOAD)
+      @requestable_api_user_search_tokens = {}
+      @requestable_api_before_request = nil
+    end
+  end
+end

data/lib/t/search.rb

@@ -1,5 +1,4 @@
 require "thor"
-require "twitter"
 require "t/collectable"
 require "t/printable"
 require "t/rcfile"
@@ -32,28 +31,10 @@ module T
     method_option "relative_dates", aliases: "-a", type: :boolean, desc: "Show relative dates."
     def all(query)
       count = options["number"] || DEFAULT_NUM_RESULTS
-      opts = {count: MAX_SEARCH_RESULTS}
-      opts[:include_entities] = !!options["decode_uris"]
-      tweets = client.search(query, opts).take(count)
+      opts = {count: MAX_SEARCH_RESULTS, include_entities: !!options["decode_uris"]}
+      tweets = x_search(query, opts).take(count)
       tweets.reverse! if options["reverse"]
-      if options["csv"]
-        require "csv"
-        say TWEET_HEADINGS.to_csv unless tweets.empty?
-        tweets.each do |tweet|
-          say [tweet.id, csv_formatted_time(tweet), tweet.user.screen_name, decode_full_text(tweet, options["decode_uris"])].to_csv
-        end
-      elsif options["long"]
-        array = tweets.collect do |tweet|
-          [tweet.id, ls_formatted_time(tweet), "@#{tweet.user.screen_name}", decode_full_text(tweet, options["decode_uris"]).gsub(/\n+/, " ")]
-        end
-        format = options["format"] || Array.new(TWEET_HEADINGS.size) { "%s" }
-        print_table_with_headings(array, TWEET_HEADINGS, format)
-      else
-        say unless tweets.empty?
-        tweets.each do |tweet|
-          print_message(tweet.user.screen_name, decode_full_text(tweet, options["decode_uris"]))
-        end
-      end
+      print_search_results(tweets)
     end
 
     desc "favorites [USER] QUERY", "Returns Tweets you've favorited that match the specified query."
@@ -68,20 +49,19 @@ module T
       opts = {count: MAX_NUM_RESULTS}
       opts[:include_entities] = !!options["decode_uris"]
       if user
-        require "t/core_ext/string"
-        user = options["id"] ? user.to_i : user.strip_ats
+        user = options["id"] ? user.to_i : user.tr("@", "")
         tweets = collect_with_max_id do |max_id|
           opts[:max_id] = max_id unless max_id.nil?
-          client.favorites(user, opts)
+          x_favorites(user, opts)
         end
       else
         tweets = collect_with_max_id do |max_id|
           opts[:max_id] = max_id unless max_id.nil?
-          client.favorites(opts)
+          x_favorites(opts)
         end
       end
       tweets = tweets.select do |tweet|
-        /#{query}/i.match(tweet.full_text)
+        /#{query}/i.match(tweet["full_text"])
       end
       print_tweets(tweets)
     end
@@ -99,10 +79,10 @@ module T
       opts[:include_entities] = !!options["decode_uris"]
       tweets = collect_with_max_id do |max_id|
         opts[:max_id] = max_id unless max_id.nil?
-        client.list_timeline(owner, list_name, opts)
+        x_list_timeline(owner, list_name, opts)
       end
       tweets = tweets.select do |tweet|
-        /#{query}/i.match(tweet.full_text)
+        /#{query}/i.match(tweet["full_text"])
       end
       print_tweets(tweets)
     end
@@ -117,10 +97,10 @@ module T
       opts[:include_entities] = !!options["decode_uris"]
       tweets = collect_with_max_id do |max_id|
         opts[:max_id] = max_id unless max_id.nil?
-        client.mentions(opts)
+        x_mentions(opts)
       end
       tweets = tweets.select do |tweet|
-        /#{query}/i.match(tweet.full_text)
+        /#{query}/i.match(tweet["full_text"])
       end
       print_tweets(tweets)
     end
@@ -138,20 +118,19 @@ module T
       opts = {count: MAX_NUM_RESULTS}
       opts[:include_entities] = !!options["decode_uris"]
       if user
-        require "t/core_ext/string"
-        user = options["id"] ? user.to_i : user.strip_ats
+        user = options["id"] ? user.to_i : user.tr("@", "")
         tweets = collect_with_max_id do |max_id|
           opts[:max_id] = max_id unless max_id.nil?
-          client.retweeted_by_user(user, opts)
+          x_retweeted_by_user(user, opts)
         end
       else
         tweets = collect_with_max_id do |max_id|
           opts[:max_id] = max_id unless max_id.nil?
-          client.retweeted_by_me(opts)
+          x_retweeted_by_me(opts)
         end
       end
       tweets = tweets.select do |tweet|
-        /#{query}/i.match(tweet.full_text)
+        /#{query}/i.match(tweet["full_text"])
       end
       print_tweets(tweets)
     end
@@ -169,28 +148,13 @@ module T
     def timeline(*args)
       query = args.pop
       user = args.pop
-      opts = {count: MAX_NUM_RESULTS}
-      opts[:exclude_replies] = true if options["exclude"] == "replies"
-      opts[:include_entities] = !!options["decode_uris"]
-      opts[:include_rts] = false if options["exclude"] == "retweets"
-      opts[:max_id] = options["max_id"] if options["max_id"]
-      opts[:since_id] = options["since_id"] if options["since_id"]
-      if user
-        require "t/core_ext/string"
-        user = options["id"] ? user.to_i : user.strip_ats
-        tweets = collect_with_max_id do |max_id|
-          opts[:max_id] = max_id unless max_id.nil?
-          client.user_timeline(user, opts)
-        end
-      else
-        tweets = collect_with_max_id do |max_id|
-          opts[:max_id] = max_id unless max_id.nil?
-          client.home_timeline(opts)
-        end
-      end
-      tweets = tweets.select do |tweet|
-        /#{query}/i.match(tweet.full_text)
+      opts = build_timeline_opts.merge(count: MAX_NUM_RESULTS)
+      user = resolve_user_input(user) if user
+      tweets = collect_with_max_id do |max_id|
+        opts[:max_id] = max_id unless max_id.nil?
+        user ? x_user_timeline(user, opts) : x_home_timeline(opts)
       end
+      tweets = tweets.select { |tweet| /#{query}/i.match(tweet["full_text"]) }
       print_tweets(tweets)
     end
     map %w[tl] => :timeline
@@ -204,9 +168,30 @@ module T
     method_option "unsorted", aliases: "-u", type: :boolean, desc: "Output is not sorted."
     def users(query)
       users = collect_with_page do |page|
-        client.user_search(query, page:)
+        x_user_search(query, page:)
       end
       print_users(users)
     end
+
+  private
+
+    def print_search_results(tweets)
+      if options["csv"]
+        require "csv"
+        say TWEET_HEADINGS.to_csv unless tweets.empty?
+        tweets.each { |tweet| print_csv_tweet(tweet) }
+      elsif options["long"]
+        array = tweets.collect { |tweet| build_long_tweet(tweet) }
+        format = options["format"] || Array.new(TWEET_HEADINGS.size) { "%s" }
+        print_table_with_headings(array, TWEET_HEADINGS, format)
+      else
+        print_search_messages(tweets)
+      end
+    end
+
+    def print_search_messages(tweets)
+      say unless tweets.empty?
+      tweets.each { |tweet| print_message(tweet["user"]["screen_name"], decode_full_text(tweet, decode_full_uris: options["decode_uris"])) }
+    end
   end
 end

data/lib/t/set.rb

@@ -15,8 +15,7 @@ module T
 
     desc "active SCREEN_NAME [CONSUMER_KEY]", "Set your active account."
     def active(screen_name, consumer_key = nil)
-      require "t/core_ext/string"
-      screen_name = screen_name.strip_ats
+      screen_name = screen_name.tr("@", "")
       @rcfile.path = options["profile"] if options["profile"]
       consumer_key = @rcfile[screen_name].keys.last if consumer_key.nil?
       @rcfile.active_profile = {"username" => @rcfile[screen_name][consumer_key]["username"], "consumer_key" => consumer_key}
@@ -26,46 +25,46 @@ module T
 
     desc "bio DESCRIPTION", "Edits your Bio information on your Twitter profile."
     def bio(description)
-      client.update_profile(description:)
+      x_update_profile(description:)
       say "@#{@rcfile.active_profile[0]}'s bio has been updated."
     end
 
     desc "language LANGUAGE_NAME", "Selects the language you'd like to receive notifications in."
     def language(language_name)
-      client.settings(lang: language_name)
+      x_settings(lang: language_name)
       say "@#{@rcfile.active_profile[0]}'s language has been updated."
     end
 
     desc "location PLACE_NAME", "Updates the location field in your profile."
     def location(place_name)
-      client.update_profile(location: place_name)
+      x_update_profile(location: place_name)
       say "@#{@rcfile.active_profile[0]}'s location has been updated."
     end
 
     desc "name NAME", "Sets the name field on your Twitter profile."
     def name(name)
-      client.update_profile(name:)
+      x_update_profile(name:)
       say "@#{@rcfile.active_profile[0]}'s name has been updated."
     end
 
     desc "profile_background_image FILE", "Sets the background image on your Twitter profile."
     method_option "tile", aliases: "-t", type: :boolean, desc: "Whether or not to tile the background image."
     def profile_background_image(file)
-      client.update_profile_background_image(File.new(File.expand_path(file)), tile: options["tile"], skip_status: true)
+      x_update_profile_background_image(File.new(File.expand_path(file)), tile: options["tile"], skip_status: true)
       say "@#{@rcfile.active_profile[0]}'s background image has been updated."
     end
     map %w[background background_image] => :profile_background_image
 
     desc "profile_image FILE", "Sets the image on your Twitter profile."
     def profile_image(file)
-      client.update_profile_image(File.new(File.expand_path(file)))
+      x_update_profile_image(File.new(File.expand_path(file)))
       say "@#{@rcfile.active_profile[0]}'s image has been updated."
     end
     map %w[avatar image] => :profile_image
 
     desc "website URI", "Sets the website field on your profile."
     def website(uri)
-      client.update_profile(url: uri)
+      x_update_profile(url: uri)
       say "@#{@rcfile.active_profile[0]}'s website has been updated."
     end
   end