twitter 8.2.0 → 8.3.1

data/lib/twitter/rest/places_and_geo.rb

@@ -4,80 +4,96 @@ require "twitter/rest/utils"
 
 module Twitter
   module REST
+    # Methods for working with places and geo data
     module PlacesAndGeo
       include Twitter::REST::Utils
 
       # Returns all the information about a known place
       #
+      # @api public
       # @see https://dev.twitter.com/rest/reference/get/geo/id/:place_id
       # @rate_limited Yes
       # @authentication Requires user context
       # @raise [Twitter::Error::Unauthorized] Error raised when supplied user credentials are not valid.
-      # @param place_id [String] A place in the world. These IDs can be retrieved from {Twitter::REST::PlacesAndGeo#reverse_geocode}.
+      # @example
+      #   client.place('df51dec6f4ee2b2c')
+      # @param place_id [String] A place in the world.
       # @param options [Hash] A customizable set of options.
       # @return [Twitter::Place] The requested place.
       def place(place_id, options = {})
-        perform_get_with_object("/1.1/geo/id/#{place_id}.json", options, Twitter::Place)
+        perform_get_with_object("/1.1/geo/id/#{place_id}.json", options, Place)
       end
 
       # Searches for up to 20 places that can be used as a place_id
       #
+      # @api public
       # @see https://dev.twitter.com/rest/reference/get/geo/reverse_geocode
-      # @note This request is an informative call and will deliver generalized results about geography.
+      # @note Delivers generalized results about geography.
       # @rate_limited Yes
       # @authentication Requires user context
       # @raise [Twitter::Error::Unauthorized] Error raised when supplied user credentials are not valid.
+      # @example
+      #   client.reverse_geocode(lat: 37.7821, long: -122.4093)
       # @param options [Hash] A customizable set of options.
-      # @option options [Float] :lat The latitude to search around. This option will be ignored unless it is inside the range -90.0 to +90.0 (North is positive) inclusive. It will also be ignored if there isn't a corresponding :long option.
-      # @option options [Float] :long The longitude to search around. The valid range for longitude is -180.0 to +180.0 (East is positive) inclusive. This option will be ignored if outside that range, if it is not a number, if geo_enabled is disabled, or if there not a corresponding :lat option.
-      # @option options [String] :accuracy ('0m') A hint on the "region" in which to search. If a number, then this is a radius in meters, but it can also take a string that is suffixed with ft to specify feet. If coming from a device, in practice, this value is whatever accuracy the device has measuring its location (whether it be coming from a GPS, WiFi triangulation, etc.).
-      # @option options [String] :granularity ('neighborhood') This is the minimal granularity of place types to return and must be one of: 'poi', 'neighborhood', 'city', 'admin' or 'country'.
-      # @option options [Integer] :max_results A hint as to the number of results to return. This does not guarantee that the number of results returned will equal max_results, but instead informs how many "nearby" results to return. Ideally, only pass in the number of places you intend to display to the user here.
+      # @option options [Float] :lat The latitude to search around.
+      # @option options [Float] :long The longitude to search around.
+      # @option options [String] :accuracy ('0m') A hint on the region in which to search.
+      # @option options [String] :granularity ('neighborhood') Minimal granularity of place types to return.
+      # @option options [Integer] :max_results A hint as to the number of results to return.
       # @return [Array<Twitter::Place>]
       def reverse_geocode(options = {})
-        perform_get_with_object("/1.1/geo/reverse_geocode.json", options, Twitter::GeoResults)
+        perform_get_with_object("/1.1/geo/reverse_geocode.json", options, GeoResults)
       end
 
-      # Search for places that can be attached to a {Twitter::REST::Tweets#update}
+      # Searches for places that can be attached to a tweet
       #
+      # @api public
       # @see https://dev.twitter.com/rest/reference/get/geo/search
       # @rate_limited Yes
       # @authentication Requires user context
       # @raise [Twitter::Error::Unauthorized] Error raised when supplied user credentials are not valid.
+      # @example
+      #   client.geo_search(query: 'Twitter HQ')
       # @param options [Hash] A customizable set of options.
