tweetstream 1.0.5 → 1.1.0.rc1

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,13 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg
+Gemfile.lock
+coverage/*
+.yardoc/*
+doc/*
+.bundle
+.swp
+.idea
+.rvmrc

data/.rspec

@@ -0,0 +1,2 @@
+--colour
+--format doc

data/.yardopts

@@ -0,0 +1,4 @@
+--markup markdown
+-
+RELEASE_NOTES.md
+LICENSE.md

data/Gemfile

@@ -0,0 +1,2 @@
+source :rubygems
+gemspec

data/Guardfile

@@ -0,0 +1,10 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec', :version => 2 do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec/" }
+  watch('spec/data/.+')  { "spec/" }
+end
+

data/{LICENSE → LICENSE.md}

@@ -1,4 +1,4 @@
-Copyright (c) 2009 Intridea, Inc.
+Copyright (c) 2011 Intridea, Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -0,0 +1,223 @@
+TweetStream
+===========
+
+TweetStream provides simple Ruby access to [Twitter's Streaming API](http://developer.twitter.com/pages/streaming_api).
+
+Installation
+------------
+
+To install:
+
+    gem install tweetstream
+
+Usage
+-----
+
+Using TweetStream is quite simple:
+
+    require 'rubygems'
+    require 'tweetstream'
+
+    TweetStream.configure do |config|
+      config.consumer_key = 'abcdefghijklmnopqrstuvwxyz'
+      config.consumer_secret = '0123456789'
+      config.oauth_token = 'abcdefghijklmnopqrstuvwxyz'
+      config.oauth_token_secret = '0123456789'
+      config.auth_method = :oauth
+      config.parser   = :yajl
+    end
+
+    # This will pull a sample of all tweets based on
+    # your Twitter account's Streaming API role.
+    TweetStream::Client.new.sample do |status|
+      # The status object is a special Hash with
+      # method access to its keys.
+      puts "#{status.text}"
+    end
+
+You can also use it to track keywords or follow a given set of
+user ids:
+
+    # Use 'track' to track a list of single-word keywords
+    TweetStream::Client.new.track('term1', 'term2') do |status|
+      puts "#{status.text}"
+    end
+
+    # Use 'follow' to follow a group of user ids (integers, not screen names)
+    TweetStream::Client.new.follow(14252, 53235) do |status|
+      puts "#{status.text}"
+    end
+
+The methods available to TweetStream::Client will be kept in parity
+with the methods available on the Streaming API wiki page.
+
+Configuration and Changes in 1.1.0
+----------------------------------
+
+As of version 1.1.0.rc1 TweetStream supports OAuth.  Please note that in order
+to support OAuth, the `TweetStream::Client` initializer no longer accepts a
+username/password.  `TweetStream::Client` now accepts a hash:
+
+    TweetStream::Client.new(:username => 'you', :password => 'pass')
+
+Alternatively, you can configure TweetStream via the configure method:
+
+    TweetStream.configure do |config|
+      config.consumer_key = 'cVcIw5zoLFE2a4BdDsmmA'
+      config.consumer_secret = 'yYgVgvTT9uCFAi2IuscbYTCqwJZ1sdQxzISvLhNWUA'
+      config.oauth_token = '4618-H3gU7mjDQ7MtFkAwHhCqD91Cp4RqDTp1AKwGzpHGL3I'
+      config.oauth_token_secret = 'xmc9kFgOXpMdQ590Tho2gV7fE71v5OmBrX8qPGh7Y'
+      config.auth_method = :oauth
+      config.parser   = :yajl
+    end
+
+If you are using Basic Auth:
+
+    TweetStream.configure do |config|
+      config.username = 'username'
+      config.password = 'password'
+      config.auth_method = :basic
+      config.parser   = :yajl
+    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.
+
+Swappable JSON Parsing
+----------------------
+
+As of version 1.1, TweetStream supports swappable JSON backends via MultiJson. You can
+specify a parser during configuration:
+
+    # Parse tweets using Yajl-Ruby
+    TweetStream.configure do |config|
+      ..
+      config.parser   = :yajl
+    end.
+
+Available options are `:yajl`, `:json_gem` (default),
+`:json_pure`, and `:active_support`.
+
+Handling Deletes and Rate Limitations
+-------------------------------------
+
+Sometimes the Streaming API will send messages other than statuses.
+Specifically, it does so when a status is deleted or rate limitations
+have caused some tweets not to appear in the stream. To handle these,
+you can use the on_delete and on_limit methods. Example:
+
+    @client = TweetStream::Client.new
+
+    @client.on_delete do |status_id, user_id|
+      Tweet.delete(status_id)
+    end
+
+    @client.on_limit do |skip_count|
+      # do something
+    end
+
+    @client.track('intridea')
+
+The on_delete and on_limit methods can also be chained, like so:
+
+    TweetStream::Client.new.on_delete{ |status_id, user_id|
+      Tweet.delete(status_id)
+    }.on_limit { |skip_count|
+      # do something
+    }.track('intridea') do |status|
+      # do something with the status like normal
+    end
+
+You can also provide `:delete` and/or `:limit`
+options when you make your method call:
+
+    TweetStream::Client.new.track('intridea',
+      :delete => Proc.new{ |status_id, user_id| # do something },
+      :limit => Proc.new{ |skip_count| # do something }
+    ) do |status|
+      # do something with the status like normal
+    end
+
+Twitter recommends honoring deletions as quickly as possible, and
+you would likely be wise to integrate this functionality into your
+application.
+
+Errors and Reconnecting
+-----------------------
+
+TweetStream uses EventMachine to connect to the Twitter Streaming
+API, and attempts to honor Twitter's guidelines in terms of automatic
+reconnection. When Twitter becomes unavailable, the block specified
+by you in `on_error` will be called. Note that this does not
+indicate something is actually wrong, just that Twitter is momentarily
+down. It could be for routine maintenance, etc.
+
+    TweetStream::Client.new.on_error do |message|
+      # Log your error message somewhere
+    end.track('term') do |status|
+      # Do things when nothing's wrong
+    end
+
+However, if the maximum number of reconnect attempts has been reached,
+TweetStream will raise a `TweetStream::ReconnectError` with
+information about the timeout and number of retries attempted.
+
+Terminating a TweetStream
+-------------------------
+
+It is often the case that you will need to change the parameters of your
+track or follow tweet streams. In the case that you need to terminate
+a stream, you may add a second argument to your block that will yield
+the client itself:
+
+    # Stop after collecting 10 statuses
+    @statuses = []
+    TweetStream::Client.new.sample do |status, client|
+      @statuses << status
+      client.stop if @statuses.size >= 10
+    end
+
+When `stop` is called, TweetStream will return from the block
+the last successfully yielded status, allowing you to make note of
+it in your application as necessary.
+
+Daemonizing
+-----------
+
+It is also possible to create a daemonized script quite easily
+using the TweetStream library:
+
+    # The third argument is an optional process name
+    TweetStream::Daemon.new('username','password', 'tracker').track('term1', 'term2') do |status|
+      # do something in the background
+    end
+
+If you put the above into a script and run the script with `ruby scriptname.rb`, you will see a list of daemonization commands such
+as start, stop, and run.
+
+TODO
+----
+
+* UserStream support
+* SiteStream support
+
+Note on Patches/Pull Requests
+-----------------------------
+
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a future version unintentionally.
+* Commit, do not mess with rakefile, version, or history. (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+Contributors
+------------
+
+* Michael Bleigh (initial gem)
+* Steve Agalloco (current maintainer)
+
+Copyright
+---------
+
+Copyright (c) 2011 Intridea, Inc. (http://www.intridea.com/). See [LICENSE](https://github.com/intridea/tweetstream/blob/master/LICENSE.md) for details.

data/{RELEASE_NOTES.rdoc → RELEASE_NOTES.md}

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

data/Rakefile

@@ -1,60 +1,19 @@
-require 'rubygems'
-require 'rake'
+require 'bundler'
+Bundler::GemHelper.install_tasks
 
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |gem|
-    gem.name = "tweetstream"
-    gem.summary = %Q{TweetStream is a simple wrapper for consuming the Twitter Streaming API.}
-    gem.description = %Q{TweetStream allows you to easily consume the Twitter Streaming API utilizing the YAJL Ruby gem.}
-    gem.email = ["michael@intridea.com", "steve.agalloco@gmail.com"]
-    gem.homepage = "http://github.com/intridea/tweetstream"
-    gem.authors = ["Michael Bleigh", "Steve Agalloco"]
-    gem.files = FileList["[A-Z]*", "{lib,spec,examples}/**/*"] - FileList["**/*.log"]
-    gem.add_development_dependency "rspec"
-    gem.add_dependency 'twitter-stream'
-    gem.add_dependency 'daemons'
-    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
-  end
-  Jeweler::GemcutterTasks.new
-rescue LoadError
-  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
-end
-
-namespace :release do
-  %w(patch minor major).each do |level|
-    desc "Tag a #{level} version and push it to Gemcutter."
-    task level.to_sym => %w(version:bump:patch release gemcutter:release)
-  end
-end
-
-require 'spec/rake/spectask'
-Spec::Rake::SpecTask.new(:spec) do |spec|
-  spec.libs << 'lib' << 'spec'
-  spec.spec_files = FileList['spec/**/*_spec.rb']
-end
-
-Spec::Rake::SpecTask.new(:rcov) do |spec|
-  spec.libs << 'lib' << 'spec'
-  spec.pattern = 'spec/**/*_spec.rb'
-  spec.rcov = true
-  spec.rcov_opts = %w{--exclude "spec\/*,gems\/*"}
-end
-
-task :spec => :check_dependencies
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
 
