rorra-twitter_oauth 0.4.3

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) Richard Taylor
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.textile

@@ -0,0 +1,127 @@
+h1. Twitter OAuth REST API client library for Ruby
+
+h2. Install the gem
+
+sudo gem install twitter_oauth # (via gemcutter)
+
+h2. Using the gem
+
+To make authorized requests with the client library you'll need to "create a Twitter OAuth Application":http://twitter.com/oauth_clients/new.
+
+See "sinitter":http://github.com/moomerman/sinitter/tree/master for a full website integration example.
+
+h2. Unauthorized request example
+
+The Twitter API can be called to make public requests without needing any client credentials.
+Most methods will not work in this mode but some of them do.  An example to retrieve the public details
+about a Twitter user is below. 
+
+<pre><code>client = TwitterOAuth::Client.new  
+
+puts client.show('twitter')
+=> => {"status"=>{"truncated"=>false, "favorited"=>false, "text"=>"Update on service issues http://tinyurl.com/ca872j", "id"=>1357776683, "in_reply_to_user_id"=>nil, "in_reply_to_status_id"=>nil, "source"=>"<a href=\"http://twitterfeed.com\">twitterfeed</a>", "created_at"=>"Fri Mar 20 01:17:35 +0000 2009"}, "name"=>"Twitter", "profile_sidebar_fill_color"=>"CDFFFF", "profile_sidebar_border_color"=>"8a6447", "profile_background_tile"=>false, "profile_link_color"=>"0000ff", "url"=>"http://twitter.com", "favourites_count"=>0, "id"=>783214, "description"=>"Always wondering what everyone's doing.", "profile_text_color"=>"000000", "protected"=>false, "utc_offset"=>-28800, "screen_name"=>"twitter", "profile_background_color"=>"9ae4e8", "time_zone"=>"Pacific Time (US & Canada)", "followers_count"=>469150, "profile_background_image_url"=>"http://static.twitter.com/images/themes/theme1/bg.gif", "friends_count"=>30, "statuses_count"=>290, "location"=>"San Francisco, CA", "profile_image_url"=>"http://s3.amazonaws.com/twitter_production/profile_images/75075164/twitter_bird_profile_normal.png", "created_at"=>"Tue Feb 20 14:35:54 +0000 2007"}
+</code></pre>
+
+You can also access to the search API which is available in either authorized or unauthorized modes.
+
+<pre><code>search = client.search('twitter')
+search.results.size => 20
+search.results.first.from_user => "josephpred"
+search.results.first.text
+=> "Useful public service Twitter account for those of you hitting Tahoe or just needing to cross the pass to Reno: @i80chains"
+</code></pre>
+
+h2. Authorized request example
+
+To use the full power of the Twitter API you need to authorize your application and a valid Twitter user via OAuth.
+An example showing how to update the status of an authorized user is below.
+
+Firstly we need to create an instance of the client with your application client credentials you have been given by Twitter
+when you set up your application.
+
+<pre><code>client = TwitterOAuth::Client.new(
+    :consumer_key => 'YOUR_APP_CONSUMER_KEY',
+    :consumer_secret => 'YOURA_APP_CONSUMER_SECRET'
+)
+request_token = client.request_token(:oauth_callback => oauth_confirm_url)
+#:oauth_callback required for web apps, since oauth gem by default force PIN-based flow 
+#( see http://groups.google.com/group/twitter-development-talk/browse_thread/thread/472500cfe9e7cdb9/848f834227d3e64d )
+
+
+request_token.authorize_url
+=> http://twitter.com/oauth/authorize?oauth_token=TOKEN
+</code></pre>
+
+In your application your user would be redirected to Twitter to authorize the application at this point.  You'll need to store
+the request token (usually in the session) for later.  The code continues below assuming the user has authorized your application.
+
+<pre><code>access_token = client.authorize(
+  request_token.token,
+  request_token.secret,
+  :oauth_verifier => params[:oauth_verifier]
+)
+
+client.authorized?
+=> true
+
+client.update('checking out the twitter_oauth library') # sends a twitter status update
+</code></pre>
+
+Now if you keep hold of the access_token (usually in the database) for this user you won't need to re-authorize them next time.  When you create an instance of the client you can just pass in the access token and secret that you have stored.
+
+<pre><code>access_token = @user.access_token # assuming @user
+client = TwitterOAuth::Client.new(
+    :consumer_key => 'YOUR_CONSUMER_KEY',
+    :consumer_secret => 'YOUR-CONSUMER-SECRET',
+    :token => access_token.token, 
+    :secret => access_token.secret
+)
+
+client.authorized?
+=> true
+</code></pre>
+
+h2. Working with a Proxy
+
+Services such as "Apigee Analytics and API Management":http://apigee.com/ require you to proxy your API requests through their servers.  The workflow is as follows.
+
+First you need to authorize the Twitter user via OAuth directly via the Twitter API (this part cannot be proxied)
+
+<pre><code>client = TwitterOAuth::Client.new(
+    :consumer_key => 'YOUR_APP_CONSUMER_KEY',
+    :consumer_secret => 'YOURA_APP_CONSUMER_SECRET'
+)
+request_token = client.request_token(:oauth_callback => 'YOUR_CALLBACK_URL')
+
+request_token.authorize_url
+=> http://twitter.com/oauth/authorize?oauth_token=TOKEN
+</code></pre>
+
+The user is sent to Twitter to allow the application to access their account and then you need to obtain the access token for the user
+
+<pre><code>access_token = client.authorize(
+  request_token.token,
+  request_token.secret,
+  :oauth_verifier => params[:oauth_verifier]
+)
+
+client.authorized?
+=> true
+</code></pre>
+
+Now you can make all further API calls through the proxy of your choice:
+
+<pre><code>access_token = @user.access_token # assuming @user
+client = TwitterOAuth::Client.new(
+    :proxy => 'http://XXX.YYY.apigee.com',
+    :consumer_key => 'YOUR_CONSUMER_KEY',
+    :consumer_secret => 'YOUR-CONSUMER-SECRET',
+    :token => access_token.token, 
+    :secret => access_token.secret
+)
+
+client.authorized?
+=> true
+
+client.update('Proxy via Apigee is working')
+</code></pre>

