tweetstream 1.1.5 → 2.0.0

data/lib/tweetstream/configuration.rb

@@ -16,8 +16,14 @@ module TweetStream
       :oauth_token,
       :oauth_token_secret].freeze
 
+    OAUTH_OPTIONS_KEYS = [
+      :consumer_key,
+      :consumer_secret,
+      :oauth_token,
+      :oauth_token_secret].freeze
+
     # The parser that will be used to connect if none is set
-    DEFAULT_PARSER = MultiJson.default_adapter
+    DEFAULT_PARSER = MultiJson.default_engine
 
     # By default, don't set a username
     DEFAULT_USERNAME = nil
@@ -47,9 +53,6 @@ module TweetStream
     # By default, don't set a user oauth secret
     DEFAULT_OAUTH_TOKEN_SECRET = nil
 
-    # Default time interval for use with on_interval
-    DEFAULT_TIMER_INTERVAL = 30
-
     # @private
     attr_accessor *VALID_OPTIONS_KEYS
 
@@ -68,9 +71,13 @@ module TweetStream
       Hash[*VALID_OPTIONS_KEYS.map {|key| [key, send(key)] }.flatten]
     end
 
+    # Create a hash of options and their values
+    def oauth_options
+      Hash[*OAUTH_OPTIONS_KEYS.map {|key| [key, send(key)] }.flatten]
+    end
+
     # Reset all configuration options to defaults
     def reset
-      self.parser             = DEFAULT_PARSER
       self.username           = DEFAULT_USERNAME
       self.password           = DEFAULT_PASSWORD
       self.user_agent         = DEFAULT_USER_AGENT

data/lib/tweetstream/site_stream_client.rb

@@ -0,0 +1,123 @@
+require 'em-http'
+require 'em-http/middleware/oauth'
+require 'em-http/middleware/json_response'
+
+module TweetStream
+  class SiteStreamClient
+
+    attr_accessor *Configuration::OAUTH_OPTIONS_KEYS
+
+    def initialize(config_uri, oauth = {})
+      @config_uri = config_uri
+
+      options = TweetStream.oauth_options.merge(oauth)
+      Configuration::OAUTH_OPTIONS_KEYS.each do |key|
+        send("#{key}=", options[key])
+      end
+
+      EventMachine::HttpRequest.use EventMachine::Middleware::JSONResponse
+    end
+
+    def on_error(&block)
+      if block_given?
+        @on_error = block
+        self
+      else
+        @on_error
+      end
+    end
+
+    def info(&block)
+      error_msg = 'Failed to retrieve SiteStream info.'
+
+      http = connection.get(:path => info_path)
+      http.callback do
+        if http.response_header.status == 200
+          block.call http.response if block && block.kind_of?(Proc)
+        else
+          @on_error.call(error_msg) if @on_error && @on_error.kind_of?(Proc)
+        end
+      end
+      http.errback do
+        @on_error.call(error_msg) if @on_error && @on_error.kind_of?(Proc)
+      end
+    end
+
+    def add_user(user_id, &block)
+      error_msg = 'Failed to add user to SiteStream'
+      user_management(add_user_path, user_id, error_msg, &block)
+    end
+
+    def remove_user(user_id, &block)
+      error_msg = 'Failed to remove user from SiteStream.'
+      user_management(remove_user_path, user_id, error_msg, &block)
+    end
+
+    def friends_ids(user_id, &block)
+      error_msg = 'Failed to retrieve SiteStream friends ids.'
+
+      http = connection.post(:path => friends_ids_path, :body => { 'user_id' => user_id })
+      http.callback do
+        if http.response_header.status == 200
+          block.call http.response if block && block.kind_of?(Proc)
+        else
+          @on_error.call(error_msg) if @on_error && @on_error.kind_of?(Proc)
+        end
+      end
+      http.errback do
+        @on_error.call(error_msg) if @on_error && @on_error.kind_of?(Proc)
+      end
+    end
+
+    private
+
+    def user_management(path, user_id, error_msg, &block)
+      user_id = user_id.join(',') if user_id.kind_of?(Array)
+
+      http = connection.post(:path => path, :body => { 'user_id' => user_id })
+      http.callback do
+        if http.response_header.status == 200
+          block.call if block && block.kind_of?(Proc)
+        else
+          @on_error.call(error_msg) if @on_error && @on_error.kind_of?(Proc)
+        end
+      end
+      http.errback do
+        @on_error.call(error_msg) if @on_error && @on_error.kind_of?(Proc)
+      end
+    end
+
+    def connection
+      return @conn if @conn
+
+      @conn = EventMachine::HttpRequest.new('https://sitestream.twitter.com/')
+      @conn.use EventMachine::Middleware::OAuth, oauth_configuration
+      @conn
+    end
+
+    def oauth_configuration
+      {
+        :consumer_key => consumer_key,
+        :consumer_secret => consumer_secret,
+        :access_token => oauth_token,
+        :access_token_secret => oauth_token_secret
+      }
+    end
+
+    def info_path
+      @config_uri + '/info.json'
+    end
+
+    def add_user_path
+      @config_uri + '/add_user.json'
+    end
+
+    def remove_user_path
+      @config_uri + '/remove_user.json'
+    end
+
+    def friends_ids_path
+      @config_uri + '/friends/ids.json'
+    end
+  end
+end