-      # @option options [Float] :lat The latitude to search around. This option will be ignored unless it is inside the range -90.0 to +90.0 (North is positive) inclusive. It will also be ignored if there isn't a corresponding :long option.
-      # @option options [Float] :long The longitude to search around. The valid range for longitude is -180.0 to +180.0 (East is positive) inclusive. This option will be ignored if outside that range, if it is not a number, if geo_enabled is disabled, or if there not a corresponding :lat option.
-      # @option options [String] :query Free-form text to match against while executing a geo-based query, best suited for finding nearby locations by name.
-      # @option options [String] :ip An IP address. Used when attempting to fix geolocation based off of the user's IP address.
-      # @option options [String] :granularity ('neighborhood') This is the minimal granularity of place types to return and must be one of: 'poi', 'neighborhood', 'city', 'admin' or 'country'.
-      # @option options [String] :accuracy ('0m') A hint on the "region" in which to search. If a number, then this is a radius in meters, but it can also take a string that is suffixed with ft to specify feet. If coming from a device, in practice, this value is whatever accuracy the device has measuring its location (whether it be coming from a GPS, WiFi triangulation, etc.).
-      # @option options [Integer] :max_results A hint as to the number of results to return. This does not guarantee that the number of results returned will equal max_results, but instead informs how many "nearby" results to return. Ideally, only pass in the number of places you intend to display to the user here.
-      # @option options [String] :contained_within This is the place_id which you would like to restrict the search results to. Setting this value means only places within the given place_id will be found.
-      # @option options [String] :"attribute:street_address" This option searches for places which have this given street address. There are other well-known and application-specific attributes available. Custom attributes are also permitted.
+      # @option options [Float] :lat The latitude to search around.
+      # @option options [Float] :long The longitude to search around.
+      # @option options [String] :query Free-form text to match against.
+      # @option options [String] :ip An IP address for geolocation.
+      # @option options [String] :granularity ('neighborhood') Minimal granularity of place types to return.
+      # @option options [String] :accuracy ('0m') A hint on the region in which to search.
+      # @option options [Integer] :max_results A hint as to the number of results to return.
+      # @option options [String] :contained_within The place_id to restrict results to.
       # @return [Array<Twitter::Place>]
       def geo_search(options = {})
-        perform_get_with_object("/1.1/geo/search.json", options, Twitter::GeoResults)
+        perform_get_with_object("/1.1/geo/search.json", options, GeoResults)
       end
-      alias places_nearby geo_search
+      # @!method places_nearby
+      #   @api public
+      #   @see #geo_search
+      alias_method :places_nearby, :geo_search
 
       # Locates places near the given coordinates which are similar in name
       #
+      # @api public
       # @see https://dev.twitter.com/rest/reference/get/geo/similar_places
-      # @note Conceptually, you would use this method to get a list of known places to choose from first. Then, if the desired place doesn't exist, make a request to {Twitter::REST::PlacesAndGeo#place} to create a new one. The token contained in the response is the token necessary to create a new place.
       # @rate_limited Yes
       # @authentication Requires user context
       # @raise [Twitter::Error::Unauthorized] Error raised when supplied user credentials are not valid.
+      # @example
+      #   client.similar_places(lat: 37.7821, long: -122.4093, name: 'Twitter')
       # @param options [Hash] A customizable set of options.
-      # @option options [Float] :lat The latitude to search around. This option will be ignored unless it is inside the range -90.0 to +90.0 (North is positive) inclusive. It will also be ignored if there isn't a corresponding :long option.
-      # @option options [Float] :long The longitude to search around. The valid range for longitude is -180.0 to +180.0 (East is positive) inclusive. This option will be ignored if outside that range, if it is not a number, if geo_enabled is disabled, or if there not a corresponding :lat option.
+      # @option options [Float] :lat The latitude to search around.
+      # @option options [Float] :long The longitude to search around.
       # @option options [String] :name The name a place is known as.
-      # @option options [String] :contained_within This is the place_id which you would like to restrict the search results to. Setting this value means only places within the given place_id will be found.
-      # @option options [String] :"attribute:street_address" This option searches for places which have this given street address. There are other well-known and application-specific attributes available. Custom attributes are also permitted.
+      # @option options [String] :contained_within The place_id to restrict results to.
       # @return [Array<Twitter::Place>]
       def similar_places(options = {})