data/lib/twitter_oauth.rb

@@ -0,0 +1,9 @@
+require 'oauth'
+require 'json'
+require 'mime/types'
+
+require 'twitter_oauth/client'
+
+module TwitterOAuth
+  VERSION = '0.4.3'
+end

data/lib/twitter_oauth/account.rb

@@ -0,0 +1,53 @@
+module TwitterOAuth
+  class Client
+    
+    # Returns an HTTP 200 OK response code and a representation of the requesting user if authentication was successful; 
+    # returns a 401 status code and an error message if not.
+    def authorized?
+      oauth_response = access_token.get('/account/verify_credentials.json')
+      return oauth_response.class == Net::HTTPOK
+    end
+    
+    # Returns client info
+    def info
+      get('/account/verify_credentials.json')
+    end
+    
+    # Returns the remaining number of API requests available to the requesting user before the API limit is reached for the current hour.
+    def rate_limit_status
+      get('/account/rate_limit_status.json')
+    end
+    
+    # Updates profile background image. Takes a File object and optional tile argument.
+    # Returns extended user info object.
+    def update_profile_background_image(image, tile = false)
+      body, headers = http_multipart_data({:image => image, :tile => tile})
+      post('/account/update_profile_background_image.json', body, headers)
+    end
+    
+    # Updates profile avatar image. Takes a File object which should be an image.
+    # Returns extended user info object.
+    def update_profile_image(image)
+      body, headers = http_multipart_data({:image => image})
+      post('/account/update_profile_image.json', body, headers)
+    end
+    
+    # colors hash must contain at least one or more of the following keys :profile_background_color, :profile_text_color, :profile_link_color, :profile_sidebar_fill_color, :profile_sidebar_border_color 
+    # returns extended user info object.
+    def update_profile_colors(colors)
+      post('/account/update_profile_colors.json', colors)
+    end
+    
+    # Sets values that users are able to set under the "Account" tab of their settings page.
+    # Valid parameters are:
+    #   :name     Full name associated with the profile. Maximum of 20 characters.
+    #   :url      URL associated with the profile. Will be prepended with "http://" if not present. Maximum of 100 characters.
+    #   :location The city or country describing where the user of the account is located. The contents are not normalized
+    #             or geocoded in any way. Maximum of 30 characters.
+    #   :description A description of the user owning the account. Maximum of 160 characters.
+    def update_profile(params)
+      post('/account/update_profile', params)
+    end
+    
+  end
+end

data/lib/twitter_oauth/blocks.rb

@@ -0,0 +1,33 @@
+module TwitterOAuth
+  class Client
+    
+    # Blocks the user specified in the ID parameter as the authenticating user. 
+    # Destroys a friendship to the blocked user if it exists. 
+    # Returns the blocked user in the requested format when successful.
+    def block(id)
+      post("/blocks/create/#{id}.json")
+    end
+    
+    # Un-blocks the user specified in the ID parameter for the authenticating user.  
+    # Returns the un-blocked user in the requested format when successful.
+    def unblock(id)
+      post("/blocks/destroy/#{id}.json")
+    end
+    
+    # Returns if the authenticating user is blocking a target user.
+    def blocked?(id)
+      get("/blocks/exists/#{id}.json")
+    end
+    
+    # Returns an array of user objects that the authenticating user is blocking.
+    def blocking
+      get("/blocks/blocking.json")
+    end
+    
+    # Returns an array of numeric user ids the authenticating user is blocking.
+    def blocking_ids
+      get("/blocks/blocking/ids.json")
+    end
+    
+  end
+end

data/lib/twitter_oauth/client.rb

@@ -0,0 +1,90 @@
+require 'twitter_oauth/timeline'
+require 'twitter_oauth/status'
+require 'twitter_oauth/account'
+require 'twitter_oauth/direct_messages'
+require 'twitter_oauth/search'
+require 'twitter_oauth/notifications'
+require 'twitter_oauth/blocks'
+require 'twitter_oauth/friendships'
+require 'twitter_oauth/user'
+require 'twitter_oauth/favorites'
+require 'twitter_oauth/utils'
+require 'twitter_oauth/trends'
+require 'twitter_oauth/lists'
+require 'twitter_oauth/saved_searches'
+require 'twitter_oauth/spam'
+require 'twitter_oauth/geo'
+
+module TwitterOAuth
+  class Client
+    
+    def initialize(options = {})
+      @consumer_key = options[:consumer_key]
+      @consumer_secret = options[:consumer_secret]
+      @token = options[:token]
+      @secret = options[:secret]
+      @proxy = options[:proxy]
+    end
+  
+    def authorize(token, secret, options = {})
+      request_token = OAuth::RequestToken.new(
+        consumer, token, secret
+      )
+      @access_token = request_token.get_access_token(options)
+      @token = @access_token.token
+      @secret = @access_token.secret
+      @access_token
+    end
+  
+    def show(username)
+      get("/users/show/#{username}.json")
+    end
+    
+    # Returns the string "ok" in the requested format with a 200 OK HTTP status code.
+    def test
+      get("/help/test.json")
+    end
+    
+    def request_token(options={})
+      consumer.get_request_token(options)
+    end
+    
+    def authentication_request_token(options={})
+      consumer.options[:authorize_path] = '/oauth/authenticate'
+      request_token(options)
+    end
+    
+    private
+    
+      def consumer
+        @consumer ||= OAuth::Consumer.new(
+          @consumer_key,
+          @consumer_secret,
+          { :site => 'http://api.twitter.com', :request_endpoint => @proxy }
+        )
+      end
+
+      def access_token
+        @access_token ||= OAuth::AccessToken.new(consumer, @token, @secret)
+      end
+      
+      def get(path, headers={})
+        headers.merge!("User-Agent" => "twitter_oauth gem v#{TwitterOAuth::VERSION}")
+        oauth_response = access_token.get("/1#{path}", headers)
+        JSON.parse(oauth_response.body)
+      end
+
+      def post(path, body='', headers={})
+        headers.merge!("User-Agent" => "twitter_oauth gem v#{TwitterOAuth::VERSION}")
+        oauth_response = access_token.post("/1#{path}", body, headers)
+        JSON.parse(oauth_response.body)
+      end
+
+      def delete(path, headers={})
+        headers.merge!("User-Agent" => "twitter_oauth gem v#{TwitterOAuth::VERSION}")
+        oauth_response = access_token.delete("/1#{path}", headers)
+        JSON.parse(oauth_response.body)
+      end
+  end
+end
+   

