chirpstream 0.0.8 → 0.1.0

data/Gemfile

@@ -6,3 +6,5 @@ gem "yajl-ruby", ">= 0.7.5"
 gem "load_path_find", ">= 0.0.5"
 gem "oauth", ">= 0.4.0"
 gem 'rainbow'
+gem 'growl'
+gem 'json'

data/Gemfile.lock

@@ -8,6 +8,14 @@ dependencies:
     group: 
     - :default
     version: ">= 0"
+  growl: 
+    group: 
+    - :default
+    version: ">= 0"
+  json: 
+    group: 
+    - :default
+    version: ">= 0"
   em-http-request: 
     group: 
     - :default
@@ -33,6 +41,10 @@ specs:
     version: 0.12.10
 - em-http-request: 
     version: 0.2.7
+- growl: 
+    version: 1.0.3
+- json: 
+    version: 1.4.3
 - load_path_find: 
     version: 0.0.5
 - oauth: 
@@ -41,7 +53,7 @@ specs:
     version: 1.0.4
 - yajl-ruby: 
     version: 0.7.6
-hash: d6cefb455573e16292480b49ad20114ca5876dac
+hash: 751ca486a5dabecc00361525588fc94f8bf428d9
 sources: 
 - Rubygems: 
     uri: http://gemcutter.org

data/Readme.rdoc

@@ -19,26 +19,35 @@ Wow! It's growling my tweets! How meta.
   require 'chirpstream'
   require 'rainbow'
   
-  chirp = Chirpstream.new('joshbuddy', 'xxxxxxxx')
-  chirp.reconnect{ puts "reconnecting..." }
-  chirp.tweet {|t| puts "#{t.text} (from #{t.user.name.foreground(:red)} (#{('@' + t.user.screen_name).foreground(:green)}))" }
-  chirp.follow {|t| puts "#{t.source.screen_name.foreground(:green)} following #{t.target.screen_name.foreground(:green)}" }
-  chirp.favorite {|t| puts "#{t.source.screen_name.foreground(:green)} <3 -> #{t.target_object.text}" }
-  chirp.retweet {|t| puts "#{t.source.screen_name.foreground(:green)} RT -> #{t.target_object.text}" }
-  chirp.direct_message {|t| puts "DM : #{t.text} (from #{t.sender.name.foreground(:red)} (#{('@' + t.sender.screen_name).foreground(:green)}))" }
-  chirp.connect
+  chirp = Chirpstream.new
+  chirp.on_reconnect{ puts "reconnecting..." }
+  chirp.on_tweet {|t, u| puts "#{t.text} (from #{t.user.name.foreground(:red)} (#{('@' + t.user.screen_name).foreground(:green)}))" }
+  chirp.on_follow {|t, u| puts "#{t.source.screen_name.foreground(:green)} following #{t.target.screen_name.foreground(:green)}" }
+  chirp.on_favorite {|t, u| puts "#{t.source.screen_name.foreground(:green)} <3 -> #{t.target_object.text}" }
+  chirp.on_retweet {|t, u| puts "#{t.source.screen_name.foreground(:green)} RT -> #{t.target_object.text}" }
+  chirp.on_direct_message {|t, u| puts "DM : #{t.text} (from #{t.sender.name.foreground(:red)} (#{('@' + t.sender.screen_name).foreground(:green)}))" }
+  chirp.connect(Chirpstream::Connect::User.basic('joshbuddy', 'xxxxxxxx'))
 
 == Oauth Usage
 