-        perform_get_with_object("/1.1/geo/similar_places.json", options, Twitter::GeoResults)
+        perform_get_with_object("/1.1/geo/similar_places.json", options, GeoResults)
       end
-      alias places_similar similar_places
+      # @!method places_similar
+      #   @api public
+      #   @see #similar_places
+      alias_method :places_similar, :similar_places
     end
   end
 end

data/lib/twitter/rest/premium_search.rb

@@ -3,31 +3,36 @@ require "twitter/premium_search_results"
 
 module Twitter
   module REST
+    # Methods for Premium Search API
     module PremiumSearch
+      # Maximum tweets per request
       MAX_TWEETS_PER_REQUEST = 100
 
-      # Returns tweets from the 30-Day API that match a specified query.
+      # Returns tweets from the Premium API that match a specified query
       #
+      # @api public
       # @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.
+      # @example
+      #   client.premium_search('twitter')
       # @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
+      # @option options [String] :tag Tags for segregating rules into logical groups.
+      # @option options [Integer] :maxResults The maximum number of search results.
+      # @option options [String] :fromDate The oldest UTC timestamp.
+      # @option options [String] :toDate The latest UTC timestamp.
+      # @param request_config [Hash] Request configuration options.
+      # @option request_config [String] :product The search endpoint (30day or fullarchive).
+      # @return [Twitter::PremiumSearchResults] Tweets matching the query.
       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[:request_method] = :json_post if request_config[:request_method].nil? || request_config.fetch(:request_method).eql?(: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:))
-        Twitter::PremiumSearchResults.new(request, request_config)
+        path = "/1.1/tweets/search/#{request_config.fetch(:product)}/#{dev_environment}.json" # steep:ignore NoMethod
+        request = Request.new(self, request_config.fetch(:request_method), path, options.merge(query:))
+        PremiumSearchResults.new(request, request_config)
       end
     end
   end

data/lib/twitter/rest/request.rb

@@ -1,6 +1,5 @@
-require "addressable/uri"
+require "uri"
 require "http"
-require "http/form_data"
 require "json"
 require "openssl"
 require "twitter/error"
@@ -11,128 +10,242 @@ require "twitter/rest/form_encoder"
 
 module Twitter
   module REST
+    # Handles HTTP requests to the Twitter API
     class Request # rubocop:disable Metrics/ClassLength
       include Twitter::Utils
+
+      # The base URL for Twitter API requests
       BASE_URL = "https://api.twitter.com".freeze
-      attr_accessor :client, :headers, :options, :path, :rate_limit,
-                    :request_method, :uri
-      alias verb request_method
 
+      # The client making the request
+      #
+      # @api public
+      # @example
+      #   request.client # => #<Twitter::REST::Client>
+      # @return [Twitter::Client]
+      attr_accessor :client
+
+      # The request headers
+      #
+      # @api public
+      # @example
+      #   request.headers # => {user_agent: "...", authorization: "..."}
+      # @return [Hash]
+      attr_accessor :headers
+
+      # The request options
+      #
+      # @api public
+      # @example
+      #   request.options # => {count: 10}
+      # @return [Hash]
+      attr_accessor :options
+
+      # The request path
+      #
+      # @api public
+      # @example
+      #   request.path # => "/1.1/statuses/home_timeline.json"
+      # @return [String]
+      attr_accessor :path
+
+      # The rate limit information from the response
+      #
+      # @api public
+      # @example
+      #   request.rate_limit # => #<Twitter::RateLimit>
+      # @return [Twitter::RateLimit]
+      attr_accessor :rate_limit
+
+      # The HTTP request method
+      #
+      # @api public
+      # @example
+      #   request.request_method # => :get
+      # @return [Symbol]
+      attr_accessor :request_method
+
+      # The request URI
+      #
+      # @api public
+      # @example
+      #   request.uri # => #<URI::HTTPS>
+      # @return [URI::Generic]
+      attr_accessor :uri
+
+      # Returns the HTTP verb
+      #
+      # @api public
+      # @example
+      #   request.verb # => :get
+      # @return [Symbol]
+      def verb
+        request_method
+      end
+
+      # Initializes a new Request
+      #
+      # @api public
+      # @example
+      #   Twitter::REST::Request.new(client, :get, "/1.1/statuses/home_timeline.json")
       # @param client [Twitter::Client]
       # @param request_method [String, Symbol]
       # @param path [String]
       # @param options [Hash]