data/lib/twitter_oauth/direct_messages.rb

@@ -0,0 +1,32 @@
+module TwitterOAuth
+  class Client
+    
+    # Return the most recent direct messages sent to the authenticating user.
+    # By default, returns the last 20. See http://apiwiki.twitter.com/Twitter-REST-API-Method:-direct_messages
+    # for other options
+    def messages(options={})
+      args = options.map{|k,v| "#{k}=#{v}"}.join('&')
+      get("/direct_messages.json?#{args}")
+    end
+    
+    # By default, returns a list of the 20 most recent direct messages sent by the authenticating user.
+    def sent_messages(options={})
+      args = options.map{|k,v| "#{k}=#{v}"}.join('&')
+      get("/direct_messages/sent.json?#{args}")
+    end
+    
+    # Sends a new direct message to the specified user from the authenticating user.
+    def message(user, text)
+	    body = {:text => text}
+	    body[:screen_name] = user["screen_name"] if user.has_key?("screen_name")
+		  body[:user_id] = user["id"] if user.has_key?("id")
+      post('/direct_messages/new.json', body)
+    end
+    
+    # Destroys the direct message specified in the required ID parameter.
+    def message_destroy(id)
+      post("/direct_messages/destroy/#{id}.json")
+    end
+    
+  end
+end

data/lib/twitter_oauth/favorites.rb

@@ -0,0 +1,22 @@
+module TwitterOAuth
+  class Client
+    
+    # Returns the 20 most recent favorite statuses for the authenticating user or user specified by the ID parameter.
+    def favorites(page=1)
+      get("/favorites.json?page=#{page}")
+    end
+    
+    # Favorites the status specified in the ID parameter as the authenticating user. 
+    # Returns the favorite status when successful.
+    def favorite(id)
+      post("/favorites/create/#{id}.json")
+    end
+    
+    # Un-favorites the status specified in the ID parameter as the authenticating user. 
+    # Returns the un-favorited status when successful.
+    def unfavorite(id)
+      post("/favorites/destroy/#{id}.json")
+    end
+    
+  end
+end

data/lib/twitter_oauth/friendships.rb

@@ -0,0 +1,39 @@
+module TwitterOAuth
+  class Client
+    
+    # Returns an array of numeric IDs for every user the specified user is following.
+    def friends_ids(options={})
+      args = options.map{|k,v| "#{k}=#{v}"}.join('&')
+      get("/friends/ids.json?#{args}")
+    end
+    
+    # Returns an array of numeric IDs for every user following the specified user.
+    def followers_ids(options={})
+      args = options.map{|k,v| "#{k}=#{v}"}.join('&')
+      get("/followers/ids.json?#{args}")
+    end
+    
+    # Allows the authenticating user to follow the specified user. Returns the befriended user when successful.
+    def friend(id)
+      post("/friendships/create/#{id}.json")
+    end
+    
+    # Allows the authenticating users to unfollow the specified user. Returns the unfollowed user when successful. 
+    def unfriend(id)
+      post("/friendships/destroy/#{id}.json")
+    end
+    
+    # Tests for the existence of friendship between two users. Will return true if user_a follows user_b, otherwise will return false.
+    # You are better off using get_friendship as it returns more extended information.
+    def friends?(a, b)
+      oauth_response = access_token.get("/friendships/exists.json?user_a=#{a}&user_b=#{b}")
+      oauth_response.body.strip == 'true'
+    end
+    
+    # Returns detailed information about the relationship between two users.
+    def get_friendship(a, b)
+      get("/friendships/show.json?source_screen_name=#{a}&target_screen_name=#{b}")
+    end
+    
+  end
+end

data/lib/twitter_oauth/geo.rb

