twitter 4.8.1 → 5.0.0

data/lib/twitter/rest/client.rb

@@ -0,0 +1,175 @@
+require 'base64'
+require 'faraday'
+require 'faraday/request/multipart'
+require 'json'
+require 'twitter/client'
+require 'twitter/error'
+require 'twitter/error/configuration_error'
+require 'twitter/rest/api/direct_messages'
+require 'twitter/rest/api/favorites'
+require 'twitter/rest/api/friends_and_followers'
+require 'twitter/rest/api/help'
+require 'twitter/rest/api/lists'
+require 'twitter/rest/api/oauth'
+require 'twitter/rest/api/places_and_geo'
+require 'twitter/rest/api/saved_searches'
+require 'twitter/rest/api/search'
+require 'twitter/rest/api/spam_reporting'
+require 'twitter/rest/api/suggested_users'
+require 'twitter/rest/api/timelines'
+require 'twitter/rest/api/trends'
+require 'twitter/rest/api/tweets'
+require 'twitter/rest/api/undocumented'
+require 'twitter/rest/api/users'
+require 'twitter/rest/request/multipart_with_file'
+require 'twitter/rest/response/parse_json'
+require 'twitter/rest/response/raise_error'
+
+module Twitter
+  module REST
+    # Wrapper for the Twitter REST API
+    #
+    # @note All methods have been separated into modules and follow the same grouping used in {http://dev.twitter.com/doc the Twitter API Documentation}.
+    # @see http://dev.twitter.com/pages/every_developer
+    class Client < Twitter::Client
+      include Twitter::REST::API::DirectMessages
+      include Twitter::REST::API::Favorites
+      include Twitter::REST::API::FriendsAndFollowers
+      include Twitter::REST::API::Help
+      include Twitter::REST::API::Lists
+      include Twitter::REST::API::OAuth
+      include Twitter::REST::API::PlacesAndGeo
+      include Twitter::REST::API::SavedSearches
+      include Twitter::REST::API::Search
+      include Twitter::REST::API::SpamReporting
+      include Twitter::REST::API::SuggestedUsers
+      include Twitter::REST::API::Timelines
+      include Twitter::REST::API::Trends
+      include Twitter::REST::API::Tweets
+      include Twitter::REST::API::Undocumented
+      include Twitter::REST::API::Users
+      attr_accessor :bearer_token
+      attr_writer :connection_options, :middleware
+      ENDPOINT = 'https://api.twitter.com'
+
+      def connection_options
+        @connection_options ||= {
+          :builder => middleware,
+          :headers => {
+            :accept => 'application/json',
+            :user_agent => user_agent,
+          },
+          :request => {
+            :open_timeout => 5,
+            :timeout => 10,
+          },
+        }
+      end
+
+      # @note Faraday's middleware stack implementation is comparable to that of Rack middleware.  The order of middleware is important: the first middleware on the list wraps all others, while the last middleware is the innermost one.
+      # @see https://github.com/technoweenie/faraday#advanced-middleware-usage
+      # @see http://mislav.uniqpath.com/2011/07/faraday-advanced-http/
+      # @return [Faraday::Builder]
+      def middleware
+        @middleware ||= Faraday::Builder.new do |builder|
+          # Convert file uploads to Faraday::UploadIO objects
+          builder.use Twitter::REST::Request::MultipartWithFile
+          # Checks for files in the payload
+          builder.use Faraday::Request::Multipart
+          # Convert request params to "www-form-urlencoded"
+          builder.use Faraday::Request::UrlEncoded
+          # Handle error responses
+          builder.use Twitter::REST::Response::RaiseError
+          # Parse JSON response bodies
+          builder.use Twitter::REST::Response::ParseJson
+          # Set Faraday's HTTP adapter
+          builder.adapter Faraday.default_adapter
+        end
+      end
+
+      # Perform an HTTP DELETE request
+      def delete(path, params={})
+        request(:delete, path, params)
+      end
+
+      # Perform an HTTP GET request
+      def get(path, params={})
+        request(:get, path, params)
+      end
+
+      # Perform an HTTP POST request
+      def post(path, params={})
+        signature_params = params.values.any?{|value| value.respond_to?(:to_io)} ? {} : params
+        request(:post, path, params, signature_params)
+      end
+
+      # Perform an HTTP PUT request
+      def put(path, params={})
+        request(:put, path, params)
+      end
+
+      # @return [Boolean]
+      def bearer_token?
+        !!bearer_token
+      end
+
+      # @return [Boolean]
+      def credentials?
+        super || bearer_token?
+      end
+
+    private
+
+      # Returns a Faraday::Connection object
+      #
+      # @return [Faraday::Connection]
+      def connection
+        @connection ||= Faraday.new(ENDPOINT, connection_options)
+      end
+
+      def request(method, path, params={}, signature_params=params)
+        response = connection.send(method.to_sym, path, params) do |request|
+          bearer_token_request = params.delete(:bearer_token_request)
+          if bearer_token_request
+            request.headers[:accept] = '*/*' # It is important we set this, otherwise we get an error.
+            request.headers[:authorization] = bearer_token_credentials_auth_header
+            request.headers[:content_type] = 'application/x-www-form-urlencoded; charset=UTF-8'
+          else
+            request.headers[:authorization] = auth_token(method, path, params, signature_params)
+          end
+        end
+        response.env
+      rescue Faraday::Error::ClientError, JSON::ParserError
+        raise Twitter::Error
+      end
+
+      def auth_token(method, path, params={}, signature_params=params)
+        if !user_token?
+          @bearer_token = token unless bearer_token?
+          bearer_auth_header
+        else
+          oauth_auth_header(method, ENDPOINT + path, signature_params).to_s
+        end
+      end
+
+      # Generates authentication header for a bearer token request
+      #
+      # @return [String]
+      def bearer_token_credentials_auth_header
+        basic_auth_token = strict_encode64("#{@consumer_key}:#{@consumer_secret}")
+        "Basic #{basic_auth_token}"
+      end
+
+      def bearer_auth_header
+        token = bearer_token.is_a?(Twitter::Token) && bearer_token.bearer? ? bearer_token.access_token : bearer_token
+        "Bearer #{token}"
+      end
+
+      # Base64.strict_encode64 is not available on Ruby 1.8.7
+      def strict_encode64(str)
+        Base64.encode64(str).gsub("\n", "")
+      end
+
+    end
+  end
+end