data/lib/tweetstream/version.rb

@@ -1,3 +1,3 @@
 module TweetStream
-  VERSION = '1.1.5'
+  VERSION = '2.0.0' unless defined?(TweetStream::VERSION)
 end

data/spec/fixtures/ids.json

@@ -0,0 +1,30 @@
+{
+    "follow":
+    {
+        "user":
+        {
+            "id":119476949,
+            "name":"oauth_dancer",
+            "dm":false
+        },
+        "friends":
+        [
+            795649,
+            819797,
+            1401881,
+            3191321,
+            6253282,
+            8285392,
+            9160152,
+            13058772,
+            15147442,
+            15266205,
+            15822993,
+            27831060,
+            101058399,
+            289788076
+        ],
+        "previous_cursor":0,
+        "next_cursor":0
+    }
+}

data/spec/fixtures/info.json

@@ -0,0 +1,18 @@
+{
+    "info":
+    {
+        "users":
+        [
+            {
+                "id":119476949,
+                "name":"oauth_dancer",
+                "dm":false
+            }
+        ],
+        "delimited":"none",
+        "include_followings_activity":false,
+        "include_user_changes":false,
+        "replies":"none",
+        "with":"user"
+    }
+}

data/spec/spec_helper.rb

@@ -7,7 +7,9 @@ unless ENV['CI']
 end
 
 require 'tweetstream'
+require 'tweetstream/site_stream_client'
 require 'rspec'
+require 'webmock/rspec'
 require 'yajl'
 require 'json'
 
@@ -30,3 +32,16 @@ def sample_direct_messages
   end
   @direct_messages
 end
+
+def fixture_path
+  File.expand_path("../fixtures", __FILE__)
+end
+
+def fixture(file)
+  File.new(fixture_path + '/' + file)
+end
+
+FakeHttp = Class.new do
+  def callback; end
+  def errback; end
+end

data/spec/tweetstream/client_spec.rb

@@ -3,9 +3,10 @@ require 'spec_helper'
 describe TweetStream::Client do
   before(:each) do
     TweetStream.configure do |config|
-      config.username = 'abc'
-      config.password = 'def'
-      config.auth_method = :basic
+      config.consumer_key = 'abc'
+      config.consumer_secret = 'def'
+      config.oauth_token = '123'
+      config.oauth_token_secret = '456'
     end
     @client = TweetStream::Client.new
   end
@@ -48,49 +49,53 @@ describe TweetStream::Client do
 
   describe '#start' do
     before do
