tweetstream 0.3.0 → 1.0.0

data/README.rdoc

@@ -4,16 +4,9 @@ TweetStream provides simple Ruby access to Twitter's Streaming API
 (http://apiwiki.twitter.com/Streaming-API-Documentation).
 
 == Installation
-
-The TweetStream gem is available on GitHub and Gemcutter. To get the
-latest gem from GitHub:
-
-    gem sources -a http://gems.github.com/
-    gem install intridea-tweetstream
     
 To install from Gemcutter:
 
-    gem sources -a http://gemcutter.org/
     gem install tweetstream
 
 == Usage
@@ -47,6 +40,18 @@ user ids:
 The methods available to TweetStream::Client will be kept in parity
 with the methods available on the Streaming API wiki page.
 
+== Swappable JSON Parsing
+
+As of version 1.0, TweetStream supports swappable JSON backends for
+parsing the Tweets. These are specified when you initialize the
+client or daemon by passing it in as the last argument:
+
+    # Parse tweets using Yajl-Ruby
+    TweetStream::Client.new('abc','def',:yajl) # ...
+    
+Available options are <tt>:yajl</tt>, <tt>:json_gem</tt> (default),
+<tt>:json_pure</tt>, and <tt>:active_support</tt>.
+
 == Handling Deletes and Rate Limitations
 
 Sometimes the Streaming API will send messages other than statuses.
@@ -90,18 +95,37 @@ Twitter recommends honoring deletions as quickly as possible, and
 you would likely be wise to integrate this functionality into your
 application.
 
+== Errors and Reconnecting
+
+TweetStream uses EventMachine to connect to the Twitter Streaming
+API, and attempts to honor Twitter's guidelines in terms of automatic
+reconnection. When Twitter becomes unavailable, the block specified
+by you in <tt>on_error</tt> will be called. Note that this does not
+indicate something is actually wrong, just that Twitter is momentarily
+down. It could be for routine maintenance, etc.
+
+    TweetStream::Client.new('abc','def').on_error do |message|
+      # Log your error message somewhere
+    end.track('term') do |status|
+      # Do things when nothing's wrong
+    end
+
+However, if the maximum number of reconnect attempts has been reached,
+TweetStream will raise a <tt>TweetStream::ReconnectError</tt> with 
+information about the timeout and number of retries attempted.
+
 == Terminating a TweetStream
 
 It is often the case that you will need to change the parameters of your
 track or follow tweet streams. In the case that you need to terminate
-a stream, simply call <tt>TweetStream::Client.stop</tt> from within your
-loop:
+a stream, you may add a second argument to your block that will yield
+the client itself:
 
     # Stop after collecting 10 statuses
     @statuses = []
-    TweetStream::Client.new('username','password').track('term1', 'term2') do |status|
+    TweetStream::Client.new('username','password').sample do |status, client|
       @statuses << status
-      TweetStream::Client.stop if @statuses.size >= 10
+      client.stop if @statuses.size >= 10
     end
     
 When <tt>stop</tt> is called, TweetStream will return from the block

data/RELEASE_NOTES.rdoc

@@ -0,0 +1,5 @@
+== Version 1.0.0
+
+* Swappable JSON backend support
+* Switches to use EventMachine instead of Yajl for the HTTP Stream
+* Support reconnect and on_error

data/Rakefile

@@ -10,9 +10,9 @@ begin
     gem.email = "michael@intridea.com"
     gem.homepage = "http://github.com/intridea/tweetstream"
     gem.authors = ["Michael Bleigh"]
-    gem.files = FileList["[A-Z]*", "{lib,spec}/**/*"] - FileList["**/*.log"]
+    gem.files = FileList["[A-Z]*", "{lib,spec,examples}/**/*"] - FileList["**/*.log"]
     gem.add_development_dependency "rspec"
-    gem.add_dependency 'yajl-ruby', '>= 0.6.6'
+    gem.add_dependency 'twitter-stream'
     gem.add_dependency 'daemons'
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
   end

data/VERSION

@@ -1 +1 @@
-0.3.0
+1.0.0

data/examples/growl_daemon.rb

@@ -0,0 +1,14 @@
+require 'rubygems'
+require 'tweetstream'
+require 'ruby-growl'
+
+if args_start = ARGV.index('--')
+  username, password = ARGV[args_start + 1].split(':')
+  tracks = ARGV[args_start + 2 .. -1] 
+  puts "Starting a GrowlTweet to track: #{tracks.inspect}"
+end
+
+TweetStream::Daemon.new(username,password).track(*tracks) do |status|
+  g = Growl.new 'localhost', 'growltweet', ['tweet']
+  g.notify 'tweet', status.user.screen_name, status.text
+end

data/lib/tweetstream/client.rb

@@ -1,7 +1,9 @@
 require 'uri'
 require 'cgi'
 require 'yajl'
-require 'yajl/http_stream'
+require 'eventmachine'
+require 'twitter/json_stream'
+require 'json'
 
 module TweetStream
   # Provides simple access to the Twitter Streaming API (http://apiwiki.twitter.com/Streaming-API-Documentation)
@@ -20,12 +22,29 @@ module TweetStream
   # view the TweetStream::Daemon class.
   class Client
     attr_accessor :username, :password
+    attr_reader :parser
+
+    # Set the JSON Parser for this client. Acceptable options are:
+    #
+    # <tt>:json_gem</tt>:: Parse using the JSON gem.
+    # <tt>:json_pure</tt>:: Parse using the pure-ruby implementation of the JSON gem.
+    # <tt>:active_support</tt>:: Parse using ActiveSupport::JSON.decode
+    # <tt>:yajl</tt>:: Parse using <tt>yajl-ruby</tt>.
+    #
+    # You may also pass a class that will return a hash with symbolized
+    # keys when <tt>YourClass.parse</tt> is called with a JSON string.
+    def parser=(parser)
+      @parser = parser_from(parser)
+    end
     
     # Create a new client with the Twitter credentials
-    # of the account you want to be using its API quota. 
-    def initialize(user, pass)
+    # of the account you want to be using its API quota.
+    # You may also set the JSON parsing library as specified
+    # in the #parser= setter.
+    def initialize(user, pass, parser = :json_gem)
       self.username = user
       self.password = pass
+      self.parser = parser
     end
    
     # Returns all public statuses. The Firehose is not a generally
@@ -136,49 +155,96 @@ module TweetStream
       end
     end
     
+    # Set a Proc to be run when an HTTP error is encountered in the
+    # processing of the stream. Note that TweetStream will automatically
+    # try to reconnect, this is for reference only. Don't panic!
+    #
+    #     @client = TweetStream::Client.new('user','pass')
+    #     @client.on_error do |message|
+    #       # Make note of error message
+    #     end
+    #
+    # Block must take one argument: the error message.
+    # If no block is given, it will return the currently set 
+    # error proc. When a block is given, the TweetStream::Client
+    # object is returned to allow for chaining.
+    def on_error(&block)
+      if block_given?
+        @on_limit = block
+        self
+      else
+        @on_limit
+      end
+    end
+    
     def start(path, query_parameters = {}, &block) #:nodoc:
       method = query_parameters.delete(:method) || :get
       delete_proc = query_parameters.delete(:delete) || self.on_delete
       limit_proc = query_parameters.delete(:limit) || self.on_limit
+      error_proc = query_parameters.delete(:error) || self.on_error
       
       uri = method == :get ? build_uri(path, query_parameters) : build_uri(path)
       
-      args = [uri]
-      args << build_post_body(query_parameters) if method == :post
-      args << {:symbolize_keys => true}
-
-      @stream = Yajl::HttpStream.new
-
-      @stream.send(method, *args) do |hash|
-        if hash[:delete] && hash[:delete][:status]
-          delete_proc.call(hash[:delete][:status][:id], hash[:delete][:status][:user_id]) if delete_proc.is_a?(Proc)
-        elsif hash[:limit] && hash[:limit][:track]
-          limit_proc.call(hash[:limit][:track]) if limit_proc.is_a?(Proc)
-        elsif hash[:text] && hash[:user]
-          @last_status = TweetStream::Status.new(hash)
-          yield @last_status
+      EventMachine::run {
+        @stream = Twitter::JSONStream.connect(
+          :path => uri,
+          :auth => "#{URI.encode self.username}:#{URI.encode self.password}",
+          :method => method.to_s.upcase,
+          :content => (method == :post ? build_post_body(query_parameters) : ''),
+          :user_agent => 'TweetStream'
+        )
+        
+        @stream.each_item do |item|
+          hash = TweetStream::Hash.new(@parser.decode(item)) # @parser.parse(item)
+          
+          if hash[:delete] && hash[:delete][:status]
+            delete_proc.call(hash[:delete][:status][:id], hash[:delete][:status][:user_id]) if delete_proc.is_a?(Proc)
+          elsif hash[:limit] && hash[:limit][:track]
+            limit_proc.call(hash[:limit][:track]) if limit_proc.is_a?(Proc)
+          elsif hash[:text] && hash[:user]
+            @last_status = TweetStream::Status.new(hash)
+            
+            # Give the block the option to receive either one
+            # or two arguments, depending on its arity.
+            case block.arity
+              when 1
+                yield @last_status
+              when 2
+                yield @last_status, self
+            end
+          end
         end
-      end
-    rescue TweetStream::Terminated
-      return @last_status
-    rescue Yajl::HttpStream::InvalidContentType
-      raise TweetStream::ConnectionError, "There was an error connecting to the Twitter streaming service. Please check your credentials and the current status of the Streaming API."
+        
+        @stream.on_error do |message|
+          error_proc.call(message) if error_proc.is_a?(Proc)
+        end
+        
+        @stream.on_max_reconnects do |timeout, retries|
+          raise TweetStream::ReconnectError.new(timeout, retries)
+        end
+      }
     end
     
-    # Terminate the currently running TweetStream.
-    def self.stop
-      raise TweetStream::Terminated
-    end
-
     # Terminate the currently running TweetStream.
     def stop
-      @stream.terminate unless @stream.nil?
+      EventMachine.stop_event_loop
+      @last_status
     end
  
     protected
 
+    def parser_from(parser)
+      case parser
+        when Class
+          parser
+        when Symbol
+          require "tweetstream/parsers/#{parser.to_s}"
+          eval("TweetStream::Parsers::#{parser.to_s.split('_').map(&:capitalize).join('')}")
+      end
+    end
+    
     def build_uri(path, query_parameters = {}) #:nodoc:
-      URI.parse("http://#{URI.encode self.username}:#{URI.encode self.password}@stream.twitter.com/1/#{path}.json#{build_query_parameters(query_parameters)}")
+      URI.parse("/1/#{path}.json#{build_query_parameters(query_parameters)}")
     end
 
     def build_query_parameters(query)

data/lib/tweetstream/daemon.rb

@@ -26,9 +26,9 @@ class TweetStream::Daemon < TweetStream::Client
   # Twitter account you wish to use. The daemon has
   # an optional process name for use when querying
   # running processes.
-  def initialize(user, pass, app_name=nil)
+  def initialize(user, pass, app_name=nil, parser=:json_gem)
     @app_name = app_name
-    super(user, pass)
+    super(user, pass, parser)
   end
   
   def start(path, query_parameters = {}, &block) #:nodoc:

data/lib/tweetstream/hash.rb

@@ -1,10 +1,12 @@
 class TweetStream::Hash < ::Hash #:nodoc: all
   def initialize(other_hash = {})
     other_hash.keys.each do |key|
-      self[key.to_sym] = other_hash[key]
+      value = other_hash[key]
+      value = TweetStream::Hash.new(value) if value.is_a?(::Hash)
+      self[key.to_sym] = value
     end
   end
-  
+    
   def method_missing(method_name, *args)
     if key?(method_name.to_sym)
       self[method_name.to_sym]

data/lib/tweetstream/parsers/active_support.rb

@@ -0,0 +1,11 @@
+require 'active_support/json' unless defined?(::ActiveSupport::JSON)
+
+module TweetStream
+  module Parsers
+    class ActiveSupport
+      def self.decode(string)
+        ::ActiveSupport::JSON.decode(string)
+      end
+    end
+  end
+end

data/lib/tweetstream/parsers/json_gem.rb

@@ -0,0 +1,11 @@
+require 'json' unless defined?(JSON)
+
+module TweetStream
+  module Parsers
+    class JsonGem
+      def self.decode(string)
+        ::JSON.parse(string)
+      end
+    end
+  end
+end

data/lib/tweetstream/parsers/json_pure.rb

@@ -0,0 +1,11 @@
+require 'json/pure' unless defined?(::JSON)
+
+module TweetStream
+  module Parsers
+    class JsonPure
+      def self.decode(string)
+        ::JSON.parse(string)
+      end
+    end
+  end
+end

data/lib/tweetstream/parsers/yajl.rb

@@ -0,0 +1,11 @@
+require 'yajl' unless defined?(Yajl)
+
+module TweetStream
+  module Parsers
+    class Yajl
+      def self.decode(string)
+        ::Yajl::Parser.new(:symbolize_keys => true).parse(string)
+      end
+    end
+  end
+end

data/lib/tweetstream/status.rb

@@ -5,4 +5,8 @@ class TweetStream::Status < TweetStream::Hash
     super
     self[:user] = TweetStream::User.new(self[:user])
   end
+  
+  def id
+    self[:id] || super
+  end
 end

data/lib/tweetstream/user.rb

@@ -1,5 +1,7 @@
 # A simple Hash wrapper that gives you method-based
 # access to user properties returned by the streamer.
 class TweetStream::User < TweetStream::Hash
-  
+  def id
+    self[:id] || super
+  end
 end

data/lib/tweetstream.rb

@@ -8,4 +8,14 @@ module TweetStream
   class Terminated < ::StandardError; end
   class Error < ::StandardError; end
   class ConnectionError < TweetStream::Error; end
+  # A ReconnectError is raised when the maximum number of retries has
+  # failed to re-establish a connection.
+  class ReconnectError < StandardError
+    attr_accessor :timeout, :retries
+    def initialize(timeout, retries)
+      self.timeout = timeout
+      self.retries = retries
+      super("Failed to reconnect after #{retries} tries.")
+    end
+  end
 end

data/spec/spec_helper.rb

@@ -6,6 +6,7 @@ require 'tweetstream'
 require 'spec'
 require 'spec/autorun'
 require 'yajl'
+require 'json'
 
 def sample_tweets
   if @tweets

data/spec/tweetstream/client_spec.rb

@@ -16,11 +16,6 @@ describe TweetStream::Client do
       @client.send(:build_uri, '').is_a?(URI).should be_true
     end
 
-    it 'should contain the auth information from the client' do
-      @client.send(:build_uri, '').user.should == 'abc'
-      @client.send(:build_uri, '').password.should == 'def'
-    end
-
     it 'should have the specified path with the version prefix and a json extension' do
       @client.send(:build_uri, 'awesome').path.should == '/1/awesome.json'
     end
@@ -58,52 +53,96 @@ describe TweetStream::Client do
 
   describe '#start' do
     before do
+      @stream = stub("Twitter::JSONStream", 
+        :connect => true,
+        :unbind => true, 
+        :each_item => true, 
+        :on_error => true,
+        :on_max_reconnects => true,
+        :connection_completed => true
+      )
+      EM.stub!(:run).and_yield
+      Twitter::JSONStream.stub!(:connect).and_return(@stream)
       @client = TweetStream::Client.new('abc','def')
     end
-
-    it 'should make a call to Yajl::HttpStream' do
-      Yajl::HttpStream.should_receive(:new).and_return(y = mock("Yajl::HttpStream"))
-      y.should_receive(:get).once.with(URI.parse('http://abc:def@stream.twitter.com/1/cool.json'), :symbolize_keys => true).and_return({})
-      @client.start('cool')
+    
+    it 'should try to connect via a JSON stream' do
+      Twitter::JSONStream.should_receive(:connect).with(
+        :auth => 'abc:def',
+        :content => 'track=monday',
+        :path => URI.parse('/1/statuses/filter.json'),
+        :method => 'POST',
+        :user_agent => 'TweetStream'
+      ).and_return(@stream)
+      
+      @client.track('monday')
     end
-
-    it 'should yield a TwitterStream::Status for each update' do
-      Yajl::HttpStream.should_receive(:new).and_return(y = mock("Yajl::HttpStream"))
-      y.should_receive(:post).once.with(URI.parse('http://abc:def@stream.twitter.com/1/statuses/filter.json'), 'track=musicmonday', :symbolize_keys => true).and_yield(sample_tweets[0])
-      @client.track('musicmonday') do |status|
-        status.is_a?(TweetStream::Status).should be_true
-        @yielded = true
+    
+    describe '#each_item' do
+      it 'should call the appropriate parser' do
+        @client = TweetStream::Client.new('abc','def',:active_support)
+        TweetStream::Parsers::ActiveSupport.should_receive(:decode).and_return({})
+        @stream.should_receive(:each_item).and_yield(sample_tweets[0].to_json)
+        @client.track('abc','def')
+      end
+      
+      it 'should yield a TweetStream::Status' do
+        @stream.should_receive(:each_item).and_yield(sample_tweets[0].to_json)
+        @client.track('abc'){|s| s.should be_kind_of(TweetStream::Status)}
+      end
+      
+      it 'should also yield the client if a block with arity 2 is given' do
+        @stream.should_receive(:each_item).and_yield(sample_tweets[0].to_json)
+        @client.track('abc'){|s,c| c.should == @client}
+      end
+      
+      it 'should include the proper values' do
+        tweet = sample_tweets[0]
+        tweet[:id] = 123
+        tweet[:user][:screen_name] = 'monkey'
+        tweet[:text] = "Oo oo aa aa"
+        @stream.should_receive(:each_item).and_yield(tweet.to_json)
+        @client.track('abc') do |s| 
+          s[:id].should == 123
+          s.user.screen_name.should == 'monkey'
+          s.text.should == 'Oo oo aa aa'
+        end
+      end
+      
+      it 'should call the on_delete if specified' do
+        delete = '{ "delete": { "status": { "id": 1234, "user_id": 3 } } }'
+        @stream.should_receive(:each_item).and_yield(delete)
+        @client.on_delete do |id, user_id| 
+          id.should == 1234
+          user_id.should == 3
+        end.track('abc')
+      end
+      
+      it 'should call the on_limit if specified' do
+        limit = '{ "limit": { "track": 1234 } }'
+        @stream.should_receive(:each_item).and_yield(limit)
+        @client.on_limit do |track|
+          track.should == 1234
+        end.track('abc')
       end
-      @yielded.should be_true
     end
     
-    it 'should wrap Yajl errors in TweetStream errors' do
-      Yajl::HttpStream.should_receive(:new).and_return(y = mock("Yajl::HttpStream"))
-      y.should_receive(:get).once.with(URI.parse('http://abc:def@stream.twitter.com/1/cool.json'), :symbolize_keys => true).and_raise(Yajl::HttpStream::InvalidContentType)
-      lambda{@client.start('cool')}.should raise_error(TweetStream::ConnectionError)
+    describe '#on_error' do
+      it 'should pass the message on to the error block' do
+        @stream.should_receive(:on_error).and_yield('Uh oh')
+        @client.on_error do |m|
+          m.should == 'Uh oh'
+        end.track('abc')
+      end
     end
     
-    {
-      :delete => {:delete => {:status => {:id => 1234, :user_id => 3}}},
-      :limit => {:limit => {:track => 1234}}
-    }.each_pair do |special_method, special_object|
-      it "should make a call to the #{special_method} proc if a #{special_method} object is given" do
-        @called = false
-        @proc = Proc.new{|*args| @called = true }
-        @client.send("on_#{special_method}", &@proc)
-        Yajl::HttpStream.should_receive(:new).and_return(y = mock("Yajl::HttpStream"))
-        y.should_receive(:post).once.with(URI.parse('http://abc:def@stream.twitter.com/1/statuses/filter.json'), "track=musicmonday", :symbolize_keys => true).and_yield(special_object)
-        @client.track('musicmonday')
-        @called.should == true
-      end
-      
-      it "should accept a proc on a :#{special_method} option if a #{special_method} object is given" do
-        @called = false
-        @proc = Proc.new{|*args| @called = true }
-        Yajl::HttpStream.should_receive(:new).and_return(y = mock("Yajl::HttpStream"))
-        y.should_receive(:post).once.with(URI.parse('http://abc:def@stream.twitter.com/1/statuses/filter.json'), "track=musicmonday", :symbolize_keys => true).and_yield(special_object)
-        @client.track('musicmonday', special_method => @proc)
-        @called.should == true
+    describe '#on_max_reconnects' do
+      it 'should raise a ReconnectError' do
+        @stream.should_receive(:on_max_reconnects).and_yield(30, 20)
+        lambda{@client.track('abc')}.should raise_error(TweetStream::ReconnectError) do |e|
+          e.timeout.should == 30
+          e.retries.should == 20
+        end
       end
     end
   end
@@ -170,34 +209,18 @@ describe TweetStream::Client do
       @client.track('rock')
     end
   end
-  
-  describe '.stop' do
-    it 'should raise a TweetStream::Terminated error' do
-      lambda{ TweetStream::Client.stop }.should raise_error(TweetStream::Terminated)
-    end
-    
-    it 'should not cause a TweetStream to crash with a real exception' do
-      @client = TweetStream::Client.new('abc','def')
-      @statuses = []
-      Yajl::HttpStream.should_receive(:new).and_return(y = mock("Yajl::HttpStream"))
-      y.should_receive(:post).once.with(URI.parse('http://abc:def@stream.twitter.com/1/statuses/filter.json'), 'track=musicmonday', :symbolize_keys => true).and_yield(sample_tweets[0])
-      @client.track('musicmonday') do |status|
-        @statuses << status
-        TweetStream::Client.stop
-      end.should == @statuses.first
-      @statuses.size.should == 1
-    end
-  end
 
   describe 'instance .stop' do
-    it 'should stop to receive the stream' do
-      @client = TweetStream::Client.new('abc','def')
-      Yajl::HttpStream.should_receive(:new).and_return(y = mock('Yajl::HttpStream'))
-      y.should_receive(:post)
-      y.should_receive(:terminate).once
-
-      @client.follow('10')
-      @client.stop
+    it 'should call EventMachine::stop_event_loop' do
+      EventMachine.should_receive :stop_event_loop
+      TweetStream::Client.new('test','fake').stop.should be_nil
+    end
+    
+    it 'should return the last status yielded' do
+      EventMachine.should_receive :stop_event_loop
+      client = TweetStream::Client.new('test','fake')
+      client.send(:instance_variable_set, :@last_status, {})
+      client.stop.should == {}
     end
   end
 end

data/spec/tweetstream/parser_spec.rb

@@ -0,0 +1,39 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe 'TweetStream JSON Parsers' do
+  it 'should default to the JSON Gem' do
+    TweetStream::Client.new('test','fake').parser.should == TweetStream::Parsers::JsonGem
+  end
+  
+  [:json_gem, :yajl, :active_support, :json_pure].each do |engine|
+    describe "#{engine} parsing" do
+      before do
+        @client = TweetStream::Client.new('test','fake',engine)
+        @class_name = "TweetStream::Parsers::#{engine.to_s.split('_').map(&:capitalize).join('')}"
+      end
+      
+      it 'should set the parser to the appropriate class' do
+        @client.parser.to_s == @class_name
+      end
+      
+      it 'should be settable via client.parser=' do
+        @client.parser = nil
+        @client.parser.should be_nil
+        @client.parser = engine
+        @client.parser.to_s.should == @class_name
+      end
+    end
+  end
+  
+  class FakeParser
+    def self.decode(text)
+      {}
+    end
+  end
+  
+  it 'should be settable to a class' do
+    @client = TweetStream::Client.new('abc','def')
+    @client.parser = FakeParser
+    @client.parser.should == FakeParser
+  end
+end

data/spec/tweetstream/status_spec.rb

@@ -6,4 +6,10 @@ describe TweetStream::Status do
     @status.user.is_a?(TweetStream::User).should be_true
     @status.user.screen_name.should == 'bob'
   end
+  
+  it 'should override the #id method for itself and the user' do
+    @status = TweetStream::Status.new(:id => 123, :user => {:id => 345})
+    @status.id.should == 123
+    @status.user.id.should == 345
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: tweetstream
 version: !ruby/object:Gem::Version 
-  version: 0.3.0
+  version: 1.0.0
 platform: ruby
 authors: 
 - Michael Bleigh
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-12-03 00:00:00 -05:00
+date: 2010-01-25 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -23,14 +23,14 @@ dependencies:
         version: "0"
     version: 
 - !ruby/object:Gem::Dependency 
-  name: yajl-ruby
+  name: twitter-stream
   type: :runtime
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.6.6
+        version: "0"
     version: 
 - !ruby/object:Gem::Dependency 
   name: daemons
@@ -54,12 +54,18 @@ extra_rdoc_files:
 files: 
 - LICENSE
 - README.rdoc
+- RELEASE_NOTES.rdoc
 - Rakefile
 - VERSION
+- examples/growl_daemon.rb
 - lib/tweetstream.rb
 - lib/tweetstream/client.rb
 - lib/tweetstream/daemon.rb
 - lib/tweetstream/hash.rb
+- lib/tweetstream/parsers/active_support.rb
+- lib/tweetstream/parsers/json_gem.rb
+- lib/tweetstream/parsers/json_pure.rb
+- lib/tweetstream/parsers/yajl.rb
 - lib/tweetstream/status.rb
 - lib/tweetstream/user.rb
 - spec/data/statuses.json
@@ -67,6 +73,7 @@ files:
 - spec/spec_helper.rb
 - spec/tweetstream/client_spec.rb
 - spec/tweetstream/hash_spec.rb
+- spec/tweetstream/parser_spec.rb
 - spec/tweetstream/status_spec.rb
 - spec/tweetstream_spec.rb
 has_rdoc: true
@@ -101,5 +108,7 @@ test_files:
 - spec/spec_helper.rb
 - spec/tweetstream/client_spec.rb
 - spec/tweetstream/hash_spec.rb
+- spec/tweetstream/parser_spec.rb
 - spec/tweetstream/status_spec.rb
 - spec/tweetstream_spec.rb
+- examples/growl_daemon.rb