+task :test => :spec
 task :default => :spec
 
-require 'rake/rdoctask'
-Rake::RDocTask.new do |rdoc|
-  if File.exist?('VERSION')
-    version = File.read('VERSION')
-  else
-    version = ""
+namespace :doc do
+  require 'yard'
+  YARD::Rake::YardocTask.new do |task|
+    task.files   = ['RELEASE_NOTES.md', 'LICENSE.md', 'lib/**/*.rb']
+    task.options = [
+      '--output-dir', 'doc/yard',
+      '--markup', 'markdown',
+    ]
   end
-
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "tweetstream #{version}"
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
 end

data/examples/oauth.rb

@@ -0,0 +1,17 @@
+require 'yajl'
+require 'tweetstream'
+
+TweetStream.configure do |config|
+  config.consumer_key = 'abcdefghijklmnopqrstuvwxyz'
+  config.consumer_secret = '0123456789'
+  config.oauth_token = 'abcdefghijklmnopqrstuvwxyz'
+  config.oauth_token_secret = '0123456789'
+  config.auth_method = :oauth
+  config.parser   = :yajl
+end
+
+TweetStream::Client.new.on_error do |message|
+  puts message
+end.track("yankees")  do |status|
+  puts "#{status.text}"
+end

data/lib/tweetstream.rb

