twitter 4.8.1 → 5.0.0.rc.1

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,67 @@
-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
+
+    # Construct a new SearchResults object from a response hash
+    #
+    # @param response [Hash]
+    # @return [Twitter::Base]
+    def self.from_response(response={})
+      new(response[:body])
+    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|
+        Twitter::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][:next_results].nil? if @attrs[:search_metadata]
     end
     alias next_page? next_results?
 
@@ -69,11 +81,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

@@ -12,7 +12,7 @@ module Twitter
       super || size_equal(other) || attrs_equal(other)
     end
 
-  protected
+  private
 
     # @param other [Twitter::Size]
     # @return [Boolean]

data/lib/twitter/streaming/client.rb

@@ -0,0 +1,77 @@
+require 'http/request'
+require 'twitter/arguments'
+require 'twitter/client'
+require 'twitter/streaming/connection'
+require 'twitter/streaming/response'
+
+module Twitter
+  module Streaming
+    class Client < Twitter::Client
+      attr_writer :connection
+
+      def initialize(options={}, &block)
+        super
+        @connection = Twitter::Streaming::Connection.new
+      end
+
+      def filter(options={}, &block)
+        request(:get, 'https://stream.twitter.com:443/1.1/statuses/filter.json', options, &block)
+      end
+
+      def firehose(options={}, &block)
+        request(:get, 'https://stream.twitter.com:443/1.1/statuses/firehose.json', options, &block)
+      end
+
+      def sample(options={}, &block)
+        request(:get, 'https://stream.twitter.com:443/1.1/statuses/sample.json', options, &block)
+      end
+
+      def site(*args, &block)
+        arguments = Twitter::Arguments.new(args)
+        request(:get, 'https://sitestream.twitter.com:443/1.1/site.json', arguments.options.merge(:follow => arguments.join(',')), &block)
+      end
+
+      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 on_request(&block)
+        if block_given?
+          @on_request = block
+          self
+        elsif instance_variable_defined?(:@on_request)
+          @on_request
+        else
+          Proc.new {}
+        end
+      end
+
+    private
+
+      def request(method, uri, params, &block)
+        on_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 = Twitter::Streaming::Response.new do |data|
+          yield(Tweet.new(data)) if data[:id]
+        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/response.rb

@@ -0,0 +1,30 @@
+require 'buftok'
+
+module Twitter
+  module Streaming
+    class 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

@@ -12,8 +12,10 @@ module Twitter
 
     # @return [Array<Twitter::User>]
     def users
-      @users ||= Array(@attrs[:users]).map do |user|
-        Twitter::User.fetch_or_new(user)
+      memoize(:users) do
+        Array(@attrs[:users]).map do |user|
+          Twitter::User.new(user)
+        end
       end
     end
 

data/lib/twitter/token.rb

@@ -3,5 +3,13 @@ require 'twitter/base'
 module Twitter
   class Token < Twitter::Base
     attr_reader :token_type, :access_token
+
+    BEARER_TYPE = "bearer"
+
+    # @return [Boolean]
+    def bearer?
+      @attrs[:token_type] == BEARER_TYPE
+    end
+
   end
 end

data/lib/twitter/trend.rb

@@ -2,7 +2,8 @@ require 'twitter/base'
 
 module Twitter
   class Trend < Twitter::Base
-    attr_reader :events, :name, :promoted_content, :query, :url
+    attr_reader :events, :name, :promoted_content, :query
+    uri_attr_reader :uri
 
     # @param other [Twitter::Trend]
     # @return [Boolean]

data/lib/twitter/trend_results.rb

