twitter 6.2.0 → 7.0.0

data/lib/twitter/rest/direct_messages/welcome_messages.rb

@@ -0,0 +1,90 @@
+require 'twitter/arguments'
+require 'twitter/rest/upload_utils'
+require 'twitter/rest/utils'
+require 'twitter/utils'
+
+module Twitter
+  module REST
+    module DirectMessages
+      module WelcomeMessages
+        include Twitter::REST::UploadUtils
+        include Twitter::REST::Utils
+        include Twitter::Utils
+
+        # Welcome Message
+
+        def create_welcome_message(text, name = nil, options = {})
+          json_options = {
+            welcome_message: {
+              message_data: {
+                text: text,
+              },
+            },
+          }
+          json_options[:welcome_message][:name] = name if name
+          welcome_message_wrapper = perform_request_with_object(:json_post, '/1.1/direct_messages/welcome_messages/new.json', json_options.merge!(options), Twitter::DirectMessages::WelcomeMessageWrapper)
+          welcome_message_wrapper.welcome_message
+        end
+
+        def destroy_welcome_message(*ids)
+          perform_requests(:delete, '/1.1/direct_messages/welcome_messages/destroy.json', ids)
+        end
+
+        def update_welcome_message(welcome_message_id, text, options = {})
+          params = {
+            id: welcome_message_id,
+          }
+          json_options = {
+            message_data: {
+              text: text,
+            },
+          }
+          welcome_message_wrapper = perform_request_with_object(:json_put, '/1.1/direct_messages/welcome_messages/update.json', json_options.merge!(options), Twitter::DirectMessages::WelcomeMessageWrapper, params)
+          welcome_message_wrapper.welcome_message
+        end
+
+        def welcome_message(id, options = {})
+          options = options.dup
+          options[:id] = id
+          welcome_message_wrapper = perform_get_with_object('/1.1/direct_messages/welcome_messages/show.json', options, Twitter::DirectMessages::WelcomeMessageWrapper)
+          welcome_message_wrapper.welcome_message
+        end
+
+        def welcome_message_list(options = {})
+          limit = options.fetch(:count, 20)
+          welcome_message_wrappers = perform_get_with_cursor('/1.1/direct_messages/welcome_messages/list.json', options.merge!(no_default_cursor: true, count: 50, limit: limit), :welcome_messages, Twitter::DirectMessages::WelcomeMessageWrapper)
+          welcome_message_wrappers.collect(&:welcome_message)
+        end
+
+        # Welcome Message Rule
+
+        def create_welcome_message_rule(welcome_message_id, options = {})
+          json_options = {
+            welcome_message_rule: {
+              welcome_message_id: welcome_message_id,
+            },
+          }
+          rule_wrapper = perform_request_with_object(:json_post, '/1.1/direct_messages/welcome_messages/rules/new.json', json_options.merge!(options), Twitter::DirectMessages::WelcomeMessageRuleWrapper)
+          rule_wrapper.welcome_message_rule
+        end
+
+        def destroy_welcome_message_rule(*ids)
+          perform_requests(:delete, '/1.1/direct_messages/welcome_messages/rules/destroy.json', ids)
+        end
+
+        def welcome_message_rule(id, options = {})
+          options = options.dup
+          options[:id] = id
+          rule_wrapper = perform_get_with_object('/1.1/direct_messages/welcome_messages/rules/show.json', options, Twitter::DirectMessages::WelcomeMessageRuleWrapper)
+          rule_wrapper.welcome_message_rule
+        end
+
+        def welcome_message_rule_list(options = {})
+          limit = options.fetch(:count, 20)
+          rule_wrappers = perform_get_with_cursor('/1.1/direct_messages/welcome_messages/rules/list.json', options.merge!(no_default_cursor: true, count: 50, limit: limit), :welcome_message_rules, Twitter::DirectMessages::WelcomeMessageRuleWrapper)
+          rule_wrappers.collect(&:welcome_message_rule)
+        end
+      end
+    end
+  end
+end

data/lib/twitter/rest/favorites.rb

@@ -20,14 +20,14 @@ module Twitter
       #   Returns the 20 most recent favorite Tweets for the authenticating user
       #
       #   @param options [Hash] A customizable set of options.
-      #   @option options [Integer] :count Specifies the number of records to retrieve. Must be less than or equal to 100.
+      #   @option options [Integer] :count Specifies the number of records to retrieve. Must be less than or equal to 200.
       #   @option options [Integer] :since_id Returns results with an ID greater than (that is, more recent than) the specified ID.
       # @overload favorites(user, options = {})
       #   Returns the 20 most recent favorite Tweets for the specified user
       #
       #   @param user [Integer, String, Twitter::User] A Twitter user ID, screen name, URI, or object.
       #   @param options [Hash] A customizable set of options.
