dustin-twitter 0.3.2.1

data/lib/twitter/base.rb

@@ -0,0 +1,248 @@
+# This is the base class for the twitter library. It makes all the requests 
+# to twitter, parses the xml (using hpricot) and returns ruby objects to play with.
+#
+# For complete documentation on the options, check out the twitter api docs.
+#   http://groups.google.com/group/twitter-development-talk/web/api-documentation
+module Twitter
+  class Base
+
+    # Initializes the configuration for making requests to twitter
+    def initialize(email, password, host='twitter.com')
+      @config, @config[:email], @config[:password] = {}, email, password
+      @api_host = host
+    end
+    
+    # Returns an array of statuses for a timeline; Defaults to your friends timeline.
+    def timeline(which=:friends, options={})
+      raise UnknownTimeline unless [:friends, :public, :user].include?(which)
+      auth = which.to_s.include?('public') ? false : true
+      statuses(call("#{which}_timeline", :auth => auth, :since => options[:since], :args => parse_options(options)))
+    end
+    
+    # Returns an array of users who are in your friends list
+    def friends(options={})
+      users(call(:friends, {:args => parse_options(options)}))
+    end
+    
+    # Returns an array of users who are friends for the id or username passed in
+    def friends_for(id, options={})
+      friends(options.merge({:id => id}))
+    end
+    
+    # Returns an array of users who are following you
+    def followers(options={})
+      users(call(:followers, {:args => parse_options(options)}))
+    end
+    
+    def followers_for(id, options={})
+      followers(options.merge({:id => id}))
+    end
+    
+    # Returns a single status for a given id
+    def status(id)
+      statuses(call("show/#{id}")).first
+    end
+    
+    # returns all the profile information and the last status for a user
+    def user(id_or_screenname)
+      users(request("users/show/#{id_or_screenname}.xml", :auth => true)).first
+    end
+    
+    # Returns an array of statuses that are replies
+    def replies(options={})
+      statuses(call(:replies, :since => options[:since], :args => parse_options(options)))
+    end
+    
+    # Destroys a status by id
+    def destroy(id)
+      call("destroy/#{id}")
+    end
+    
+    def rate_limit_status
+      RateLimitStatus.new_from_xml request("account/rate_limit_status.xml", :auth => true)
+    end
+    
+    # waiting for twitter to correctly implement this in the api as it is documented
+    def featured
+      users(call(:featured))
+    end
+    
+    # Returns an array of all the direct messages for the authenticated user
+    def direct_messages(options={})
+      doc = request(build_path('direct_messages.xml', parse_options(options)), {:auth => true, :since => options[:since]})
+      (doc/:direct_message).inject([]) { |dms, dm| dms << DirectMessage.new_from_xml(dm); dms }
+    end
+    alias :received_messages :direct_messages
+    
+    # Returns direct messages sent by auth user
+    def sent_messages(options={})
+      doc = request(build_path('direct_messages/sent.xml', parse_options(options)), {:auth => true, :since => options[:since]})
+      (doc/:direct_message).inject([]) { |dms, dm| dms << DirectMessage.new_from_xml(dm); dms }
+    end
+    
+    # destroys a give direct message by id if the auth user is a recipient
+    def destroy_direct_message(id)
+      request("direct_messages/destroy/#{id}.xml", :auth => true)
+    end
+    
+    # Sends a direct message <code>text</code> to <code>user</code>
+    def d(user, text)
+      url = URI.parse("http://#{@api_host}/direct_messages/new.xml")
+      req = Net::HTTP::Post.new(url.path)
+      req.basic_auth(@config[:email], @config[:password])
+      req.set_form_data({'text' => text, 'user' => user})
+      response = Net::HTTP.new(url.host, url.port).start { |http| http.request(req) }
+      DirectMessage.new_from_xml(parse(response.body).at('direct_message'))
+    end
+    
+    # Befriends id_or_screenname for the auth user
+    def create_friendship(id_or_screenname)
+      users(request("friendships/create/#{id_or_screenname}.xml", :auth => true)).first
+    end
+    
+    # Defriends id_or_screenname for the auth user
+    def destroy_friendship(id_or_screenname)
+      users(request("friendships/destroy/#{id_or_screenname}.xml", :auth => true)).first
+    end
+    
+    # Returns true if friendship exists, false if it doesn't.
+    def friendship_exists?(user_a, user_b)
+      doc = request(build_path("friendships/exists.xml", {:user_a => user_a, :user_b => user_b}), :auth => true)
+      doc.at('friends').innerHTML == 'true' ? true : false
+    end
+    
+    # Updates your location and returns Twitter::User object
+    def update_location(location)
+      users(request(build_path('account/update_location.xml', {'location' => location}), :auth => true)).first
+    end
+    
+    # Updates your deliver device and returns Twitter::User object
+    def update_delivery_device(device)
+      users(request(build_path('account/update_delivery_device.xml', {'device' => device}), :auth => true)).first
+    end
+    
+    # Turns notifications by id_or_screenname on for auth user.
+    def follow(id_or_screenname)
+      users(request("notifications/follow/#{id_or_screenname}.xml", :auth => true)).first
+    end
+
+    # Turns notifications by id_or_screenname off for auth user.    
+    def leave(id_or_screenname)
+      users(request("notifications/leave/#{id_or_screenname}.xml", :auth => true)).first
+    end
+    
+    # Returns the most recent favorite statuses for the autenticating user
+    def favorites(options={})
+      statuses(request(build_path('favorites.xml', parse_options(options)), :auth => true))
+    end
+    
+    # Favorites the status specified by id for the auth user
+    def create_favorite(id)
+      statuses(request("favorites/create/#{id}.xml", :auth => true)).first
+    end
+
+    # Un-favorites the status specified by id for the auth user
+    def destroy_favorite(id)
+      statuses(request("favorites/destroy/#{id}.xml", :auth => true)).first
+    end
+    
+    # Blocks the user specified by id for the auth user
+    def block(id)
+      users(request("blocks/create/#{id}.xml", :auth => true)).first
+    end
+    
+    # Unblocks the user specified by id for the auth user
+    def unblock(id)
+      users(request("blocks/destroy/#{id}.xml", :auth => true)).first
+    end
+    
+    # Posts a new update to twitter for auth user.
+    def post(status, options={})
+      form_data = {'status' => status}
+      form_data.merge({'source' => options[:source]}) if options[:source]
+      url = URI.parse("http://#{@api_host}/statuses/update.xml")
+      req = Net::HTTP::Post.new(url.path)
+      req.basic_auth(@config[:email], @config[:password])
+      req.set_form_data(form_data)
+      response = Net::HTTP.new(url.host, url.port).start { |http| http.request(req) }
+      Status.new_from_xml(parse(response.body).at('status'))
+    end
+    alias :update :post
+    
+    # Verifies the credentials for the auth user.
+    #   raises Twitter::CantConnect on failure.
+    def verify_credentials
+      request('account/verify_credentials', :auth => true)
+    end
+    
+    private      
+      # Converts an hpricot doc to an array of statuses
+      def statuses(doc)
+        (doc/:status).inject([]) { |statuses, status| statuses << Status.new_from_xml(status); statuses }
+      end
+      
+      # Converts an hpricot doc to an array of users
+      def users(doc)
+        (doc/:user).inject([]) { |users, user| users << User.new_from_xml(user); users }
+      end
+      
+      # Calls whatever api method requested that deals with statuses
+      # 
+      # ie: call(:public_timeline, :auth => false)
+      def call(method, options={})
+        options.reverse_merge!({ :auth => true, :args => {} })
+        # Following line needed as lite=false doesn't work in the API: http://tinyurl.com/yo3h5d
+        options[:args].delete(:lite) unless options[:args][:lite]
+        args = options.delete(:args)
+        request(build_path("statuses/#{method.to_s}.xml", args), options)
+      end
+      
+      # Makes a request to twitter.
+      def request(path, options={})
+        options.reverse_merge!({:headers => { "User-Agent" => @config[:email] }})
+        unless options[:since].blank?
+          since = options[:since].kind_of?(Date) ? options[:since].strftime('%a, %d-%b-%y %T GMT') : options[:since].to_s  
+          options[:headers]["If-Modified-Since"] = since
+        end
+        
+        begin
+          response = Net::HTTP.start(@api_host, 80) do |http|
+            req = Net::HTTP::Get.new('/' + path, options[:headers])
+            req.basic_auth(@config[:email], @config[:password]) if options[:auth]
+            http.request(req)
+          end
+        rescue => error
+          raise CantConnect, error.message
+        end
+        
+        if %w[200 304].include?(response.code)
+          response = parse(response.body)
+          raise RateExceeded if (response/:hash/:error).text =~ /Rate limit exceeded/
+          response
+        elsif response.code == '503'
+          raise Unavailable, response.message
+        elsif response.code == '401'
+          raise CantConnect, 'Authentication failed. Check your username and password'
+        else
+          raise CantConnect, "Twitter is returning a #{response.code}: #{response.message}"
+        end
+      end      
+    
+      # Given a path and a hash, build a full path with the hash turned into a query string
+      def build_path(path, options)
+        path += "?#{options.to_query}" unless options.blank?
+        path
+      end
+
+      # Tries to get all the options in the correct format before making the request
+      def parse_options(options)
+        options[:since] = options[:since].kind_of?(Date) ? options[:since].strftime('%a, %d-%b-%y %T GMT') : options[:since].to_s if options[:since]
+        options
+      end
+      
+      # Converts a string response into an Hpricot xml element.
+      def parse(response)
+        Hpricot.XML(response || '')
+      end
+  end
+end