@@ -0,0 +1,27 @@
+module TwitterOAuth
+  class Client
+    
+    # Search for places (cities and neighborhoods) that can be attached to a statuses/update. 
+    # Given a latitude and a longitude, return a list of all the valid places that can be used as a place_id when updating a status
+    def reverse_geocode(lat, lng, options={})
+      options[:lat] = lat; options[:lng] = lng
+      args = options.map{|k,v| "#{k}=#{v}"}.join('&')
+      get "/geo/reverse_geocode.json?#{args}"
+    end
+    
+    # Search for places (cities and neighborhoods) that can be attached to a statuses/update. 
+    # Given a latitude and a longitude pair, or an IP address, return a list of all the valid cities 
+    # and neighborhoods that can be used as a place_id when updating a status.
+    def geo_search(options={})
+      options[:query] = URI.escape(options[:query]) if options[:query]
+      args = options.map{|k,v| "#{k}=#{v}"}.join('&')
+      get "/geo/search.json?#{args}"
+    end
+    
+    # Find out more details of a place that was returned from the geo/reverse_geocode method.
+    def geo(id)
+      get "/geo/id/#{id}.json"
+    end
+  
+  end
+end

data/lib/twitter_oauth/lists.rb

@@ -0,0 +1,100 @@
+module TwitterOAuth
+  class Client
+    
+    #
+    # List methods
+    #
+    
+    # Creates a new list for the authenticated user. Accounts are limited to 20 lists. 
+    def create_list(user, list, options={})
+      post("/#{user}/lists.json", options.merge(:name => list))
+    end
+    
+    # Updates the specified list. 
+    def update_list(user, list, options={})
+      post("/#{user}/lists/#{list}.json", options)
+    end
+    
+    # List the lists of the specified user. 
+    # Private lists will be included if the authenticated user is the same as the user whose lists are being returned.
+    def get_lists(user)
+      get("/#{user}/lists.json")
+    end
+    
+    # Show the specified list. Private lists will only be shown if the authenticated user owns the specified list.
+    def get_list(user, list)
+      get("/#{user}/lists/#{list}.json")
+    end
+    
+    # Deletes the specified list. Must be owned by the authenticated user. 
+    def delete_list(user, list)
+      delete("/#{user}/lists/#{list}.json")
+    end
+    
+    # Show tweet timeline for members of the specified list.
+    def list_statuses(user, list)
+      get("/#{user}/lists/#{list}/statuses.json")
+    end
+    
+    # List the lists the specified user has been added to.
+    def list_memberships(user)
+      get("/#{user}/lists/memberships.json")
+    end
+    
+    # List the lists the specified user follows.
+    def list_subscriptions(user)
+      get("/#{user}/lists/subscriptions.json")
+    end
+    
+    #
+    # List Members Methods
+    #
+    
+    # Returns the members of the specified list.
+    def list_members(user, list)
+      get("/#{user}/#{list}/members.json")
+    end
+    
+    # Add a member to a list. The authenticated user must own the list to be able to add members to it. 
+    # Lists are limited to having 500 members.
+    def add_member_to_list(user, list, member_id, options={})
+      post("/#{user}/#{list}/members.json", options.merge(:id => member_id))
+    end
+    
+    # Removes the specified member from the list. 
+    # The authenticated user must be the list's owner to remove members from the list.
+    def remove_member_from_list(user, list, member_id)
+      delete("/#{user}/#{list}/members.json?id=#{member_id}")
+    end
+    
+    # Check if a user is a member of the specified list.
+    def get_member_of_list(user, list, member_id)
+      get("/#{user}/#{list}/members/#{member_id}.json")
+    end
+    
+    #
+    # List Subscribers Methods
+    #
+    
+    # Returns the subscribers of the specified list.
+    def list_subscribers(user, list)
+      get("/#{user}/#{list}/subscribers.json")
+    end
+    
+    # Make the authenticated user follow the specified list.
+    def subscribe_to_list(user, list, options={})
+      post("/#{user}/#{list}/subscribers.json")
+    end
+    
+    # Unsubscribes the authenticated user form the specified list.
+    def unsubscribe_from_list(user, list)
+      delete("/#{user}/#{list}/subscribers.json")
+    end
+    
+    # Check if the specified user is a subscriber of the specified list.
+    def get_subscriber_of_list(user, list, subscriber_id)
+      get("/#{user}/#{list}/subscribers/#{subscriber_id}.json")
+    end
+    
+  end
+end