-  chirp = Chirpstream.new
-  chirp.consumer_token = "XXX"
-  chirp.consumer_secret = "XXX"
-  chirp.access_token = "XXX"
-  chirp.access_secret = "XXX"
-  chirp.reconnect{ puts "reconnecting..." }
-  chirp.tweet {|t| puts "#{t.text} (from #{t.user.name.foreground(:red)} (#{('@' + t.user.screen_name).foreground(:green)}))" }
-  chirp.follow {|t| puts "#{t.source.screen_name.foreground(:green)} following #{t.target.screen_name.foreground(:green)}" }
-  chirp.favorite {|t| puts "#{t.source.screen_name.foreground(:green)} <3 -> #{t.target_object.text}" }
-  chirp.retweet {|t| puts "#{t.source.screen_name.foreground(:green)} RT -> #{t.target_object.text}" }
-  chirp.direct_message {|t| puts "DM : #{t.text} (from #{t.sender.name.foreground(:red)} (#{('@' + t.sender.screen_name).foreground(:green)}))" }
-  chirp.connect_oauth
+  chirp = Chirpstream.oauth(consumer_token, consumer_secret)
+  chirp.on_reconnect{ puts "reconnecting..." }
+  chirp.on_tweet {|t, u| puts "#{t.text} (from #{t.user.name.foreground(:red)} (#{('@' + t.user.screen_name).foreground(:green)}))" }
+  chirp.on_follow {|t, u| puts "#{t.source.screen_name.foreground(:green)} following #{t.target.screen_name.foreground(:green)}" }
+  chirp.on_favorite {|t, u| puts "#{t.source.screen_name.foreground(:green)} <3 -> #{t.target_object.text}" }
+  chirp.on_retweet {|t, u| puts "#{t.source.screen_name.foreground(:green)} RT -> #{t.target_object.text}" }
+  chirp.on_direct_message {|t, u| puts "DM : #{t.text} (from #{t.sender.name.foreground(:red)} (#{('@' + t.sender.screen_name).foreground(:green)}))" }
+  chirp.connect(Chirpstream::Connect::User.oauth(access_token, access_secret))
+
+== Multi User Usage
+
+  chirp = Chirpstream.new(consumer_token, consumer_secret)
+  
+  chirp.on_reconnect{ puts "reconnecting..." }
+  chirp.on_tweet {|t, u| puts "#{t.text} (from #{t.user.name.foreground(:red)} (#{('@' + t.user.screen_name).foreground(:green)}))" }
+  chirp.on_follow {|t, u| puts "#{t.source.screen_name.foreground(:green)} following #{t.target.screen_name.foreground(:green)}" }
+  chirp.on_favorite {|t, u| puts "#{t.source.screen_name.foreground(:green)} <3 -> #{t.target_object.text}" }
+  chirp.on_retweet {|t, u| puts "#{t.source.screen_name.foreground(:green)} RT -> #{t.target_object.text}" }
+  chirp.on_direct_message {|t, u| puts "DM : #{t.text} (from #{t.sender.name.foreground(:red)} (#{('@' + t.sender.screen_name).foreground(:green)}))" }
+  
+  chirp.connect(Chirpstream::Connect::User.oauth(access_token1, access_secret1), Chirpstream::Connect::User.oauth(access_token2, access_secret2))

data/VERSION

@@ -1 +1 @@
-0.0.8
+0.1.0

data/bin/chirp_growl

@@ -36,7 +36,7 @@ else
   File.open(json_file, 'w') {|f| f << {:username => @username, :password => @password}.to_json}
 end
 