data/lib/twitter/rest/request/multipart_with_file.rb

@@ -0,0 +1,36 @@
+require 'faraday'
+
+module Twitter
+  module REST
+    module Request
+      class MultipartWithFile < Faraday::Middleware
+        CONTENT_TYPE = 'Content-Type'
+
+        def call(env)
+          env[:body].each do |key, value|
+            if value.respond_to?(:to_io)
+              env[:body][key] = Faraday::UploadIO.new(value, mime_type(value.path), value.path)
+            end
+          end if env[:body].is_a?(::Hash)
+          @app.call(env)
+        end
+
+      private
+
+        def mime_type(path)
+          case path
+          when /\.jpe?g/i
+            'image/jpeg'
+          when /\.gif$/i
+            'image/gif'
+          when /\.png$/i
+            'image/png'
+          else
+            'application/octet-stream'
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/twitter/rest/response/parse_error_json.rb

@@ -0,0 +1,15 @@
+require 'twitter/rest/response/parse_json'
+
+module Twitter
+  module REST
+    module Response
+      class ParseErrorJson < Twitter::REST::Response::ParseJson
+
+        def unparsable_status_codes
+          super + [200]
+        end
+
+      end
+    end
+  end
+end

data/lib/twitter/rest/response/parse_json.rb

@@ -0,0 +1,31 @@
+require 'faraday'
+require 'json'
+
+module Twitter
+  module REST
+    module Response
+      class ParseJson < Faraday::Response::Middleware
+
+        def parse(body)
+          case body
+          when /\A^\s*$\z/, nil
+            nil
+          else
+            JSON.parse(body, :symbolize_names => true)
+          end
+        end
+
+        def on_complete(env)
+          if respond_to?(:parse)
+            env[:body] = parse(env[:body]) unless unparsable_status_codes.include?(env[:status])
+          end
+        end
+
+        def unparsable_status_codes
+          [204, 301, 302, 304]
+        end
+
+      end
+    end
+  end
+end