@@ -1,3 +1,4 @@
+require 'tweetstream/configuration'
 require 'tweetstream/client'
 require 'tweetstream/hash'
 require 'tweetstream/status'
@@ -5,6 +6,8 @@ require 'tweetstream/user'
 require 'tweetstream/daemon'
 
 module TweetStream
+  extend Configuration
+
   class Terminated < ::StandardError; end
   class Error < ::StandardError; end
   class ConnectionError < TweetStream::Error; end
@@ -18,4 +21,22 @@ module TweetStream
       super("Failed to reconnect after #{retries} tries.")
     end
   end
+
+  # Alias for TweetStream::Client.new
+  #
+  # @return [TweetStream::Client]
+  def self.client(options={})
+    TweetStream::Client.new(options)
+  end
+
+  # Delegate to TweetStream::Client
+  def self.method_missing(method, *args, &block)
+    return super unless client.respond_to?(method)
+    client.send(method, *args, &block)
+  end
+
+  # Delegate to TweetStream::Client
+  def self.respond_to?(method)
+    client.respond_to?(method) || super
+  end
 end

data/lib/tweetstream/client.rb

@@ -2,7 +2,7 @@ require 'uri'
 require 'cgi'
 require 'eventmachine'
 require 'twitter/json_stream'
-require 'json'
+require 'multi_json'
 
 module TweetStream
   # Provides simple access to the Twitter Streaming API (http://apiwiki.twitter.com/Streaming-API-Documentation)