@@ -0,0 +1,59 @@
+require 'twitter/creatable'
+require 'twitter/enumerable'
+require 'twitter/null_object'
+
+module Twitter
+  class TrendResults
+    include Twitter::Creatable
+    include Twitter::Enumerable
+    attr_reader :attrs
+    alias to_h attrs
+    alias to_hash attrs
+    alias to_hsh attrs
+
+    # Construct a new SearchResults object from a response hash
+    #
+    # @param response [Hash]
+    # @return [Twitter::Base]
+    def self.from_response(response={})
+      new(response[:body].first)
+    end
+
+    # Initializes a new SearchResults object
+    #
+    # @param attrs [Hash]
+    # @return [Twitter::TrendResults]
+    def initialize(attrs={})
+      @attrs = attrs
+      @collection = Array(@attrs[:trends]).map do |trend|
+        Twitter::Trend.new(trend)
+      end
+    end
+
+    # Time when the object was created on Twitter
+    #
+    # @return [Time]
+    def as_of
+      @as_of ||= Time.parse(@attrs[:as_of]) if @attrs[:as_of]
+    end
+
+    def as_of?
+      !!@attrs[:as_of]
+    end
+
+    # @return [Twitter::Place, NullObject]
+    def location
+      @location ||= if location?
+        Twitter::Place.new(@attrs[:locations].first)
+      else
+        Twitter::NullObject.instance
+      end
+    end
+
+    # @return [Boolean]
+    def location?
+      !@attrs[:locations].nil? && !@attrs[:locations].first.nil?
+    end
+
+  end
+end

data/lib/twitter/tweet.rb

@@ -1,44 +1,35 @@
-require 'forwardable'
 require 'twitter/creatable'
-require 'twitter/exceptable'
-require 'twitter/identity'
 
 module Twitter
   class Tweet < Twitter::Identity
-    extend Forwardable
     include Twitter::Creatable
-    include Twitter::Exceptable
-    attr_reader :favorite_count, :favorited, :favoriters, :from_user_id,
-      :from_user_name, :in_reply_to_screen_name, :in_reply_to_attrs_id,
-      :in_reply_to_status_id, :in_reply_to_user_id, :lang, :repliers,
-      :retweeted, :retweeters, :source, :text, :to_user, :to_user_id,
-      :to_user_name, :truncated
-    alias in_reply_to_tweet_id in_reply_to_status_id
+    attr_reader :favorite_count, :favorited, :in_reply_to_screen_name,
+      :in_reply_to_attrs_id, :in_reply_to_status_id, :in_reply_to_user_id,
+      :lang, :retweet_count, :retweeted, :source, :text, :truncated
     alias favorites_count favorite_count
     alias favourite_count favorite_count
     alias favourites_count favorite_count
+    alias favoriters_count favorite_count
     alias favouriters_count favorite_count
     alias favourited favorited
     alias favourited? favorited?
-    alias favouriters favoriters
-    def_delegators :user, :profile_image_url, :profile_image_url_https
+    alias in_reply_to_tweet_id in_reply_to_status_id
+    alias retweeters_count retweet_count
+    object_attr_reader :GeoFactory, :geo
+    object_attr_reader :Metadata, :metadata
+    object_attr_reader :Place, :place
+    object_attr_reader :Tweet, :retweeted_status
+    alias retweet retweeted_status
+    alias retweeted_tweet retweeted_status
+    alias retweet? retweeted_status?
+    alias retweeted_tweet? retweeted_status?
+    object_attr_reader :User, :user, :status
 
     # @return [Boolean]
     def entities?
       !@attrs[:entities].nil?
     end
 
-    # @return [Integer]
-    def favoriters_count
-      favoriters_count = @attrs[:favoriters_count]
-      favoriters_count.to_i if favoriters_count
-    end
-
-    # @return [String]
-    def from_user
-      @attrs[:from_user] || user && user.screen_name
-    end
-
     def filter_level
       @attrs[:filter_level] || "none"
     end
@@ -46,7 +37,7 @@ module Twitter
     # @return [String]
     # @note May be > 140 characters.
     def full_text
-      if retweeted_status
+      if retweeted_status?
         prefix = text[/\A(RT @[a-z0-9_]{1,20}: )/i, 1]
         [prefix, retweeted_status.text].compact.join
       else
@@ -54,91 +45,56 @@ module Twitter
       end
     end
 