-      #   @option options [Integer] :count Specifies the number of records to retrieve. Must be less than or equal to 100.
+      #   @option options [Integer] :count Specifies the number of records to retrieve. Must be less than or equal to 200.
       #   @option options [Integer] :since_id Returns results with an ID greater than (that is, more recent than) the specified ID.
       def favorites(*args)
         arguments = Twitter::Arguments.new(args)

data/lib/twitter/rest/lists.rb

@@ -484,6 +484,7 @@ module Twitter
       # @return [Hash]
       def merge_owner!(hash, user)
         return hash if hash[:owner_id] || hash[:owner_screen_name]
+
         if user
           merge_user!(hash, user, 'owner')
           hash[:owner_id] = hash.delete(:owner_user_id) unless hash[:owner_user_id].nil?

data/lib/twitter/rest/premium_search.rb

@@ -0,0 +1,34 @@
+require 'twitter/rest/request'
+require 'twitter/premium_search_results'
+
+module Twitter
+  module REST
+    module PremiumSearch
+      MAX_TWEETS_PER_REQUEST = 100
+
+      # Returns tweets from the 30-Day API that match a specified query.
+      #
+      # @see https://developer.twitter.com/en/docs/tweets/search/overview/premium
+      # @see https://developer.twitter.com/en/docs/tweets/search/api-reference/premium-search.html#DataEndpoint
+      # @rate_limited Yes
+      # @raise [Twitter::Error::Unauthorized] Error raised when supplied user credentials are not valid.
+      # @param query [String] A search term.
+      # @param options [Hash] A customizable set of options.
+      # @option options [String] :tag Tags can be used to segregate rules and their matching data into different logical groups.
+      # @option options [Integer] :maxResults The maximum number of search results to be returned by a request. A number between 10 and the system limit (currently 500, 100 for Sandbox environments). By default, a request response will return 100 results
+      # @option options [String] :fromDate The oldest UTC timestamp (from most recent 30 days) from which the Tweets will be provided. Date should be formatted as yyyymmddhhmm.
+      # @option options [String] :toDate The latest, most recent UTC timestamp to which the activities will be provided. Date should be formatted as yyyymmddhhmm.
+      # @option request_config [String] :product Indicates the search endpoint you are making requests to, either 30day or fullarchive. Default 30day
+      # @return [Twitter::PremiumSearchResults] Return tweets that match a specified query with search metadata
+      def premium_search(query, options = {}, request_config = {})
+        options = options.clone
+        options[:maxResults] ||= MAX_TWEETS_PER_REQUEST
+        request_config[:request_method] = :json_post if request_config[:request_method].nil? || request_config[:request_method] == :post
+        request_config[:product] ||= '30day'
+        path = "/1.1/tweets/search/#{request_config[:product]}/#{dev_environment}.json"
+        request = Twitter::REST::Request.new(self, request_config[:request_method], path, options.merge(query: query))
+        Twitter::PremiumSearchResults.new(request, request_config)
+      end
+    end
+  end
+end

data/lib/twitter/rest/request.rb

@@ -10,7 +10,7 @@ require 'twitter/utils'
 
 module Twitter
   module REST
-    class Request
+    class Request # rubocop:disable Metrics/ClassLength
       include Twitter::Utils
       BASE_URL = 'https://api.twitter.com'.freeze
       attr_accessor :client, :headers, :options, :path, :rate_limit,
@@ -22,18 +22,20 @@ module Twitter
       # @param path [String]
       # @param options [Hash]
       # @return [Twitter::REST::Request]
-      def initialize(client, request_method, path, options = {})
+      def initialize(client, request_method, path, options = {}, params = nil)
         @client = client
         @uri = Addressable::URI.parse(path.start_with?('http') ? path : BASE_URL + path)
-        set_multipart_options!(request_method, options)
+        multipart_options = params || options
+        set_multipart_options!(request_method, multipart_options)
         @path = uri.path
         @options = options
+        @options_key = {get: :params, json_post: :json, json_put: :json, delete: :params}[request_method] || :form
+        @params = params
       end
 
       # @return [Array, Hash]
       def perform
-        options_key = @request_method == :get ? :params : :form
-        response = http_client.headers(@headers).public_send(@request_method, @uri.to_s, options_key => @options)
+        response = http_client.headers(@headers).public_send(@request_method, @uri.to_s, request_options)
         response_body = response.body.empty? ? '' : symbolize_keys!(response.parse)
         response_headers = response.headers
         fail_or_return_response_body(response.code, response_body, response_headers)