@@ -23,38 +23,41 @@ module TweetStream
     attr_accessor :username, :password
     attr_reader :parser
 
-    # Set the JSON Parser for this client. Acceptable options are:
-    #
-    # <tt>:json_gem</tt>:: Parse using the JSON gem.
-    # <tt>:json_pure</tt>:: Parse using the pure-ruby implementation of the JSON gem.
-    # <tt>:active_support</tt>:: Parse using ActiveSupport::JSON.decode
-    # <tt>:yajl</tt>:: Parse using <tt>yajl-ruby</tt>.
-    #
-    # You may also pass a class that will return a hash with symbolized
-    # keys when <tt>YourClass.parse</tt> is called with a JSON string.
-    def parser=(parser)
-      @parser = parser_from(parser)
+    # @private
+    attr_accessor *Configuration::VALID_OPTIONS_KEYS
+
+    # Creates a new API
+    def initialize(options={})
+      options = TweetStream.options.merge(options)
+      Configuration::VALID_OPTIONS_KEYS.each do |key|
+        send("#{key}=", options[key])
+      end
     end
-    
+
+    # Get the JSON parser class for this client.
+    def json_parser
+      parser_from(parser)
+    end
+
     # Create a new client with the Twitter credentials
     # of the account you want to be using its API quota.
     # You may also set the JSON parsing library as specified
     # in the #parser= setter.
-    def initialize(user, pass, parser = :json_gem)
-      self.username = user
-      self.password = pass
-      self.parser = parser
-    end
-   
+    # def initialize(ouser, pass, parser = :json_gem)
+    #   self.username = user
+    #   self.password = pass
+    #   self.parser = parser
+    # end
+
     # Returns all public statuses. The Firehose is not a generally
-    # available resource. Few applications require this level of access. 
-    # Creative use of a combination of other resources and various access 
-    # levels can satisfy nearly every application use case. 
+    # available resource. Few applications require this level of access.
+    # 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)
     end
-    
-    # Returns all retweets. The retweet stream is not a generally available 
+
+    # Returns all retweets. The retweet stream is not a generally available
     # resource. Few applications require this level of access. Creative
     # use of a combination of other resources and various access levels
     # can satisfy nearly every application use case. As of 9/11/2009,
@@ -63,8 +66,8 @@ module TweetStream
     def retweet(query_parameters = {}, &block)
       start('statuses/retweet', query_parameters, &block)
     end
-    
-    # Returns a random sample of all public statuses. The default access level 
+
+    # Returns a random sample of all public statuses. The default access level
     # provides a small proportion of the Firehose. The "Gardenhose" access
     # level provides a proportion more suitable for data mining and
     # research applications that desire a larger proportion to be statistically
@@ -73,11 +76,11 @@ module TweetStream
       start('statuses/sample', query_parameters, &block)
     end
 
-    # Specify keywords to track. Queries are subject to Track Limitations, 
-    # described in Track Limiting and subject to access roles, described in 
-    # the statuses/filter method. Track keywords are case-insensitive logical 
+    # Specify keywords to track. Queries are subject to Track Limitations,
+    # described in Track Limiting and subject to access roles, described in
+    # the statuses/filter method. Track keywords are case-insensitive logical
     # ORs. Terms are exact-matched, and also exact-matched ignoring
-    # punctuation. Phrases, keywords with spaces, are not supported. 
+    # punctuation. Phrases, keywords with spaces, are not supported.
     # Keywords containing punctuation will only exact match tokens.
     # Query parameters may be passed as the last argument.
     def track(*keywords, &block)
@@ -86,8 +89,8 @@ module TweetStream
       filter(query_params.merge(:track => keywords), &block)
     end
 
-    # Returns public statuses from or in reply to a set of users. Mentions 
-    # ("Hello @user!") and implicit replies ("@user Hello!" created without 
+    # Returns public statuses from or in reply to a set of users. Mentions
+    # ("Hello @user!") and implicit replies ("@user Hello!" created without
     # 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)