-chirp = Chirpstream.new(@username, @password)
+chirp = Chirpstream.new
 
 Growl.notify {
   self.message = 'Starting chirp_growl...'
@@ -44,8 +44,8 @@ Growl.notify {
   self.image = File.join(File.dirname(__FILE__), '..', 'image', 'bird.png')
 }
 
-chirp.tweet { |t| 
-  t.user.with_profile_image(cache_dir) do |image_path|
+chirp.on_tweet { |t, u| 
+  t.user.with_profile_image(u, cache_dir) do |image_path|
     Growl.notify {
       self.message = t.text
       self.title = "@#{t.user.screen_name}"
@@ -54,6 +54,6 @@ chirp.tweet { |t|
   end
 }
 
-chirp.connect
+chirp.connect(Chirpstream::Connect::User.basic(@username, @password))
 
 

data/lib/chirpstream.rb

@@ -15,76 +15,71 @@ require 'chirpstream/event/follow'
 require 'chirpstream/event/direct_message'
 require 'chirpstream/event/retweet'
 require 'chirpstream/event/favorite'
+require 'chirpstream/event/unfavorite'
 require 'chirpstream/event/delete'
 require 'chirpstream/user'
 require 'chirpstream/tweet'
+require 'chirpstream/connect'
 
 class Chirpstream
   
+  include Connect
+
   attr_reader :handlers
   
-  Handlers = Struct.new(:friend, :tweet, :follow, :favorite, :retweet, :delete, :reconnect, :direct_message)
-
-  attr_reader :username, :password
-  attr_accessor :consumer_token, :consumer_secret, :access_token, :access_secret, :fill_in
-
-  def self.basic(username, password, options = nil)
-    chirpstream = new(username, password)
-    chirpstream.fill_in = options[:fill_in] if options && options.key?(:fill_in)
-  end
+  Handlers = Struct.new(:friend, :tweet, :follow, :favorite, :unfavorite, :retweet, :delete, :reconnect, :connect, :direct_message)
 
-  def self.oauth(consumer_token, consumer_secret, access_token, access_secret, options = nil)
-    chirpstream = new
-    chirpstream.consumer_token = consumer_token
-    chirpstream.consumer_secret = consumer_secret
-    chirpstream.access_token = access_token
-    chirpstream.access_secret = access_secret
-    chirpstream.fill_in = options[:fill_in] if options && options.key?(:fill_in)
-    chirpstream
-  end
+  attr_reader :consumer_token, :consumer_secret, :fill_in
 
-  def initialize(username=nil, password=nil, fill_in = true)
-    @fill_in = fill_in
-    @username = username
-    @password = password
+  def initialize(options = nil)
+    @consumer_token = options && options[:consumer_token]
+    @consumer_secret = options && options[:consumer_secret]
+    @fill_in = options && options[:fill_in]
     @connect_url = "http://chirpstream.twitter.com/2b/user.json"
-    @handlers = Handlers.new([], [], [], [], [], [], [], [])
-    @data = ''
+    @handlers = Handlers.new([], [], [], [], [], [], [], [], [], [])
   end
-  
-  def friend(&block)
+
+  def on_friend(&block)
     @handlers.friend << block
   end
   
-  def tweet(&block)
+  def on_tweet(&block)
     @handlers.tweet << block
   end
   
-  def follow(&block)
+  def on_follow(&block)
     @handlers.follow << block
   end
   
-  def favorite(&block)
+  def on_favorite(&block)
     @handlers.favorite << block
   end
   
-  def retweet(&block)
+  def on_unfavorite(&block)
+    @handlers.unfavorite << block
+  end
+  
+  def on_retweet(&block)
     @handlers.retweet << block
   end
   
-  def direct_message(&block)
+  def on_direct_message(&block)
     @handlers.direct_message << block
   end
 
-  def delete(&block)
+  def on_delete(&block)
     @handlers.delete << block
   end
   
-  def reconnect(&block)
+  def on_reconnect(&block)
     @handlers.reconnect << block
   end
   
-  def dispatch_friend(data)
+  def on_connect(&block)
+    @handlers.connect << block
+  end
+  
+  def dispatch_friend(user, data)
     unless @handlers.friend.empty?
       data['friends'].each_slice(100) do |friend_ids|
         parser = Yajl::Parser.new
@@ -93,141 +88,145 @@ class Chirpstream
             @handlers.friend.each{|h| h.call(friend)}
           end
         }
-        friend_http = EM::HttpRequest.new("http://api.twitter.com/1/users/lookup.json").post(:body => {'user_id' => friend_ids.join(',')}, :head => {'authorization' => [@username, @password]})
-        http.stream { |chunk|
+        friend_http = get_connection(user, "http://api.twitter.com/1/users/lookup.json", :post, :body => {'user_id' => friend_ids.join(',')})
+        friend_http.stream { |chunk|
           parser << chunk
         }
       end
     end
   end
   
-  def dispatch_tweet(data)
+  def dispatch_tweet(user, data)
     unless @handlers.tweet.empty?
       tweet = Tweet.new(self, data)
-      @fill_in ? tweet.load_all { |t|
-        @handlers.tweet.each{|h| h.call(tweet)}
-      } : @handlers.tweet.each{|h| h.call(tweet)}
+      @fill_in ? tweet.load_all(user) { |f|
+        @handlers.tweet.each{|h| h.call(f, user)}
+      } : @handlers.tweet.each{|h| h.call(tweet, user)}
     end
   end
   
-  def dispatch_follow(data)
+  def dispatch_follow(user, data)
     unless @handlers.follow.empty?
       follow = Follow.new(self, data)
-      @fill_in ? follow.load_all { |f|
-        @handlers.follow.each{|h| h.call(f)}
-      } : @handlers.follow.each{|h| h.call(follow)}
+      @fill_in ? follow.load_all(user) { |f|
+        @handlers.follow.each{|h| h.call(f, user)}
+      } : @handlers.follow.each{|h| h.call(follow, user)}
     end
   end
   
-  def dispatch_direct_message(data)
+  def dispatch_direct_message(user, data)
     unless @handlers.direct_message.empty?
       dm = DirectMessage.new(self, data)
-      @fill_in ? dm.load_all { |f|
-        @handlers.direct_message.each{|h| h.call(f)}
-      } : @handlers.direct_message.each{|h| h.call(dm)}
+      @fill_in ? dm.load_all(user) { |f|
+        @handlers.direct_message.each{|h| h.call(f, user)}
+      } : @handlers.direct_message.each{|h| h.call(dm, user)}
     end
   end
 
-  def dispatch_favorite(data)
+  def dispatch_favorite(user, data)
     unless @handlers.favorite.empty?
       favorite = Favorite.new(self, data)
-      @fill_in ? favorite.load_all { |f|
-        @handlers.favorite.each{|h| h.call(f)}
-      } : @handlers.favorite.each{|h| h.call(favorite)}
+      @fill_in ? favorite.load_all(user) { |f|
+        @handlers.favorite.each{|h| h.call(f, user)}
+      } : @handlers.favorite.each{|h| h.call(favorite, user)}
+    end
+  end
+  
+  def dispatch_unfavorite(user, data)
+    unless @handlers.unfavorite.empty?
+      unfavorite = Unfavorite.new(self, data)
+      @fill_in ? unfavorite.load_all(user) { |f|
+        @handlers.unfavorite.each{|h| h.call(f, user)}
+      } : @handlers.unfavorite.each{|h| h.call(unfavorite, user)}
     end
   end
   
-  def dispatch_retweet(data)
+  def dispatch_retweet(user, data)
     unless @handlers.retweet.empty?
       retweet = Retweet.new(self, data)
-      @fill_in ? retweet.load_all { |f|
-        @handlers.retweet.each{|h| h.call(f)}
-      } : @handlers.retweet.each{|h| h.call(retweet)}
+      @fill_in ? retweet.load_all(user) { |f|
+        @handlers.retweet.each{|h| h.call(f, user)}
+      } : @handlers.retweet.each{|h| h.call(retweet, user)}
     end
   end
     
-  def dispatch_delete(data)
+  def dispatch_delete(user, data)
     unless @handlers.delete.empty?
       delete = Delete.new(self, data)
-      @fill_in ? delete.load_all { |f|
-        @handlers.delete.each{|h| h.call(f)}
-      } : @handlers.delete.each{|h| h.call(delete)}
+      @fill_in ? delete.load_all(user) { |f|
+        @handlers.delete.each{|h| h.call(f, user)}
+      } : @handlers.delete.each{|h| h.call(delete, user)}
     end
   end
   
-  def dispatch_reconnect
+  def dispatch_reconnect(user)
     return if @handlers.reconnect.empty?
-    @handlers.reconnect.each{|h| h.call}
-  end
-  
-  def handle_tweet(parsed_data)
-    if parsed_data['direct_message']
-      dispatch_direct_message(parsed_data)
-    elsif parsed_data['friends']
-      dispatch_friend(parsed_data)
-    elsif parsed_data['text']
-      dispatch_tweet(parsed_data)
-    elsif parsed_data['event']
-      case parsed_data['event']
-      when 'follow'
-        dispatch_follow(parsed_data)
-      when 'favorite'
-        dispatch_favorite(parsed_data)
-      when 'retweet'
-        dispatch_retweet(parsed_data)
+    @handlers.reconnect.each{|h| h.call(user)}
+  end
+  
+  def dispatch_connect(user)
+    while h = @handlers.connect.shift
+      h.call(user)
+    end
+  end
+  
+  def data_handler(user)
+    Proc.new{|parsed_data|
+      if parsed_data['direct_message']
+        dispatch_direct_message(user, parsed_data)
+      elsif parsed_data['friends']
+        dispatch_friend(user, parsed_data)
+      elsif parsed_data['text']
+        dispatch_tweet(user, parsed_data)
+      elsif parsed_data['event']
+        case parsed_data['event']
+        when 'follow'
+          dispatch_follow(user, parsed_data)
+        when 'favorite'
+          dispatch_favorite(user, parsed_data)
+        when 'unfavorite'
+          dispatch_unfavorite(user, parsed_data)
+        when 'retweet'
+          dispatch_retweet(user, parsed_data)
+        else
+          puts "weird event"
+          pp parsed_data
+        end
+      elsif parsed_data['delete']
+        dispatch_delete(user, parsed_data)
       else
-        puts "weird event"
+        puts "i didn't know what to do with this!"
         pp parsed_data
       end
-    elsif parsed_data['delete']
-      dispatch_delete(parsed_data)
-    else
-      puts "i didn't know what to do with this!"
-      pp parsed_data
-    end
+    }
   end
   
-  def connect
+  def connect(*users)
     unless EM.reactor_running?
-      EM.run { connect }
+      EM.run { connect(*users) }
     else
-      parser = Yajl::Parser.new
-      parser.on_parse_complete = method(:handle_tweet)
-      http = new_client(@connect_url, :get)
-      http.errback { |e, err|
-        dispatch_reconnect
-        connect
-      }
-      http.stream { |chunk|
-        begin
-          parser << chunk
-        rescue Yajl::ParseError
-          puts "bad chunk: #{chunk.inspect}"
-        end
-      }
+      users.each do |user, index|
+        connect_single(user)
+      end
     end
   end
 
-  #
-  # Oauth example
-  #
-  def twitter_oauth_consumer
-    @twitter_oauth_consumer ||= OAuth::Consumer.new(consumer_token, consumer_secret, :site => "http://twitter.com")
-  end
-
-  def twitter_oauth_access_token
-    @twitter_oauth_access_token ||= OAuth::AccessToken.new(twitter_oauth_consumer, access_token, access_secret)
-  end
-
-  def new_client(url, method, extras = nil)
-    options = extras ? extras.merge(:timeout => 0) : {:timeout => 0}
-    if consumer_token
-      request = EM::HttpRequest.new(url)
-      request.send(method, options) do |client|
-        twitter_oauth_consumer.sign!(client, twitter_oauth_access_token)
+  def connect_single(user)
+    parser = Yajl::Parser.new
+    parser.on_parse_complete = data_handler(user)
+    http = get_connection(user, @connect_url, :get)
+    http.errback { |e, err|
+      dispatch_reconnect(user)
+      connect
+    }
+    http.stream { |chunk|
+      dispatch_connect(user)
+      begin
+        parser << chunk
+      rescue Yajl::ParseError
+        p $!
+        puts "bad chunk: #{chunk.inspect}"
       end
-    else
-      http = EM::HttpRequest.new(url).send(method, options.merge(:head => {'authorization' => [@username, @password]}))
-    end
+    }
   end
 end

data/lib/chirpstream/connect.rb

@@ -0,0 +1,62 @@
+class Chirpstream
+  module Connect
+    class User
+      
+      class Oauth
+        attr_reader :name, :access_token, :access_secret
+        def initialize(access_token, access_secret, name = nil)
+          @name = name
+          @access_token = access_token
+          @access_secret = access_secret
+        end
+        
+        def oauth?
+          true
+        end
+      end
+
+      class Basic
+        attr_reader :name, :password
+        def initialize(name, password)
+          @name = name
+          @password = password
+        end
+
+        def oauth?
+          false
+        end
+      end
+
+      def self.oauth(access_token, access_secret, name = nil)
+        Oauth.new(access_token, access_secret, name)
+      end
+      
+      def self.basic(name, password)
+        Basic.new(name, password)
+      end
+    end
+
+    def get_connection(user, url, method, extras = nil)
+      options = extras ? extras.merge(:timeout => 0) : {:timeout => 0}
+      if user.oauth?
+        request = EM::HttpRequest.new(url)
+        request.send(method, options) do |client|
+          twitter_oauth_consumer.sign!(client, twitter_oauth_access_token(user.access_token, user.access_secret))
+        end
+      else
+        http = EM::HttpRequest.new(url).send(method, options.merge(:head => {'authorization' => [user.name, user.password]}))
+      end
+      
+    end
+
+    def twitter_oauth_consumer
+      @twitter_oauth_consumer ||= OAuth::Consumer.new(consumer_token, consumer_secret, :site => "http://twitter.com")
+    end
+
+    def twitter_oauth_access_token(token=nil,secret=nil)
+  		token ||= access_token
+  		secret ||= access_secret
+      @twitter_oauth_access_token ||= OAuth::AccessToken.new(twitter_oauth_consumer, token, secret)
+    end
+  end
+end

data/lib/chirpstream/event/direct_message.rb

@@ -5,6 +5,7 @@ class Chirpstream
   
     attr_accessor *ATTRS
     user_writer :sender
+    user_writer :recipient
   
 		def initialize(base, data = nil)
 			@base = base

data/lib/chirpstream/event/unfavorite.rb

@@ -0,0 +1,8 @@
+class Chirpstream
+  class Unfavorite < Event
+    ATTRS = [ :target, :source, :target_object ]
+    attr_accessor *ATTRS
+    user_writer :target, :source
+    tweet_writer :target_object
+  end
+end

data/lib/chirpstream/twitter_object.rb

@@ -47,14 +47,14 @@ class TwitterObject
     const_get(:ATTRS)
   end
   
-  def load_all(&block)
+  def load_all(loading_user, &block)
     attrs = self.class.attrs
     if respond_to?(:loaded?) && !loaded?
       if respond_to?(:user_loadable_id)
-        from_json(get_user_data(user_loadable_id)[user_loadable_id])
+        from_json(get_user_data(loading_user, user_loadable_id)[user_loadable_id])
         load_all(&block)
       elsif respond_to?(:tweet_loadable_id)
-        from_json(get_tweet_data(tweet_loadable_id)[tweet_loadable_id])
+        from_json(get_tweet_data(loading_user, tweet_loadable_id)[tweet_loadable_id])
         load_all(&block)
       end
     else
@@ -70,9 +70,9 @@ class TwitterObject
           end
         end
       end
-      get_tweet_data(tweet_ids.values) { |tweet_data|
+      get_tweet_data(loading_user, tweet_ids.values) { |tweet_data|
         tweet_ids.each{|k,v| self.send(:"#{k}=", tweet_data[v])}
-        user_data = get_user_data(user_ids.values) { |user_data|
+        user_data = get_user_data(loading_user, user_ids.values) { |user_data|
           user_ids.each{|k,v| self.send(:"#{k}=", user_data[v])}
           yield self
         }
@@ -81,17 +81,17 @@ class TwitterObject
     
   end
   
-  def get_tweet_data(ids)
+  def get_tweet_data(loading_user, ids)
     ids = Array(ids).uniq
     data = {}
     if ids.empty?
       yield data
     else
-      load_tweet_data(ids, data) { yield data }
+      load_tweet_data(loading_user, ids, data) { yield data }
     end
   end
   
-  def load_tweet_data(ids, data, &block)
+  def load_tweet_data(loading_user, ids, data, &block)
     id = ids.shift
     if (id)
       parser = Yajl::Parser.new
@@ -99,7 +99,7 @@ class TwitterObject
         data[id] = parsed
         load_tweet_data(ids, data, &block)
       }
-      http = base.new_client("http://api.twitter.com/1/statuses/show/%s.json" % id, :get)
+      http = base.get_connection(loading_user, "http://api.twitter.com/1/statuses/show/%s.json" % id, :get)
       http.stream { |chunk|
         parser << chunk
       }
@@ -108,17 +108,17 @@ class TwitterObject
     end
   end
   
-  def get_user_data(ids)
+  def get_user_data(loading_user, ids)
     ids = Array(ids).uniq
     data = {}
     if ids.empty?
       yield data
     else
-      load_user_data(ids, data) { yield data }
+      load_user_data(loading_user, ids, data) { yield data }
     end
   end
   
-  def load_user_data(ids, data)
+  def load_user_data(loading_user, ids, data)
     parser = Yajl::Parser.new
     parser.on_parse_complete = proc { |parsed|
       parsed.each do |user|
@@ -126,7 +126,7 @@ class TwitterObject
       end
       yield
     }
-    http = base.new_client("http://api.twitter.com/1/users/lookup.json", :post, :body => {'user_id' => ids.join(',')})
+    http = base.get_connection(loading_user, "http://api.twitter.com/1/users/lookup.json", :post, :body => {'user_id' => ids.join(',')})
     http.stream { |chunk|
       parser << chunk
     }

data/lib/chirpstream/user.rb

@@ -21,7 +21,7 @@ class Chirpstream
       id
     end
     
-    def with_profile_image(cache_dir)
+    def with_profile_image(loading_user, cache_dir)
       raise unless loaded?
       
       cached_file = File.join(cache_dir, "#{Digest::MD5.hexdigest(profile_image_url)}#{File.extname(profile_image_url)}")
@@ -29,7 +29,7 @@ class Chirpstream
       if File.exist?(cached_file)
         yield cached_file
       else
-        http = EM::HttpRequest.new(profile_image_url).get :head => {'authorization' => [base.username, base.password]}
+        http = base.get_connection(loading_user, profile_image_url, :get)
         http.callback do
           if http.response_header.status == 200
             File.open(cached_file, 'w') {|f| f << http.response}

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
+  - 1
   - 0
-  - 8
-  version: 0.0.8
+  version: 0.1.0
 platform: ruby
 authors: 
 - Joshua Hull
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-20 00:00:00 -04:00
+date: 2010-05-21 00:00:00 -04:00
 default_executable: chirp_growl
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -105,12 +105,14 @@ files:
 - bin/chirp_growl
 - image/bird.png
 - lib/chirpstream.rb
+- lib/chirpstream/connect.rb
 - lib/chirpstream/event.rb
 - lib/chirpstream/event/delete.rb
 - lib/chirpstream/event/direct_message.rb
 - lib/chirpstream/event/favorite.rb
 - lib/chirpstream/event/follow.rb
 - lib/chirpstream/event/retweet.rb
+- lib/chirpstream/event/unfavorite.rb
 - lib/chirpstream/tweet.rb
 - lib/chirpstream/twitter_object.rb
 - lib/chirpstream/user.rb