@@ -41,29 +43,43 @@ module Twitter
 
     private
 
+      def request_options
+        options = {@options_key => @options}
+        if @params
+          if options[:params]
+            options[:params].merge(@params)
+          else
+            options[:params] = @params
+          end
+        end
+        options
+      end
+
       def merge_multipart_file!(options)
         key = options.delete(:key)
         file = options.delete(:file)
 
         options[key] = if file.is_a?(StringIO)
-                         HTTP::FormData::File.new(file, mime_type: 'video/mp4')
+                         HTTP::FormData::File.new(file, content_type: 'video/mp4')
                        else
-                         HTTP::FormData::File.new(file, filename: File.basename(file), mime_type: mime_type(File.basename(file)))
+                         HTTP::FormData::File.new(file, filename: File.basename(file), content_type: content_type(File.basename(file)))
                        end
       end
 
       def set_multipart_options!(request_method, options)
-        if request_method == :multipart_post
-          merge_multipart_file!(options)
+        if %i[multipart_post json_post].include?(request_method)
+          merge_multipart_file!(options) if request_method == :multipart_post
+          options = {}
           @request_method = :post
-          @headers = Twitter::Headers.new(@client, @request_method, @uri).request_headers
+        elsif request_method == :json_put
+          @request_method = :put
         else
           @request_method = request_method
-          @headers = Twitter::Headers.new(@client, @request_method, @uri, options).request_headers
         end
+        @headers = Twitter::Headers.new(@client, @request_method, @uri, options).request_headers
       end
 
-      def mime_type(basename)
+      def content_type(basename)
         case basename
         when /\.gif$/i
           'image/gif'
@@ -79,6 +95,7 @@ module Twitter
       def fail_or_return_response_body(code, body, headers)
         error = error(code, body, headers)
         raise(error) if error
+
         @rate_limit = Twitter::RateLimit.new(headers)
         body
       end
@@ -89,6 +106,8 @@ module Twitter
           forbidden_error(body, headers)
         elsif !klass.nil?
           klass.from_response(body, headers)
+        elsif body&.is_a?(Hash) && (err = body.dig(:processing_info, :error))
+          Twitter::Error::MediaError.from_processing_response(err, headers)
         end
       end
 
@@ -115,10 +134,17 @@ module Twitter
         object
       end
 
+      # Returns boolean indicating if all the keys required by HTTP::Client are present in Twitter::Client#timeouts
+      #
+      # @return [Boolean]
+      def timeout_keys_defined
+        (%i[write connect read] - (@client.timeouts&.keys || [])).empty?
+      end
+
       # @return [HTTP::Client, HTTP]
       def http_client
         client = @client.proxy ? HTTP.via(*proxy) : HTTP
-        client = client.timeout(:per_operation, connect: @client.timeouts[:connect], read: @client.timeouts[:read], write: @client.timeouts[:write]) if @client.timeouts
+        client = client.timeout(connect: @client.timeouts[:connect], read: @client.timeouts[:read], write: @client.timeouts[:write]) if timeout_keys_defined
         client
       end
 

data/lib/twitter/rest/search.rb

@@ -14,7 +14,7 @@ module Twitter
       # @rate_limited Yes
       # @authentication Requires user context
       # @raise [Twitter::Error::Unauthorized] Error raised when supplied user credentials are not valid.
-      # @param q [String] A search term.
+      # @param query [String] A search term.
       # @param options [Hash] A customizable set of options.
       # @option options [String] :geocode Returns tweets by users located within a given radius of the given latitude/longitude. The location is preferentially taking from the Geotagging API, but will fall back to their Twitter profile. The parameter value is specified by "latitude,longitude,radius", where radius units must be specified as either "mi" (miles) or "km" (kilometers). Note that you cannot use the near operator via the API to geocode arbitrary locations; however you can use this geocode parameter to search near geocodes directly.
       # @option options [String] :lang Restricts tweets to the given language, given by an ISO 639-1 code.
@@ -25,11 +25,12 @@ module Twitter
       # @option options [Integer] :since_id Returns results with an ID greater than (that is, more recent than) the specified ID. There are limits to the number of Tweets which can be accessed through the API. If the limit of Tweets has occured since the since_id, the since_id will be forced to the oldest ID available.
       # @option options [Integer] :max_id Returns results with an ID less than (that is, older than) or equal to the specified ID.
       # @option options [Boolean] :include_entities The entities node will be disincluded when set to false.
+      # @option options [String] :tweet_mode The entities node will truncate or not tweet text. Options are "compat" and "extended". The current default is "compat" (truncate).
       # @return [Twitter::SearchResults] Return tweets that match a specified query with search metadata
-      def search(q, options = {})
+      def search(query, options = {})
         options = options.dup
         options[:count] ||= MAX_TWEETS_PER_REQUEST
-        request = Twitter::REST::Request.new(self, :get, '/1.1/search/tweets.json', options.merge(q: q))
+        request = Twitter::REST::Request.new(self, :get, '/1.1/search/tweets.json', options.merge(q: query))
         Twitter::SearchResults.new(request)
       end
     end

data/lib/twitter/rest/timelines.rb

@@ -188,6 +188,7 @@ module Twitter
       def collect_with_max_id(collection = [], max_id = nil, &block)
         tweets = yield(max_id)
         return collection if tweets.nil?
+
         collection += tweets
         tweets.empty? ? collection.flatten : collect_with_max_id(collection, tweets.last.id - 1, &block)
       end

data/lib/twitter/rest/tweets.rb

@@ -2,6 +2,7 @@ require 'twitter/arguments'
 require 'twitter/error'
 require 'twitter/oembed'
 require 'twitter/rest/request'
+require 'twitter/rest/upload_utils'
 require 'twitter/rest/utils'
 require 'twitter/tweet'
 require 'twitter/utils'
@@ -9,6 +10,7 @@ require 'twitter/utils'
 module Twitter
   module REST
     module Tweets
+      include Twitter::REST::UploadUtils
       include Twitter::REST::Utils
       include Twitter::Utils
       MAX_TWEETS_PER_REQUEST = 100
@@ -323,37 +325,6 @@ module Twitter
 
     private
 
-      # Uploads images and videos. Videos require multiple requests and uploads in chunks of 5 Megabytes.
-      # The only supported video format is mp4.
-      #
-      # @see https://dev.twitter.com/rest/public/uploading-media
-      def upload(media) # rubocop:disable MethodLength, AbcSize
-        if File.basename(media) !~ /\.mp4$/
-          Twitter::REST::Request.new(self, :multipart_post, 'https://upload.twitter.com/1.1/media/upload.json', key: :media, file: media).perform
-        else
-          init = Twitter::REST::Request.new(self, :post, 'https://upload.twitter.com/1.1/media/upload.json',
-                                            command: 'INIT',
-                                            media_type: 'video/mp4',
-                                            total_bytes: media.size).perform
-
-          until media.eof?
-            chunk = media.read(5_000_000)
-            seg ||= -1
-            Twitter::REST::Request.new(self, :multipart_post, 'https://upload.twitter.com/1.1/media/upload.json',
-                                       command: 'APPEND',
-                                       media_id: init[:media_id],
-                                       segment_index: seg += 1,
-                                       key: :media,
-                                       file: StringIO.new(chunk)).perform
-          end
-
-          media.close
-
-          Twitter::REST::Request.new(self, :post, 'https://upload.twitter.com/1.1/media/upload.json',
-                                     command: 'FINALIZE', media_id: init[:media_id]).perform
-        end
-      end
-
       def array_wrap(object)
         if object.respond_to?(:to_ary)
           object.to_ary || [object]

data/lib/twitter/rest/upload_utils.rb

@@ -0,0 +1,68 @@
+require 'twitter/rest/request'
+
+module Twitter
+  module REST
+    module UploadUtils
+    private
+
+      # Uploads images and videos. Videos require multiple requests and uploads in chunks of 5 Megabytes.
+      # The only supported video format is mp4.
+      #
+      # @see https://developer.twitter.com/en/docs/media/upload-media/uploading-media/media-best-practices
+      def upload(media, media_category_prefix: 'tweet')
+        return chunk_upload(media, 'video/mp4', "#{media_category_prefix}_video") if File.extname(media) == '.mp4'
+        return chunk_upload(media, 'image/gif', "#{media_category_prefix}_gif") if File.extname(media) == '.gif' && File.size(media) > 5_000_000
+
+        Twitter::REST::Request.new(self, :multipart_post, 'https://upload.twitter.com/1.1/media/upload.json', key: :media, file: media).perform
+      end
+
+      # @raise [Twitter::Error::TimeoutError] Error raised when the upload is longer than the value specified in Twitter::Client#timeouts[:upload].
+      # @raise [Twitter::Error::MediaError] Error raised when Twitter return an error about a media which is not mapped by the gem.
+      # @raise [Twitter::Error::MediaInternalError] Error raised when Twitter returns an InternalError error.
+      # @raise [Twitter::Error::InvalidMedia] Error raised when Twitter returns an InvalidMedia error.
+      # @raise [Twitter::Error::UnsupportedMedia] Error raised when Twitter returns an UnsupportedMedia error.
+      # @see https://developer.twitter.com/en/docs/media/upload-media/uploading-media/chunked-media-upload
+      def chunk_upload(media, media_type, media_category)
+        Timeout.timeout(timeouts&.fetch(:upload, nil), Twitter::Error::TimeoutError) do
+          init = Twitter::REST::Request.new(self, :post, 'https://upload.twitter.com/1.1/media/upload.json',
+                                            command: 'INIT',
+                                            media_type: media_type,
+                                            media_category: media_category,
+                                            total_bytes: media.size).perform
+          append_media(media, init[:media_id])
+          media.close
+          finalize_media(init[:media_id])
+        end
+      end
+
+      # @see https://developer.twitter.com/en/docs/media/upload-media/api-reference/post-media-upload-append
+      def append_media(media, media_id)
+        until media.eof?
+          chunk = media.read(5_000_000)
+          seg ||= -1
+          Twitter::REST::Request.new(self, :multipart_post, 'https://upload.twitter.com/1.1/media/upload.json',
+                                     command: 'APPEND',
+                                     media_id: media_id,
+                                     segment_index: seg += 1,
+                                     key: :media,
+                                     file: StringIO.new(chunk)).perform
+        end
+      end
+
+      # @see https://developer.twitter.com/en/docs/media/upload-media/api-reference/post-media-upload-finalize
+      # @see https://developer.twitter.com/en/docs/media/upload-media/api-reference/get-media-upload-status
+      def finalize_media(media_id)
+        response = Twitter::REST::Request.new(self, :post, 'https://upload.twitter.com/1.1/media/upload.json',
+                                              command: 'FINALIZE', media_id: media_id).perform
+        loop do
+          return response if !response[:processing_info] || %w[failed succeeded].include?(response[:processing_info][:state])
+
+          sleep(response[:processing_info][:check_after_secs])
+          response = Twitter::REST::Request.new(self, :get, 'https://upload.twitter.com/1.1/media/upload.json',
+                                                command: 'STATUS', media_id: media_id).perform
+        end
+        response
+      end
+    end
+  end
+end

data/lib/twitter/rest/utils.rb

@@ -46,8 +46,8 @@ module Twitter
       # @param request_method [Symbol]
       # @param path [String]
       # @param options [Hash]
-      def perform_request(request_method, path, options = {})
-        Twitter::REST::Request.new(self, request_method, path, options).perform
+      def perform_request(request_method, path, options = {}, params = nil)
+        Twitter::REST::Request.new(self, request_method, path, options, params).perform
       end
 
       # @param path [String]
@@ -68,8 +68,8 @@ module Twitter
       # @param path [String]
       # @param options [Hash]
       # @param klass [Class]
-      def perform_request_with_object(request_method, path, options, klass)
-        response = perform_request(request_method, path, options)
+      def perform_request_with_object(request_method, path, options, klass, params = nil)
+        response = perform_request(request_method, path, options, params)
         klass.new(response)
       end
 
@@ -102,9 +102,15 @@ module Twitter
       # @param collection_name [Symbol]
       # @param klass [Class]
       def perform_get_with_cursor(path, options, collection_name, klass = nil)
-        merge_default_cursor!(options)
+        limit = options.delete(:limit)
+        if options[:no_default_cursor]
+          options.delete(:no_default_cursor)
+        else
+          merge_default_cursor!(options)
+        end
+
         request = Twitter::REST::Request.new(self, :get, path, options)
-        Twitter::Cursor.new(collection_name.to_sym, klass, request)
+        Twitter::Cursor.new(collection_name.to_sym, klass, request, limit)
       end
 
       # @param request_method [Symbol]
@@ -151,6 +157,17 @@ module Twitter
         end
       end
 
+      # @param request_method [Symbol]
+      # @param path [String]
+      # @param ids [Array]
+      # @return nil
+      def perform_requests(request_method, path, ids)
+        ids.each do |id|
+          perform_request(request_method, path, id: id)
+        end
+        nil
+      end
+
       # @param collection_name [Symbol]
       # @param klass [Class]
       # @param path [String]
@@ -229,7 +246,7 @@ module Twitter
         hash[:screen_name] = screen_names.join(',') unless screen_names.empty?
       end
 
-      def collect_users(users) # rubocop:disable MethodLength
+      def collect_users(users) # rubocop:disable Metrics/MethodLength
         user_ids = []
         screen_names = []
         users.each do |user|