@@ -95,20 +98,27 @@ module TweetStream
       query_params ||= {}
       filter(query_params.merge(:follow => user_ids), &block)
     end
-    
+
+    # Specifies a set of bounding boxes to track. Only tweets that are both created
+    # using the Geotagging API and are placed from within a tracked bounding box will
+    # be included in the stream – the user’s location field is not used to filter tweets
+    # (e.g. if a user has their location set to “San Francisco”, but the tweet was not created
+    # using the Geotagging API and has no geo element, it will not be included in the stream).
+    # Bounding boxes are specified as a comma separate list of longitude/latitude pairs, with
+    # 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 ||= {}
+        filter(query_params.merge(:locations => locations_map), &block)
+    end
+
     # Make a call to the statuses/filter method of the Streaming API,
     # you may provide <tt>:follow</tt>, <tt>:track</tt> or both as options
     # to follow the tweets of specified users or track keywords. This
     # 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)
-      [:follow, :track].each do |param|
-        if query_params[param].is_a?(Array)
-          query_params[param] = query_params[param].collect{|q| q.to_s}.join(',')
-        elsif query_params[param]
-          query_params[param] = query_params[param].to_s
-        end
-      end
       start('statuses/filter', query_params.merge(:method => :post), &block)
     end
 
@@ -121,7 +131,7 @@ module TweetStream
     #     end
     #
     # Block must take two arguments: the status id and the user id.
-    # If no block is given, it will return the currently set 
+    # If no block is given, it will return the currently set
     # deletion proc. When a block is given, the TweetStream::Client
     # object is returned to allow for chaining.
     def on_delete(&block)
@@ -132,7 +142,7 @@ module TweetStream
         @on_delete
       end
     end
-    
+
     # Set a Proc to be run when a rate limit notice is received
     # from the Twitter stream. For example:
     #
@@ -142,7 +152,7 @@ module TweetStream
     #     end
     #
     # Block must take one argument: the number of discarded tweets.
-    # If no block is given, it will return the currently set 
+    # If no block is given, it will return the currently set
     # limit proc. When a block is given, the TweetStream::Client
     # object is returned to allow for chaining.
     def on_limit(&block)
@@ -153,7 +163,7 @@ module TweetStream
         @on_limit
       end
     end
-    
+
     # Set a Proc to be run when an HTTP error is encountered in the
     # processing of the stream. Note that TweetStream will automatically
     # try to reconnect, this is for reference only. Don't panic!
@@ -164,7 +174,7 @@ module TweetStream
     #     end
     #
     # Block must take one argument: the error message.
-    # If no block is given, it will return the currently set 
+    # If no block is given, it will return the currently set
     # error proc. When a block is given, the TweetStream::Client
     # object is returned to allow for chaining.
     def on_error(&block)
@@ -175,42 +185,69 @@ module TweetStream
         @on_error
       end
     end
-    
+
+    # Set a Proc to be run when connection established.
+    # Called in EventMachine::Connection#post_init
+    #
+    #     @client = TweetStream::Client.new('user','pass')
+    #     @client.on_inited do
+    #       puts 'Connected...'
+    #     end
+    #
+    def on_inited(&block)
+      if block_given?
+        @on_inited = block
+        self
+      else
+        @on_inited
+      end
+    end
+
     def start(path, query_parameters = {}, &block) #:nodoc:
       method = query_parameters.delete(:method) || :get
       delete_proc = query_parameters.delete(:delete) || self.on_delete
       limit_proc = query_parameters.delete(:limit) || self.on_limit
       error_proc = query_parameters.delete(:error) || self.on_error