data/lib/twitter/{response → rest/response}/raise_error.rb

@@ -12,20 +12,17 @@ require 'twitter/error/unauthorized'
 require 'twitter/error/unprocessable_entity'
 
 module Twitter
-  module Response
-    class RaiseError < Faraday::Response::Middleware
+  module REST
+    module Response
+      class RaiseError < Faraday::Response::Middleware
 
-      def on_complete(env)
-        status_code = env[:status].to_i
-        error_class = @klass.errors[status_code]
-        raise error_class.from_response(env) if error_class
-      end
+        def on_complete(env)
+          status_code = env[:status].to_i
+          error_class = Twitter::Error.errors[status_code]
+          raise error_class.from_response(env) if error_class
+        end
 
-      def initialize(app, klass)
-        @klass = klass
-        super(app)
       end
-
     end
   end
 end

data/lib/twitter/search_results.rb

@@ -1,55 +1,71 @@
-require 'twitter/base'
+require 'twitter/enumerable'
 
 module Twitter
-  class SearchResults < Twitter::Base
+  class SearchResults
+    include Twitter::Enumerable
+    attr_reader :attrs
+    alias to_h attrs
+    alias to_hash attrs
+    alias to_hsh attrs
+
+    class << self
+
+      # Construct a new SearchResults object from a response hash
+      #
+      # @param response [Hash]
+      # @return [Twitter::Base]
+      def from_response(response={})
+        new(response[:body])
+      end
+
+    end
 
-    # @return [Array<Twitter::Tweet>]
-    def statuses
-      @results ||= Array(@attrs[:statuses]).map do |tweet|
-        Twitter::Tweet.fetch_or_new(tweet)
+    # Initializes a new SearchResults object
+    #
+    # @param attrs [Hash]
+    # @return [Twitter::SearchResults]
+    def initialize(attrs={})
+      @attrs = attrs
+      @collection = Array(@attrs[:statuses]).map do |tweet|
+        Tweet.new(tweet)
       end
     end
-    alias collection statuses
-    alias results statuses
 
     # @return [Float]
     def completed_in
-      @attrs[:search_metadata][:completed_in] if search_metadata?
+      @attrs[:search_metadata][:completed_in] if @attrs[:search_metadata]
     end
 
     # @return [Integer]
     def max_id
-      @attrs[:search_metadata][:max_id] if search_metadata?
+      @attrs[:search_metadata][:max_id] if @attrs[:search_metadata]
     end
 
     # @return [Integer]
     def page
-      @attrs[:search_metadata][:page] if search_metadata?
+      @attrs[:search_metadata][:page] if @attrs[:search_metadata]
     end
 
     # @return [String]
     def query
-      @attrs[:search_metadata][:query] if search_metadata?
+      @attrs[:search_metadata][:query] if @attrs[:search_metadata]
     end
 
     # @return [Integer]
     def results_per_page
-      @attrs[:search_metadata][:results_per_page] if search_metadata?
+      @attrs[:search_metadata][:count] if @attrs[:search_metadata]
     end
     alias rpp results_per_page
-
-    def search_metadata?
-      !@attrs[:search_metadata].nil?
-    end
+    alias count results_per_page
 
     # @return [Integer]
     def since_id
-      @attrs[:search_metadata][:since_id] if search_metadata?
+      @attrs[:search_metadata][:since_id] if @attrs[:search_metadata]
     end
 
     # @return [Boolean]
     def next_results?
-      !@attrs[:search_metadata][:next_results].nil? if search_metadata?
+      !!(@attrs[:search_metadata] && @attrs[:search_metadata][:next_results])
     end
     alias next_page? next_results?
 
@@ -69,11 +85,11 @@ module Twitter
     #
     # @note Returned Hash can be merged into the previous search options list to easily access the refresh page.
     # @return [Hash] The parameters needed to refresh the page.
-    def refresh_url
+    def refresh_results
       query_string = strip_first_character(@attrs[:search_metadata][:refresh_url])
       query_string_to_hash(query_string)
     end
-    alias refresh_page refresh_url
+    alias refresh_page refresh_results
 
   private
 

data/lib/twitter/settings.rb

