weeter 0.11.0 → 0.13.0

data/.gitignore

@@ -1,8 +1,10 @@
 .rvmrc
 .bundle
+.rspec
 weeter.pid
 weeter.conf
 log/*.log
 vendor/bundle
 .DS_Store
-Gemfile.lock
+Gemfile.lock
+pkg

data/.travis.yml

@@ -1,5 +1,5 @@
 language: ruby
 bundler_args: --without debug
 rvm:
-  - 1.9.2
+  - 1.9.3
 script: bundle exec rspec spec

data/lib/weeter/limitator.rb

@@ -2,10 +2,15 @@ require 'active_support/core_ext/numeric/time'
 
 module Weeter
   class Limitator
+    Result = Struct.new(:status, :limited_keys)
+
+    DO_NOT_LIMIT      = :do_not_limit
+    INITIATE_LIMITING = :initiate_limiting
+    CONTINUE_LIMITING = :continue_limiting
 
     module UNLIMITED
-      def self.limit?(*args)
-        false
+      def self.limit_status(*args)
+        DO_NOT_LIMIT
       end
     end
 
@@ -27,7 +32,7 @@ module Weeter
     attr_accessor :lookup, :window, :max
 
     def initialize(options = {})
-      self.window= TimeWindow.new({
+      self.window = TimeWindow.new({
         start: self.now,
         duration: options.fetch(:duration)
       })
@@ -37,14 +42,26 @@ module Weeter
       flush
     end
 
-    def limit?(*keys)
+    def process(*keys)
       ensure_correct_window
 
       keys.each do |key|
         increment(key)
       end
 
-      keys.any? { |key| exceeds_max?(key) }
+      result = Result.new
+      limited_keys = keys.select { |key| exceeds_max?(key) }
+      if limited_keys.any?
+        result[:limited_keys] = limited_keys
+        if limited_keys.any? { |key| exceeds_max_by_one?(key) }
+          result[:status] = INITIATE_LIMITING
+        else
+          result[:status] = CONTINUE_LIMITING
+        end
+      else
+        result[:status] = DO_NOT_LIMIT
+      end
+      result
     end
 
   protected
@@ -61,6 +78,10 @@ module Weeter
       lookup[key] > max
     end
 
+    def exceeds_max_by_one?(key)
+      lookup[key] == max + 1
+    end
+
     def ensure_correct_window
       return unless window.over?(now)
 

data/lib/weeter/plugins/lib/redis.rb

@@ -5,13 +5,12 @@ module Weeter
     module Net
       module Redis
         def create_redis_client
-          @redis ||= begin
-            redis = EM::Hiredis.connect(@config.redis_uri)
-            redis.callback { Weeter.logger.info "Connected to Redis" }
-            redis
-          end
+          redis = EM::Hiredis.connect(@config.redis_uri)
+          redis.callback { Weeter.logger.info "Connected to Redis" }
+          redis.errback { |message| Weeter.logger.err "Failed to connect to Redis: #{message}" }
+          redis
         end
       end
     end
   end
-end
+end

data/lib/weeter/plugins/notification/http.rb

@@ -20,7 +20,15 @@ module Weeter
           Weeter.logger.info("Deleting tweet #{id} for user #{user_id}")
           Weeter::Plugins::Net::OauthHttp.delete(@config, @config.delete_url, {:id => id, :twitter_user_id => user_id})
         end
+
+        def notify_missed_tweets(tweet_item)
+          Weeter.logger.info("Weeter was limited by Twitter. #{tweet_item.missed_tweets_count} tweets missed.")
+        end
+
+        def notify_rate_limiting_initiated(tweet_item, limited_keys)
+          Weeter.logger.info("Initiated rate limiting with tweet: #{tweet_item.to_json}")
+        end
       end
     end
   end
-end
+end

data/lib/weeter/plugins/notification/resque.rb

@@ -3,7 +3,7 @@ module Weeter
     module Notification
       class Resque
         include Weeter::Plugins::Net::Redis
-        
+
         def initialize(client_app_config)
           @config = client_app_config
         end
@@ -20,12 +20,26 @@ module Weeter
           enqueue(resque_job)
         end
 
+        def notify_missed_tweets(tweet_item)
+          resque_job = %Q|{"class":"WeeterMissedTweetsJob","args":[#{tweet_item.to_json}]}|
+          Weeter.logger.info("Notifying of missed tweets (#{tweet_item.missed_tweets_count}).")
+          enqueue(resque_job)
+        end
+
+        def notify_rate_limiting_initiated(tweet_item, limited_keys)
+          payload = tweet_item.to_hash.merge(:limited_keys => limited_keys)
+          payload_json = MultiJson.encode(payload)
+          resque_job = %Q|{"class":"WeeterRateLimitingInitiatedJob","args":[#{payload_json}]}|
+          Weeter.logger.info("Initiated rate limiting with tweet: #{payload_json}")
+          enqueue(resque_job)
+        end
+
       protected
-      
+
         def redis
           @redis ||= create_redis_client
         end
-      
+
         def enqueue(job)
           redis.rpush(queue_key, job)
         end
@@ -36,4 +50,4 @@ module Weeter
       end
     end
   end
-end
+end

data/lib/weeter/plugins/notification_plugin.rb

@@ -7,13 +7,16 @@ require 'active_support/core_ext/module/delegation'
 module Weeter
   module Plugins
     class NotificationPlugin
-      delegate :publish_tweet, :to => :configured_plugin
-      delegate :delete_tweet, :to => :configured_plugin
-      
+      delegate :publish_tweet,
+               :delete_tweet,
+               :notify_rate_limiting_initiated,
+               :notify_missed_tweets,
+            :to => :configured_plugin
+
       def initialize(client_app_config)
         @config = client_app_config
       end
-      
+
     protected
       def configured_plugin
         @configured_plugin ||= begin
@@ -23,4 +26,4 @@ module Weeter
       end
     end
   end
-end
+end

data/lib/weeter/plugins/subscription/redis.rb

@@ -11,20 +11,24 @@ module Weeter
         end
 
         def get_initial_filters(&block)
-          redis.get(@config.subscriptions_key) do |value|
+          deferred_get = redis.get(@config.subscriptions_key) do |value|
             if value.nil?
               raise "Expected to find subscription data at redis key #{@config.subscriptions_key}"
             end
             yield MultiJson.decode(value)
           end
+          deferred_get.errback do |message|
+            Weeter.logger.error(message)
+          end
         end
 
         def listen_for_filter_update(tweet_consumer)
           pub_sub_redis.subscribe(@config.subscriptions_changed_channel)
           pub_sub_redis.on(:message) do |channel, message|
             Weeter.logger.info [:message, channel, message]
-            Weeter.logger.info("Reconnecting Twitter stream")
+            Weeter.logger.info("Retrieving updated filters from redis")
             get_initial_filters do |filter_params|
+              Weeter.logger.info("Triggering reconnect Twitter stream with new filters")
               tweet_consumer.reconnect(filter_params)
             end
           end

data/lib/weeter/twitter/tweet_consumer.rb

@@ -4,8 +4,13 @@ require 'multi_json'
 module Weeter
   module Twitter
     class TweetConsumer
+      extend ::Forwardable
 
-      attr_reader :limiter
+      attr_reader :limiter, :notifier
+      def_delegators :@notifier, :notify_missed_tweets,
+                                 :notify_rate_limiting_initiated,
+                                 :delete_tweet,
+                                 :publish_tweet
 
       def initialize(twitter_config, notifier, limiter, subscriptions_limit = nil)
         @config = twitter_config
@@ -18,31 +23,31 @@ module Weeter
         filter_params = limit_filter_params(filter_params) if @subscriptions_limit
         filter_params = clean_filter_params(filter_params)
 
+
         connect_options = {
           ssl:    true,
           params: filter_params,
           method: 'POST'
         }.merge(@config.auth_options)
 
+        Weeter.logger.info("Connecting to Twitter stream...")
         @stream = ::Twitter::JSONStream.connect(connect_options)
 
         @stream.each_item do |item|
           begin
             tweet_item = TweetItem.new(MultiJson.decode(item))
 
-            if tweet_item.deletion?
-              @notifier.delete_tweet(tweet_item)
+            if tweet_item.limit_notice?
+              notify_missed_tweets(tweet_item)
+            elsif tweet_item.deletion?
+              delete_tweet(tweet_item)
             elsif tweet_item.publishable?
-              if limiter.limit?(*tweet_item.limiting_facets)
-                rate_limit_tweet(tweet_item)
-              else
-                @notifier.publish_tweet(tweet_item)
-              end
+              publish_or_rate_limit(tweet_item)
             else
               ignore_tweet(tweet_item)
             end
           rescue => ex
-            Weeter.logger.error("Twitter stream tweet exception: #{ex.class.name}: #{ex.message}")
+            Weeter.logger.error("Twitter stream tweet exception: #{ex.class.name}: #{ex.message} #{tweet_item.to_json}")
           end
         end
 
@@ -57,6 +62,7 @@ module Weeter
 
       def reconnect(filter_params)
         @stream.stop
+        @stream.unbind
         connect(filter_params)
       end
 
@@ -97,15 +103,17 @@ module Weeter
         return {} if p.nil?
         cleaned_params = {}
         cleaned_params['follow'] = p['follow'] if (p['follow'] || []).any?
-        cleaned_params['follow'] = cleaned_params['follow'].map(&:to_i)
+        cleaned_params['follow'] = cleaned_params['follow'].map(&:to_i) if cleaned_params['follow']
         cleaned_params['track'] = p['track'] if (p['track'] || []).any?
         cleaned_params
       end
 
       def ignore_tweet(tweet_item)
+        return if tweet_item.disconnect_notice?
         id = tweet_item['id_str']
         text = tweet_item['text']
-        user_id = tweet_item['user']['id_str']
+        user = tweet_item['user']
+        user_id = user['id_str'] if user
         Weeter.logger.info("Ignoring tweet #{id} from user #{user_id}: #{text}")
       end
 
@@ -116,6 +124,19 @@ module Weeter
 
         Weeter.logger.info("Rate Limiting tweet #{id} from user #{user_id}: #{text}")
       end
+
+      def publish_or_rate_limit(tweet_item)
+        limit_result = limiter.process(*tweet_item.limiting_facets)
+        case limit_result.status
+        when Weeter::Limitator::INITIATE_LIMITING
+          notify_rate_limiting_initiated(tweet_item, limit_result.limited_keys)
+          rate_limit_tweet(tweet_item)
+        when Weeter::Limitator::CONTINUE_LIMITING
+          rate_limit_tweet(tweet_item)
+        when Weeter::Limitator::DO_NOT_LIMIT
+          publish_tweet(tweet_item)
+        end
+      end
     end
   end
 end

data/lib/weeter/twitter/tweet_item.rb

@@ -20,7 +20,20 @@ module Weeter
     end
 
     def publishable?
-      !retweeted? && !reply?
+      !retweeted? && !reply? && !disconnect_notice? && !limit_notice?
+    end
+
+    def disconnect_notice?
+      !@tweet_hash['disconnect'].nil?
+    end
+
+    def limit_notice?
+      !@tweet_hash['limit'].nil?
+    end
+
+    def missed_tweets_count
+      return nil unless limit_notice?
+      @tweet_hash['limit']['track']
     end
 
     def [](val)
@@ -31,6 +44,10 @@ module Weeter
       MultiJson.encode(@tweet_hash)
     end
 
+    def to_hash
+      @tweet_hash
+    end
+
     def limiting_facets
       self['entities']['hashtags'].map do |tag|
         tag['text'].downcase.chomp

data/lib/weeter/version.rb

@@ -1,3 +1,3 @@
 module Weeter
-  VERSION = "0.11.0"
+  VERSION = "0.13.0"
 end

data/spec/weeter/limitator_spec.rb

@@ -17,46 +17,57 @@ describe Weeter::Limitator do
     it { limitator.should be }
   end
 
-  describe '#limit?' do
+  describe '#limit_status' do
 
     subject do
-      limitator.limit?(*keys)
+      limitator.process(*keys)
     end
 
     context 'max: 0' do
       let(:max) { 0 }
-      it { should be_true }
+      its(:status) { should == Weeter::Limitator::INITIATE_LIMITING }
+      its(:limited_keys) { should == keys }
 
       context 'no keys' do
         let(:keys) { [] }
-        it { should be_false }
+        its(:status) { should == Weeter::Limitator::DO_NOT_LIMIT }
+        its(:limited_keys) { should == nil }
+      end
+
+      context 'two keys' do
+        let(:keys) { ['key', 'key2'] }
+        its(:status) { should == Weeter::Limitator::INITIATE_LIMITING }
+        its(:limited_keys) { should == keys }
       end
     end
 
     context 'max: 1' do
       let(:max) { 1 }
 
-      it { should be_false }
+      its(:status) { should == Weeter::Limitator::DO_NOT_LIMIT }
+      its(:limited_keys) { should == nil }
 
       context 'two keys within max' do
         let(:keys) { ['key', 'key2'] }
 
-        it { should be_false }
+        its(:status) { should == Weeter::Limitator::DO_NOT_LIMIT }
       end
 
       context 'no keys' do
         let(:keys) { [] }
-        it { should be_false }
+        its(:status) { should == Weeter::Limitator::DO_NOT_LIMIT }
+        its(:limited_keys) { should == nil }
       end
 
-      context 'one key outside max' do
+      context 'one key just outside max' do
         before do
           max.times do
-            limitator.limit?(*keys)
+            limitator.process(*keys)
           end
         end
 
-        it { should be_true }
+        its(:status) { should == Weeter::Limitator::INITIATE_LIMITING }
+        its(:limited_keys) { should == keys }
 
         context 'outside duration' do
           let(:some_time_after_duration) do
@@ -67,31 +78,71 @@ describe Weeter::Limitator do
             limitator.stub(:now).and_return(some_time_after_duration)
           end
 
-          it { should be_false }
+          its(:status) { should == Weeter::Limitator::DO_NOT_LIMIT }
+          its(:limited_keys) { should == nil }
+        end
+      end
+
+      context 'two keys just past max' do
+        let(:keys) { ['key', 'key2'] }
+
+        before do
+          limitator.process(*keys)
         end
+
+        its(:status) { should == Weeter::Limitator::INITIATE_LIMITING }
+        its(:limited_keys) { should == keys }
       end
 
-      context 'two keys outside' do
+      context 'two keys past max' do
         let(:keys) { ['key', 'key2'] }
 
         before do
-          limitator.limit?(*keys)
+          limitator.process(*keys)
+          limitator.process(*keys)
         end
 
-        it { should be_true }
+        its(:status) { should == Weeter::Limitator::CONTINUE_LIMITING }
+        its(:limited_keys) { should == keys }
       end
 
-      context 'one key outside max: 1, one key within max: 1' do
+      context 'one key just past max: 1, one key within max: 1' do
         let(:max) { 1 }
         let(:keys) { ['key', 'key2'] }
 
         before do
-          limitator.limit?(*[keys.first])
+          limitator.process(keys.first)
         end
 
-        it { should be_true }
+        its(:status) { should == Weeter::Limitator::INITIATE_LIMITING }
+        its(:limited_keys) { should == [keys.first] }
+      end
+
+      context 'one key past max: 1, one key within max: 1' do
+        let(:max) { 1 }
+        let(:keys) { ['key', 'key2'] }
+
+        before do
+          limitator.process(keys.first)
+          limitator.process(keys.first)
+        end
+
+        its(:status) { should == Weeter::Limitator::CONTINUE_LIMITING }
+        its(:limited_keys) { should == [keys.first] }
+      end
+
+      context 'one key past max: 1, one key just past max: 1' do
+        let(:max) { 1 }
+        let(:keys) { ['key', 'key2'] }
+
+        before do
+          limitator.process(*[keys.first])
+          limitator.process(*[keys.first, keys.last])
+        end
+
+        its(:status) { should == Weeter::Limitator::INITIATE_LIMITING }
+        its(:limited_keys) { should == keys }
       end
     end
   end
 end
-

data/spec/weeter/twitter/tweet_consumer_spec.rb

@@ -10,7 +10,7 @@ describe Weeter::Twitter::TweetConsumer do
 
   describe "auth" do
     it 'should use connect to JSON stream with auth options for the configuration' do
-      @mock_stream = mock('JSONStream', :each_item => nil, :on_error => nil, :on_max_reconnects => nil)
+      @mock_stream = mock('JSONStream', :each_item => nil, :on_error => nil, :on_max_reconnects => nil, :on_close => nil)
       Twitter::JSONStream.stub!(:connect).and_return(@mock_stream)
 
       Weeter::Configuration::TwitterConfig.instance.stub!(:auth_options).and_return(:foo => :bar)
@@ -91,13 +91,22 @@ describe Weeter::Twitter::TweetConsumer do
 
   describe "connecting to twitter" do
 
+    let(:tweet_values) {
+      [@tweet_hash]
+    }
+    let(:mock_stream) {
+      mock_stream = mock('JSONStream', :on_error => nil, :on_max_reconnects => nil, :on_close => nil)
+      each_item_stub = mock_stream.stub!(:each_item)
+      tweet_values.each do |t|
+        each_item_stub.and_yield(MultiJson.encode(t))
+      end
+      mock_stream
+    }
     before(:each) do
       @filter_params = {'follow' => ['1','2','3']}
       Weeter::Configuration::TwitterConfig.instance.stub!(:auth_options).and_return(:foo => :bar)
-      @tweet_values = {'text' => "Hey", 'id_str' => "123", 'user' => {'id_str' => "1"}}
-      @mock_stream = mock('JSONStream', :on_error => nil, :on_max_reconnects => nil)
-      @mock_stream.stub!(:each_item).and_yield(MultiJson.encode(@tweet_values))
-      Twitter::JSONStream.stub!(:connect).and_return(@mock_stream)
+      @tweet_hash = {'text' => "Hey", 'id_str' => "123", 'user' => {'id_str' => "1"}}
+      Twitter::JSONStream.stub!(:connect).and_return(mock_stream)
       @client_proxy = mock('NotificationPlugin', :publish_tweet => nil)
       @consumer = Weeter::Twitter::TweetConsumer.new(Weeter::Configuration::TwitterConfig.instance, @client_proxy, limiter)
     end
@@ -107,7 +116,7 @@ describe Weeter::Twitter::TweetConsumer do
     end
 
     it "should instantiate a TweetItem" do
-      tweet_item = Weeter::TweetItem.new(@tweet_values)
+      tweet_item = Weeter::TweetItem.new(@tweet_hash)
       Weeter::TweetItem.should_receive(:new).with({'text' => "Hey", 'id_str' => "123", 'user' => {'id_str' => "1"}}).and_return(tweet_item)
     end
 
@@ -117,22 +126,41 @@ describe Weeter::Twitter::TweetConsumer do
     end
 
     it "should publish new tweet if publishable" do
-      mock_tweet = mock('tweet', :deletion? => false, :publishable? => true, :limiting_facets => [])
-      tweet_item = Weeter::TweetItem.stub!(:new).and_return mock_tweet
+      mock_tweet = mock('tweet', :deletion? => false, :publishable? => true, :limit_notice? => false, :limiting_facets => [])
+      Weeter::TweetItem.stub!(:new).and_return(mock_tweet)
       @client_proxy.should_receive(:publish_tweet).with(mock_tweet)
     end
 
     it "should not publish unpublishable tweets" do
-      mock_tweet = mock('tweet', :deletion? => false, :publishable? => false, :[] => '', :limiting_facets => [])
-      tweet_item = Weeter::TweetItem.stub!(:new).and_return mock_tweet
+      mock_tweet = mock('tweet', :deletion? => false, :publishable? => false, :limit_notice? => false, :[] => '', :limiting_facets => [])
+      Weeter::TweetItem.stub!(:new).and_return mock_tweet
       @client_proxy.should_not_receive(:publish_tweet).with(mock_tweet)
     end
 
     it "should delete deletion tweets" do
-      mock_tweet = mock('tweet', :deletion? => true, :publishable? => false, :limiting_facets => [])
-      tweet_item = Weeter::TweetItem.stub!(:new).and_return mock_tweet
+      mock_tweet = mock('tweet', :deletion? => true, :publishable? => false, :limit_notice? => false, :limiting_facets => [])
+      Weeter::TweetItem.stub!(:new).and_return mock_tweet
       @client_proxy.should_receive(:delete_tweet).with(mock_tweet)
     end
+
+    it "should notify when stream is limited by Twitter" do
+      tweet_item = Weeter::TweetItem.new({'limit' => { 'track' => 65 } })
+      Weeter::TweetItem.stub!(:new).and_return(tweet_item)
+      @client_proxy.should_receive(:notify_missed_tweets).with(tweet_item)
+    end
+
+    context "when weeter is initiating rate-limiting on a facet" do
+      let(:tweet_values) {
+        [@tweet_hash, @tweet_hash]
+      }
+      it "should notify that rate limiting is being initiated" do
+        tweet_item1 = mock('tweet', :deletion? => false, :publishable? => true, :limit_notice? => false, :limiting_facets => ['key'], :[] => '1')
+        tweet_item2 = mock('tweet', :deletion? => false, :publishable? => true, :limit_notice? => false, :limiting_facets => ['key'], :[] => '2')
+        Weeter::TweetItem.stub!(:new).and_return(tweet_item1, tweet_item2)
+
+        @client_proxy.should_receive(:notify_rate_limiting_initiated).with(tweet_item2, ['key'])
+      end
+    end
   end
 
 end

data/spec/weeter/twitter/tweet_item_spec.rb

@@ -1,6 +1,9 @@
 require 'spec_helper'
 
 describe Weeter::TweetItem do
+  let(:tweet_json) {
+    {'text' => "Hey", 'id_str' => "123", 'user' => {'id_str' => '1'}}
+  }
 
   describe "deletion?" do
     it "should be true if it is a deletion request" do
@@ -16,37 +19,54 @@ describe Weeter::TweetItem do
 
   describe "publishable" do
 
-    before do
-      @tweet_json = {'text' => "Hey", 'id_str' => "123", 'user' => {'id_str' => '1'}}
-    end
 
     it "should be publishable if not a reply or a retweet" do
-      item = Weeter::TweetItem.new(@tweet_json)
+      item = Weeter::TweetItem.new(tweet_json)
       item.should be_publishable
     end
 
     it "should not be publishable if implicitly retweeted" do
-      item = Weeter::TweetItem.new(@tweet_json.merge({'text' => 'RT @joe Hey'}))
+      item = Weeter::TweetItem.new(tweet_json.merge({'text' => 'RT @joe Hey'}))
       item.should_not be_publishable
     end
 
     it "should not be publishable if explicitly retweeted" do
-      item = Weeter::TweetItem.new(@tweet_json.merge('retweeted_status' => {'id_str' => '111', 'text' => 'Hey', 'user' => {'id_str' => "1"}}))
+      item = Weeter::TweetItem.new(tweet_json.merge('retweeted_status' => {'id_str' => '111', 'text' => 'Hey', 'user' => {'id_str' => "1"}}))
       item.should_not be_publishable
     end
 
     it "should not be publishable if implicit reply" do
-      item = Weeter::TweetItem.new(@tweet_json.merge('text' => '@joe Hey'))
+      item = Weeter::TweetItem.new(tweet_json.merge('text' => '@joe Hey'))
       item.should_not be_publishable
     end
 
     it "should not be publishable if explicit reply" do
-      item = Weeter::TweetItem.new(@tweet_json.merge('text' => '@joe Hey', 'in_reply_to_user_id_str' => '1'))
+      item = Weeter::TweetItem.new(tweet_json.merge('text' => '@joe Hey', 'in_reply_to_user_id_str' => '1'))
+      item.should_not be_publishable
+    end
+
+    it "should not be publishable if disconnect message" do
+      item = Weeter::TweetItem.new({"disconnect" => {"code" => 7,"stream_name" => "YappBox-statuses668638","reason" => "admin logout"}})
       item.should_not be_publishable
     end
 
   end
 
+  describe "limit_notice?" do
+    it "should be true if it's a limit notice" do
+      item = Weeter::TweetItem.new({ 'limit' => { 'track' => 65 }})
+      item.should be_limit_notice
+      item.missed_tweets_count.should == 65
+    end
+    it "should not be true if it's a limit notice" do
+      item = Weeter::TweetItem.new(tweet_json)
+      item.should_not be_limit_notice
+      lambda {
+        item.missed_tweets_count
+      }.should_not raise_error
+    end
+  end
+
   describe "json attributes" do
 
     it "should delegate hash calls to its json" do
@@ -63,4 +83,4 @@ describe Weeter::TweetItem do
 
 
 
-end
+end

data/weeter.gemspec

@@ -31,4 +31,5 @@ Gem::Specification.new do |s|
   s.add_dependency('lukemelia-twitter-stream', '~> 0.1.15')
 
   s.add_development_dependency 'rspec', '~> 2.6.0'
+  s.add_development_dependency 'ZenTest'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: weeter
 version: !ruby/object:Gem::Version
-  version: 0.11.0
+  version: 0.13.0
   prerelease: 
 platform: ruby
 authors:
@@ -11,11 +11,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-15 00:00:00.000000000Z
+date: 2012-12-04 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: eventmachine
-  requirement: &2154031740 !ruby/object:Gem::Requirement
+  requirement: &2161838440 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -23,10 +23,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *2154031740
+  version_requirements: *2161838440
 - !ruby/object:Gem::Dependency
   name: eventmachine_httpserver
-  requirement: &2154030760 !ruby/object:Gem::Requirement
+  requirement: &2161836940 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -34,10 +34,10 @@ dependencies:
         version: 0.2.1
   type: :runtime
   prerelease: false
-  version_requirements: *2154030760
+  version_requirements: *2161836940
 - !ruby/object:Gem::Dependency
   name: em-hiredis
-  requirement: &2154030240 !ruby/object:Gem::Requirement
+  requirement: &2161835100 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -45,10 +45,10 @@ dependencies:
         version: 0.1.0
   type: :runtime
   prerelease: false
-  version_requirements: *2154030240
+  version_requirements: *2161835100
 - !ruby/object:Gem::Dependency
   name: multi_json
-  requirement: &2154029760 !ruby/object:Gem::Requirement
+  requirement: &2161833640 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -56,10 +56,10 @@ dependencies:
         version: 1.0.2
   type: :runtime
   prerelease: false
-  version_requirements: *2154029760
+  version_requirements: *2161833640
 - !ruby/object:Gem::Dependency
   name: hashie
-  requirement: &2154029080 !ruby/object:Gem::Requirement
+  requirement: &2161832500 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -67,10 +67,10 @@ dependencies:
         version: 1.1.0
   type: :runtime
   prerelease: false
-  version_requirements: *2154029080
+  version_requirements: *2161832500
 - !ruby/object:Gem::Dependency
   name: em-http-request
-  requirement: &2154028360 !ruby/object:Gem::Requirement
+  requirement: &2161832040 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -78,10 +78,10 @@ dependencies:
         version: 1.0.0
   type: :runtime
   prerelease: false
-  version_requirements: *2154028360
+  version_requirements: *2161832040
 - !ruby/object:Gem::Dependency
   name: i18n
-  requirement: &2154027700 !ruby/object:Gem::Requirement
+  requirement: &2161831220 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -89,10 +89,10 @@ dependencies:
         version: 0.6.0
   type: :runtime
   prerelease: false
-  version_requirements: *2154027700
+  version_requirements: *2161831220
 - !ruby/object:Gem::Dependency
   name: activesupport
-  requirement: &2154027240 !ruby/object:Gem::Requirement
+  requirement: &2161830060 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -100,10 +100,10 @@ dependencies:
         version: 3.1.1
   type: :runtime
   prerelease: false
-  version_requirements: *2154027240
+  version_requirements: *2161830060
 - !ruby/object:Gem::Dependency
   name: simple_oauth
-  requirement: &2154026740 !ruby/object:Gem::Requirement
+  requirement: &2161829240 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -111,10 +111,10 @@ dependencies:
         version: 0.1.5
   type: :runtime
   prerelease: false
-  version_requirements: *2154026740
+  version_requirements: *2161829240
 - !ruby/object:Gem::Dependency
   name: lukemelia-twitter-stream
-  requirement: &2154026240 !ruby/object:Gem::Requirement
+  requirement: &2161828460 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -122,10 +122,10 @@ dependencies:
         version: 0.1.15
   type: :runtime
   prerelease: false
-  version_requirements: *2154026240
+  version_requirements: *2161828460
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &2154025660 !ruby/object:Gem::Requirement
+  requirement: &2161827700 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -133,7 +133,18 @@ dependencies:
         version: 2.6.0
   type: :development
   prerelease: false
-  version_requirements: *2154025660
+  version_requirements: *2161827700
+- !ruby/object:Gem::Dependency
+  name: ZenTest
+  requirement: &2161826960 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2161826960
 description: Weeter subscribes to a set of twitter users or search terms using Twitter's
   streaming API, and notifies your app with each new tweet.
 email: