tweetstream 1.0.5 → 1.1.0.rc1

data/lib/tweetstream/configuration.rb

@@ -0,0 +1,82 @@
+require 'multi_json'
+require 'tweetstream/version'
+
+module TweetStream
+  # Defines constants and methods related to configuration
+  module Configuration
+    # An array of valid keys in the options hash when configuring TweetStream.
+    VALID_OPTIONS_KEYS = [
+      :parser,
+      :username,
+      :password,
+      :user_agent,
+      :auth_method,
+      :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_engine
+
+    # By default, don't set a username
+    DEFAULT_USERNAME = nil
+
+    # By default, don't set a password
+    DEFAULT_PASSWORD = nil
+
+    # The user agent that will be sent to the API endpoint if none is set
+    DEFAULT_USER_AGENT = "TweetStream Ruby Gem #{TweetStream::VERSION}".freeze
+
+    # The default authentication method
+    DEFAULT_AUTH_METHOD = :oauth
+
+    VALID_FORMATS = [
+      :basic,
+      :oauth].freeze
+
+    # By default, don't set an application key
+    DEFAULT_CONSUMER_KEY = nil
+
+    # By default, don't set an application secret
+    DEFAULT_CONSUMER_SECRET = nil
+
+    # By default, don't set a user oauth token
+    DEFAULT_OAUTH_TOKEN = nil
+
+    # By default, don't set a user oauth secret
+    DEFAULT_OAUTH_TOKEN_SECRET = nil
+
+    # @private
+    attr_accessor *VALID_OPTIONS_KEYS
+
+    # When this module is extended, set all configuration options to their default values
+    def self.extended(base)
+      base.reset
+    end
+
+    # Convenience method to allow configuration options to be set in a block
+    def configure
+      yield self
+    end
+
+    # Create a hash of options and their values
+    def options
+      Hash[VALID_OPTIONS_KEYS.map {|key| [key, send(key)] }]
+    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
+      self.auth_method        = DEFAULT_AUTH_METHOD
+      self.consumer_key       = DEFAULT_CONSUMER_KEY
+      self.consumer_secret    = DEFAULT_CONSUMER_SECRET
+      self.oauth_token        = DEFAULT_OAUTH_TOKEN
+      self.oauth_token_secret = DEFAULT_OAUTH_TOKEN_SECRET
+      self
+    end
+  end
+end

data/lib/tweetstream/daemon.rb

@@ -30,10 +30,14 @@ class TweetStream::Daemon < TweetStream::Client
     @app_name = app_name
     super(user, pass, parser)
   end
-  
+
   def start(path, query_parameters = {}, &block) #:nodoc:
+    # Because of a change in Ruvy 1.8.7 patchlevel 249, you cannot call anymore
+    # super inside a block. So I assign to a variable the base class method before
+    # the Daemons block begins.
+    startmethod = super.start
     Daemons.run_proc(@app_name || 'tweetstream', :multiple => true) do
-      super(path, query_parameters, &block)
+      startmethod(path, query_parameters, &block)
     end
   end
 end

data/lib/tweetstream/version.rb

@@ -0,0 +1,3 @@
+module TweetStream
+  VERSION = '1.1.0.rc1'
+end

data/spec/spec_helper.rb

@@ -1,10 +1,15 @@
+require 'simplecov'
+SimpleCov.start do
+  add_group 'Tweetstream', 'lib/tweetstream'
+  add_group 'Specs', 'spec'
+end
+
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 
-require 'rubygems'
 require 'tweetstream'
-require 'spec'
-require 'spec/autorun'
+require 'rspec'
+require 'rspec/autorun'
 require 'yajl'
 require 'json'
 
@@ -19,7 +24,3 @@ def sample_tweets
     @tweets
   end
 end
-
-Spec::Runner.configure do |config|
-  
-end

data/spec/tweetstream/client_spec.rb

@@ -1,17 +1,16 @@
 require File.dirname(__FILE__) + '/../spec_helper'
 
 describe TweetStream::Client do
-  it 'should set the username and password from the initializers' do
-    @client = TweetStream::Client.new('abc','def')
-    @client.username.should == 'abc'
-    @client.password.should == 'def'
+  before(:each) do
+    TweetStream.configure do |config|
+      config.username = 'abc'
+      config.password = 'def'
+      config.auth_method = :basic
+    end
+    @client = TweetStream::Client.new
   end
 
   describe '#build_uri' do
-    before do
-      @client = TweetStream::Client.new('abc','def')
-    end
-
     it 'should return a URI' do
       @client.send(:build_uri, '').is_a?(URI).should be_true
     end
@@ -26,10 +25,6 @@ describe TweetStream::Client do
   end
 
   describe '#build_post_body' do
-    before do
-      @client = TweetStream::Client.new('abc','def')
-    end
-  
     it 'should return a blank string if passed a nil value' do
       @client.send(:build_post_body, nil).should == ''
     end
@@ -53,71 +48,73 @@ describe TweetStream::Client do
 
   describe '#start' do
     before do
-      @stream = stub("Twitter::JSONStream", 
+      @stream = stub("Twitter::JSONStream",
         :connect => true,
-        :unbind => true, 
-        :each_item => 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 try to connect via a JSON stream' do
+
+    it 'should try to connect via a JSON stream with basic auth' 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'
+        :user_agent => TweetStream::Configuration::DEFAULT_USER_AGENT,
+        :on_inited => nil,
+        :filters => 'monday',
+        :params => {},
+        :ssl => true,
+        :auth => 'abc:def'
       ).and_return(@stream)
-      
+
       @client.track('monday')
     end
-    
+
     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({})
+        @client = TweetStream::Client.new
+        MultiJson.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| 
+        @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| 
+        @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)
@@ -125,15 +122,22 @@ describe TweetStream::Client do
           track.should == 1234
         end.track('abc')
       end
-      
+
       it 'should call on_error if a non-hash response is received' do
         @stream.should_receive(:each_item).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':}")
+        @client.on_error do |message|
+          message.should == "MultiJson::DecodeError occured in stream: {'a_key':}"
+        end.track('abc')
+      end
     end
-    
+
     describe '#on_error' do
       it 'should pass the message on to the error block' do
         @stream.should_receive(:on_error).and_yield('Uh oh')
@@ -142,7 +146,7 @@ describe TweetStream::Client do
         end.track('abc')
       end
     end
-    
+
     describe '#on_max_reconnects' do
       it 'should raise a ReconnectError' do
         @stream.should_receive(:on_max_reconnects).and_yield(30, 20)
@@ -153,51 +157,52 @@ describe TweetStream::Client do
       end
     end
   end
-  
+
   describe ' API methods' do
-    before do
-      @client = TweetStream::Client.new('abc','def')
-    end
-    
     %w(firehose retweet sample).each do |method|
       it "##{method} should make a call to start with \"statuses/#{method}\"" do
         @client.should_receive(:start).once.with('statuses/' + method, {})
         @client.send(method)
       end
     end
-    
+
     it '#track should make a call to start with "statuses/filter" and a track query parameter' do
-      @client.should_receive(:start).once.with('statuses/filter', :track => 'test', :method => :post)
+      @client.should_receive(:start).once.with('statuses/filter', :track => ['test'], :method => :post)
       @client.track('test')
     end
-    
+
     it '#track should comma-join multiple arguments' do
-      @client.should_receive(:start).once.with('statuses/filter', :track => 'foo,bar,baz', :method => :post)
+      @client.should_receive(:start).once.with('statuses/filter', :track => ['foo', 'bar', 'baz'], :method => :post)
       @client.track('foo', 'bar', 'baz')
     end
-    
+
+    it '#track should comma-join an array of arguments' do
+      @client.should_receive(:start).once.with('statuses/filter', :track => [['foo','bar','baz']], :method => :post)
+      @client.track(['foo','bar','baz'])
+    end
+
     it '#follow should make a call to start with "statuses/filter" and a follow query parameter' do
-      @client.should_receive(:start).once.with('statuses/filter', :follow => '123', :method => :post)
+      @client.should_receive(:start).once.with('statuses/filter', :follow => [123], :method => :post)
       @client.follow(123)
     end
-    
+
     it '#follow should comma-join multiple arguments' do
-      @client.should_receive(:start).once.with('statuses/filter', :follow => '123,456', :method => :post)
+      @client.should_receive(:start).once.with('statuses/filter', :follow => [123,456], :method => :post)
       @client.follow(123, 456)
     end
-    
+
     it '#filter should make a call to "statuses/filter" with the query params provided' do
-      @client.should_receive(:start).once.with('statuses/filter', :follow => '123', :method => :post)
+      @client.should_receive(:start).once.with('statuses/filter', :follow => 123, :method => :post)
       @client.filter(:follow => 123)
     end
+    it '#filter should make a call to "statuses/filter" with the query params provided longitude/latitude pairs, separated by commas ' do
+      @client.should_receive(:start).once.with('statuses/filter', :locations => '-122.75,36.8,-121.75,37.8,-74,40,-73,41', :method => :post)
+      @client.filter(:locations => '-122.75,36.8,-121.75,37.8,-74,40,-73,41')
+    end
   end
-  
-  %w(on_delete on_limit).each do |proc_setter|
+
+  %w(on_delete on_limit on_inited).each do |proc_setter|
     describe "##{proc_setter}" do
-      before do
-        @client = TweetStream::Client.new('abc','def')
-      end
-      
       it 'should set when a block is given' do
         proc = Proc.new{|a,b| puts a }
         @client.send(proc_setter, &proc)
@@ -207,27 +212,82 @@ describe TweetStream::Client do
   end
 
   describe '#track' do
-    before do
-      @client = TweetStream::Client.new('abc','def')
-    end
-
     it 'should call #start with "statuses/filter" and the provided queries' do
-      @client.should_receive(:start).once.with('statuses/filter', :track => 'rock', :method => :post)
+      @client.should_receive(:start).once.with('statuses/filter', :track => ['rock'], :method => :post)
       @client.track('rock')
     end
   end
 
+  describe '#locations' do
+    it 'should call #start with "statuses/filter" with the query params provided longitude/latitude pairs' do
+      @client.should_receive(:start).once.with('statuses/filter', :locations => ['-122.75,36.8,-121.75,37.8,-74,40,-73,41'], :method => :post)
+      @client.locations('-122.75,36.8,-121.75,37.8,-74,40,-73,41')
+    end
+
+    it 'should call #start with "statuses/filter" with the query params provided longitude/latitude pairs and additional filter' do
+      @client.should_receive(:start).once.with('statuses/filter', :locations => ['-122.75,36.8,-121.75,37.8,-74,40,-73,41'], :track => 'rock', :method => :post)
+      @client.locations('-122.75,36.8,-121.75,37.8,-74,40,-73,41', :track => 'rock')
+    end
+  end
+
   describe 'instance .stop' do
     it 'should call EventMachine::stop_event_loop' do
       EventMachine.should_receive :stop_event_loop
-      TweetStream::Client.new('test','fake').stop.should be_nil
+      TweetStream::Client.new.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 = TweetStream::Client.new
       client.send(:instance_variable_set, :@last_status, {})
       client.stop.should == {}
     end
   end
+
+  describe "oauth" do
+    describe '#start' do
+      before do
+        TweetStream.configure do |config|
+          config.consumer_key = '123456789'
+          config.consumer_secret = 'abcdefghijklmnopqrstuvwxyz'
+          config.oauth_token = '123456789'
+          config.oauth_token_secret = 'abcdefghijklmnopqrstuvwxyz'
+          config.auth_method = :oauth
+        end
+        @client = TweetStream::Client.new
+
+        @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)
+      end
+
+      it 'should try to connect via a JSON stream with oauth' do
+        Twitter::JSONStream.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,
+          :oauth => {
+            :consumer_key => '123456789',
+            :consumer_secret => 'abcdefghijklmnopqrstuvwxyz',
+            :access_key => '123456789',
+            :access_secret => 'abcdefghijklmnopqrstuvwxyz'
+          }
+        ).and_return(@stream)
+
+        @client.track('monday')
+      end
+    end
+  end
+
 end