@@ -5,11 +5,6 @@ module Twitter
     attr_reader :always_use_https, :discoverable_by_email, :geo_enabled,
       :language, :protected, :screen_name, :show_all_inline_media, :sleep_time,
       :time_zone
-
-    # @return [Twitter::Place]
-    def trend_location
-      @trend_location ||= Twitter::Place.fetch_or_new(Array(@attrs[:trend_location]).first)
-    end
-
+    object_attr_reader :Place, :trend_location
   end
 end

data/lib/twitter/size.rb

@@ -1,24 +1,11 @@
+require 'equalizer'
 require 'twitter/base'
 
 module Twitter
   class Size < Twitter::Base
+    include Equalizer.new(:h, :w)
     attr_reader :h, :resize, :w
     alias height h
     alias width w
-
-    # @param other [Twitter::Size]
-    # @return [Boolean]
-    def ==(other)
-      super || size_equal(other) || attrs_equal(other)
-    end
-
-  protected
-
-    # @param other [Twitter::Size]
-    # @return [Boolean]
-    def size_equal(other)
-      self.class == other.class && !other.h.nil? && h == other.h && !other.w.nil? && w == other.w
-    end
-
   end
 end

data/lib/twitter/streaming/client.rb

@@ -0,0 +1,89 @@
+require 'http/request'
+require 'twitter/arguments'
+require 'twitter/client'
+require 'twitter/streaming/connection'
+require 'twitter/streaming/response'
+require 'twitter/streaming/message_parser'
+require 'twitter/streaming/event'
+require 'twitter/streaming/friend_list'
+
+module Twitter
+  module Streaming
+    class Client < Twitter::Client
+      attr_writer :connection
+
+      # Initializes a new Client object
+      #
+      # @return [Twitter::Streaming::Client]
+      def initialize(options={}, &block)
+        super
+        @connection = Streaming::Connection.new
+      end
+
+      # @yield [Twitter::Tweet] A stream of tweets.
+      def filter(options={}, &block)
+        request(:post, 'https://stream.twitter.com:443/1.1/statuses/filter.json', options, &block)
+      end
+
+      # @yield [Twitter::Tweet] A stream of tweets.
+      def firehose(options={}, &block)
+        request(:get, 'https://stream.twitter.com:443/1.1/statuses/firehose.json', options, &block)
+      end
+
+      # @yield [Twitter::Tweet] A stream of tweets.
+      def sample(options={}, &block)
+        request(:get, 'https://stream.twitter.com:443/1.1/statuses/sample.json', options, &block)
+      end
+
+      # @yield [Twitter::Tweet] A stream of tweets.
+      def site(*args, &block)
+        arguments = Arguments.new(args)
+        request(:get, 'https://sitestream.twitter.com:443/1.1/site.json', arguments.options.merge(:follow => arguments.join(',')), &block)
+      end
+
+      # @yield [Twitter::Tweet] A stream of tweets.
+      def user(options={}, &block)
+        request(:get, 'https://userstream.twitter.com:443/1.1/user.json', options, &block)
+      end
+
+      # Set a Proc to be run when connection established.
+      def before_request(&block)
+        if block_given?
+          @before_request = block
+          self
+        elsif instance_variable_defined?(:@before_request)
+          @before_request
+        else
+          Proc.new {}
+        end
+      end
+
+    private
+
+      def request(method, uri, params, &block)
+        before_request.call
+        headers  = default_headers.merge(:authorization => oauth_auth_header(method, uri, params).to_s)
+        request  = HTTP::Request.new(method, uri + '?' + to_url_params(params), headers)
+        response = Streaming::Response.new do |data|
+          if item = Streaming::MessageParser.parse(data)
+            yield item
+          end
+        end
+        @connection.stream(request, response)
+      end
+
+      def to_url_params(params)
+        params.map do |param, value|
+          [param, URI.encode(value)].join("=")
+        end.sort.join('&')
+      end
+
+      def default_headers
+        @default_headers ||= {
+          :accept     => '*/*',
+          :user_agent => user_agent,
+        }
+      end
+    end
+  end
+end

data/lib/twitter/streaming/connection.rb