+      # @param params [Hash]
       # @return [Twitter::REST::Request]
       def initialize(client, request_method, path, options = {}, params = nil)
         @client = client
-        @uri = Addressable::URI.parse(path.start_with?("http") ? path : BASE_URL + path)
+        @uri = URI.parse(path.start_with?("http") ? path : BASE_URL + path)
         multipart_options = params || options
         set_multipart_options!(request_method, multipart_options)
-        @path = uri.path
+        @path = uri.path # steep:ignore NoMethod,IncompatibleAssignment
         @options = options
         @options_key = {get: :params, json_post: :json, json_put: :json, delete: :params}[request_method] || :form
         @params = params
       end
 
+      # Performs the HTTP request and returns the response
+      #
+      # @api public
+      # @example
+      #   request.perform # => [{id: 123, text: "Hello"}]
       # @return [Array, Hash]
       def perform
-        response = http_client.headers(@headers).public_send(@request_method, @uri.to_s, request_options)
+        response = http_client.headers(@headers).public_send(@request_method, @uri.to_str, **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)
+        fail_or_return_response_body(response.code, response_body, response)
       end
 
-    private
+      private
 
+      # Build the request options hash
+      #
+      # @api private
+      # @return [Hash]
       def request_options
-        options = if @options_key == :form
-                    {form: HTTP::FormData.create(@options, encoder: Twitter::REST::FormEncoder.method(:encode))}
-                  else
-                    {@options_key => @options}
-                  end
-
-        if @params
-          if options[:params]
-            options[:params].merge(@params)
-          else
-            options[:params] = @params
-          end
+        options = if @options_key.eql?(:form)
+          {form: HTTP::FormData.create(@options, encoder: FormEncoder.public_method(:encode))}
+        else
+          {@options_key => @options}
         end
+
+        options[:params] = @params if @params # steep:ignore ArgumentTypeMismatch
         options
       end
 
+      # Merge multipart file data into options
+      #
+      # @api private
+      # @param options [Hash]
+      # @return [void]
       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, content_type: "video/mp4")
-                       else
-                         HTTP::FormData::File.new(file, filename: File.basename(file), content_type: content_type(File.basename(file)))
-                       end
+        options[key] = if file.instance_of?(StringIO)
+          HTTP::FormData::File.new(file, content_type: "video/mp4")
+        else
+          HTTP::FormData::File.new(file, filename: File.basename(file), content_type: content_type(File.basename(file)))
+        end
       end
 
+      # Set multipart and header options based on request method
+      #
+      # @api private
+      # @param request_method [Symbol]
+      # @param options [Hash]
+      # @return [void]
       def set_multipart_options!(request_method, options)
         if %i[multipart_post json_post].include?(request_method)
-          merge_multipart_file!(options) if request_method == :multipart_post
-          options = {}
+          merge_multipart_file!(options) if request_method.eql?(:multipart_post)
+          options = {} # : Hash[Symbol, untyped]
           @request_method = :post
-        elsif request_method == :json_put
+        elsif request_method.eql?(:json_put)
           @request_method = :put
         else
           @request_method = request_method
         end
-        @headers = Twitter::Headers.new(@client, @request_method, @uri, options).request_headers
+        @headers = Headers.new(@client, @request_method, @uri, options).request_headers # steep:ignore ArgumentTypeMismatch
       end
 
+      # Determine content type based on file extension
+      #
+      # @api private
+      # @param basename [String]
+      # @return [String]
       def content_type(basename)
         case basename
-        when /\.gif$/i
+        when /\.gif\z/i
           "image/gif"