data/lib/twitter_oauth/notifications.rb

@@ -0,0 +1,17 @@
+module TwitterOAuth
+  class Client
+    
+    # Enables device notifications for updates from the specified user.  
+    # Returns the specified user when successful.
+    def follow(id)
+      post("/notifications/follow/#{id}.json")
+    end
+    
+    # Disables notifications for updates from the specified user to the authenticating user.  
+    # Returns the specified user when successful.
+    def leave(id)
+      post("/notifications/leave/#{id}.json")
+    end
+    
+  end
+end

data/lib/twitter_oauth/saved_searches.rb

@@ -0,0 +1,24 @@
+module TwitterOAuth
+  class Client
+    
+    # Returns the authenticated user's saved search queries.
+    def saved_searches
+      get("/saved_searches.json")
+    end
+    
+    # Retrieve the data for a saved search owned by the authenticating user specified by the given id.
+    def get_saved_search(search_id)
+      get("/saved_searches/show/#{search_id}.json")
+    end
+    
+    # Creates a saved search for the authenticated user.
+    def create_saved_search(query)
+      post("/saved_searches/create.json", :query => query)
+    end
+    
+    def delete_saved_search(search_id)
+      post("/saved_searches/destroy/#{search_id}.json")
+    end
+    
+  end
+end

data/lib/twitter_oauth/search.rb

@@ -0,0 +1,35 @@
+require 'open-uri'
+
+module TwitterOAuth
+  class Client
+    
+    def search(q, options={})
+      options[:page] ||= 1
+      options[:rpp] ||= 20
+      options[:q] = URI.escape(q)
+      args = options.map{|k,v| "#{k}=#{v}"}.join('&')
+      search_get("/search.json?#{args}")
+    end
+    
+    # Returns the current top 10 trending topics on Twitter.
+    def current_trends
+      search_get("/trends/current.json")
+    end
+    
+    # Returns the top 20 trending topics for each hour in a given day.
+    def daily_trends
+      search_get("/trends/daily.json")
+    end
+    
+    # Returns the top 30 trending topics for each day in a given week.
+    def weekly_trends
+      search_get("/trends/weekly.json")
+    end
+    
+    private
+      def search_get(path)
+        response = open('http://search.twitter.com' + path, 'User-Agent' => 'github.com/moomerman/twitter_outh')
+        JSON.parse(response.read)
+      end
+  end
+end

data/lib/twitter_oauth/spam.rb

@@ -0,0 +1,10 @@
+module TwitterOAuth
+  class Client
+    
+    # The user specified in the id is blocked by the authenticated user and reported as a spammer.
+    def report_spam(user)
+      post("/report_spam.json", :id => user)
+    end
+    
+  end
+end

data/lib/twitter_oauth/status.rb

@@ -0,0 +1,30 @@
+module TwitterOAuth
+  class Client
+    
+    # Returns a single status, specified by the id parameter below.
+    def status(id)
+      get("/statuses/show/#{id}.json")
+    end
+    
+    # Updates the authenticating user's status.
+    def update(message, options={})
+      post('/statuses/update.json', options.merge(:status => message))
+    end
+
+    # Destroys the status specified by the required ID parameter
+    def status_destroy(id)
+      post("/statuses/destroy/#{id}.json")
+    end
+    
+    # Retweets the tweet specified by the id parameter. Returns the original tweet with retweet details embedded.
+    def retweet(id)
+      post("/statuses/retweet/#{id}.json")
+    end
+    
+    # Returns the 100 most recent retweets of the tweet.
+    def retweets(id)
+      get("/statuses/retweets/#{id}.json")
+    end
+    
+  end
+end

data/lib/twitter_oauth/timeline.rb