@@ -0,0 +1,22 @@
+require 'http/parser'
+require 'openssl'
+require 'resolv'
+
+module Twitter
+  module Streaming
+    class Connection
+
+      def stream(request, response)
+        client_context = OpenSSL::SSL::SSLContext.new
+        client         = TCPSocket.new(Resolv.getaddress(request.uri.host), request.uri.port)
+        ssl_client     = OpenSSL::SSL::SSLSocket.new(client, client_context)
+        ssl_client.connect
+        request.stream(ssl_client)
+        while body = ssl_client.readpartial(1024)
+          response << body
+        end
+      end
+
+    end
+  end
+end

data/lib/twitter/streaming/event.rb

@@ -0,0 +1,35 @@
+module Twitter
+  module Streaming
+    class Event
+
+      LIST_EVENTS = [
+        :list_created, :list_destroyed, :list_updated, :list_member_added, 
+        :list_member_added, :list_member_removed, :list_user_subscribed, 
+        :list_user_subscribed, :list_user_unsubscribed, :list_user_unsubscribed
+      ]
+
+      TWEET_EVENTS = [
+        :favorite, :unfavorite
+      ]
+        
+      attr_reader :name, :source, :target, :target_object
+
+      # @param data [Hash]
+      def initialize(data)
+        @name = data[:event].intern
+        @source = Twitter::User.new(data[:source])
+        @target = Twitter::User.new(data[:target])
+        @target_object = target_object_factory(@name, data[:target_object])
+      end
+
+    private
+      def target_object_factory(event_name, data)
+        if LIST_EVENTS.include?(event_name)
+          Twitter::List.new(data)
+        elsif TWEET_EVENTS.include?(event_name)
+          Twitter::Tweet.new(data)
+        end
+      end
+    end
+  end
+end

data/lib/twitter/streaming/friend_list.rb

@@ -0,0 +1,13 @@
+module Twitter
+  module Streaming
+    class FriendList
+
+      attr_reader :friend_ids
+
+      # @param friend_ids [Array]
+      def initialize(friend_ids)
+        @friend_ids = friend_ids
+      end
+    end
+  end
+end

data/lib/twitter/streaming/message_parser.rb

@@ -0,0 +1,18 @@
+module Twitter
+  module Streaming
+    class MessageParser
+
+      def self.parse(data)
+        if data[:id]
+          Tweet.new(data)
+        elsif data[:event]
+          Event.new(data)
+        elsif data[:direct_message]
+          DirectMessage.new(data[:direct_message])
+        elsif data[:friends]
+          FriendList.new(data[:friends])
+        end
+      end
+    end
+  end
+end

data/lib/twitter/streaming/response.rb

@@ -0,0 +1,34 @@
+require 'buftok'
+
+module Twitter
+  module Streaming
+    class Response
+
+      # Initializes a new Response object
+      #
+      # @return [Twitter::Streaming::Response]
+      def initialize(&block)
+        @block     = block
+        @parser    = Http::Parser.new(self)
+        @tokenizer = BufferedTokenizer.new("\r\n")
+      end
+
+      def <<(data)
+        @parser << data
+      end
+
+      def on_headers_complete(headers)
+        # TODO: handle response codes
+        p(:status_code => @parser.status_code, :header => headers) unless @parser.status_code == 200
+      end
+
+      def on_body(data)
+        @tokenizer.extract(data).each do |line|
+          next if line.empty?
+          @block.call(JSON.parse(line, :symbolize_names => true))
+        end
+      end
+
+    end
+  end
+end

data/lib/twitter/suggestion.rb

@@ -1,21 +1,18 @@
+require 'equalizer'
 require 'twitter/base'
 
 module Twitter
   class Suggestion < Twitter::Base
+    include Equalizer.new(:slug)
     attr_reader :name, :size, :slug
 
-    # @param other [Twitter::Suggestion]
-    # @return [Boolean]
-    def ==(other)
-      super || attr_equal(:slug, other) || attrs_equal(other)
-    end
-
     # @return [Array<Twitter::User>]
     def users
-      @users ||= Array(@attrs[:users]).map do |user|
-        Twitter::User.fetch_or_new(user)
+      Array(@attrs[:users]).map do |user|
+        User.new(user)
       end
     end
+    memoize :users
 
   end
 end