tweetstream 2.1.0 → 2.2.0

data/README.md

@@ -1,8 +1,9 @@
-# TweetStream [![Build Status](https://secure.travis-ci.org/intridea/tweetstream.png?branch=master)][travis] [![Dependency Status](https://gemnasium.com/intridea/tweetstream.png?travis)][gemnasium]
+# TweetStream [![Build Status](https://secure.travis-ci.org/intridea/tweetstream.png?branch=master)][travis] [![Dependency Status](https://gemnasium.com/intridea/tweetstream.png?travis)][gemnasium] [![Code Climate](https://codeclimate.com/badge.png)][codeclimate]
 TweetStream provides simple Ruby access to [Twitter's Streaming API](https://dev.twitter.com/docs/streaming-api).
 
 [travis]: http://travis-ci.org/intridea/tweetstream
 [gemnasium]: https://gemnasium.com/intridea/tweetstream
+[codeclimate]: https://codeclimate.com/github/intridea/tweetstream
 
 ## Installation
 
@@ -57,7 +58,7 @@ additions in 2.0 include:
 
 ### OAuth
 
-OAuth is now the default authentication method.  Both userstreams and Site 
+OAuth is now the default authentication method.  Both userstreams and Site
 Streams exclusively work with OAuth.  TweetStream still supports Basic Auth,
 however it is no longer the default.  If you are still using Basic Auth, you
 should plan to move to OAuth as soon as possible.
@@ -68,7 +69,7 @@ Site Streams are now fully supported, including the connection management functi
 
 ### Compatablity with the Twitter gem
 
-TweetStream now emits objects from the [Twitter gem](https://github.com/jnunemaker/twitter) instead of custom hashes. These objects are already defined in the `twitter` gem and are superior to the custom objects in the following ways:
+TweetStream now emits objects from the [Twitter gem](https://github.com/sferik/twitter) instead of custom hashes. These objects are already defined in the `twitter` gem and are superior to the custom objects in the following ways:
 
 1. Object equivalence (`#==` returns true if `#id`s are the same).
 2. The `#created_at` method returns a `Date` instead of a `String`.
@@ -85,14 +86,14 @@ It offers functionality parity with twitter-stream while also supporting several
 
 ### Removal of on_interval callback
 
-We have removed the `on_interval` callback.  If you require interval-based timers, it is possible to run 
+We have removed the `on_interval` callback.  If you require interval-based timers, it is possible to run
 TweetStream inside an already running EventMachine reactor in which you can define `EM::Timer` or `EM::PeriodicTimer`
 for time-based operations:
 
 ```ruby
 EM.run do
   client = TweetStream::Client.new
-  
+
   EM::PeriodicTimer.new(10) do
     # do something on an interval
   end
@@ -141,12 +142,12 @@ client.control.friends_ids('115192457') do |friends|
 end
 
 # obtain the current state of the stream
-client.control.info do |info| 
+client.control.info do |info|
   # do something
 end
 ```
 
-Note that per Twitter's documentation, connection management features are not 
+Note that per Twitter's documentation, connection management features are not
 immediately available when connected
 
 You also can use method hooks for both regular timeline statuses and direct messages.
@@ -169,7 +170,7 @@ client.userstream
 
 ## Authentication
 
-TweetStream supports OAuth and Basic Auth.  `TweetStream::Client` now accepts 
+TweetStream supports OAuth and Basic Auth.  `TweetStream::Client` now accepts
 a hash:
 
 ```ruby
@@ -200,12 +201,12 @@ end
 
 TweetStream assumes OAuth by default.  If you are using Basic Auth, it is recommended
 that you update your code to use OAuth as Twitter is likely to phase out Basic Auth
-support.  Basic Auth is only available for public streams as User Stream and Site Stream 
+support.  Basic Auth is only available for public streams as User Stream and Site Stream
 functionality [only support OAuth](https://dev.twitter.com/docs/streaming-apis/connecting#Authentication).
 
-## Parsing JSON 
+## Parsing JSON
 
-TweetStream supports swappable JSON backends via MultiJson. Simply require your preferred 
+TweetStream supports swappable JSON backends via MultiJson. Simply require your preferred
 JSON parser and it will be used to parse responses.
 
 ## Handling Deletes and Rate Limitations

data/lib/tweetstream/client.rb

@@ -1,18 +1,16 @@
-require 'cgi'
 require 'em-twitter'
 require 'eventmachine'
 require 'multi_json'
 require 'twitter'
-require 'uri'
 
 module TweetStream
-  # Provides simple access to the Twitter Streaming API (http://apiwiki.twitter.com/Streaming-API-Documentation)
+  # Provides simple access to the Twitter Streaming API (https://dev.twitter.com/docs/streaming-api)
   # for Ruby scripts that need to create a long connection to
   # Twitter for tracking and other purposes.
   #
   # Basic usage of the library is to call one of the provided
   # methods and provide a block that will perform actions on
-  # a yielded Twitter::Status. For example:
+  # a yielded Twitter::Tweet. For example:
   #
   #     TweetStream::Client.new.track('fail') do |status|
   #       puts "[#{status.user.screen_name}] #{status.text}"
@@ -22,6 +20,21 @@ module TweetStream
   # view the TweetStream::Daemon class.
   class Client
 
+    OPTION_CALLBACKS = [:delete,
+                        :scrub_geo,
+                        :limit,
+                        :error,
+                        :enhance_your_calm,
+                        :unauthorized,
+                        :reconnect,
+                        :inited,
+                        :direct_message,
+                        :timeline_status,
+                        :anything,
+                        :no_data_received,
+                        :status_withheld,
+                        :user_withheld].freeze unless defined?(OPTION_CALLBACKS)
+
     # @private
     attr_accessor *Configuration::VALID_OPTIONS_KEYS
     attr_accessor :options
@@ -34,6 +47,7 @@ module TweetStream
       Configuration::VALID_OPTIONS_KEYS.each do |key|
         send("#{key}=", merged_options[key])
       end
+      @callbacks = {}
     end
 
     # Returns all public statuses. The Firehose is not a generally
@@ -41,7 +55,7 @@ module TweetStream
     # Creative use of a combination of other resources and various access
     # levels can satisfy nearly every application use case.
     def firehose(query_parameters = {}, &block)
-      start('statuses/firehose', query_parameters, &block)
+      start('/1/statuses/firehose.json', query_parameters, &block)
     end
 
     # Returns all statuses containing http: and https:. The links stream is
@@ -49,7 +63,7 @@ module TweetStream
     # of access. Creative use of a combination of other resources and various
     # access levels can satisfy nearly every application use case.
     def links(query_parameters = {}, &block)
-      start('statuses/links', query_parameters, &block)
+      start('/1/statuses/links.json', query_parameters, &block)
     end
 
     # Returns all retweets. The retweet stream is not a generally available
@@ -59,7 +73,7 @@ module TweetStream
     # the site-wide retweet feature has not yet launched,
     # so there are currently few, if any, retweets on this stream.
     def retweet(query_parameters = {}, &block)
-      start('statuses/retweet', query_parameters, &block)
+      start('/1/statuses/retweet.json', query_parameters, &block)
     end
 
     # Returns a random sample of all public statuses. The default access level
@@ -68,7 +82,7 @@ module TweetStream
     # research applications that desire a larger proportion to be statistically
     # significant sample.
     def sample(query_parameters = {}, &block)
-      start('statuses/sample', query_parameters, &block)
+      start('/1/statuses/sample.json', query_parameters, &block)
     end
 
     # Specify keywords to track. Queries are subject to Track Limitations,
@@ -79,8 +93,7 @@ module TweetStream
     # Keywords containing punctuation will only exact match tokens.
     # Query parameters may be passed as the last argument.
     def track(*keywords, &block)
-      query_params = keywords.pop if keywords.last.is_a?(::Hash)
-      query_params ||= {}
+      query_params = keywords.extract_options!
       filter(query_params.merge(:track => keywords), &block)
     end
 
@@ -89,8 +102,7 @@ module TweetStream
     # pressing the reply "swoosh") are not matched. Requires integer user
     # IDs, not screen names. Query parameters may be passed as the last argument.
     def follow(*user_ids, &block)
-      query_params = user_ids.pop if user_ids.last.is_a?(::Hash)
-      query_params ||= {}
+      query_params = user_ids.extract_options!
       filter(query_params.merge(:follow => user_ids), &block)
     end
 
@@ -103,8 +115,7 @@ module TweetStream
     # the first pair denoting the southwest corner of the box
     # longitude/latitude pairs, separated by commas. The first pair specifies the southwest corner of the box.
     def locations(*locations_map, &block)
-      query_params = locations_map.pop if locations_map.last.is_a?(::Hash)
-      query_params ||= {}
+      query_params = locations_map.extract_options!
       filter(query_params.merge(:locations => locations_map), &block)
     end
 
@@ -114,26 +125,26 @@ module TweetStream
     # method is provided separately for cases when it would conserve the
     # number of HTTP connections to combine track and follow.
     def filter(query_params = {}, &block)
-      start('statuses/filter', query_params.merge(:method => :post), &block)
+      start('/1/statuses/filter.json', query_params.merge(:method => :post), &block)
     end
 
     # Make a call to the userstream api for currently authenticated user
     def userstream(query_params = {}, &block)
-      stream_params = { :host => "userstream.twitter.com", :path => "/2/user.json" }
+      stream_params = { :host => "userstream.twitter.com" }
       query_params.merge!(:extra_stream_parameters => stream_params)
-      start('', query_params, &block)
+      start('/2/user.json', query_params, &block)
     end
 
     # Make a call to the userstream api
     def sitestream(user_ids = [], query_params = {}, &block)
-      stream_params = { :host => "sitestream.twitter.com", :path => '/2b/site.json' }
+      stream_params = { :host => "sitestream.twitter.com" }
       query_params.merge!({
         :method => :post,
         :follow => user_ids,
         :extra_stream_parameters => stream_params
       })
       query_params.merge!(:with => 'followings') if query_params.delete(:followings)
-      start('', query_params, &block)
+      start('/2b/site.json', query_params, &block)
     end
 
     # Set a Proc to be run when a deletion notice is received
@@ -149,12 +160,7 @@ module TweetStream
     # deletion proc. When a block is given, the TweetStream::Client
     # object is returned to allow for chaining.
     def on_delete(&block)
-      if block_given?
-        @on_delete = block
-        self
-      else
-        @on_delete
-      end
+      on('delete', &block)
     end
 
     # Set a Proc to be run when a scrub_geo notice is received
@@ -170,12 +176,7 @@ module TweetStream
     # scrub_geo proc. When a block is given, the TweetStream::Client
     # object is returned to allow for chaining.
     def on_scrub_geo(&block)
-      if block_given?
-        @on_scrub_geo = block
-        self
-      else
-        @on_scrub_geo
-      end
+      on('scrub_geo', &block)
     end
 
     # Set a Proc to be run when a rate limit notice is received
@@ -191,12 +192,7 @@ module TweetStream
     # limit proc. When a block is given, the TweetStream::Client
     # object is returned to allow for chaining.
     def on_limit(&block)
-      if block_given?
-        @on_limit = block
-        self
-      else
-        @on_limit
-      end
+      on('limit', &block)
     end
 
     # Set a Proc to be run when an HTTP error is encountered in the
@@ -213,12 +209,7 @@ module TweetStream
     # 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_error = block
-        self
-      else
-        @on_error
-      end
+      on('error', &block)
     end
 
     # Set a Proc to be run when an HTTP status 401 is encountered while
@@ -229,12 +220,7 @@ module TweetStream
     # unauthorized proc. When a block is given, the TweetStream::Client
     # object is returned to allow for chaining.
     def on_unauthorized(&block)
-      if block_given?
-        @on_unauthorized = block
-        self
-      else
-        @on_unauthorized
-      end
+      on('unauthorized', &block)
     end
 
     # Set a Proc to be run when a direct message is encountered in the
@@ -250,12 +236,7 @@ module TweetStream
     # direct message proc. When a block is given, the TweetStream::Client
     # object is returned to allow for chaining.
     def on_direct_message(&block)
-      if block_given?
-        @on_direct_message = block
-        self
-      else
-        @on_direct_message
-      end
+      on('direct_message', &block)
     end
 
     # Set a Proc to be run whenever anything is encountered in the
@@ -271,12 +252,7 @@ module TweetStream
     # timeline status proc. When a block is given, the TweetStream::Client
     # object is returned to allow for chaining.
     def on_anything(&block)
-      if block_given?
-        @on_anything = block
-        self
-      else
-        @on_anything
-      end
+      on('anything', &block)
     end
 
     # Set a Proc to be run when a regular timeline message is encountered in the
@@ -292,12 +268,7 @@ module TweetStream
     # timeline status proc. When a block is given, the TweetStream::Client
     # object is returned to allow for chaining.
     def on_timeline_status(&block)
-      if block_given?
-        @on_timeline_status = block
-        self
-      else
-        @on_timeline_status
-      end
+      on('timeline_status', &block)
     end
 
     # Set a Proc to be run on reconnect.
@@ -308,12 +279,7 @@ module TweetStream
     #     end
     #
     def on_reconnect(&block)
-      if block_given?
-        @on_reconnect = block
-        self
-      else
-        @on_reconnect
-      end
+      on('reconnect', &block)
     end
 
     # Set a Proc to be run when connection established.
@@ -325,28 +291,18 @@ module TweetStream
     #     end
     #
     def on_inited(&block)
-      if block_given?
-        @on_inited = block
-        self
-      else
-        @on_inited
-      end
+      on('inited', &block)
     end
 
     # Set a Proc to be run when no data is received from the server
     # and a stall occurs.  Twitter defines this to be 90 seconds.
     #
     #     @client = TweetStream::Client.new
-    #     @client.on_no_data do
+    #     @client.on_no_data_received do
     #       # Make note of no data, possi
     #     end
     def on_no_data_received(&block)
-      if block_given?
-        @on_no_data = block
-        self
-      else
-        @on_no_data
-      end
+      on('no_data_received', &block)
     end
 
     # Set a Proc to be run when enhance_your_calm signal is received.
@@ -356,11 +312,45 @@ module TweetStream
     #       # do something, your account has been blocked
     #     end
     def on_enhance_your_calm(&block)
+      on('enhance_your_calm', &block)
+    end
+
+    # Set a Proc to be run when a status_withheld message is received.
+    #
+    #     @client = TweetStream::Client.new
+    #     @client.on_status_withheld do |status|
+    #       # do something with the status
+    #     end
+    def on_status_withheld(&block)
+      on('status_withheld', &block)
+    end
+
+    # Set a Proc to be run when a status_withheld message is received.
+    #
+    #     @client = TweetStream::Client.new
+    #     @client.on_user_withheld do |status|
+    #       # do something with the status
+    #     end
+    def on_user_withheld(&block)
+      on('user_withheld', &block)
+    end
+
+    # Set a Proc to be run on userstream events
+    #
+    #     @client = TweetStream::Client.new
+    #     @client.event(:favorite) do |event|
+    #       # do something with the status
+    #     end
+    def on_event(event, &block)
+      on(event, &block)
+    end
+
+    def on(event, &block)
       if block_given?
-        @on_enhance_your_calm = block
+        @callbacks[event.to_s] = block
         self
       else
-        @on_enhance_your_calm
+        @callbacks[event.to_s]
       end
     end
 
@@ -379,33 +369,24 @@ module TweetStream
     end
 
     # connect to twitter without starting a new EventMachine run loop
-    def connect(path, query_parameters = {}, &block)
-      method = query_parameters.delete(:method) || :get
-      delete_proc = query_parameters.delete(:delete) || self.on_delete
-      scrub_geo_proc = query_parameters.delete(:scrub_geo) || self.on_scrub_geo
-      limit_proc = query_parameters.delete(:limit) || self.on_limit
-      error_proc = query_parameters.delete(:error) || self.on_error
-      enhance_your_calm_proc = query_parameters.delete(:enhance_your_calm) || self.on_error
-      unauthorized_proc = query_parameters.delete(:unauthorized) || self.on_unauthorized
-      reconnect_proc = query_parameters.delete(:reconnect) || self.on_reconnect
-      inited_proc = query_parameters.delete(:inited) || self.on_inited
-      direct_message_proc = query_parameters.delete(:direct_message) || self.on_direct_message
-      timeline_status_proc = query_parameters.delete(:timeline_status) || self.on_timeline_status
-      anything_proc = query_parameters.delete(:anything) || self.on_anything
-      no_data_proc = query_parameters.delete(:no_data_received) || self.on_no_data_received
-
-      params = normalize_filter_parameters(query_parameters)
-
-      extra_stream_parameters = query_parameters.delete(:extra_stream_parameters) || {}
-
-      uri = method == :get ? build_uri(path, params) : build_uri(path)
+    def connect(path, options = {}, &block)
+      request_method          = options.delete(:method) || :get
+      warn_if_callbacks(options)
+
+      callbacks = @callbacks.dup
+      OPTION_CALLBACKS.each do |callback|
+        callbacks.merge(callback.to_s => options.delete(callback)) if options[callback]
+      end
+
+      inited_proc             = options.delete(:inited)                  || @callbacks['inited']
+      extra_stream_parameters = options.delete(:extra_stream_parameters) || {}
 
       stream_params = {
-        :path => uri,
-        :method => method.to_s.upcase,
+        :path       => path,
+        :method     => request_method.to_s.upcase,
         :user_agent => user_agent,
-        :on_inited => inited_proc,
-        :params => params
+        :on_inited  => inited_proc,
+        :params     => normalize_filter_parameters(options)
       }.merge(extra_stream_parameters).merge(auth_params)
 
       @stream = EM::Twitter::Client.connect(stream_params)
@@ -413,76 +394,36 @@ module TweetStream
         begin
           hash = MultiJson.decode(item, :symbolize_keys => true)
         rescue MultiJson::DecodeError
-          error_proc.call("MultiJson::DecodeError occured in stream: #{item}") if error_proc.is_a?(Proc)
+          invoke_callback(callbacks['error'], "MultiJson::DecodeError occured in stream: #{item}")
           next
         end
 
         unless hash.is_a?(::Hash)
-          error_proc.call("Unexpected JSON object in stream: #{item}") if error_proc.is_a?(Proc)
+          invoke_callback(callbacks['error'], "Unexpected JSON object in stream: #{item}")
           next
         end
 
         Twitter.identity_map = false
 
-        if hash[:control] && hash[:control][:control_uri]
-          @control_uri = hash[:control][:control_uri]
-          require 'tweetstream/site_stream_client'
-          @control = TweetStream::SiteStreamClient.new(@control_uri, options)
-          @control.on_error(&self.on_error)
-        elsif 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[:scrub_geo] && hash[:scrub_geo][:up_to_status_id]
-          scrub_geo_proc.call(hash[:scrub_geo][:up_to_status_id], hash[:scrub_geo][:user_id]) if scrub_geo_proc.is_a?(Proc)
-        elsif hash[:limit] && hash[:limit][:track]
-          limit_proc.call(hash[:limit][:track]) if limit_proc.is_a?(Proc)
-        elsif hash[:direct_message]
-          yield_message_to direct_message_proc, Twitter::DirectMessage.new(hash[:direct_message])
-        elsif hash[:text] && hash[:user]
-          @last_status = Twitter::Status.new(hash)
-          yield_message_to timeline_status_proc, @last_status
-
-          if block_given?
-            # 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
-        elsif hash[:for_user]
-          @message = hash
-
-          if block_given?
-            # Give the block the option to receive either one
-            # or two arguments, depending on its arity.
-            case block.arity
-            when 1
-              yield @message
-            when 2
-              yield @message, self
-            end
-          end
-        end
+        respond_to(hash, callbacks, &block)
 
-        yield_message_to anything_proc, hash
+        yield_message_to(callbacks['anything'], hash)
       end
 
       @stream.on_error do |message|
-        error_proc.call(message) if error_proc.is_a?(Proc)
+        invoke_callback(callbacks['error'], message)
       end
 
       @stream.on_unauthorized do
-        unauthorized_proc.call if unauthorized_proc.is_a?(Proc)
+        invoke_callback(callbacks['unauthorized'])
       end
 
       @stream.on_enhance_your_calm do
-        enhance_your_calm_proc.call if enhance_your_calm_proc.is_a?(Proc)
+        invoke_callback(callbacks['enhance_your_calm'])
       end
 
       @stream.on_reconnect do |timeout, retries|
-        reconnect_proc.call(timeout, retries) if reconnect_proc.is_a?(Proc)
+        invoke_callback(callbacks['reconnect'], timeout, retries)
       end
 
       @stream.on_max_reconnects do |timeout, retries|
@@ -490,12 +431,42 @@ module TweetStream
       end
 
       @stream.on_no_data_received do
-        no_data_proc.call if no_data_proc.is_a?(Proc)
+        invoke_callback(callbacks['no_data_received'])
       end
 
       @stream
     end
 
+    def respond_to(hash, callbacks, &block)
+      if hash[:control] && hash[:control][:control_uri]
+        @control_uri = hash[:control][:control_uri]
+        require 'tweetstream/site_stream_client'
+        @control = TweetStream::SiteStreamClient.new(@control_uri, options)
+        @control.on_error(&callbacks['error'])
+      elsif hash[:delete] && hash[:delete][:status]
+        invoke_callback(callbacks['delete'], hash[:delete][:status][:id], hash[:delete][:status][:user_id])
+      elsif hash[:scrub_geo] && hash[:scrub_geo][:up_to_status_id]
+        invoke_callback(callbacks['scrub_geo'], hash[:scrub_geo][:up_to_status_id], hash[:scrub_geo][:user_id])
+      elsif hash[:limit] && hash[:limit][:track]
+        invoke_callback(callbacks['limit'], hash[:limit][:track])
+      elsif hash[:direct_message]
+        yield_message_to(callbacks['direct_message'], Twitter::DirectMessage.new(hash[:direct_message]))
+      elsif hash[:status_withheld]
+        invoke_callback(callbacks['status_withheld'], hash[:status_withheld])
+      elsif hash[:user_withheld]
+        invoke_callback(callbacks['user_withheld'], hash[:user_withheld])
+      elsif hash[:event]
+        invoke_callback(callbacks[hash[:event].to_s], hash)
+      elsif hash[:text] && hash[:user]
+        @last_status = Twitter::Tweet.new(hash)
+        yield_message_to(callbacks['timeline_status'], @last_status)
+
+        yield_message_to(block, @last_status) if block_given?
+      elsif hash[:for_user]
+        yield_message_to(block, hash) if block_given?
+      end
+    end
+
     # Terminate the currently running TweetStream and close EventMachine loop
     def stop
       EventMachine.stop_event_loop
@@ -513,23 +484,6 @@ module TweetStream
 
     protected
 
-    def build_uri(path, query_parameters = {}) #:nodoc:
-      URI.parse("/1/#{path}.json#{build_query_parameters(query_parameters)}")
-    end
-
-    def build_query_parameters(query)
-      query.size > 0 ? "?#{build_post_body(query)}" : ''
-    end
-
-    def build_post_body(query) #:nodoc:
-      return '' unless query && query.is_a?(::Hash) && query.size > 0
-
-      query.map do |k, v|
-        v = v.flatten.collect { |q| q.to_s }.join(',') if v.is_a?(Array)
-        "#{k.to_s}=#{CGI.escape(v.to_s)}"
-      end.join('&')
-    end
-
     def normalize_filter_parameters(query_parameters = {})
       [:follow, :track, :locations].each do |param|
         if query_parameters[param].kind_of?(Array)
@@ -542,38 +496,43 @@ module TweetStream
     end
 
     def auth_params
-      if auth_method == :basic
-        { :basic => basic_auth_params }
+      if auth_method.to_s == 'basic'
+        { :basic => {
+            :username => username,
+            :password => password
+          }
+        }
       else
-        { :oauth => oauth_params }
+        { :oauth => {
+          :consumer_key => consumer_key,
+          :consumer_secret => consumer_secret,
+          :token => oauth_token,
+          :token_secret => oauth_token_secret
+        }
+       }
       end
     end
 
-    def basic_auth_params
-      {
-        :username => username,
-        :password => password
-      }
-    end
-
-    def oauth_params
-      {
-        :consumer_key => consumer_key,
-        :consumer_secret => consumer_secret,
-        :token => oauth_token,
-        :token_secret => oauth_token_secret
-      }
+    # A utility method used to invoke callback methods against the Client
+    def invoke_callback(callback, *args)
+      callback.call(*args) if callback
     end
 
     def yield_message_to(procedure, message)
+      # Give the block the option to receive either one
+      # or two arguments, depending on its arity.
       if procedure.is_a?(Proc)
         case procedure.arity
-          when 1
-            procedure.call(message)
-          when 2
-            procedure.call(message, self)
+        when 1 then invoke_callback(procedure, message)
+        when 2 then invoke_callback(procedure, message, self)
         end
       end
     end
+
+    def warn_if_callbacks(options={})
+      if OPTION_CALLBACKS.select { |callback| options[callback] }.size > 0
+        Kernel.warn("Passing callbacks via the options hash is deprecated and will be removed in TweetStream 3.0")
+      end
+    end
   end
 end