-    # @return [Twitter::Geo]
-    def geo
-      @geo ||= Twitter::GeoFactory.fetch_or_new(@attrs[:geo])
-    end
-
     # @note Must include entities in your request for this method to work
     # @return [Array<Twitter::Entity::Hashtag>]
     def hashtags
-      @hashtags ||= entities(Twitter::Entity::Hashtag, :hashtags)
+      memoize(:hashtags) do
+        entities(Twitter::Entity::Hashtag, :hashtags)
+      end
     end
 
     # @note Must include entities in your request for this method to work
     # @return [Array<Twitter::Media>]
     def media
-      @media ||= entities(Twitter::MediaFactory, :media)
-    end
-
-    # @return [Twitter::Metadata]
-    def metadata
-      @metadata ||= Twitter::Metadata.fetch_or_new(@attrs[:metadata])
-    end
-
-    # @return [Twitter::Place]
-    def place
-      @place ||= Twitter::Place.fetch_or_new(@attrs[:place])
-    end
-
-    # @return [Integer]
-    def repliers_count
-      repliers_count = @attrs[:repliers_count]
-      repliers_count.to_i if repliers_count
+      memoize(:media) do
+        entities(Twitter::MediaFactory, :media)
+      end
     end
-    alias reply_count repliers_count
 
     # @return [Boolean]
     def reply?
-      !!in_reply_to_status_id
-    end
-
-    # @return [Boolean]
-    def retweet?
-      !!retweeted_status
-    end
-
-    # If this Tweet is a retweet, the original Tweet is available here.
-    #
-    # @return [Twitter::Tweet]
-    def retweeted_status
-      @retweeted_status ||= self.class.fetch_or_new(@attrs[:retweeted_status])
-    end
-    alias retweeted_tweet retweeted_status
-    alias retweet retweeted_status
-
-    # @return [String]
-    def retweeters_count
-      retweeters_count = (@attrs[:retweet_count] || @attrs[:retweeters_count])
-      retweeters_count.to_i if retweeters_count
+      !!@attrs[:in_reply_to_status_id]
     end
-    alias retweet_count retweeters_count
 
     # @note Must include entities in your request for this method to work
     # @return [Array<Twitter::Entity::Symbol>]
     def symbols
-      @symbols ||= entities(Twitter::Entity::Symbol, :symbols)
+      memoize(:symbols) do
+        entities(Twitter::Entity::Symbol, :symbols)
+      end
     end
 
-    # @note Must include entities in your request for this method to work
-    # @return [Array<Twitter::Entity::Url>]
-    def urls
-      @urls ||= entities(Twitter::Entity::Url, :urls)
+    # @return [String] The URL to the tweet.
+    def uri
+      @uri ||= ::URI.parse("https://twitter.com/#{user.screen_name}/status/#{id}")
     end
+    alias url uri
 
-    # @return [Twitter::User]
-    def user
-      @user ||= fetch_or_new_without_self(Twitter::User, @attrs, :user, :status)
+    # @note Must include entities in your request for this method to work
+    # @return [Array<Twitter::Entity::URI>]
+    def uris
+      memoize(:uris) do
+        entities(Twitter::Entity::URI, :urls)
+      end
     end
+    alias urls uris
 
     # @note Must include entities in your request for this method to work
     # @return [Array<Twitter::Entity::UserMention>]
     def user_mentions
-      @user_mentions ||= entities(Twitter::Entity::UserMention, :user_mentions)
-    end
-
-    def user?
-      !@attrs[:user].nil?
+      memoize(:user_mentions) do
+        entities(Twitter::Entity::UserMention, :user_mentions)
+      end
     end
 
   private
@@ -148,7 +104,7 @@ module Twitter
     def entities(klass, key)
       if entities?
         Array(@attrs[:entities][key.to_sym]).map do |entity|
-          klass.fetch_or_new(entity)
+          klass.new(entity)
         end
       else
         warn "#{Kernel.caller.first}: To get #{key.to_s.tr('_', ' ')}, you must pass `:include_entities => true` when requesting the #{self.class.name}."