data/lib/twitter/cli/config.rb

@@ -0,0 +1,9 @@
+module Twitter
+  module CLI
+    Config = {
+      :adapter => 'sqlite3', 
+      :database => File.join(ENV['HOME'], '.twitter.db'), 
+      :timeout => 5000
+    }
+  end
+end

data/lib/twitter/cli/helpers.rb

@@ -0,0 +1,97 @@
+module Twitter
+  module CLI
+    module Helpers
+      class NoActiveAccount < StandardError; end
+      class NoAccounts < StandardError; end
+      
+      def output_tweets(collection, options={})
+        options.reverse_merge!({
+          :cache        => false,
+          :since_prefix => '',
+          :empty_msg    => 'Nothing new since your last check.'
+        })
+        if collection.size > 0
+          justify   = collection.collect { |s| s.user.screen_name }.max { |a,b| a.length <=> b.length }.length rescue 0
+          indention = ' ' * (justify + 3)
+          say("\n#{indention}#{collection.size} new tweet(s) found.\n\n")
+          collection.each do |s|
+            Tweet.create_from_tweet(current_account, s) if options[:cache]
+            occurred_at    = Time.parse(s.created_at).strftime('On %b %d at %l:%M%P')
+            formatted_time = '-' * occurred_at.length + "\n#{indention}#{occurred_at}"
+            formatted_name = s.user.screen_name.rjust(justify + 1)
+            formatted_msg  = ''
+            s.text.split(' ').in_groups_of(6, false) { |row| formatted_msg += row.join(' ') + "\n#{indention}" }
+            say "#{CGI::unescapeHTML(formatted_name)}: #{CGI::unescapeHTML(formatted_msg)}#{formatted_time}\n\n"
+          end
+          Configuration["#{options[:since_prefix]}_since_id"] = collection.first.id
+        else
+          say(options[:empty_msg])
+        end
+      end
+      
+      def base(username=current_account.username, password=current_account.password)
+        @base ||= Twitter::Base.new(username, password)
+      end
+      
+      def current_account
+        @current_account ||= Account.active        
+        raise Account.count == 0 ? NoAccounts : NoActiveAccount if @current_account.blank?
+        @current_account
+      end
+      
+      def attempt_import(&block)
+        tweet_file = File.join(ENV['HOME'], '.twitter')
+        if File.exists?(tweet_file)
+          say '.twitter file found, attempting import...'
+          config = YAML::load(File.read(tweet_file))
+          if !config['email'].blank? && !config['password'].blank?
+            Account.add(:username => config['email'], :password => config['password'])
+            say 'Account imported'
+            block.call if block_given?
+            true
+          else
+            say "Either your username or password were blank in your .twitter file so I could not import. Use 'twitter add' to add an account."
+            false
+          end
+        end
+      end
+                  
+      def do_work(&block)
+        connect
+        begin
+          block.call
+        rescue Twitter::RateExceeded
+          say("Twitter says you've been making too many requests. Wait for a bit and try again.")
+        rescue Twitter::Unavailable
+          say("Twitter is unavailable right now. Try again later.")
+        rescue Twitter::CantConnect => msg
+          say("Can't connect to twitter because: #{msg}")
+        rescue Twitter::CLI::Helpers::NoActiveAccount
+          say("You have not set an active account. Use 'twitter change' to set one now.")
+        rescue Twitter::CLI::Helpers::NoAccounts
+          unless attempt_import { block.call }
+            say("You have not created any accounts. Use 'twitter add' to create one now.")
+          end
+        end
+      end
+      
+      def connect
+        ActiveRecord::Base.logger = Logger.new('/tmp/twitter_ar_logger.log')
+        ActiveRecord::Base.establish_connection(Twitter::CLI::Config)
+        ActiveRecord::Base.connection
+      end
+
+      def migrate
+        connect
+        ActiveRecord::Migrator.migrate("#{CLI_ROOT}/migrations/")
+      end
+
+      def connect_and_migrate
+        say('Attempting to establish connection...')
+        connect
+        say('Connection established...migrating database...')
+        migrate
+      end
+    end
+  end
+end