-      @stream = stub("Twitter::JSONStream",
+      @stream = stub("EM::Twitter::Client",
         :connect => true,
         :unbind => true,
-        :each_item => true,
+        :each => true,
         :on_error => true,
         :on_max_reconnects => true,
         :on_reconnect => true,
-        :connection_completed => true
+        :connection_completed => true,
+        :on_no_data_received => true
       )
       EM.stub!(:run).and_yield
-      Twitter::JSONStream.stub!(:connect).and_return(@stream)
+      EM::Twitter::Client.stub!(:connect).and_return(@stream)
     end
 
     it 'should try to connect via a JSON stream with basic auth' do
-      Twitter::JSONStream.should_receive(:connect).with(
+      EM::Twitter::Client.should_receive(:connect).with(
         :path => URI.parse('/1/statuses/filter.json'),
         :method => 'POST',
         :user_agent => TweetStream::Configuration::DEFAULT_USER_AGENT,
         :on_inited => nil,
-        :filters => 'monday',
-        :params => {},
-        :ssl => true,
-        :auth => 'abc:def'
+        :params => { :track => 'monday'},
+        :oauth => {
+          :consumer_key => 'abc',
+          :consumer_secret => 'def',
+          :token => '123',
+          :token_secret => '456'
+        }
       ).and_return(@stream)
 
       @client.track('monday')
     end
 
-    describe '#each_item' do
+    describe '#each' do
       it 'should call the appropriate parser' do
         @client = TweetStream::Client.new
         MultiJson.should_receive(:decode).and_return({})
-        @stream.should_receive(:each_item).and_yield(sample_tweets[0].to_json)
+        @stream.should_receive(:each).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)}
+      it 'should yield a Twitter::Status' do
+        @stream.should_receive(:each).and_yield(sample_tweets[0].to_json)
+        @client.track('abc'){|s| s.should be_kind_of(Twitter::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)
+        @stream.should_receive(:each).and_yield(sample_tweets[0].to_json)
         @client.track('abc'){|s,c| c.should == @client}
       end
 
@@ -99,7 +104,7 @@ describe TweetStream::Client do
         tweet[:id] = 123
         tweet[:user][:screen_name] = 'monkey'
         tweet[:text] = "Oo oo aa aa"
-        @stream.should_receive(:each_item).and_yield(tweet.to_json)
+        @stream.should_receive(:each).and_yield(tweet.to_json)
         @client.track('abc') do |s|
           s[:id].should == 123
           s.user.screen_name.should == 'monkey'
@@ -109,7 +114,7 @@ describe TweetStream::Client do
 
       it 'should call the on_scrub_geo if specified' do
         scrub_geo = '{ "scrub_geo": { "user_id": 1234, "user_id_str": "1234", "up_to_status_id":9876, "up_to_status_id_string": "9876" } }'
-        @stream.should_receive(:each_item).and_yield(scrub_geo)
+        @stream.should_receive(:each).and_yield(scrub_geo)
         @client.on_scrub_geo do |up_to_status_id, user_id|
           up_to_status_id.should == 9876
           user_id.should == 1234
@@ -118,7 +123,7 @@ describe TweetStream::Client do
 
       it 'should call the delete if specified' do
         delete = '{ "delete": { "status": { "id": 1234, "user_id": 3 } } }'
-        @stream.should_receive(:each_item).and_yield(delete)
+        @stream.should_receive(:each).and_yield(delete)
         @client.on_delete do |id, user_id|
           id.should == 1234
           user_id.should == 3
@@ -127,7 +132,7 @@ describe TweetStream::Client do
 
       it 'should call the on_limit if specified' do
         limit = '{ "limit": { "track": 1234 } }'
-        @stream.should_receive(:each_item).and_yield(limit)
+        @stream.should_receive(:each).and_yield(limit)
         @client.on_limit do |track|
           track.should == 1234
         end.track('abc')
@@ -136,17 +141,17 @@ describe TweetStream::Client do
       context "using on_anything" do
         it "yields the raw hash" do
           hash = {:id => 1234}
-          @stream.should_receive(:each_item).and_yield(hash.to_json)
+          @stream.should_receive(:each).and_yield(hash.to_json)
           yielded_hash = nil
           @client.on_anything do |hash|
             yielded_hash = hash
           end.track('abc')
           yielded_hash.should_not be_nil
-          yielded_hash.id.should == 1234
+          yielded_hash['id'].should == 1234
         end
         it 'yields itself if block has an arity of 2' do
           hash = {:id => 1234}
-          @stream.should_receive(:each_item).and_yield(hash.to_json)
+          @stream.should_receive(:each).and_yield(hash.to_json)
           yielded_client = nil
           @client.on_anything do |_, client|
             yielded_client = client
@@ -162,7 +167,7 @@ describe TweetStream::Client do
           tweet[:id] = 123
           tweet[:user][:screen_name] = 'monkey'
           tweet[:text] = "Oo oo aa aa"
-          @stream.should_receive(:each_item).and_yield(tweet.to_json)
+          @stream.should_receive(:each).and_yield(tweet.to_json)
           yielded_status = nil
           @client.on_timeline_status do |status|
             yielded_status = status
@@ -173,7 +178,7 @@ describe TweetStream::Client do
           yielded_status.text.should == 'Oo oo aa aa'
         end
         it 'yields itself if block has an arity of 2' do
-          @stream.should_receive(:each_item).and_yield(sample_tweets[0].to_json)
+          @stream.should_receive(:each).and_yield(sample_tweets[0].to_json)
           yielded_client = nil
           @client.on_timeline_status do |_, client|
             yielded_client = client
@@ -188,18 +193,18 @@ describe TweetStream::Client do
           direct_message = sample_direct_messages[0]
           direct_message["direct_message"]["id"] = 1234
           direct_message["direct_message"]["sender"]["screen_name"] = "coder"
-          @stream.should_receive(:each_item).and_yield(direct_message.to_json)
+          @stream.should_receive(:each).and_yield(direct_message.to_json)
           yielded_dm = nil
           @client.on_direct_message do |dm|
             yielded_dm = dm
           end.userstream
           yielded_dm.should_not be_nil
           yielded_dm.id.should == 1234
-          yielded_dm.user.screen_name.should == "coder"
+          yielded_dm.sender.screen_name.should == "coder"
         end
 
         it 'yields itself if block has an arity of 2' do
-          @stream.should_receive(:each_item).and_yield(sample_direct_messages[0].to_json)
+          @stream.should_receive(:each).and_yield(sample_direct_messages[0].to_json)
           yielded_client = nil
           @client.on_direct_message do |_, client|
             yielded_client = client
@@ -209,14 +214,14 @@ describe TweetStream::Client do
       end
 
       it 'should call on_error if a non-hash response is received' do
-        @stream.should_receive(:each_item).and_yield('["favorited"]')
+        @stream.should_receive(:each).and_yield('["favorited"]')
         @client.on_error do |message|
           message.should == 'Unexpected JSON object in stream: ["favorited"]'
         end.track('abc')
       end
 
       it 'should call on_error if a json parse error occurs' do
-        @stream.should_receive(:each_item).and_yield("{'a_key':}")
+        @stream.should_receive(:each).and_yield("{'a_key':}")
         @client.on_error do |message|
           message.should == "MultiJson::DecodeError occured in stream: {'a_key':}"
         end.track('abc')
@@ -320,7 +325,7 @@ describe TweetStream::Client do
     end
   end
 
-  %w(on_delete on_limit on_inited on_reconnect).each do |proc_setter|
+  %w(on_delete on_limit on_inited on_reconnect on_no_data_received).each do |proc_setter|
     describe "##{proc_setter}" do
       it 'should set when a block is given' do
         proc = Proc.new{|a,b| puts a }
@@ -334,23 +339,6 @@ describe TweetStream::Client do
     end
   end
 
-  describe '#on_interval' do
-    it 'should set when a block is given' do
-      @client.on_interval(5) { puts 'hi' }
-      @client.on_interval[0].should == 5
-      @client.on_interval[1].should be_kind_of(Proc)
-    end
-
-    it 'should should create a periodic timer' do
-      # need to figure out a better way to test this
-      # for now, using on_inited to stop the reactor
-      proc = Proc.new{ puts 'hi' }
-      EM.should_receive(:add_periodic_timer).once.with(5)
-      @client.on_inited { EM.stop }.on_interval(5, &proc)
-      @client.track('go')
-    end
-  end
-
   describe '#stop' do
     it 'should call EventMachine::stop_event_loop' do
       EventMachine.should_receive :stop_event_loop
@@ -374,17 +362,18 @@ describe TweetStream::Client do
 
   describe '#stop_stream' do
     before(:each) do
-      @stream = stub("Twitter::JSONStream",
+      @stream = stub("EM::Twitter::Client",
         :connect => true,
         :unbind => true,
-        :each_item => true,
+        :each => true,
         :on_error => true,
         :on_max_reconnects => true,
         :on_reconnect => true,
         :connection_completed => true,
+        :on_no_data_received => true,
         :stop => true
       )
-      Twitter::JSONStream.stub!(:connect).and_return(@stream)
+      EM::Twitter::Client.stub!(:connect).and_return(@stream)
       @client = TweetStream::Client.new
       @client.connect('/')
     end
@@ -400,6 +389,46 @@ describe TweetStream::Client do
     end
   end
 
+  describe "basic auth" do
+    before do
+      TweetStream.configure do |config|
+        config.username = 'tweetstream'
+        config.password = 'rubygem'
+        config.auth_method = :basic
+      end
+      @client = TweetStream::Client.new
+
+      @stream = stub("EM::Twitter::Client",
+        :connect => true,
+        :unbind => true,
+        :each => true,
+        :on_error => true,
+        :on_max_reconnects => true,
+        :on_reconnect => true,
+        :connection_completed => true,
+        :on_no_data_received => true
+      )
+      EM.stub!(:run).and_yield
+      EM::Twitter::Client.stub!(:connect).and_return(@stream)
+    end
+
+    it 'should try to connect via a JSON stream with oauth' do
+      EM::Twitter::Client.should_receive(:connect).with(
+        :path => URI.parse('/1/statuses/filter.json'),
+        :method => 'POST',
+        :user_agent => TweetStream::Configuration::DEFAULT_USER_AGENT,
+        :on_inited => nil,
+        :params => {:track => 'monday'},
+        :basic => {
+          :username => 'tweetstream',
+          :password => 'rubygem'
+        }
+      ).and_return(@stream)
+
+      @client.track('monday')
+    end
+  end
+
   describe "oauth" do
     describe '#start' do
       before do
@@ -412,33 +441,32 @@ describe TweetStream::Client do
         end
         @client = TweetStream::Client.new
 
-        @stream = stub("Twitter::JSONStream",
+        @stream = stub("EM::Twitter::Client",
           :connect => true,
           :unbind => true,
-          :each_item => true,
+          :each => true,
           :on_error => true,
           :on_max_reconnects => true,
           :on_reconnect => true,
-          :connection_completed => true
+          :connection_completed => true,
+          :on_no_data_received => true
         )
         EM.stub!(:run).and_yield
-        Twitter::JSONStream.stub!(:connect).and_return(@stream)
+        EM::Twitter::Client.stub!(:connect).and_return(@stream)
       end
 
       it 'should try to connect via a JSON stream with oauth' do
-        Twitter::JSONStream.should_receive(:connect).with(
+        EM::Twitter::Client.should_receive(:connect).with(
           :path => URI.parse('/1/statuses/filter.json'),
           :method => 'POST',
           :user_agent => TweetStream::Configuration::DEFAULT_USER_AGENT,
           :on_inited => nil,
-          :filters => 'monday',
-          :params => {},
-          :ssl => true,
+          :params => {:track => 'monday'},
           :oauth => {
             :consumer_key => '123456789',
             :consumer_secret => 'abcdefghijklmnopqrstuvwxyz',
-            :access_key => '123456789',
-            :access_secret => 'abcdefghijklmnopqrstuvwxyz'
+            :token => '123456789',
+            :token_secret => 'abcdefghijklmnopqrstuvwxyz'
           }
         ).and_return(@stream)
 
@@ -447,15 +475,94 @@ describe TweetStream::Client do
 
       context "when calling #userstream" do
         it "sends the userstream host" do
-          Twitter::JSONStream.should_receive(:connect).with(hash_including(:host => "userstream.twitter.com")).and_return(@stream)
+          EM::Twitter::Client.should_receive(:connect).with(hash_including(:host => "userstream.twitter.com")).and_return(@stream)
           @client.userstream
         end
 
         it "uses the userstream uri" do
-          Twitter::JSONStream.should_receive(:connect).with(hash_including(:path => "/2/user.json")).and_return(@stream)
+          EM::Twitter::Client.should_receive(:connect).with(hash_including(:path => "/2/user.json")).and_return(@stream)
           @client.userstream
         end
       end
+
+      context "when calling #sitestream" do
+        it "sends the sitestream host" do
+          EM::Twitter::Client.should_receive(:connect).with(hash_including(:host => "sitestream.twitter.com")).and_return(@stream)
+          @client.sitestream
+        end
+
+        it "uses the userstream uri" do
+          EM::Twitter::Client.should_receive(:connect).with(hash_including(:path => "/2b/site.json")).and_return(@stream)
+          @client.sitestream
+        end
+
+        it 'supports the "with followings"' do
+          @client.should_receive(:start).once.with('', hash_including(:with => 'followings')).and_return(@stream)
+          @client.sitestream(['115192457'], :followings => true)
+        end
+
+        context 'control management' do
+          before do
+            @control_response = {"control" =>
+              {
+                "control_uri" =>"/2b/site/c/01_225167_334389048B872A533002B34D73F8C29FD09EFC50"
+              }
+            }
+          end
+          it 'assigns the control_uri' do
+            @stream.should_receive(:each).and_yield(@control_response.to_json)
+            @client.sitestream
+
+            @client.control_uri.should eq("/2b/site/c/01_225167_334389048B872A533002B34D73F8C29FD09EFC50")
+          end
+
+          it 'instantiates a SiteStreamClient' do
+            @stream.should_receive(:each).and_yield(@control_response.to_json)
+            @client.sitestream
+
+            @client.control.should be_kind_of(TweetStream::SiteStreamClient)
+          end
+
+          it "passes the client's on_error to the SiteStreamClient" do
+            called = false
+            @client.on_error { |err| called = true }
+            @stream.should_receive(:each).and_yield(@control_response.to_json)
+            @client.sitestream
+
+            @client.control.on_error.call
+
+            called.should be_true
+          end
+        end
+
+        context 'data handling' do
+          before do
+            tweet = sample_tweets[0]
+            @ss_message = {'for_user' => '12345', 'message' => {'id' => 123, 'user' => {'screen_name' => 'monkey'}, 'text' => 'Oo oo aa aa'}}
+          end
+
+          it 'yields a site stream message' do
+            @stream.should_receive(:each).and_yield(@ss_message.to_json)
+            yielded_status = nil
+            @client.sitestream do |message|
+              yielded_status = message
+            end
+            yielded_status.should_not be_nil
+            yielded_status['for_user'].should == '12345'
+            yielded_status['message']['user']['screen_name'].should == 'monkey'
+            yielded_status['message']['text'].should == 'Oo oo aa aa'
+          end
+          it 'yields itself if block has an arity of 2' do
+            @stream.should_receive(:each).and_yield(@ss_message.to_json)
+            yielded_client = nil
+            @client.sitestream do |_, client|
+              yielded_client = client
+            end
+            yielded_client.should_not be_nil
+            yielded_client.should == @client
+          end
+        end
+      end
     end
   end