-        when /\.jpe?g/i
+        when /\.jpe?g\z/i
           "image/jpeg"
-        when /\.png$/i
+        when /\.png\z/i
           "image/png"
         else
           "application/octet-stream"
         end
       end
 
-      def fail_or_return_response_body(code, body, headers)
+      # Check response and return body or raise error
+      #
+      # @api private
+      # @param code [Integer]
+      # @param body [Hash, Array, String]
+      # @param response [HTTP::Response]
+      # @return [Hash, Array, String]
+      def fail_or_return_response_body(code, body, response)
+        headers = response.headers
         error = error(code, body, headers)
         raise(error) if error
 
-        @rate_limit = Twitter::RateLimit.new(headers)
+        @rate_limit = RateLimit.new(headers)
         body
       end
 
-      def error(code, body, headers)
-        klass = Twitter::Error::ERRORS[code]
-        if klass == Twitter::Error::Forbidden
-          forbidden_error(body, headers)
+      # Build error object from response
+      #
+      # @api private
+      # @param code [Integer]
+      # @param body [Hash, Array, String]
+      # @param response [HTTP::Response]
+      # @return [Twitter::Error, nil]
+      def error(code, body, response)
+        klass = Error::ERRORS[code]
+        if klass.eql?(Error::Forbidden)
+          forbidden_error(body, response)
         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)
+          klass.from_response(body, response)
+        elsif body.instance_of?(Hash) && (err = body.dig(:processing_info, :error))
+          Error::MediaError.from_processing_response(err, response)
         end
       end
 
-      def forbidden_error(body, headers)
-        error = Twitter::Error::Forbidden.from_response(body, headers)
-        klass = Twitter::Error::FORBIDDEN_MESSAGES[error.message]
+      # Build forbidden error with specific message handling
+      #
+      # @api private
+      # @param body [Hash, Array, String]
+      # @param response [HTTP::Response]
+      # @return [Twitter::Error]
+      def forbidden_error(body, response)
+        error = Error::Forbidden.from_response(body, response)
+        klass = Error::FORBIDDEN_MESSAGES[error.message]
         if klass
-          klass.from_response(body, headers)
+          klass.from_response(body, response)
         else
           error
         end
       end
 
+      # Recursively symbolize hash keys
+      #
+      # @api private
+      # @param object [Hash, Array, Object]
+      # @return [Hash, Array, Object]
       def symbolize_keys!(object)
         case object
         when Array
-          object.each_with_index do |val, index|
-            object[index] = symbolize_keys!(val)
-          end
+          object.each { |val| symbolize_keys!(val) }
         when Hash
           object.dup.each_key do |key|
             object[key.to_sym] = symbolize_keys!(object.delete(key))
@@ -141,22 +254,27 @@ module Twitter
         object
       end
 
-      # Returns boolean indicating if all the keys required by HTTP::Client are present in Twitter::Client#timeouts
+      # Check if all timeout keys are defined
       #
+      # @api private
       # @return [Boolean]
-      def timeout_keys_defined
+      def timeout_keys_defined?
         (%i[write connect read] - (@client.timeouts&.keys || [])).empty?
       end
 
-      # @return [HTTP::Client, HTTP]
+      # Build HTTP client with proxy and timeout settings
+      #
+      # @api private
+      # @return [HTTP::Session, HTTP]
       def http_client
         client = @client.proxy ? HTTP.via(*proxy) : HTTP
-        client = client.timeout(connect: @client.timeouts[:connect], read: @client.timeouts[:read], write: @client.timeouts[:write]) if timeout_keys_defined
+        client = client.timeout(connect: @client.timeouts.fetch(:connect), read: @client.timeouts.fetch(:read), write: @client.timeouts.fetch(:write)) if timeout_keys_defined?
         client
       end
 
       # Return proxy values as a compacted array
       #
+      # @api private
       # @return [Array]
       def proxy
         @client.proxy.values_at(:host, :port, :username, :password).compact

data/lib/twitter/rest/saved_searches.rb

@@ -5,13 +5,19 @@ require "twitter/utils"
 
 module Twitter
   module REST
+    # Methods for working with saved searches
     module SavedSearches
       include Twitter::REST::Utils
       include Twitter::Utils
 