data/lib/twitter/cli/migrations/20080722194500_create_accounts.rb

@@ -0,0 +1,13 @@
+class CreateAccounts < ActiveRecord::Migration
+  def self.up
+    create_table :accounts do |t|
+      t.string :username, :password
+      t.boolean :current
+      t.timestamps
+    end
+  end
+
+  def self.down
+    drop_table :accounts
+  end
+end

data/lib/twitter/cli/migrations/20080722194508_create_tweets.rb

@@ -0,0 +1,16 @@
+class CreateTweets < ActiveRecord::Migration
+  def self.up
+    create_table :tweets do |t|
+      t.datetime :occurred_at
+      t.boolean :truncated, :favorited, :user_protected, :default => false
+      t.integer :twitter_id, :user_id, :in_reply_to_status_id, :in_reply_to_user_id, :user_followers_count
+      t.text :body
+      t.string :source, :user_name, :user_screen_name, :user_location, :user_description, :user_profile_image_url, :user_url
+      t.timestamps
+    end
+  end
+
+  def self.down
+    drop_table :tweets
+  end
+end

data/lib/twitter/cli/migrations/20080722214605_add_account_id_to_tweets.rb

@@ -0,0 +1,9 @@
+class AddAccountIdToTweets < ActiveRecord::Migration
+  def self.up
+    add_column :tweets, :account_id, :integer
+  end
+
+  def self.down
+    remove_column :tweets, :account_id
+  end
+end