@@ -0,0 +1,56 @@
+module TwitterOAuth
+  class Client
+    
+    # Returns the 20 most recent statuses from non-protected users who have set a custom user icon.
+    def public_timeline(options={})
+      args = options.map{|k,v| "#{k}=#{v}"}.join('&')
+      get("/statuses/public_timeline.json?#{args}")
+    end
+    
+    # Returns the 20 most recent statuses, including retweets, posted by the authenticating user and that user's friends. 
+    # This is the equivalent of /timeline/home on the Web.
+    def home_timeline(options={})
+      args = options.map{|k,v| "#{k}=#{v}"}.join('&')
+      get("/statuses/home_timeline.json?#{args}")
+    end
+    
+    # Returns the 20 most recent statuses posted by the authenticating user and that user's friends.
+    def friends_timeline(options={})
+      args = options.map{|k,v| "#{k}=#{v}"}.join('&')
+      get("/statuses/friends_timeline.json?#{args}")
+    end
+    
+    # Returns the 20 most recent statuses posted from the authenticating user.
+    def user_timeline(options={})
+      args = options.map{|k,v| "#{k}=#{v}"}.join('&')
+      get("/statuses/user_timeline.json?#{args}")
+    end
+    alias :user :user_timeline
+    
+    # Returns the 20 most recent @replies (status updates prefixed with @username) for the authenticating user.
+    def mentions(options={})
+      args = options.map{|k,v| "#{k}=#{v}"}.join('&')
+      get("/statuses/mentions.json?#{args}")
+    end
+    alias :replies :mentions
+    
+    # Returns the 20 most recent retweets posted by the authenticating user
+    def retweeted_by_me(options={})
+      args = options.map{|k,v| "#{k}=#{v}"}.join('&')
+      get("/statuses/retweeted_by_me.json?#{args}")
+    end
+    
+    # Returns the 20 most recent retweets posted by the authenticating user's friends.
+    def retweeted_to_me(options={})
+      args = options.map{|k,v| "#{k}=#{v}"}.join('&')
+      get("/statuses/retweeted_to_me.json?#{args}")
+    end
+    
+    # Returns the 20 most recent tweets of the authenticated user that have been retweeted by others.
+    def retweets_of_me(options={})
+      args = options.map{|k,v| "#{k}=#{v}"}.join('&')
+      get("/statuses/retweets_of_me.json?#{args}")
+    end
+    
+  end
+end

data/lib/twitter_oauth/trends.rb

@@ -0,0 +1,25 @@
+module TwitterOAuth
+  class Client
+    
+    # Returns the top ten topics that are currently trending on Twitter.
+    def trends
+      get("/trends.json")
+    end
+    
+    # Returns the locations that Twitter has trending topic information for. 
+    # The response is an array of "locations" that encode the location's WOEID (a Yahoo! Where On Earth ID)
+    # and some other human-readable information such as a canonical name and country the location belongs in.
+    def trends_available
+      get("/trends/available.json")
+    end
+    
+    # Returns the top 10 trending topics for a specific location Twitter has trending topic information for. 
+    # The response is an array of "trend" objects that encode the name of the trending topic, the query 
+    # parameter that can be used to search for the topic on Search, and the direct URL that can be issued against Search. 
+    # This information is cached for five minutes, and therefore users are discouraged from querying these endpoints 
+    # faster than once every five minutes.  Global trends information is also available from this API by using a WOEID of 1.
+    def trends_for_location(woeid)
+      get("/trends/woeid.json")
+    end
+  end
+end

data/lib/twitter_oauth/user.rb

@@ -0,0 +1,60 @@
+module TwitterOAuth
+  class Client
+     
+    # Returns the 100 last friends
+    # The page parameter is implemented for legacy reasons, but use of this is slow
+    # as passing page is no longer supported by the Twitter API as the use of cursors
+    # is now obligitory. It is recommended that you use all_friends instead
+    def friends(page=1)
+      return get("/statuses/friends.json?page=#{page}") if page == 1
+      users = []
+      cursor = "-1"
+      page.times do 
+        return [] if cursor == 0 
+        json = get("/statuses/friends.json?cursor=#{cursor}")
+        cursor = json["next_cursor"]
+        users = json["users"]
+      end
+      users
+    end 
+
+    # Returns all pages of friends
+    def all_friends
+      users = []
+      cursor = "-1"
+      while cursor != 0 do 
+        json = get("/statuses/friends.json?cursor=#{cursor}")
+        cursor = json["next_cursor"]
+        users += json["users"]
+      end
+      users
+    end
+    
+    # Returns the 100 last followers
+    def followers(page=1)
+      return get("/statuses/followers.json?page=#{page}") if page == 1
+      users = []
+      cursor = "-1"
+      page.times do 
+        return [] if cursor == 0 
+        json = get("/statuses/followers.json?cursor=#{cursor}")
+        cursor = json["next_cursor"]
+        users = json["users"]
+      end
+      users
+    end 
+
+    # Returns all pages of followers
+    def all_followers
+      users = []
+      cursor = "-1"
+      while cursor != 0 do 
+        json = get("/statuses/followers.json?cursor=#{cursor}")
+        cursor = json["next_cursor"]
+        users += json["users"]
+      end
+      users
+    end
+
+  end
+end

