tweedle 0.1.0

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rdoc_options

@@ -0,0 +1,16 @@
+--- !ruby/object:RDoc::Options
+encoding: UTF-8
+static_path: []
+rdoc_include:
+- .
+charset: UTF-8
+exclude: ["test"]
+hyperlink_all: false
+line_numbers: true
+main_page: README.rdoc
+markup: tomdoc
+show_hash: false
+tab_width: 8
+title: Tweedle
+visibility: :protected
+webcvs: 

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+rvm:
+  - 1.9.2
+  - 1.9.3
+  - ruby-head
+  - jruby-19mode
+  - rbx-19mode

data/Gemfile

@@ -0,0 +1,15 @@
+source :rubygems
+
+group :development do
+  gem "rake"
+end
+
+group :test do
+  gem "minitest",  "~> 2.12.1"
+  gem "mocha",     "~> 0.11.2"
+  gem "simplecov", "~> 0.6.2"
+  gem "fakeweb",   "~> 1.3.0"
+end
+
+# Specify your gem's dependencies in tweedle.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Tobias Svensson
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,137 @@
+= Tweedle
+
+Lightweight wrapper for the Twitter Streaming API.
+
+---
+
+Tweedle is a lightweight wrapper for the
+{Twitter Streaming API}[https://dev.twitter.com/docs/streaming-api],
+written out of the need for a library that does not depend on
+{EventMachine}[http://rubyeventmachine.com/].
+
+The library currently only supports the regular
+{Streaming API Methods}[https://dev.twitter.com/docs/streaming-api/methods].
+{User Streams}[https://dev.twitter.com/docs/streaming-api/user-streams] and
+{Site Streams}[https://dev.twitter.com/docs/streaming-api/site-streams] are
+currently not implemented.
+
+== Installation
+
+The best way to install Tweedle is with RubyGems:
+
+  $ [sudo] gem install tweedle
+
+Or add it to your Gemfile:
+
+  gem 'foo'
+
+And then execute:
+
+  $ bundle install
+
+If you're installing from source, you can use Bundler to pick up all the gems,
+including those required for running the tests and creating coverage reports:
+
+  $ bundle install
+
+Consult the online documentation for more information on
+{Bundler}[http://gembundler.com/]
+
+== Dependencies
+
+The goal is to keep Tweedle's dependencies to a minimum. However, in
+order to keep the source as simple as possible, it requires the
+following gems:
+
+* {OAuth}[http://github.com/pelle/oauth] to authenticate with Twitter
+  and sign the requests.
+* {multi_json}[http://github.com/intridea/multi_json] to parse the
+  response bodies.
+
+== Getting started
+
+First, setup the library to use the desired OAuth credentials:
+
+  Tweedle.configure do |config|
+    config.consumer_key    = "the_consumer_key"
+    config.consumer_secret = "the_consumer_secret"
+    config.oauth_token     = "the_oauth_token"
+    config.oauth_secret    = "the_oauth_secret"
+  end
+
+Then, create a client:
+
+  client = Tweedle.new
+
+Try things out by streaming Twitter's sample stream:
+
+  client.statuses.sample do |tweet|
+    next unless text = tweet[:text]
+    puts "#{tweet[:user][:screen_name]}: #{text}"
+  end
+
+HTTP parameters are supported, too:
+
+  client.statuses.sample(stall_warnings: true, count: 1000) do |tweet|
+    next unless text = tweet[:text]
+    puts "#{tweet[:user][:screen_name]}: #{text}"
+  end
+
+And the wrapper for the filter stream uses POST requsts, as
+recommended by Twitter:
+
+  predicates = {
+    locations: [-122.75, 36.8, -121.75, 37.8, -74,40, -73,41],
+        track: ["ruby", "tweedle"]
+  }
+
+  client.statuses.filter(stall_warnings: true, predicates: predicates) do |tweet|
+    next unless text = tweet[:text]
+    puts "#{tweet[:user][:screen_name]}: #{text}"
+  end
+
+The full API documentation is available
+{online}[http://rdoc.info/github/tobiassvn/tweedle/master/frames].
+
+== Contributing
+
+If you'd like to contribute to Tweedle, start by forking the repo on GitHub:
+
+{http://github.com/tobiassvn/tweedle}[http://github.com/tobiassvn/tweedle]
+
+To get all of the dependencies, install the gem first. The best way to
+getyour changes merged back into core is as follows:
+
+* Clone down your fork.
+* Create a thoughtfully named topic branch to contain your change.
+* Hack away.
+* Add tests and make sure everything still passes by running rake.
+* If you are adding new functionality, document it in the README.
+* If you add new attributes, classes, constants or methods, document
+  in the {TomDoc}[http://tomdoc.org/] format.
+* Do not change the version number, I will do that on my end.
+* If necessary, rebase your commits into logical chunks, without errors
+* Push the branch up to GitHub
+* Send a pull request to the tobiassvn/tweedle project.
+
+== License
+
+  Copyright (c) 2012 Tobias Svensson.
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in
+  all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+  THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,9 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.pattern = "test/test_*.rb"
+end
+
+task :default => :test

data/examples/statuses.filter.rb

@@ -0,0 +1,18 @@
+require "tweedle"
+
+Tweedle.configure do |config|
+  config.consumer_key    = "the_consumer_key"
+  config.consumer_secret = "the_consumer_secret"
+  config.oauth_token     = "the_oauth_token"
+  config.oauth_secret    = "the_oauth_secret"
+end
+
+predicates = {
+  locations: [-122.75, 36.8, -121.75, 37.8, -74,40, -73,41],
+  track:     ["ruby", "tweedle"]
+}
+
+Tweedle.new.statuses.filter(predicates: predicates) do |tweet|
+  next unless text = tweet[:text]
+  puts "#{tweet[:user][:screen_name]}: #{text}"
+end

data/examples/statuses.sample.rb

@@ -0,0 +1,13 @@
+require "tweedle"
+
+Tweedle.configure do |config|
+  config.consumer_key    = "the_consumer_key"
+  config.consumer_secret = "the_consumer_secret"
+  config.oauth_token     = "the_oauth_token"
+  config.oauth_secret    = "the_oauth_secret"
+end
+
+Tweedle.new.statuses.sample do |tweet|
+  next unless text = tweet[:text]
+  puts "#{tweet[:user][:screen_name]}: #{text}"
+end

data/lib/tweedle/client.rb

@@ -0,0 +1,268 @@
+module Tweedle
+  # Public: The Tweedle::Client class wraps methods for accessing
+  # sections of the Twitter streaming API and handles all client ->
+  # server requests.
+  class Client
+    # Public: The configuration used by the Tweedle::Client instance.
+    attr_reader :config
+
+    # Initializes a new Tweedle::Client.
+    #
+    # config - Options object for the Tweedle client. By default uses
+    #          the global Tweedle configuarion (default: Tweedle.config).
+    #
+    # Examples
+    #
+    #   Tweedle::Client.new
+    #   # => Tweedle::Client
+    #
+    #   Tweedle::Client.new(config_object)
+    #   # => Tweedle::Client
+    #
+    # Returns a Tweedle::Client instance.
+    def initialize(config = Tweedle.config)
+      @config = config
+    end
+
+    # Returns a new Tweedle::Statuses instance associated with the
+    # client.
+    #
+    # Examples
+    #
+    #   client = Tweedle.new
+    #   client.statuses
+    #   # => Tweedle::Statuses
+    #
+    # Returns a Tweedle::Statuses instance.
+    def statuses
+      Tweedle::Statuses.new(self)
+    end
+
+    # Internal: Sends a GET request to the given stream.
+    #
+    # uri    - A String containing the request URI.
+    # block  - Optional block to yield the response body to.
+    # params - Optional request parameters (default: empty Hash)
+    #
+    # Examples
+    #
+    #   get(URI.parse("http://www.google.com/") do |body|
+    #     puts body
+    #   end
+    #
+    # Returns nothing.
+    # Raises Tweedle::ConnectionError if the server response is not an
+    #   Net::HTTPSuccess.
+    def get(uri, params = {}, &block)
+      uri = build_uri(uri, params)
+      http = build_http(uri)
+      request = build_get_request(uri, http, params)
+
+      begin
+        http.request(request) { |response| handle_response(response, &block) }
+      rescue *[Timeout::Error, Errno::ECONNRESET, EOFError]
+        retry # reconnect
+      ensure
+        http.finish
+      end
+    end
+
+    # Internal: Sends a POST request to the given stream.
+    #
+    # uri       - A String containing the request URI.
+    # block     - Optional block to yield the response body to.
+    # post_data - Object responding to #to_s containing the data for
+    #             the POST request
+    # params    - Optional request parameters (default: empty Hash)
+    #
+    # Examples
+    #
+    #   post(URI.parse("http://www.google.com/", "follow=12") do |body|
+    #     puts body
+    #   end
+    #
+    # Returns nothing.
+    # Raises Tweedle::ConnectionError if the server response is not an
+    #   Net::HTTPSuccess.
+    def post(uri, post_data, params = {}, &block)
+      uri = build_uri(uri, params)
+      http = build_http(uri)
+      request = build_post_request(uri, http, post_data, params)
+
+      begin
+        http.request(request) { |response| handle_response(response, &block) }
+      rescue *[Timeout::Error, Errno::ECONNRESET, EOFError]
+        retry # reconnect
+      ensure
+        http.finish
+      end
+    end
+
+    private
+
+    # Private: Reads the streaming body of a given HTTP response and
+    # yields a parsed JSON object to the given block for each received chunk.
+    #
+    # response - A Net::HTTPResponse object.
+    #
+    # Examples
+    #
+    #   handle_response(response_object) do |body|
+    #     puts body
+    #   end
+    #
+    # Returns nothing.
+    # Raises Tweedle::ConnectionError if the server response is not an
+    #   Net::HTTPSuccess.
+    def handle_response(response)
+      unless response.kind_of?(Net::HTTPSuccess)
+        msg = "#{response.code}: #{response.message}\n#{response.body}"
+        raise Tweedle::ConnectionError.new(msg)
+      end
+
+      response.read_body do |body|
+        begin
+          yield MultiJson.load(body, symbolize_keys: true) if block_given?
+        rescue
+          # Wrap this to not die on keep alive data sent by the
+          # Streaming API.
+        end
+      end
+    end
+
+    # Private: Returns the OAuth consumer object.
+    #
+    # Examples
+    #
+    #   consumer
+    #   # => Oauth::Consumer
+    #
+    # Returns a OAuth::Consumer instance.
+    def consumer
+      @consumer ||= OAuth::Consumer.new(@config.consumer_key,
+                                        @config.consumer_secret)
+    end
+
+    # Private: Returns the OAuth access token.
+    #
+    # Examples
+    #
+    #   access_token
+    #   # => Oauth::Token
+    #
+    # Returns a OAuth::Token instance.
+    def access_token
+      @access_token ||= OAuth::Token.new(@config.oauth_token,
+                                         @config.oauth_secret)
+    end
+
+    # Private: Builds a new HTTP client object with SSL enabled for the given URI.
+    #
+    # uri - A URI instance.
+    #
+    # Examples
+    #
+    #   build_http URI.parse("http://www.google.com/")
+    #   # => Net::HTTP
+    #
+    # Returns a Net::HTTP instance.
+    def build_http(uri)
+      Net::HTTP.new(uri.host, uri.port).tap do |http|
+        http.use_ssl = true
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        http.start
+      end
+    end
+
+    # Private: Builds a Net::HTTP::Get request objext for the given
+    # URI and performs an OAuth sign using the given Net::HTTP instance.
+    #
+    # uri    - A String containing the request URI.
+    # http   - A Net:HTTP instance.
+    # params - Optional request parameters (default: empty Hash).
+    #
+    # Examples
+    #
+    #   uri = URI.parse("http://www.google.com/")
+    #   build_get_request(uri, build_http(uri))
+    #   # => Net::HTTP::Get
+    #
+    # Returns a Net::HTTP::Get instance.
+    def build_get_request(uri, http, params = {})
+      Net::HTTP::Get.new(uri.request_uri).tap do |request|
+        request.oauth!(http, consumer, access_token)
+      end
+    end
+
+    # Private: Builds a Net::HTTP::Post request objext for the given
+    # URI and performs an OAuth sign using the given Net::HTTP instance.
+    #
+    # uri       - A String containing the request URI.
+    # http      - A Net:HTTP instance.
+    # post_data - Object containing the POST data (converted using #encode_params)
+    # params    - Optional request parameters (default: empty Hash).
+    #
+    # Examples
+    #
+    #   uri = URI.parse("http://www.google.com/")
+    #   build_post_request(uri, "follow=12",build_http(uri))
+    #   # => Net::HTTP::Post
+    #
+    # Returns a Net::HTTP::Post instance.
+    def build_post_request(uri, http, post_data, params = {})
+      Net::HTTP::Post.new(uri.request_uri).tap do |request|
+        request["content-type"] = "application/x-www-form-urlencoded"
+        request.body = encode_params(post_data)
+        request.oauth!(http, consumer, access_token)
+      end
+    end
+
+    # Private: Builds a URI object for a given URI String and a
+    # parameter hash.
+    #
+    # uri    - String containing the request URI.
+    # params - Optional request parameters to encode.
+    #
+    # Examples
+    #
+    #   build_uri("http://www.google.com/search", q: "test search")
+    #   # => #<URI::HTTP URL:http://www.google.com/search?q=test+search>
+    #
+    # Returns a URI instance.
+    def build_uri(uri, params)
+      full_path = params.empty? ? uri : "#{uri}?#{encode_params(params)}"
+      URI.parse(full_path)
+    end
+
+    # Private: Encodes a parameter hash.
+    #
+    # params - The parameter hash to encode.
+    #
+    # Examples
+    #
+    #   encode_params(foo: "bar")
+    #   # => "foo=bar"
+    #
+    #   encode_params(foo: "bar", baz: 42)
+    #   # => "foo=bar&baz=42"
+    #
+    #   encode_params(follow: [1, 2, 3], baz: 42)
+    #   # => "follow=1,2,3&baz=42"
+    #
+    #   encode_params(q: "test search")
+    #   # => "q=test+search"
+    #
+    # Returns a String.
+    def encode_params(params)
+      params.map do |key, value|
+        escaped = if value.kind_of?(Array)
+          value.map { |val| CGI::escape(val.to_s) }.join(",")
+        else
+          CGI::escape(value.to_s)
+        end
+        "#{key}=#{escaped}"
+      end.join("&")
+    end
+  end
+end
+

data/lib/tweedle/errors.rb

@@ -0,0 +1,6 @@
+module Tweedle
+  # Public: A ConnectionError is raised by all Tweedle methods if the
+  # server does not response with an HTTP success.
+  class ConnectionError < StandardError
+  end
+end

data/lib/tweedle/statuses.rb

@@ -0,0 +1,160 @@
+module Tweedle
+  # Public: Wraps all generic {Twitter Streaming API methods}[https://dev.twitter.com/docs/streaming-api/methods].
+  class Statuses
+    # Public: The Twitter Stream server used by Tweedle::Statuses.
+    SERVER = "https://stream.twitter.com"
+
+    # Public: The Tweedle::Client used by the Tweedle::Statuses instance.
+    attr_reader :client
+
+    # Initializes a new Tweedle::Statuses instance.
+    #
+    # client - The Tweedle::Client used by the instance.
+    #
+    # Examples
+    #
+    #   Tweedle::Statuses.new
+    #   # => Tweedle::Statuses
+    #
+    #   Tweedle::Statuses.new(client_instance)
+    #   # => Tweedle::Statuses
+    #
+    # Returns a Tweedle::Statuses instance.
+    def initialize(client)
+      @client = client
+    end
+
+    # Returns all statuses containing http: and https:. The links
+    # stream is not a generally available resource.
+    #
+    # params - Hash containing request parameters (default: empty Hash).
+    #
+    # Examples
+    #
+    #   links(stall_warnings: true) do |body|
+    #     next unless text = tweet[:text]
+    #     puts "#{tweet[:user][:screen_name]}: #{text}"
+    #   end
+    #
+    # Returns nothing.
+    # Raises Tweedle::ConnectionError if the server response is not an
+    #   Net::HTTPSuccess.
+    def links(params = {})
+      get("/1/statuses/links.json", params) do |body|
+        yield body if block_given?
+      end
+    end
+
+    # Returns a random sample of all public statuses.
+    #
+    # params - Hash containing request parameters (default: empty Hash).
+    #
+    # Examples
+    #
+    #   sample(stall_warnings: true) do |body|
+    #     next unless text = tweet[:text]
+    #     puts "#{tweet[:user][:screen_name]}: #{text}"
+    #   end
+    #
+    # Returns nothing.
+    # Raises Tweedle::ConnectionError if the server response is not an
+    #   Net::HTTPSuccess.
+    def sample(params = {})
+      get("/1/statuses/sample.json", params) do |body|
+        yield body if block_given?
+      end
+    end
+
+    # Returns all public statuses. The Firehose is not a generally
+    # available resource.
+    #
+    # params - Hash containing request parameters (default: empty Hash).
+    #
+    # Examples
+    #
+    #   firehose(stall_warnings: true) do |body|
+    #     next unless text = tweet[:text]
+    #     puts "#{tweet[:user][:screen_name]}: #{text}"
+    #   end
+    #
+    # Returns nothing.
+    # Raises Tweedle::ConnectionError if the server response is not an
+    #   Net::HTTPSuccess.
+    def firehose(params = {})
+      get("/1/statuses/firehose.json", params) do |body|
+        yield body if block_given?
+      end
+    end
+
+    # Returns all retweets. The retweet stream is not a generally
+    # available resource.
+    #
+    # params - Hash containing request parameters (default: empty Hash).
+    #
+    # Examples
+    #
+    #   retweet(stall_warnings: true) do |body|
+    #     next unless text = tweet[:text]
+    #     puts "#{tweet[:user][:screen_name]}: #{text}"
+    #   end
+    #
+    # Returns nothing.
+    # Raises Tweedle::ConnectionError if the server response is not an
+    #   Net::HTTPSuccess.
+    def retweet(params = {})
+      get("/1/statuses/retweet.json", params) do |body|
+        yield body if block_given?
+      end
+    end
+
+    # Returns public statuses that match one or more filter
+    # predicates. At least one predicate parameter, follow,
+    # locations, or track must be specified. Multiple parameters
+    # may be specified.
+    #
+    # The default access level allows up to 400 track keywords, 5,000
+    # follow userids and 25 0.1-360 degree location boxes.
+    #
+    # This method uses a POST request to submit the filter predicates
+    # to the Twitter Streaming API.
+    #
+    # params - Hash containing the request parameters and filter predicates.
+    #
+    # Examples:
+    #
+    #   predicates = {
+    #    locations: [-122.75, 36.8, -121.75, 37.8, -74,40, -73,41],
+    #        track: ["ruby", "tweedle"]
+    #   }
+    #
+    #   filter(predicates: predicates) do |body|
+    #     next unless text = tweet[:text]
+    #     puts "#{tweet[:user][:screen_name]}: #{text}"
+    #   end
+    #
+    #   filter(predicates: predicates, count: 100, stall_warnings: true) do |body|
+    #     next unless text = tweet[:text]
+    #     puts "#{tweet[:user][:screen_name]}: #{text}"
+    #   end
+    #
+    # Returns nothing.
+    # Raises Tweedle::ConnectionError if the server response is not an
+    #   Net::HTTPSuccess.
+    def filter(params)
+      predicates = params.delete(:predicates)
+      post("/1/statuses/filter.json", predicates, params) do |body|
+        yield body if block_given?
+      end
+    end
+
+    private
+
+    def post(path, post_data, params, &block)
+      @client.post(SERVER + path, post_data, params, &block)
+    end
+
+    def get(path, params, &block)
+      @client.get(SERVER + path, params, &block)
+    end
+  end
+end

data/lib/tweedle/version.rb

@@ -0,0 +1,4 @@
+module Tweedle
+  # Public: The current Tweedle version.
+  VERSION = "0.1.0"
+end

data/lib/tweedle.rb

@@ -0,0 +1,58 @@
+# gems
+require "multi_json"
+require "oauth"
+
+# stdlib
+require "ostruct"
+require "cgi"
+
+# internal
+require "tweedle/version"
+require "tweedle/client"
+require "tweedle/statuses"
+require "tweedle/errors"
+
+# Public: The Tweedle namespace.
+module Tweedle
+  class << self
+    # Public: Holds the global Tweedle configuration OpenStruct object.
+    attr_accessor :config
+
+    # Yields the global configuration OpenStruct object to the passed
+    # block. Will assign a new OpenStruct object if none has been set.
+    #
+    # Examples
+    #
+    #   Tweedle.configure do |config|
+    #     config.consumer_key    = "the_consumer_key"
+    #     config.consumer_secret = "the_consumer_secret"
+    #     config.oauth_token     = "the_oauth_token"
+    #     config.oauth_secret    = "the_oauth_secret"
+    #   end
+    #
+    # Returns nothing.
+    def configure
+      @config ||= OpenStruct.new
+      yield @config if block_given?
+    end
+
+    # Initializes a new Tweedle::Client.
+    #
+    # config - Options object for the Tweedle client. By default uses
+    #          the global Tweedle configuarion (default: Tweedle.config).
+    #
+    # Examples
+    #
+    #   Tweedle.new
+    #   # => Tweedle::Client
+    #
+    #   Tweedle.new(config_object)
+    #   # => Tweedle::Client
+    #
+    # Returns a Tweedle::Client instance.
+    def new(config = Tweedle.config)
+      Tweedle::Client.new(config)
+    end
+  end
+end
+

data/test/helper.rb

@@ -0,0 +1,19 @@
+if ENV['COVERAGE'] && (RUBY_ENGINE == "ruby")
+  require 'simplecov'
+  SimpleCov.start { add_filter "/test/" }
+end
+
+require 'minitest/autorun'
+require "mocha"
+require "fakeweb"
+require "tweedle"
+
+FakeWeb.allow_net_connect = false
+
+Tweedle.configure do |config|
+  config.consumer_key    = "abc"
+  config.consumer_secret = "def"
+  config.oauth_token     = "ghi"
+  config.oauth_secret    = "jkl"
+end
+

data/test/test_client.rb

@@ -0,0 +1,136 @@
+require_relative "helper"
+
+class TestClient < MiniTest::Unit::TestCase
+  def setup
+    @uri     = "https://www.google.com"
+
+    FakeWeb.register_uri :get,
+                         @uri,
+                         body: "[ \"ok\" ]"
+
+    FakeWeb.register_uri :get,
+                         @uri + "?foo=bar",
+                         body: "[ \"foo=bar\" ]"
+
+    FakeWeb.register_uri :get,
+                         @uri + "?foo=bar,baz",
+                         body: "[ \"foo=bar,baz\" ]"
+
+    FakeWeb.register_uri :get,
+                         @uri + "?foo=bar&baz=42",
+                         body: "[ \"foo=bar&baz=42\" ]"
+
+    FakeWeb.register_uri :post,
+                         @uri,
+                         body: "[ \"post\" ]"
+
+    FakeWeb.register_uri :post,
+                         @uri + "?bar=baz",
+                         body: "[ \"post bar=baz\" ]"
+
+    FakeWeb.register_uri :post,
+                         @uri + "?bar=baz,42",
+                         body: "[ \"post bar=baz,42\" ]"
+
+    FakeWeb.register_uri :post,
+                         @uri + "?bar=baz&ok=42",
+                         body: "[ \"post bar=baz&ok=42\" ]"
+
+    @invalid = "https://www.invalid.com"
+
+    FakeWeb.register_uri :get,
+                         @invalid,
+                         body: "[ \"error\" ]",
+                         status: ["404", "Not Found"]
+
+    FakeWeb.register_uri :post,
+                         @invalid,
+                         body: "[ \"error\" ]",
+                         status: ["404", "Not Found"]
+  end
+
+  def teardown
+    FakeWeb.clean_registry
+  end
+
+  def test_config
+    assert_equal :foo, Tweedle::Client.new(:foo).config
+  end
+
+  def test_default_config
+    assert_equal Tweedle.config, Tweedle::Client.new.config
+  end
+
+  def test_statuses
+    client = Tweedle.new
+    statuses = client.statuses
+    assert_instance_of Tweedle::Statuses, statuses
+    assert_equal client, statuses.client
+  end
+
+  def test_get
+    Tweedle.new.get(@uri) { |body| assert_equal ["ok"], body }
+  end
+
+  def test_post
+    Tweedle.new.post(@uri, foo: "bar") do |body|
+      assert_equal ["post"], body
+    end
+    assert_equal "foo=bar", FakeWeb.last_request.body
+
+    Tweedle.new.post(@uri, foo: ["bar", "baz"]) do |body|
+      assert_equal ["post"], body
+    end
+    assert_equal "foo=bar,baz", FakeWeb.last_request.body
+
+    Tweedle.new.post(@uri, foo: "bar", baz: 42) do |body|
+      assert_equal ["post"], body
+    end
+    assert_equal "foo=bar&baz=42", FakeWeb.last_request.body
+  end
+
+  def test_get_with_params
+    Tweedle.new.get(@uri, foo: "bar") do |body|
+      assert_equal ["foo=bar"], body
+    end
+
+    Tweedle.new.get(@uri, foo: ["bar", "baz"]) do |body|
+      assert_equal ["foo=bar,baz"], body
+    end
+
+    Tweedle.new.get(@uri, foo: "bar", baz: 42) do |body|
+      assert_equal ["foo=bar&baz=42"], body
+    end
+  end
+
+
+  def test_post_with_params
+    Tweedle.new.post(@uri, { foo: "bar" }, { bar: "baz" }) do |body|
+      assert_equal ["post bar=baz"], body
+    end
+    assert_equal "foo=bar", FakeWeb.last_request.body
+
+    Tweedle.new.post(@uri, { foo: "bar" }, { bar: ["baz", 42] }) do |body|
+      assert_equal ["post bar=baz,42"], body
+    end
+    assert_equal "foo=bar", FakeWeb.last_request.body
+
+    Tweedle.new.post(@uri, { foo: "bar" }, { bar: "baz", ok: 42 }) do |body|
+      assert_equal ["post bar=baz&ok=42"], body
+    end
+    assert_equal "foo=bar", FakeWeb.last_request.body
+  end
+
+  def test_get_with_invalid_response
+    assert_raises(Tweedle::ConnectionError) do
+      Tweedle.new.get(@invalid)
+    end
+  end
+
+  def test_post_with_invalid_response
+    assert_raises(Tweedle::ConnectionError) do
+      Tweedle.new.post(@invalid, foo: "bar")
+    end
+  end
+end
+

data/test/test_statuses.rb

@@ -0,0 +1,147 @@
+require_relative "helper"
+
+class TestStatuses < MiniTest::Unit::TestCase
+  def statuses
+    Tweedle.new.statuses
+  end
+
+  def setup
+    %w(firehose retweet links sample).each do |req|
+      FakeWeb.register_uri :get,
+        Tweedle::Statuses::SERVER + "/1/statuses/#{req}.json",
+        body: "[\"ok\"]"
+
+      FakeWeb.register_uri :get,
+        Tweedle::Statuses::SERVER + "/1/statuses/#{req}.json?count=100",
+        body: "[\"single\"]"
+
+      FakeWeb.register_uri :get,
+        Tweedle::Statuses::SERVER + "/1/statuses/#{req}.json?count=100,200",
+        body: "[\"array\"]"
+
+      FakeWeb.register_uri :get,
+        Tweedle::Statuses::SERVER + "/1/statuses/#{req}.json?count=1&foo=true",
+        body: "[\"multi\"]"
+    end
+
+    FakeWeb.register_uri :post,
+      Tweedle::Statuses::SERVER + "/1/statuses/filter.json",
+      body: "[\"post\"]"
+
+    FakeWeb.register_uri :post,
+      Tweedle::Statuses::SERVER + "/1/statuses/filter.json?foo=42,43&bar=true",
+      body: "[\"post with params\"]"
+  end
+
+  def teardown
+    FakeWeb.clean_registry
+  end
+
+  def test_filter
+    predicates = {
+      locations: [-122.75, 36.8, -121.75, 37.8],
+      track:     ["ruby", "tweedle"]
+    }
+
+    statuses.filter(predicates: predicates) do |body|
+      assert_equal ["post"], body
+    end
+
+    assert_equal "locations=-122.75,36.8,-121.75,37.8&track=ruby,tweedle",
+                 FakeWeb.last_request.body
+  end
+
+  def test_filter_with_params
+    predicates = {
+      locations: [-122.75, 36.8, -121.75, 37.8],
+      track:     ["ruby", "tweedle"]
+    }
+
+    statuses.filter(predicates: predicates, foo: [42, 43], bar: true) do |body|
+      assert_equal ["post with params"], body
+    end
+
+    assert_equal "locations=-122.75,36.8,-121.75,37.8&track=ruby,tweedle",
+                 FakeWeb.last_request.body
+  end
+
+  def test_firehose
+    statuses.firehose do |body|
+      assert_equal ["ok"], body
+    end
+  end
+
+  def test_firehose_with_params
+    statuses.firehose(count: 100) do |body|
+      assert_equal ["single"], body
+    end
+
+    statuses.firehose(count: [100, 200]) do |body|
+      assert_equal ["array"], body
+    end
+
+    statuses.firehose(count: 1, foo: true) do |body|
+      assert_equal ["multi"], body
+    end
+  end
+
+  def test_retweet
+    statuses.retweet do |body|
+      assert_equal ["ok"], body
+    end
+  end
+
+  def test_retweet_with_params
+    statuses.retweet(count: 100) do |body|
+      assert_equal ["single"], body
+    end
+
+    statuses.retweet(count: [100, 200]) do |body|
+      assert_equal ["array"], body
+    end
+
+    statuses.retweet(count: 1, foo: true) do |body|
+      assert_equal ["multi"], body
+    end
+  end
+
+  def test_links
+    statuses.links do |body|
+      assert_equal ["ok"], body
+    end
+  end
+
+  def test_links_with_params
+    statuses.links(count: 100) do |body|
+      assert_equal ["single"], body
+    end
+
+    statuses.links(count: [100, 200]) do |body|
+      assert_equal ["array"], body
+    end
+
+    statuses.links(count: 1, foo: true) do |body|
+      assert_equal ["multi"], body
+    end
+  end
+
+  def test_sample
+    statuses.sample do |body|
+      assert_equal ["ok"], body
+    end
+  end
+
+  def test_sample_with_params
+    statuses.sample(count: 100) do |body|
+      assert_equal ["single"], body
+    end
+
+    statuses.sample(count: [100, 200]) do |body|
+      assert_equal ["array"], body
+    end
+
+    statuses.sample(count: 1, foo: true) do |body|
+      assert_equal ["multi"], body
+    end
+  end
+end

data/test/test_tweedle.rb

@@ -0,0 +1,26 @@
+require_relative "helper"
+
+class TestTweedle < MiniTest::Unit::TestCase
+  def setup
+    @old_config = Tweedle.config
+  end
+
+  def teardown
+    Tweedle.config = @old_config
+  end
+
+  def test_new
+    assert_instance_of Tweedle::Client, Tweedle.new
+  end
+
+  def test_new_passes_arguments
+    Tweedle::Client.expects(:new).with(:foo)
+    Tweedle.new(:foo)
+  end
+
+  def test_configure
+    Tweedle.configure { |config| config.foo = :bar }
+    assert_equal :bar, Tweedle.config.foo
+  end
+end
+

data/tweedle.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/tweedle/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Tobias Svensson"]
+  gem.email         = ["tob@tobiassvensson.co.uk"]
+  gem.description   = %q{Lightweight wrapper for the Twitter Streaming API}
+  gem.summary       = gem.description
+  gem.homepage      = "http://github.com/tobiassvn/tweedle"
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.name          = "tweedle"
+  gem.require_paths = ["lib"]
+  gem.version       = Tweedle::VERSION
+
+  gem.add_dependency "multi_json",    "~> 1.3.2"
+  gem.add_dependency "oauth",         "~> 0.4.6"
+  gem.add_dependency "jruby-openssl", "~> 0.7.6.1" if RUBY_PLATFORM =~ /java/
+end

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification
+name: tweedle
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Tobias Svensson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.2
+- !ruby/object:Gem::Dependency
+  name: oauth
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.4.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.4.6
+description: Lightweight wrapper for the Twitter Streaming API
+email:
+- tob@tobiassvensson.co.uk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rdoc_options
+- .travis.yml
+- Gemfile
+- LICENSE
+- README.rdoc
+- Rakefile
+- examples/statuses.filter.rb
+- examples/statuses.sample.rb
+- lib/tweedle.rb
+- lib/tweedle/client.rb
+- lib/tweedle/errors.rb
+- lib/tweedle/statuses.rb
+- lib/tweedle/version.rb
+- test/helper.rb
+- test/test_client.rb
+- test/test_statuses.rb
+- test/test_tweedle.rb
+- tweedle.gemspec
+homepage: http://github.com/tobiassvn/tweedle
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 2043315067158047274
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 2043315067158047274
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Lightweight wrapper for the Twitter Streaming API
+test_files:
+- test/helper.rb
+- test/test_client.rb
+- test/test_statuses.rb
+- test/test_tweedle.rb