+      # Returns the authenticated user's saved search queries
+      #
+      # @api public
       # @rate_limited Yes
       # @authentication Requires user context
       # @raise [Twitter::Error::Unauthorized] Error raised when supplied user credentials are not valid.
+      # @example
+      #   client.saved_searches
       # @return [Array<Twitter::SavedSearch>] The saved searches.
       # @overload saved_search(options = {})
       #   Returns the authenticated user's saved search queries
@@ -30,9 +36,9 @@ module Twitter
       #   @param ids [Enumerable<Integer>] A collection of saved search IDs.
       #   @param options [Hash] A customizable set of options.
       def saved_searches(*args)
-        arguments = Twitter::Arguments.new(args)
+        arguments = Arguments.new(args)
         if arguments.empty?
-          perform_get_with_objects("/1.1/saved_searches/list.json", arguments.options, Twitter::SavedSearch)
+          perform_get_with_objects("/1.1/saved_searches/list.json", arguments.options, SavedSearch)
         else
           pmap(arguments) do |id|
             saved_search(id, arguments.options)
@@ -40,39 +46,48 @@ module Twitter
         end
       end
 
-      # Retrieve the data for saved searches owned by the authenticating user
+      # Retrieves a saved search by ID
       #
+      # @api public
       # @see https://dev.twitter.com/rest/reference/get/saved_searches/show/:id
       # @rate_limited Yes
       # @authentication Requires user context
       # @raise [Twitter::Error::Unauthorized] Error raised when supplied user credentials are not valid.
+      # @example
+      #   client.saved_search(16129012)
       # @return [Twitter::SavedSearch] The saved searches.
       # @param id [Integer] The ID of the saved search.
       # @param options [Hash] A customizable set of options.
       def saved_search(id, options = {})
-        perform_get_with_object("/1.1/saved_searches/show/#{id}.json", options, Twitter::SavedSearch)
+        perform_get_with_object("/1.1/saved_searches/show/#{id}.json", options, SavedSearch)
       end
 
       # Creates a saved search for the authenticated user
       #
+      # @api public
       # @see https://dev.twitter.com/rest/reference/post/saved_searches/create
       # @rate_limited No
       # @authentication Requires user context
       # @raise [Twitter::Error::Unauthorized] Error raised when supplied user credentials are not valid.
+      # @example
+      #   client.create_saved_search('twitter')
       # @return [Twitter::SavedSearch] The created saved search.
       # @param query [String] The query of the search the user would like to save.
       # @param options [Hash] A customizable set of options.
       def create_saved_search(query, options = {})
-        perform_post_with_object("/1.1/saved_searches/create.json", options.merge(query:), Twitter::SavedSearch)
+        perform_post_with_object("/1.1/saved_searches/create.json", options.merge(query:), SavedSearch)
       end
 
       # Destroys saved searches for the authenticated user
       #
+      # @api public
       # @see https://dev.twitter.com/rest/reference/post/saved_searches/destroy/:id
       # @note The search specified by ID must be owned by the authenticating user.
       # @rate_limited No
       # @authentication Requires user context
       # @raise [Twitter::Error::Unauthorized] Error raised when supplied user credentials are not valid.
+      # @example
+      #   client.destroy_saved_search(16129012)
       # @return [Array<Twitter::SavedSearch>] The deleted saved searches.
       # @overload destroy_saved_search(*ids)
       #   @param ids [Enumerable<Integer>] A collection of saved search IDs.
@@ -80,9 +95,9 @@ module Twitter
       #   @param ids [Enumerable<Integer>] A collection of saved search IDs.
       #   @param options [Hash] A customizable set of options.
       def destroy_saved_search(*args)
-        arguments = Twitter::Arguments.new(args)
+        arguments = Arguments.new(args)
         pmap(arguments) do |id|
-          perform_post_with_object("/1.1/saved_searches/destroy/#{id}.json", arguments.options, Twitter::SavedSearch)
+          perform_post_with_object("/1.1/saved_searches/destroy/#{id}.json", arguments.options, SavedSearch)
         end
       end
     end