t 0.9.9 → 1.0.0

data/README.md

@@ -2,7 +2,10 @@
 
 [icon]: https://github.com/sferik/t/raw/master/icon/t.png
 
-# Twitter CLI [![Build Status](https://secure.travis-ci.org/sferik/t.png?branch=master)][travis] [![Dependency Status](https://gemnasium.com/sferik/t.png?travis)][gemnasium] [![Click here to make a donation to T](http://www.pledgie.com/campaigns/17330.png)][pledgie]
+# Twitter CLI
+[![Build Status](https://secure.travis-ci.org/sferik/t.png?branch=master)][travis]
+[![Dependency Status](https://gemnasium.com/sferik/t.png?travis)][gemnasium]
+[![Click here to make a donation to T](http://www.pledgie.com/campaigns/17330.png)][pledgie]
 
 ### A command-line power tool for Twitter.
 
@@ -15,28 +18,53 @@ offers vastly more commands and capabilities than are available via SMS.
 [sms]: https://support.twitter.com/articles/14020-twitter-sms-command
 
 ## Installation
-    gem install t # Requires Ruby :)
+
+First, make sure you have Ruby installed.
+
+**On a Mac**, open `/Applications/Utilities/Terminal.app` and type:
+
+    ruby -v
+
+If the output looks something like this, you're in good shape:
+
+    ruby 1.9.3p194 (2012-04-20 revision 35410) [x86_64-darwin12.0.0]
+
+If the output looks more like this, you need to [install Ruby][ruby]:
+
+    ruby: command not found
+
+**On Windows**, you can install Ruby with [RubyInstaller][].
+
+Once you've verified that Ruby is installed:
+
+    gem install t
+
+[ruby]: http://www.ruby-lang.org/en/downloads/
+[rubyinstaller]: http://rubyinstaller.org/
 
 ## Configuration
 
-Twitter requires OAuth for most of its functionality, so you'll need to
-register a new application at <http://dev.twitter.com/apps/new>. Once you
-create your application, make sure to set your application's Access Level to
-"Read, Write and Access direct messages", otherwise you may receive an error
-that looks something like this:
+Twitter requires OAuth for most of its functionality, so you'll need a
+registered Twitter application. If you've never registered a Twitter
+application before, it's easy! Just sign-in using your Twitter account and the
+fill out the short form at <http://dev.twitter.com/apps/new>. If you've
+previously registered a Twitter application, it should be listed at
+<http://dev.twitter.com/apps>. Once you've registered an application, make sure
+to set your application's Access Level to "Read, Write and Access direct
+messages", otherwise you'll receive an error that looks like this:
 
     Read-only application cannot POST
 
-Once you've successfully registered your application, you'll be given a
-consumer key and secret, which you can use to authorize your Twitter account.
+Now, you're ready to authorize a Twitter account with your application. To
+proceed, type the following command at the prompt and follow the instructions:
 
-    t authorize -c YOUR_CONSUMER_KEY -s YOUR_CONSUMER_SECRET
+    t authorize
 
-This command directs you to a URL where you can sign-in to Twitter and then
-enter the returned PIN back into the terminal. If you type the PIN correctly,
-you should now be authorized to use `t` as that user. To authorize multiple
-accounts, simply repeat the last step, signing into Twitter as a different
-user.
+This command will direct you to a URL where you can sign-in to Twitter,
+authorize the application, and then enter the returned PIN back into the
+terminal. If you type the PIN correctly, you should now be authorized to use
+`t` as that user. To authorize multiple accounts, simply repeat the last step,
+signing into Twitter as a different user.
 
 You can see a list of all the accounts you've authorized by typing the command:
 
@@ -108,14 +136,17 @@ example, send a user a direct message only if he already follows you:
     t lists -l
 
 ### List all your friends, in long format, ordered by number of followers
-    t friends -lf
+    t friends -l --sort=followers
 
 ### List all your leaders (people you follow who don't follow you back)
-    t leaders -lf
+    t leaders -l --sort=followers
 
 ### Unfollow everyone you follow who doesn't follow you back
     t leaders | xargs t unfollow
 
+### Unfollow 10 people who haven't tweeted in the longest time
+    t followings -l --sort=tweeted | head -10 | awk '{print $1}' | xargs t unfollow
+
 ### Twitter roulette: randomly follow someone who follows you (who you don't already follow)
     t groupies | shuf | head -1 | xargs t follow
 
@@ -154,12 +185,12 @@ example, send a user a direct message only if he already follows you:
 
 ## Features
 * Deep search: Instead of using the Twitter Search API, [which only only goes
-  back 6-9 days][index], `t search` fetches up to 3,200 tweets via the REST API
+  back 6-9 days][search], `t search` fetches up to 3,200 tweets via the REST API
   and then checks each one against a regular expression.
-* Multithreaded: Whenever possible, Twitter API requests are made in parallel,
+* Multi-threaded: Whenever possible, Twitter API requests are made in parallel,
   resulting in faster performance for bulk operations.
 * Designed for Unix: Output is designed to be piped to other Unix utilities,
-  like grep, cut, awk, bc, wc, and xargs for advanced text processing.
+  like grep, comm, cut, awk, bc, wc, and xargs for advanced text processing.
 * Generate spreadsheets: Convert the output of any command to CSV format simply
   by adding the `--csv` flag.
 * 95% C0 Code Coverage: Well tested, with a 2.5:1 test-to-code ratio.

data/bin/t

@@ -18,7 +18,8 @@ rescue OAuth::Unauthorized
   pute "Authorization failed"
   exit 1
 rescue Twitter::Error::Unauthorized => error
-  pute "#{error.message} Run `#{$0} authorize --consumer-key=CONSUMER_KEY --consumer-secret=CONSUMER_SECRET` to authorize."
+  pute error.message
+  pute "Run `#{$0} authorize` to authorize."
   exit 1
 rescue Twitter::Error => error
   pute error.message

data/lib/t.rb

@@ -1,16 +1,9 @@
-require 'active_support/string_inquirer'
 require 't/cli'
 require 'time'
 
 module T
   class << self
 
-    attr_reader :env
-
-    def env=(environment)
-      @env = ActiveSupport::StringInquirer.new(environment)
-    end
-
     # Convert time to local time by applying the `utc_offset` setting.
     def local_time(time)
       utc_offset ? (time.utc + utc_offset) : time.localtime

data/lib/t/cli.rb

@@ -1,29 +1,28 @@
+# encoding: utf-8
+require 'oauth'
 require 'thor'
 require 'twitter'
+require 't/collectable'
+require 't/delete'
+require 't/list'
+require 't/printable'
+require 't/rcfile'
+require 't/requestable'
+require 't/search'
+require 't/set'
+require 't/stream'
+require 't/utils'
 
 module T
-  autoload :Authorizable, 't/authorizable'
-  autoload :Collectable, 't/collectable'
-  autoload :Delete, 't/delete'
-  autoload :FormatHelpers, 't/format_helpers'
-  autoload :List, 't/list'
-  autoload :Printable, 't/printable'
-  autoload :RCFile, 't/rcfile'
-  autoload :Requestable, 't/requestable'
-  autoload :Search, 't/search'
-  autoload :Set, 't/set'
-  autoload :Stream, 't/stream'
-  autoload :Version, 't/version'
   class CLI < Thor
-    include T::Authorizable
     include T::Collectable
     include T::Printable
     include T::Requestable
-    include T::FormatHelpers
+    include T::Utils
 
+    DEFAULT_HOST = 'api.twitter.com'
+    DEFAULT_PROTOCOL = 'https'
     DEFAULT_NUM_RESULTS = 20
-    MAX_SCREEN_NAME_SIZE = 20
-    MAX_USERS_PER_REQUEST = 100
     DIRECT_MESSAGE_HEADINGS = ["ID", "Posted at", "Screen name", "Text"]
     TREND_HEADINGS = ["WOEID", "Parent ID", "Type", "Name", "Country"]
 
@@ -32,11 +31,11 @@ module T
     option "host", :aliases => "-H", :type => :string, :default => DEFAULT_HOST, :desc => "Twitter API server"
     option "no-color", :aliases => "-N", :type => :boolean, :desc => "Disable colorization in output"
     option "no-ssl", :aliases => "-U", :type => :boolean, :default => false, :desc => "Disable SSL"
-    option "profile", :aliases => "-P", :type => :string, :default => File.join(File.expand_path("~"), RCFile::FILE_NAME), :desc => "Path to RC file", :banner => "FILE"
+    option "profile", :aliases => "-P", :type => :string, :default => File.join(File.expand_path("~"), T::RCFile::FILE_NAME), :desc => "Path to RC file", :banner => "FILE"
 
     def initialize(*)
+      @rcfile = T::RCFile.instance
       super
-      @rcfile = RCFile.instance
     end
 
     desc "accounts", "List accounts"
@@ -51,63 +50,75 @@ module T
     end
 
     desc "authorize", "Allows an application to request user authorization"
-    method_option "consumer-key", :aliases => "-c", :required => true, :desc => "This can be found at https://dev.twitter.com/apps", :banner => "KEY"
-    method_option "consumer-secret", :aliases => "-s", :required => true, :desc => "This can be found at https://dev.twitter.com/apps", :banner => "SECRET"
     method_option "display-url", :aliases => "-d", :type => :boolean, :default => false, :desc => "Display the authorization URL instead of attempting to open it."
-    method_option "prompt", :aliases => "-p", :type => :boolean, :default => true
     def authorize
-      request_token = consumer.get_request_token
-      url = generate_authorize_url(request_token)
-      if options['prompt']
-        say "In a moment, you will be directed to the Twitter app authorization page."
-        say "Perform the following steps to complete the authorization process:"
-        say "  1. Sign in to Twitter"
-        say "  2. Press \"Authorize app\""
-        say "  3. Copy or memorize the supplied PIN"
-        say "  4. Return to the terminal to enter the PIN"
+      @rcfile.path = options['profile'] if options['profile']
+      if @rcfile.empty?
+        say "Welcome! Before you can use t, you'll first need to register an"
+        say "application with Twitter. Just follow the steps below:"
+        say "  1. Sign in to the Twitter Developer site and click"
+        say "     \"Create a new application\"."
+        say "  2. Complete the required fields and submit the form."
+        say "     Note: Your application must have a unique name."
+        say "     We recommend: \"<your handle>/t\"."
+        say "  3. Go to the Settings tab of your application, and change the"
+        say "     Access setting to \"Read, Write and Access direct messages\"."
+        say "  4. Go to the Details tab to view the consumer key and secret,"
+        say "     which you'll need to copy and paste below when prompted."
         say
-        ask "Press [Enter] to open the Twitter app authorization page."
+        ask "Press [Enter] to open the Twitter Developer site."
+        say
+      else
+        say "It looks like you've already registered an application with Twitter."
+        say "To authorize a new account, just follow the steps below:"
+        say "  1. Sign in to the Twitter Developer site."
+        say "  2. Select the application for which you'd like to authorize an account."
+        say "  3. Copy and paste the consumer key and secret below when prompted."
+        say
+        ask "Press [Enter] to open the Twitter Developer site."
         say
       end
       require 'launchy'
+      Launchy.open("https://dev.twitter.com/apps", :dry_run => options['display-url'])
+      key = ask "Enter your consumer key:"
+      secret = ask "Enter your consumer secret:"
+      consumer = OAuth::Consumer.new(key, secret, :site => base_url)
+      request_token = consumer.get_request_token
+      url = generate_authorize_url(consumer, request_token)
+      say
+      say "In a moment, you will be directed to the Twitter app authorization page."
+      say "Perform the following steps to complete the authorization process:"
+      say "  1. Sign in to Twitter."
+      say "  2. Press \"Authorize app\"."
+      say "  3. Copy and paste the supplied PIN below when prompted."
+      say
+      ask "Press [Enter] to open the Twitter app authorization page."
+      say
       Launchy.open(url, :dry_run => options['display-url'])
-      pin = ask "Paste in the supplied PIN:"
+      pin = ask "Enter the supplied PIN:"
       access_token = request_token.get_access_token(:oauth_verifier => pin.chomp)
       oauth_response = access_token.get('/1/account/verify_credentials.json')
       screen_name = oauth_response.body.match(/"screen_name"\s*:\s*"(.*?)"/).captures.first
-      @rcfile.path = options['profile'] if options['profile']
       @rcfile[screen_name] = {
-        options['consumer-key'] => {
+        key => {
           'username' => screen_name,
-          'consumer_key' => options['consumer-key'],
-          'consumer_secret' => options['consumer-secret'],
+          'consumer_key' => key,
+          'consumer_secret' => secret,
           'token' => access_token.token,
           'secret' => access_token.secret,
         }
       }
-      @rcfile.active_profile = {'username' => screen_name, 'consumer_key' => options['consumer-key']}
+      @rcfile.active_profile = {'username' => screen_name, 'consumer_key' => key}
       say "Authorization successful."
     end
 
     desc "block USER [USER...]", "Block users."
     method_option "id", :aliases => "-i", :type => "boolean", :default => false, :desc => "Specify input as Twitter user IDs instead of screen names."
     def block(user, *users)
-      users.unshift(user)
-      require 't/core_ext/string'
-      if options['id']
-        users.map!(&:to_i)
-      else
-        users.map!(&:strip_ats)
-      end
-      require 't/core_ext/enumerable'
-      require 'retryable'
-      users = users.threaded_map do |user|
-        retryable(:tries => 3, :on => Twitter::Error::ServerError, :sleep => 0) do
-          client.block(user)
-        end
+      users, number = fetch_users(users.unshift(user), options) do |users|
+        client.block(users)
       end
-      number = users.length
-      say "@#{@rcfile.active_profile[0]} blocked #{number} #{number == 1 ? 'user' : 'users'}."
+      say "@#{@rcfile.active_profile[0]} blocked #{pluralize(number, 'user')}."
       say
       say "Run `#{File.basename($0)} delete block #{users.map{|user| "@#{user.screen_name}"}.join(' ')}` to unblock."
     end
@@ -139,13 +150,13 @@ module T
         print_table_with_headings(array, DIRECT_MESSAGE_HEADINGS, format)
       else
         direct_messages.each do |direct_message|
-          say "#{direct_message.sender.screen_name.rjust(MAX_SCREEN_NAME_SIZE)}: #{direct_message.text.gsub(/\n+/, ' ')} (#{time_ago_in_words(direct_message.created_at)} ago)"
+          print_message(direct_message.sender.screen_name, direct_message.text)
         end
       end
     end
     map %w(directmessages dms) => :direct_messages
 
-    desc "direct_messages_sent", "Returns the #{DEFAULT_NUM_RESULTS} most recent Direct Messages sent to you."
+    desc "direct_messages_sent", "Returns the #{DEFAULT_NUM_RESULTS} most recent Direct Messages you've sent."
     method_option "csv", :aliases => "-c", :type => :boolean, :default => false, :desc => "Output in CSV format."
     method_option "long", :aliases => "-l", :type => :boolean, :default => false, :desc => "Output in long format."
     method_option "number", :aliases => "-n", :type => :numeric, :default => DEFAULT_NUM_RESULTS, :desc => "Limit the number of results."
@@ -172,7 +183,7 @@ module T
         print_table_with_headings(array, DIRECT_MESSAGE_HEADINGS, format)
       else
         direct_messages.each do |direct_message|
-          say "#{direct_message.recipient.screen_name.rjust(MAX_SCREEN_NAME_SIZE)}: #{direct_message.text.gsub(/\n+/, ' ')} (#{time_ago_in_words(direct_message.created_at)} ago)"
+          print_message(direct_message.recipient.screen_name, direct_message.text)
         end
       end
     end
@@ -180,15 +191,10 @@ module T
 
     desc "groupies [USER]", "Returns the list of people who follow you but you don't follow back."
     method_option "csv", :aliases => "-c", :type => :boolean, :default => false, :desc => "Output in CSV format."
-    method_option "favorites", :aliases => "-v", :type => :boolean, :default => false, :desc => "Sort by number of favorites."
-    method_option "followers", :aliases => "-f", :type => :boolean, :default => false, :desc => "Sort by number of followers."
-    method_option "friends", :aliases => "-e", :type => :boolean, :default => false, :desc => "Sort by number of friends."
     method_option "id", :aliases => "-i", :type => "boolean", :default => false, :desc => "Specify user via ID instead of screen name."
-    method_option "listed", :aliases => "-d", :type => :boolean, :default => false, :desc => "Sort by number of list memberships."
     method_option "long", :aliases => "-l", :type => :boolean, :default => false, :desc => "Output in long format."
-    method_option "posted", :aliases => "-p", :type => :boolean, :default => false, :desc => "Sort by the time when Twitter account was posted."
     method_option "reverse", :aliases => "-r", :type => :boolean, :default => false, :desc => "Reverse the order of the sort."
-    method_option "tweets", :aliases => "-t", :type => :boolean, :default => false, :desc => "Sort by number of Tweets."
+    method_option "sort", :aliases => "-s", :type => :string, :enum => %w(favorites followers friends listed screen_name since tweets tweeted), :default => "screen_name", :desc => "Specify the order of the results.", :banner => "ORDER"
     method_option "unsorted", :aliases => "-u", :type => :boolean, :default => false, :desc => "Output is not sorted."
     def groupies(user=nil)
       if user
@@ -199,21 +205,21 @@ module T
           user.strip_ats
         end
       end
-      follower_ids = collect_with_cursor do |cursor|
-        client.follower_ids(user, :cursor => cursor)
+      follower_ids = Thread.new do
+        collect_with_cursor do |cursor|
+          client.follower_ids(user, :cursor => cursor)
+        end
       end
-      following_ids = collect_with_cursor do |cursor|
-        client.friend_ids(user, :cursor => cursor)
+      following_ids = Thread.new do
+        collect_with_cursor do |cursor|
+          client.friend_ids(user, :cursor => cursor)
+        end
       end
-      disciple_ids = (follower_ids - following_ids)
-      require 'active_support/core_ext/array/grouping'
-      require 't/core_ext/enumerable'
+      disciple_ids = (follower_ids.value - following_ids.value)
       require 'retryable'
-      users = disciple_ids.in_groups_of(MAX_USERS_PER_REQUEST, false).threaded_map do |disciple_id_group|
-        retryable(:tries => 3, :on => Twitter::Error::ServerError, :sleep => 0) do
-          client.users(disciple_id_group)
-        end
-      end.flatten
+      users = retryable(:tries => 3, :on => Twitter::Error::ServerError, :sleep => 0) do
+        client.users(disciple_ids)
+      end
       print_users(users)
     end
     map %w(disciples) => :groupies
@@ -228,25 +234,14 @@ module T
         user.strip_ats
       end
       direct_message = client.direct_message_create(user, message)
-      say "Direct Message sent from @#{@rcfile.active_profile[0]} to @#{direct_message.recipient.screen_name} (#{time_ago_in_words(direct_message.created_at)} ago)."
+      say "Direct Message sent from @#{@rcfile.active_profile[0]} to @#{direct_message.recipient.screen_name}."
     end
     map %w(d m) => :dm
 
     desc "does_contain [USER/]LIST USER", "Find out whether a list contains a user."
     method_option "id", :aliases => "-i", :type => "boolean", :default => false, :desc => "Specify user via ID instead of screen name."
     def does_contain(list, user=nil)
-      owner, list = list.split('/')
-      if list.nil?
-        list = owner
-        owner = @rcfile.active_profile[0]
-      else
-        require 't/core_ext/string'
-        owner = if options['id']
-          client.user(owner.to_i).screen_name
-        else
-          owner.strip_ats
-        end
-      end
+      owner, list = extract_owner(list, options)
       if user.nil?
         user = @rcfile.active_profile[0]
       else
@@ -258,9 +253,9 @@ module T
         end
       end
       if client.list_member?(owner, list, user)
-        say "Yes, @#{owner}/#{list} contains @#{user}."
+        say "Yes, #{list} contains @#{user}."
       else
-        say "No, @#{owner}/#{list} does not contain @#{user}."
+        say "No, #{list} does not contain @#{user}."
         exit 1
       end
     end
@@ -297,15 +292,12 @@ module T
     def favorite(status_id, *status_ids)
       status_ids.unshift(status_id)
       status_ids.map!(&:to_i)
-      require 't/core_ext/enumerable'
       require 'retryable'
-      favorites = status_ids.threaded_map do |status_id|
-        retryable(:tries => 3, :on => Twitter::Error::ServerError, :sleep => 0) do
-          client.favorite(status_id)
-        end
+      favorites = retryable(:tries => 3, :on => Twitter::Error::ServerError, :sleep => 0) do
+        client.favorite(status_ids)
       end
       number = favorites.length
-      say "@#{@rcfile.active_profile[0]} favorited #{number} #{number == 1 ? 'tweet' : 'tweets'}."
+      say "@#{@rcfile.active_profile[0]} favorited #{pluralize(number, 'tweet')}."
       say
       say "Run `#{File.basename($0)} delete favorite #{status_ids.join(' ')}` to unfavorite."
     end
@@ -337,37 +329,20 @@ module T
     desc "follow USER [USER...]", "Allows you to start following users."
     method_option "id", :aliases => "-i", :type => "boolean", :default => false, :desc => "Specify input as Twitter user IDs instead of screen names."
     def follow(user, *users)
-      users.unshift(user)
-      require 't/core_ext/string'
-      if options['id']
-        users.map!(&:to_i)
-      else
-        users.map!(&:strip_ats)
-      end
-      require 't/core_ext/enumerable'
-      require 'retryable'
-      users = users.threaded_map do |user|
-        retryable(:tries => 3, :on => Twitter::Error::ServerError, :sleep => 0) do
-          client.follow(user)
-        end
+      users, number = fetch_users(users.unshift(user), options) do |users|
+        client.follow(users)
       end
-      number = users.length
-      say "@#{@rcfile.active_profile[0]} is now following #{number} more #{number == 1 ? 'user' : 'users'}."
+      say "@#{@rcfile.active_profile[0]} is now following #{pluralize(number, 'more user')}."
       say
       say "Run `#{File.basename($0)} unfollow #{users.map{|user| "@#{user.screen_name}"}.join(' ')}` to stop."
     end
 
     desc "followings [USER]", "Returns a list of the people you follow on Twitter."
     method_option "csv", :aliases => "-c", :type => :boolean, :default => false, :desc => "Output in CSV format."
-    method_option "favorites", :aliases => "-v", :type => :boolean, :default => false, :desc => "Sort by number of favorites."
-    method_option "followers", :aliases => "-f", :type => :boolean, :default => false, :desc => "Sort by number of followers."
-    method_option "friends", :aliases => "-e", :type => :boolean, :default => false, :desc => "Sort by number of friends."
     method_option "id", :aliases => "-i", :type => "boolean", :default => false, :desc => "Specify user via ID instead of screen name."
-    method_option "listed", :aliases => "-d", :type => :boolean, :default => false, :desc => "Sort by number of list memberships."
     method_option "long", :aliases => "-l", :type => :boolean, :default => false, :desc => "Output in long format."
-    method_option "posted", :aliases => "-p", :type => :boolean, :default => false, :desc => "Sort by the time when Twitter account was posted."
     method_option "reverse", :aliases => "-r", :type => :boolean, :default => false, :desc => "Reverse the order of the sort."
-    method_option "tweets", :aliases => "-t", :type => :boolean, :default => false, :desc => "Sort by number of Tweets."
+    method_option "sort", :aliases => "-s", :type => :string, :enum => %w(favorites followers friends listed screen_name since tweets tweeted), :default => "screen_name", :desc => "Specify the order of the results.", :banner => "ORDER"
     method_option "unsorted", :aliases => "-u", :type => :boolean, :default => false, :desc => "Output is not sorted."
     def followings(user=nil)
       if user
@@ -381,28 +356,19 @@ module T
       following_ids = collect_with_cursor do |cursor|
         client.friend_ids(user, :cursor => cursor)
       end
-      require 'active_support/core_ext/array/grouping'
-      require 't/core_ext/enumerable'
       require 'retryable'
-      users = following_ids.in_groups_of(MAX_USERS_PER_REQUEST, false).threaded_map do |following_id_group|
-        retryable(:tries => 3, :on => Twitter::Error::ServerError, :sleep => 0) do
-          client.users(following_id_group)
-        end
-      end.flatten
+      users = retryable(:tries => 3, :on => Twitter::Error::ServerError, :sleep => 0) do
+        client.users(following_ids)
+      end
       print_users(users)
     end
 
     desc "followers [USER]", "Returns a list of the people who follow you on Twitter."
     method_option "csv", :aliases => "-c", :type => :boolean, :default => false, :desc => "Output in CSV format."
-    method_option "favorites", :aliases => "-v", :type => :boolean, :default => false, :desc => "Sort by number of favorites."
-    method_option "followers", :aliases => "-f", :type => :boolean, :default => false, :desc => "Sort by number of followers."
-    method_option "friends", :aliases => "-e", :type => :boolean, :default => false, :desc => "Sort by number of friends."
     method_option "id", :aliases => "-i", :type => "boolean", :default => false, :desc => "Specify user via ID instead of screen name."
-    method_option "listed", :aliases => "-d", :type => :boolean, :default => false, :desc => "Sort by number of list memberships."
     method_option "long", :aliases => "-l", :type => :boolean, :default => false, :desc => "Output in long format."
-    method_option "posted", :aliases => "-p", :type => :boolean, :default => false, :desc => "Sort by the time when Twitter account was posted."
     method_option "reverse", :aliases => "-r", :type => :boolean, :default => false, :desc => "Reverse the order of the sort."
-    method_option "tweets", :aliases => "-t", :type => :boolean, :default => false, :desc => "Sort by number of Tweets."
+    method_option "sort", :aliases => "-s", :type => :string, :enum => %w(favorites followers friends listed screen_name since tweets tweeted), :default => "screen_name", :desc => "Specify the order of the results.", :banner => "ORDER"
     method_option "unsorted", :aliases => "-u", :type => :boolean, :default => false, :desc => "Output is not sorted."
     def followers(user=nil)
       if user
@@ -416,28 +382,19 @@ module T
       follower_ids = collect_with_cursor do |cursor|
         client.follower_ids(user, :cursor => cursor)
       end
-      require 'active_support/core_ext/array/grouping'
-      require 't/core_ext/enumerable'
       require 'retryable'
-      users = follower_ids.in_groups_of(MAX_USERS_PER_REQUEST, false).threaded_map do |follower_id_group|
-        retryable(:tries => 3, :on => Twitter::Error::ServerError, :sleep => 0) do
-          client.users(follower_id_group)
-        end
-      end.flatten
+      users = retryable(:tries => 3, :on => Twitter::Error::ServerError, :sleep => 0) do
+        client.users(follower_ids)
+      end
       print_users(users)
     end
 
     desc "friends [USER]", "Returns the list of people who you follow and follow you back."
     method_option "csv", :aliases => "-c", :type => :boolean, :default => false, :desc => "Output in CSV format."
-    method_option "favorites", :aliases => "-v", :type => :boolean, :default => false, :desc => "Sort by number of favorites."
-    method_option "followers", :aliases => "-f", :type => :boolean, :default => false, :desc => "Sort by number of followers."
-    method_option "friends", :aliases => "-e", :type => :boolean, :default => false, :desc => "Sort by number of friends."
     method_option "id", :aliases => "-i", :type => "boolean", :default => false, :desc => "Specify user via ID instead of screen name."
-    method_option "listed", :aliases => "-d", :type => :boolean, :default => false, :desc => "Sort by number of list memberships."
     method_option "long", :aliases => "-l", :type => :boolean, :default => false, :desc => "Output in long format."
-    method_option "posted", :aliases => "-p", :type => :boolean, :default => false, :desc => "Sort by the time when Twitter account was posted."
     method_option "reverse", :aliases => "-r", :type => :boolean, :default => false, :desc => "Reverse the order of the sort."
-    method_option "tweets", :aliases => "-t", :type => :boolean, :default => false, :desc => "Sort by number of Tweets."
+    method_option "sort", :aliases => "-s", :type => :string, :enum => %w(favorites followers friends listed screen_name since tweets tweeted), :default => "screen_name", :desc => "Specify the order of the results.", :banner => "ORDER"
     method_option "unsorted", :aliases => "-u", :type => :boolean, :default => false, :desc => "Output is not sorted."
     def friends(user=nil)
       if user
@@ -448,35 +405,30 @@ module T
           user.strip_ats
         end
       end
-      following_ids = collect_with_cursor do |cursor|
-        client.friend_ids(user, :cursor => cursor)
+      following_ids = Thread.new do
+        collect_with_cursor do |cursor|
+          client.friend_ids(user, :cursor => cursor)
+        end
       end
-      follower_ids = collect_with_cursor do |cursor|
-        client.follower_ids(user, :cursor => cursor)
+      follower_ids = Thread.new do
+        collect_with_cursor do |cursor|
+          client.follower_ids(user, :cursor => cursor)
+        end
       end
-      friend_ids = (following_ids & follower_ids)
-      require 'active_support/core_ext/array/grouping'
-      require 't/core_ext/enumerable'
+      friend_ids = (following_ids.value & follower_ids.value)
       require 'retryable'
-      users = friend_ids.in_groups_of(MAX_USERS_PER_REQUEST, false).threaded_map do |friend_id_group|
-        retryable(:tries => 3, :on => Twitter::Error::ServerError, :sleep => 0) do
-          client.users(friend_id_group)
-        end
-      end.flatten
+      users = retryable(:tries => 3, :on => Twitter::Error::ServerError, :sleep => 0) do
+        client.users(friend_ids)
+      end
       print_users(users)
     end
 
     desc "leaders [USER]", "Returns the list of people who you follow but don't follow you back."
     method_option "csv", :aliases => "-c", :type => :boolean, :default => false, :desc => "Output in CSV format."
-    method_option "favorites", :aliases => "-v", :type => :boolean, :default => false, :desc => "Sort by number of favorites."
-    method_option "followers", :aliases => "-f", :type => :boolean, :default => false, :desc => "Sort by number of followers."
-    method_option "friends", :aliases => "-e", :type => :boolean, :default => false, :desc => "Sort by number of friends."
     method_option "id", :aliases => "-i", :type => "boolean", :default => false, :desc => "Specify user via ID instead of screen name."
-    method_option "listed", :aliases => "-d", :type => :boolean, :default => false, :desc => "Sort by number of list memberships."
     method_option "long", :aliases => "-l", :type => :boolean, :default => false, :desc => "Output in long format."
-    method_option "posted", :aliases => "-p", :type => :boolean, :default => false, :desc => "Sort by the time when Twitter account was posted."
     method_option "reverse", :aliases => "-r", :type => :boolean, :default => false, :desc => "Reverse the order of the sort."
-    method_option "tweets", :aliases => "-t", :type => :boolean, :default => false, :desc => "Sort by number of Tweets."
+    method_option "sort", :aliases => "-s", :type => :string, :enum => %w(favorites followers friends listed screen_name since tweets tweeted), :default => "screen_name", :desc => "Specify the order of the results.", :banner => "ORDER"
     method_option "unsorted", :aliases => "-u", :type => :boolean, :default => false, :desc => "Output is not sorted."
     def leaders(user=nil)
       if user
@@ -487,21 +439,21 @@ module T
           user.strip_ats
         end
       end
-      following_ids = collect_with_cursor do |cursor|
-        client.friend_ids(user, :cursor => cursor)
+      following_ids = Thread.new do
+        collect_with_cursor do |cursor|
+          client.friend_ids(user, :cursor => cursor)
+        end
       end
-      follower_ids = collect_with_cursor do |cursor|
-        client.follower_ids(user, :cursor => cursor)
+      follower_ids = Thread.new do
+        collect_with_cursor do |cursor|
+          client.follower_ids(user, :cursor => cursor)
+        end
       end
-      leader_ids = (following_ids - follower_ids)
-      require 'active_support/core_ext/array/grouping'
-      require 't/core_ext/enumerable'
+      leader_ids = (following_ids.value - follower_ids.value)
       require 'retryable'
-      users = leader_ids.in_groups_of(MAX_USERS_PER_REQUEST, false).threaded_map do |leader_id_group|
-        retryable(:tries => 3, :on => Twitter::Error::ServerError, :sleep => 0) do
-          client.users(leader_id_group)
-        end
-      end.flatten
+      users = retryable(:tries => 3, :on => Twitter::Error::ServerError, :sleep => 0) do
+        client.users(leader_ids)
+      end
       print_users(users)
     end
 
@@ -509,11 +461,8 @@ module T
     method_option "csv", :aliases => "-c", :type => :boolean, :default => false, :desc => "Output in CSV format."
     method_option "id", :aliases => "-i", :type => "boolean", :default => false, :desc => "Specify user via ID instead of screen name."
     method_option "long", :aliases => "-l", :type => :boolean, :default => false, :desc => "Output in long format."
-    method_option "members", :aliases => "-m", :type => :boolean, :default => false, :desc => "Sort by number of members."
-    method_option "mode", :aliases => "-o", :type => :boolean, :default => false, :desc => "Sort by mode."
-    method_option "posted", :aliases => "-p", :type => :boolean, :default => false, :desc => "Sort by the time when Twitter list was posted."
     method_option "reverse", :aliases => "-r", :type => :boolean, :default => false, :desc => "Reverse the order of the sort."
-    method_option "subscribers", :aliases => "-s", :type => :boolean, :default => false, :desc => "Sort by number of subscribers."
+    method_option "sort", :aliases => "-s", :type => :string, :enum => %w(members mode posted slug subscribers), :default => "slug", :desc => "Specify the order of the results.", :banner => "ORDER"
     method_option "unsorted", :aliases => "-u", :type => :boolean, :default => false, :desc => "Output is not sorted."
     def lists(user=nil)
       if user
@@ -593,11 +542,7 @@ module T
       status = client.status(status_id.to_i, :include_my_retweet => false)
       users = Array(status.from_user)
       if options['all']
-        # twitter-text requires $KCODE to be set to UTF8 on Ruby versions < 1.8
-        major, minor, patch = RUBY_VERSION.split('.')
-        $KCODE='u' if major.to_i == 1 && minor.to_i < 9
-        require 'twitter-text'
-        users += Twitter::Extractor.extract_mentioned_screen_names(status.full_text)
+        users += extract_mentioned_screen_names(status.full_text)
         users.uniq!
       end
       require 't/core_ext/string'
@@ -605,7 +550,7 @@ module T
       opts = {:in_reply_to_status_id => status.id, :trim_user => true}
       opts.merge!(:lat => location.lat, :long => location.lng) if options['location']
       reply = client.update("#{users.join(' ')} #{message}", opts)
-      say "Reply created by @#{@rcfile.active_profile[0]} to #{users.join(' ')} (#{time_ago_in_words(reply.created_at)} ago)."
+      say "Reply posted by @#{@rcfile.active_profile[0]} to #{users.join(' ')}."
       say
       say "Run `#{File.basename($0)} delete status #{reply.id}` to delete."
     end
@@ -613,22 +558,10 @@ module T
     desc "report_spam USER [USER...]", "Report users for spam."
     method_option "id", :aliases => "-i", :type => "boolean", :default => false, :desc => "Specify input as Twitter user IDs instead of screen names."
     def report_spam(user, *users)
-      users.unshift(user)
-      require 't/core_ext/string'
-      if options['id']
-        users.map!(&:to_i)
-      else
-        users.map!(&:strip_ats)
-      end
-      require 't/core_ext/enumerable'
-      require 'retryable'
-      users = users.threaded_map do |user|
-        retryable(:tries => 3, :on => Twitter::Error::ServerError, :sleep => 0) do
-          client.report_spam(user)
-        end
+      users, number = fetch_users(users.unshift(user), options) do |users|
+        client.report_spam(users)
       end
-      number = users.length
-      say "@#{@rcfile.active_profile[0]} reported #{number} #{number == 1 ? 'user' : 'users'}."
+      say "@#{@rcfile.active_profile[0]} reported #{pluralize(number, 'user')}."
     end
     map %w(report reportspam spam) => :report_spam
 
@@ -636,15 +569,12 @@ module T
     def retweet(status_id, *status_ids)
       status_ids.unshift(status_id)
       status_ids.map!(&:to_i)
-      require 't/core_ext/enumerable'
       require 'retryable'
-      retweets = status_ids.threaded_map do |status_id|
-        retryable(:tries => 3, :on => Twitter::Error::ServerError, :sleep => 0) do
-          client.retweet(status_id, :trim_user => true)
-        end
+      retweets = retryable(:tries => 3, :on => Twitter::Error::ServerError, :sleep => 0) do
+        client.retweet(status_ids, :trim_user => true)
       end
       number = retweets.length
-      say "@#{@rcfile.active_profile[0]} retweeted #{number} #{number == 1 ? 'tweet' : 'tweets'}."
+      say "@#{@rcfile.active_profile[0]} retweeted #{pluralize(number, 'tweet')}."
       say
       say "Run `#{File.basename($0)} delete status #{retweets.map(&:id).join(' ')}` to undo."
     end
@@ -657,17 +587,21 @@ module T
     method_option "number", :aliases => "-n", :type => :numeric, :default => DEFAULT_NUM_RESULTS, :desc => "Limit the number of results."
     method_option "reverse", :aliases => "-r", :type => :boolean, :default => false, :desc => "Reverse the order of the sort."
     def retweets(user=nil)
-      if user
+      count = options['number'] || DEFAULT_NUM_RESULTS
+      statuses = if user
         require 't/core_ext/string'
         user = if options['id']
           user.to_i
         else
           user.strip_ats
         end
-      end
-      count = options['number'] || DEFAULT_NUM_RESULTS
-      statuses = collect_with_count(count) do |opts|
-        client.retweeted_by(user, opts)
+        collect_with_count(count) do |opts|
+          client.retweeted_by_user(user, opts)
+        end
+      else
+        collect_with_count(count) do |opts|
+          client.retweeted_by_me(opts)
+        end
       end
       print_statuses(statuses)
     end
@@ -683,12 +617,12 @@ module T
     def status(status_id)
       status = client.status(status_id.to_i, :include_my_retweet => false)
       location = if status.place
-        if status.place.name && status.place.attributes && status.place.attributes['street_address'] && status.place.attributes['locality'] && status.place.attributes['region'] && status.place.country
-          [status.place.name, status.place.attributes['street_address'], status.place.attributes['locality'], status.place.attributes['region'], status.place.country].join(", ")
-        elsif status.place.name && status.place.attributes && status.place.attributes['locality'] && status.place.attributes['region'] && status.place.country
-          [status.place.name, status.place.attributes['locality'], status.place.attributes['region'], status.place.country].join(", ")
-        elsif status.place.full_name && status.place.attributes && status.place.attributes['region'] && status.place.country
-          [status.place.full_name, status.place.attributes['region'], status.place.country].join(", ")
+        if status.place.name && status.place.attributes && status.place.attributes[:street_address] && status.place.attributes[:locality] && status.place.attributes[:region] && status.place.country
+          [status.place.name, status.place.attributes[:street_address], status.place.attributes[:locality], status.place.attributes[:region], status.place.country].join(", ")
+        elsif status.place.name && status.place.attributes && status.place.attributes[:locality] && status.place.attributes[:region] && status.place.country
+          [status.place.name, status.place.attributes[:locality], status.place.attributes[:region], status.place.country].join(", ")
+        elsif status.place.full_name && status.place.attributes && status.place.attributes[:region] && status.place.country
+          [status.place.full_name, status.place.attributes[:region], status.place.country].join(", ")
         elsif status.place.full_name && status.place.country
           [status.place.full_name, status.place.country].join(", ")
         elsif status.place.full_name
@@ -721,16 +655,11 @@ module T
 
     desc "suggest [USER]", "Returns a listing of Twitter users' accounts you might enjoy following."
     method_option "csv", :aliases => "-c", :type => :boolean, :default => false, :desc => "Output in CSV format."
-    method_option "favorites", :aliases => "-v", :type => :boolean, :default => false, :desc => "Sort by number of favorites."
-    method_option "followers", :aliases => "-f", :type => :boolean, :default => false, :desc => "Sort by number of followers."
-    method_option "friends", :aliases => "-e", :type => :boolean, :default => false, :desc => "Sort by number of friends."
     method_option "id", :aliases => "-i", :type => "boolean", :default => false, :desc => "Specify user via ID instead of screen name."
-    method_option "listed", :aliases => "-d", :type => :boolean, :default => false, :desc => "Sort by number of list memberships."
     method_option "long", :aliases => "-l", :type => :boolean, :default => false, :desc => "Output in long format."
     method_option "number", :aliases => "-n", :type => :numeric, :default => DEFAULT_NUM_RESULTS, :desc => "Limit the number of results."
-    method_option "posted", :aliases => "-p", :type => :boolean, :default => false, :desc => "Sort by the time when Twitter account was posted."
     method_option "reverse", :aliases => "-r", :type => :boolean, :default => false, :desc => "Reverse the order of the sort."
-    method_option "tweets", :aliases => "-t", :type => :boolean, :default => false, :desc => "Sort by number of Tweets."
+    method_option "sort", :aliases => "-s", :type => :string, :enum => %w(favorites followers friends listed screen_name since tweets tweeted), :default => "screen_name", :desc => "Specify the order of the results.", :banner => "ORDER"
     method_option "unsorted", :aliases => "-u", :type => :boolean, :default => false, :desc => "Output is not sorted."
     def suggest(user=nil)
       if user
@@ -813,22 +742,10 @@ module T
     desc "unfollow USER [USER...]", "Allows you to stop following users."
     method_option "id", :aliases => "-i", :type => "boolean", :default => false, :desc => "Specify input as Twitter user IDs instead of screen names."
     def unfollow(user, *users)
-      users.unshift(user)
-      require 't/core_ext/string'
-      if options['id']
-        users.map!(&:to_i)
-      else
-        users.map!(&:strip_ats)
+      users, number = fetch_users(users.unshift(user), options) do |users|
+        client.unfollow(users)
       end
-      require 't/core_ext/enumerable'
-      require 'retryable'
-      users = users.threaded_map do |user|
-        retryable(:tries => 3, :on => Twitter::Error::ServerError, :sleep => 0) do
-          client.unfollow(user)
-        end
-      end
-      number = users.length
-      say "@#{@rcfile.active_profile[0]} is no longer following #{number} #{number == 1 ? 'user' : 'users'}."
+      say "@#{@rcfile.active_profile[0]} is no longer following #{pluralize(number, 'user')}."
       say
       say "Run `#{File.basename($0)} follow #{users.map{|user| "@#{user.screen_name}"}.join(' ')}` to follow again."
     end
@@ -839,7 +756,7 @@ module T
       opts = {:trim_user => true}
       opts.merge!(:lat => location.lat, :long => location.lng) if options['location']
       status = client.update(message, opts)
-      say "Tweet created by @#{@rcfile.active_profile[0]} (#{time_ago_in_words(status.created_at)} ago)."
+      say "Tweet posted by @#{@rcfile.active_profile[0]}."
       say
       say "Run `#{File.basename($0)} delete status #{status.id}` to delete."
     end
@@ -847,15 +764,10 @@ module T
 
     desc "users USER [USER...]", "Returns a list of users you specify."
     method_option "csv", :aliases => "-c", :type => :boolean, :default => false, :desc => "Output in CSV format."
-    method_option "favorites", :aliases => "-v", :type => :boolean, :default => false, :desc => "Sort by number of favorites."
-    method_option "followers", :aliases => "-f", :type => :boolean, :default => false, :desc => "Sort by number of followers."
-    method_option "friends", :aliases => "-e", :type => :boolean, :default => false, :desc => "Sort by number of friends."
     method_option "id", :aliases => "-i", :type => "boolean", :default => false, :desc => "Specify input as Twitter user IDs instead of screen names."
-    method_option "listed", :aliases => "-d", :type => :boolean, :default => false, :desc => "Sort by number of list memberships."
     method_option "long", :aliases => "-l", :type => :boolean, :default => false, :desc => "Output in long format."
-    method_option "posted", :aliases => "-p", :type => :boolean, :default => false, :desc => "Sort by the time when Twitter account was posted."
     method_option "reverse", :aliases => "-r", :type => :boolean, :default => false, :desc => "Reverse the order of the sort."
-    method_option "tweets", :aliases => "-t", :type => :boolean, :default => false, :desc => "Sort by number of Tweets."
+    method_option "sort", :aliases => "-s", :type => :string, :enum => %w(favorites followers friends listed screen_name since tweets tweeted), :default => "screen_name", :desc => "Specify the order of the results.", :banner => "ORDER"
     method_option "unsorted", :aliases => "-u", :type => :boolean, :default => false, :desc => "Output is not sorted."
     def users(user, *users)
       users.unshift(user)
@@ -872,6 +784,7 @@ module T
 
     desc "version", "Show version."
     def version
+      require 't/version'
       say T::Version
     end
     map %w(-v --version) => :version
@@ -930,6 +843,40 @@ module T
 
   private
 
+    def extract_mentioned_screen_names(text)
+      valid_mention_preceding_chars = /(?:[^a-zA-Z0-9_!#\$%&*@＠]|^|RT:?)/o
+      at_signs = /[@＠]/
+      valid_mentions = /
+        (#{valid_mention_preceding_chars})  # $1: Preceeding character
+        (#{at_signs})                       # $2: At mark
+        ([a-zA-Z0-9_]{1,20})                # $3: Screen name
+      /ox
+
+      return [] if text !~ at_signs
+
+      text.to_s.scan(valid_mentions).map do |before, at, screen_name|
+        screen_name
+      end
+    end
+
+    def base_url
+      "#{protocol}://#{host}"
+    end
+
+    def generate_authorize_url(consumer, request_token)
+      request = consumer.create_signed_request(:get, consumer.authorize_path, request_token, pin_auth_parameters)
+      params = request['Authorization'].sub(/^OAuth\s+/, '').split(/,\s+/).map do |param|
+        key, value = param.split('=')
+        value =~ /"(.*?)"/
+        "#{key}=#{CGI::escape($1)}"
+      end.join('&')
+      "#{base_url}#{request.path}?#{params}"
+    end
+
+    def pin_auth_parameters
+      {:oauth_callback => 'oob'}
+    end
+
     def location
       return @location if @location
       require 'geokit'