-      
-      uri = method == :get ? build_uri(path, query_parameters) : build_uri(path)
-      
+      inited_proc = query_parameters.delete(:inited) || self.on_inited
+
+      params = normalize_filter_parameters(query_parameters)
+
+      uri = method == :get ? build_uri(path, params) : build_uri(path)
+
       EventMachine::run {
-        @stream = Twitter::JSONStream.connect(
-          :path => uri,
-          :auth => "#{URI.encode self.username}:#{URI.encode self.password}",
-          :method => method.to_s.upcase,
-          :content => (method == :post ? build_post_body(query_parameters) : ''),
-          :user_agent => 'TweetStream',
-          :ssl => true
-        )
-        
+        stream_params = {
+          :path       => uri,
+          :method     => method.to_s.upcase,
+          :user_agent => user_agent,
+          :on_inited  => inited_proc,
+          :filters    => params.delete(:track),
+          :params     => params,
+          :ssl        => true
+        }.merge(auth_params)
+
+        @stream = Twitter::JSONStream.connect(stream_params)
         @stream.each_item do |item|
-          raw_hash = @parser.decode(item)
-          
+          begin
+            raw_hash = json_parser.decode(item)
+          rescue MultiJson::DecodeError
+            error_proc.call("MultiJson::DecodeError occured in stream: #{item}") if error_proc.is_a?(Proc)
+            next
+          end
+
           unless raw_hash.is_a?(::Hash)
-            error_proc.call("Unexpected JSON object in stream: #{item}")
+            error_proc.call("Unexpected JSON object in stream: #{item}") if error_proc.is_a?(Proc)
             next
           end
-          
-          hash = TweetStream::Hash.new(raw_hash) # @parser.parse(item)
-          
+
+          hash = TweetStream::Hash.new(raw_hash)
+
           if hash[:delete] && hash[:delete][:status]
             delete_proc.call(hash[:delete][:status][:id], hash[:delete][:status][:user_id]) if delete_proc.is_a?(Proc)
           elsif hash[:limit] && hash[:limit][:track]
             limit_proc.call(hash[:limit][:track]) if limit_proc.is_a?(Proc)
           elsif hash[:text] && hash[:user]
             @last_status = TweetStream::Status.new(hash)
-            
+
             # Give the block the option to receive either one
             # or two arguments, depending on its arity.
             case block.arity
@@ -221,35 +258,30 @@ module TweetStream
             end
           end
         end
-        
+
         @stream.on_error do |message|
           error_proc.call(message) if error_proc.is_a?(Proc)
         end
-        
+
         @stream.on_max_reconnects do |timeout, retries|
           raise TweetStream::ReconnectError.new(timeout, retries)
         end
       }
     end
-    
+
     # Terminate the currently running TweetStream.
     def stop
       EventMachine.stop_event_loop
       @last_status
     end
- 
+
     protected
 
     def parser_from(parser)
-      case parser
-        when Class
-          parser
-        when Symbol
-          require "tweetstream/parsers/#{parser.to_s}"
-          eval("TweetStream::Parsers::#{parser.to_s.split('_').map{|s| s.capitalize}.join('')}")
-      end
+      MultiJson.engine = parser
+      MultiJson
     end
-    
+
     def build_uri(path, query_parameters = {}) #:nodoc:
       URI.parse("/1/#{path}.json#{build_query_parameters(query_parameters)}")
     end
@@ -257,16 +289,42 @@ module TweetStream
     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
       pairs = []
-      
+
       query.each_pair do |k,v|
+        v = v.flatten.collect { |q| q.to_s }.join(',') if v.is_a?(Array)
         pairs << "#{k.to_s}=#{CGI.escape(v.to_s)}"
       end
 
       pairs.join('&')
     end
+
+    def normalize_filter_parameters(query_parameters = {})
+      [:follow, :track, :locations].each do |param|
+        if query_parameters[param].kind_of?(Array)
+          query_parameters[param] = query_parameters[param].flatten.collect{|q| q.to_s}.join(',')
+        elsif query_parameters[param]
+          query_parameters[param] = query_parameters[param].to_s
+        end
+      end
+      query_parameters
+    end
+
+    def auth_params
+      case auth_method
+      when :basic
+        return :auth => "#{username}:#{password}"
+      when :oauth
+        return :oauth => {
+          :consumer_key => consumer_key,
+          :consumer_secret => consumer_secret,
+          :access_key => oauth_token,
+          :access_secret => oauth_token_secret
+        }
+      end
+    end
   end
 end