data/lib/twitter/cli/migrations/20080722214606_create_configurations.rb

@@ -0,0 +1,13 @@
+class CreateConfigurations < ActiveRecord::Migration
+  def self.up
+    create_table :configurations do |t|
+      t.string :key
+      t.text :data
+      t.timestamps
+    end
+  end
+
+  def self.down
+    drop_table :accounts
+  end
+end

data/lib/twitter/cli/models/account.rb

@@ -0,0 +1,33 @@
+class Account < ActiveRecord::Base
+  named_scope :current, :conditions => {:current => true}
+  
+  has_many :tweets, :dependent => :destroy
+  
+  def self.add(hash)
+    username = hash.delete(:username)
+    account = find_or_initialize_by_username(username)
+    account.attributes = hash
+    account.save
+    set_current(account) if new_active_needed?
+  end
+  
+  def self.active
+    current.first
+  end
+  
+  def self.set_current(account_or_id)
+    account = account_or_id.is_a?(Account) ? account_or_id : find(account_or_id)
+    account.update_attribute :current, true
+    Account.update_all "current = 0", "id != #{account.id}"
+    account
+  end
+  
+  def self.new_active_needed?
+    self.current.count == 0 && self.count > 0
+  end
+  
+  def to_s
+    "#{current? ? '*' : ' '} #{username}"
+  end
+  alias to_str to_s
+end

data/lib/twitter/cli/models/configuration.rb

@@ -0,0 +1,13 @@
+class Configuration < ActiveRecord::Base
+  serialize :data
+  
+  def self.[](key)
+    key = find_by_key(key.to_s)
+    key.nil? ? nil : key.data
+  end
+  
+  def self.[]=(key, data)
+    c = find_or_create_by_key(key.to_s)
+    c.update_attribute :data, data
+  end
+end

data/lib/twitter/cli/models/tweet.rb

@@ -0,0 +1,20 @@
+class Tweet < ActiveRecord::Base
+  belongs_to :account
+  
+  def self.create_from_tweet(account, s)
+    tweet             = account.tweets.find_or_initialize_by_twitter_id(s.id)
+    tweet.body        = s.text
+    tweet.occurred_at = s.created_at
+    
+    %w[truncated favorited in_reply_to_status_id in_reply_to_user_id source].each do |m|
+      tweet.send("#{m}=", s.send(m))
+    end
+    
+    %w[id followers_count name screen_name location description 
+      profile_image_url url protected].each do |m|
+      tweet.send("user_#{m}=", s.user.send(m))
+    end
+    tweet.save!
+    tweet
+  end
+end