data/lib/twitter_oauth/utils.rb

@@ -0,0 +1,34 @@
+module TwitterOAuth
+  class Client
+    CRLF = "\r\n"
+    
+    private
+      # Properly encodes images in form/multipart specification for upload via OAuth.
+      def http_multipart_data(params)
+        body    = ""
+        headers = {}
+        
+        boundary = Time.now.to_i.to_s(16)
+        
+        headers["Content-Type"] = "multipart/form-data; boundary=#{boundary}"
+        params.each do |key,value|
+          esc_key = OAuth::Helper.escape(key.to_s)
+          body <<  "--#{boundary}#{CRLF}"
+          
+          if value.respond_to?(:read)
+            mime_type = MIME::Types.type_for(value.path)[0] || MIME::Types["application/octet-stream"][0]
+            body << "Content-Disposition: form-data; name=\"#{esc_key}\"; filename=\"#{File.basename(value.path)}\"#{CRLF}"
+            body << "Content-Type: #{mime_type.simplified}#{CRLF*2}"
+            body << value.read
+          else
+            body << "Content-Disposition: form-data; name=\"#{esc_key}\"#{CRLF*2}#{value}"
+          end
+        end
+        
+        body << "--#{boundary}--#{CRLF*2}"
+        headers["Content-Length"] = body.size.to_s
+        
+        return [ body, headers ]
+      end
+  end
+end

metadata

@@ -0,0 +1,162 @@
+--- !ruby/object:Gem::Specification 
+name: rorra-twitter_oauth
+version: !ruby/object:Gem::Version 
+  hash: 9
+  prerelease: false
+  segments: 
+  - 0
+  - 4
+  - 3
+  version: 0.4.3
+platform: ruby
+authors: 
+- Richard Taylor
+- Rodrigo Dominguez
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-08-11 00:00:00 -03:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: oauth
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 13
+        segments: 
+        - 0
+        - 4
+        - 1
+        version: 0.4.1
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 1
+        segments: 
+        - 1
+        - 1
+        - 9
+        version: 1.1.9
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: mime-types
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 47
+        segments: 
+        - 1
+        - 16
+        version: "1.16"
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: shoulda
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id005
+description: twitter_oauth is a Ruby client for the Twitter API using OAuth.
+email: rorra@rorra.com.ar
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- LICENSE
+- README.textile
+- lib/twitter_oauth.rb
+- lib/twitter_oauth/account.rb
+- lib/twitter_oauth/blocks.rb
+- lib/twitter_oauth/client.rb
+- lib/twitter_oauth/direct_messages.rb
+- lib/twitter_oauth/favorites.rb
+- lib/twitter_oauth/friendships.rb
+- lib/twitter_oauth/geo.rb
+- lib/twitter_oauth/lists.rb
+- lib/twitter_oauth/notifications.rb
+- lib/twitter_oauth/saved_searches.rb
+- lib/twitter_oauth/search.rb
+- lib/twitter_oauth/spam.rb
+- lib/twitter_oauth/status.rb
+- lib/twitter_oauth/timeline.rb
+- lib/twitter_oauth/trends.rb
+- lib/twitter_oauth/user.rb
+- lib/twitter_oauth/utils.rb
+has_rdoc: true
+homepage: http://github.com/rorra/twitter_oauth
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: twitter_oauth
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 2
+summary: twitter_oauth is a Ruby client for the Twitter API using OAuth.
+test_files: []
+