twitter 4.8.1 → 5.0.0.rc.1

data/lib/twitter.rb

@@ -1,14 +1,10 @@
-require 'twitter/action_factory'
-require 'twitter/client'
-require 'twitter/configurable'
 require 'twitter/configuration'
 require 'twitter/cursor'
-require 'twitter/default'
 require 'twitter/direct_message'
 require 'twitter/entity'
 require 'twitter/entity/hashtag'
 require 'twitter/entity/symbol'
-require 'twitter/entity/url'
+require 'twitter/entity/uri'
 require 'twitter/entity/user_mention'
 require 'twitter/geo_factory'
 require 'twitter/language'
@@ -20,47 +16,16 @@ require 'twitter/place'
 require 'twitter/profile_banner'
 require 'twitter/rate_limit'
 require 'twitter/relationship'
+require 'twitter/rest/client'
 require 'twitter/saved_search'
 require 'twitter/search_results'
 require 'twitter/settings'
 require 'twitter/size'
 require 'twitter/source_user'
+require 'twitter/streaming/client'
 require 'twitter/suggestion'
 require 'twitter/target_user'
 require 'twitter/trend'
 require 'twitter/tweet'
 require 'twitter/user'
-
-module Twitter
-  class << self
-    include Twitter::Configurable
-
-    # Delegate to a Twitter::Client
-    #
-    # @return [Twitter::Client]
-    def client
-      @client = Twitter::Client.new(options) unless defined?(@client) && @client.hash == options.hash
-      @client
-    end
-
-    # Has a client been initialized on the Twitter module
-    #
-    # @return [Boolean]
-    def client?
-      !!@client
-    end
-
-    def respond_to_missing?(method_name, include_private=false); client.respond_to?(method_name, include_private); end if RUBY_VERSION >= "1.9"
-    def respond_to?(method_name, include_private=false); client.respond_to?(method_name, include_private) || super; end if RUBY_VERSION < "1.9"
-
-  private
-
-    def method_missing(method_name, *args, &block)
-      return super unless client.respond_to?(method_name)
-      client.send(method_name, *args, &block)
-    end
-
-  end
-end
-
-Twitter.setup
+require 'uri'

data/lib/twitter/arguments.rb

@@ -0,0 +1,11 @@
+module Twitter
+  class Arguments < Array
+    attr_reader :options
+
+    def initialize(args)
+      @options = args.last.is_a?(::Hash) ? args.pop : {}
+      super(args)
+    end
+
+  end
+end

data/lib/twitter/base.rb

@@ -1,83 +1,114 @@
-require 'twitter/error/identity_map_key_error'
+require 'forwardable'
+require 'twitter/null_object'
+require 'uri'
 
 module Twitter
   class Base
-    # Define methods that retrieve the value from an initialized instance variable Hash, using the attribute as a key
+    extend Forwardable
+    attr_reader :attrs
+    alias to_h attrs
+    alias to_hash attrs
+    alias to_hsh attrs
+    def_delegators :attrs, :delete, :update
+
+    # Define methods that retrieve the value from attributes
     #
-    # @param attrs [Array, Set, Symbol]
+    # @param attrs [Array, Symbol]
     def self.attr_reader(*attrs)
-      mod = Module.new do
-        attrs.each do |attribute|
-          define_method attribute do
-            @attrs[attribute.to_sym]
-          end
-          define_method "#{attribute}?" do
-            !!@attrs[attribute.to_sym]
-          end
-        end
+      attrs.each do |attr|
+        define_attribute_method(attr)
+        define_predicate_method(attr)
       end
-      const_set(:Attributes, mod)
-      include mod
     end
 
-    # return [Twitter::IdentityMap]
-    def self.identity_map
-      return unless Twitter.identity_map
-      @identity_map = Twitter.identity_map.new unless defined?(@identity_map) && @identity_map.class == Twitter.identity_map
-      @identity_map
+    # Define object methods from attributes
+    #
+    # @param klass [Symbol]
+    # @param key1 [Symbol]
+    # @param key2 [Symbol]
+    def self.object_attr_reader(klass, key1, key2=nil)
+      define_attribute_method(key1, klass, key2)
+      define_predicate_method(key1)
     end
 
-    # Retrieves an object from the identity map.
+    # Define URI methods from attributes
     #
-    # @param attrs [Hash]
-    # @return [Twitter::Base]
-    def self.fetch(attrs)
-      return unless identity_map
-      if object = identity_map.fetch(Marshal.dump(attrs))
-        return object
+    # @param attrs [Array, Symbol]
+    def self.uri_attr_reader(*attrs)
+      attrs.each do |uri_key|
+        array = uri_key.to_s.split("_")
+        index = array.index("uri")
+        array[index] = "url"
+        url_key = array.join("_").to_sym
+        define_uri_method(uri_key, url_key)
+        define_predicate_method(uri_key, url_key)
+        alias_method(url_key, uri_key)
+        alias_method("#{url_key}?", "#{uri_key}?")
       end
-      return yield if block_given?
-      raise Twitter::Error::IdentityMapKeyError, "key not found"
     end
 
-    # Stores an object in the identity map.
+    # Dynamically define a method for a URI
     #
-    # @param object [Object]
-    # @return [Twitter::Base]
-    def self.store(object)
-      return object unless identity_map
-      identity_map.store(Marshal.dump(object.attrs), object)
+    # @param key1 [Symbol]
+    # @param key2 [Symbol]
+    def self.define_uri_method(key1, key2)
+      define_method(key1) do
+        memoize(key1) do
+          ::URI.parse(@attrs[key2]) if @attrs[key2]
+        end
+      end
     end
 
-    # Returns a new object based on the response hash
+    # Dynamically define a method for an attribute
     #
-    # @param response [Hash]
-    # @return [Twitter::Base]
-    def self.from_response(response={})
-      fetch_or_new(response[:body])
+    # @param key1 [Symbol]
+    # @param klass [Symbol]
+    # @param key2 [Symbol]
+    def self.define_attribute_method(key1, klass=nil, key2=nil)
+      define_method(key1) do
+        memoize(key1) do
+          if klass.nil?
+            @attrs[key1]
+          else
+            if @attrs[key1]
+              if key2.nil?
+                Twitter.const_get(klass).new(@attrs[key1])
+              else
+                attrs = @attrs.dup
+                value = attrs.delete(key1)
+                Twitter.const_get(klass).new(value.update(key2 => attrs))
+              end
+            else
+              Twitter::NullObject.instance
+            end
+          end
+        end
+      end
     end
 
-    # Retrieves an object from the identity map, or stores it in the
-    # identity map if it doesn't already exist.
+    # Dynamically define a predicate method for an attribute
     #
-    # @param attrs [Hash]
-    # @return [Twitter::Base]
-    def self.fetch_or_new(attrs={})
-      return unless attrs
-      return new(attrs) unless identity_map
-
-      fetch(attrs) do
-        object = new(attrs)
-        store(object)
+    # @param key [Symbol]
+    def self.define_predicate_method(key1, key2=key1)
+      define_method(:"#{key1}?") do
+        !!@attrs[key2]
       end
     end
 
+    # Construct an object from a response hash
+    #
+    # @param response [Hash]
+    # @return [Twitter::Base]
+    def self.from_response(response={})
+      new(response[:body])
+    end
+
     # Initializes a new object
     #
     # @param attrs [Hash]
     # @return [Twitter::Base]
     def initialize(attrs={})
-      @attrs = attrs
+      @attrs = attrs || {}
     end
 
     # Fetches an attribute of an object using hash notation
@@ -89,30 +120,20 @@ module Twitter
       nil
     end
 
-    # Retrieve the attributes of an object
-    #
-    # @return [Hash]
-    def attrs
-      @attrs
-    end
-    alias to_hash attrs
-
-    # Update the attributes of an object
-    #
-    # @param attrs [Hash]
-    # @return [Twitter::Base]
-    def update(attrs)
-      @attrs.update(attrs)
-      self
+    def memoize(key, &block)
+      ivar = :"@#{key}"
+      return instance_variable_get(ivar) if instance_variable_defined?(ivar)
+      result = block.call
+      instance_variable_set(ivar, result)
     end
 
-  protected
+  private
 
     # @param attr [Symbol]
     # @param other [Twitter::Base]
     # @return [Boolean]
     def attr_equal(attr, other)
-      self.class == other.class && !other.send(attr).nil? && send(attr) == other.send(attr)
+      self.class == other.class && !other.send(attr.to_sym).nil? && send(attr.to_sym) == other.send(attr.to_sym)
     end
 
     # @param other [Twitter::Base]

data/lib/twitter/client.rb

@@ -1,147 +1,106 @@
-require 'faraday'
-require 'multi_json'
-require 'twitter/api/direct_messages'
-require 'twitter/api/favorites'
-require 'twitter/api/friends_and_followers'
-require 'twitter/api/help'
-require 'twitter/api/lists'
-require 'twitter/api/oauth'
-require 'twitter/api/places_and_geo'
-require 'twitter/api/saved_searches'
-require 'twitter/api/search'
-require 'twitter/api/spam_reporting'
-require 'twitter/api/suggested_users'
-require 'twitter/api/timelines'
-require 'twitter/api/trends'
-require 'twitter/api/tweets'
-require 'twitter/api/undocumented'
-require 'twitter/api/users'
-require 'twitter/configurable'
-require 'twitter/error/client_error'
-require 'twitter/error/decode_error'
 require 'simple_oauth'
+require 'twitter/version'
 require 'uri'
 
 module Twitter
-  # 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
-    include Twitter::API::DirectMessages
-    include Twitter::API::Favorites
-    include Twitter::API::FriendsAndFollowers
-    include Twitter::API::Help
-    include Twitter::API::Lists
-    include Twitter::API::OAuth
-    include Twitter::API::PlacesAndGeo
-    include Twitter::API::SavedSearches
-    include Twitter::API::Search
-    include Twitter::API::SpamReporting
-    include Twitter::API::SuggestedUsers
-    include Twitter::API::Timelines
-    include Twitter::API::Trends
-    include Twitter::API::Tweets
-    include Twitter::API::Undocumented
-    include Twitter::API::Users
-    include Twitter::Configurable
+    attr_writer :access_token, :access_token_secret, :consumer_key,
+      :consumer_secret, :user_agent
+    alias oauth_token= access_token=
+    alias oauth_token_secret= access_token_secret=
 
     # Initializes a new Client object
     #
     # @param options [Hash]
-    # @return [Twitter::Client]
+    # @return [Twitter::REST::Client]
     def initialize(options={})
-      Twitter::Configurable.keys.each do |key|
-        instance_variable_set(:"@#{key}", options[key] || Twitter.instance_variable_get(:"@#{key}"))
+      options.each do |key, value|
+        send(:"#{key}=", value)
       end
+      yield self if block_given?
+      validate_credential_type!
     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)
+    # @return [String]
+    def consumer_key
+      if instance_variable_defined?(:@consumer_key)
+        @consumer_key
+      else
+        ENV['TWITTER_CONSUMER_KEY']
+      end
     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)
+    # @return [String]
+    def consumer_secret
+      if instance_variable_defined?(:@consumer_secret)
+        @consumer_secret
+      else
+        ENV['TWITTER_CONSUMER_SECRET']
+      end
     end
 
-    # Perform an HTTP PUT request
-    def put(path, params={})
-      request(:put, path, params)
+    # @return [String]
+    def access_token
+      if instance_variable_defined?(:@access_token)
+        @access_token
+      else
+        ENV['TWITTER_ACCESS_TOKEN'] || ENV['TWITTER_OAUTH_TOKEN']
+      end
     end
+    alias oauth_token access_token
 
-  private
-
-    # Returns a proc that can be used to setup the Faraday::Request headers
-    #
-    # @param method [Symbol]
-    # @param path [String]
-    # @param params [Hash]
-    # @return [Proc]
-    def request_setup(method, path, params, signature_params)
-      Proc.new do |request|
-        if params.delete(:bearer_token_request)
-          request.headers[:authorization] = bearer_token_credentials_auth_header
-          request.headers[:content_type] = 'application/x-www-form-urlencoded; charset=UTF-8'
-          request.headers[:accept] = '*/*' # It is important we set this, otherwise we get an error.
-        elsif params.delete(:app_auth) || !user_token?
-          unless bearer_token?
-            @bearer_token = token
-            Twitter.client.bearer_token = @bearer_token if Twitter.client?
-          end
-          request.headers[:authorization] = bearer_auth_header
-        else
-          request.headers[:authorization] = oauth_auth_header(method, path, signature_params).to_s
-        end
+    # @return [String]
+    def access_token_secret
+      if instance_variable_defined?(:@access_token_secret)
+        @access_token_secret
+      else
+        ENV['TWITTER_ACCESS_TOKEN_SECRET'] || ENV['TWITTER_OAUTH_TOKEN_SECRET']
       end
     end
+    alias oauth_token_secret access_token_secret
 
-    def request(method, path, params={}, signature_params=params)
-      request_setup = request_setup(method, path, params, signature_params)
-      connection.send(method.to_sym, path, params, &request_setup).env
-    rescue Faraday::Error::ClientError
-      raise Twitter::Error::ClientError
-    rescue MultiJson::DecodeError
-      raise Twitter::Error::DecodeError
+    # @return [Boolean]
+    def user_token?
+      !!(access_token && access_token_secret)
     end
 
-    # Returns a Faraday::Connection object
-    #
-    # @return [Faraday::Connection]
-    def connection
-      @connection ||= Faraday.new(@endpoint, @connection_options.merge(:builder => @middleware))
+    def user_agent
+      @user_agent ||= "Twitter Ruby Gem #{Twitter::Version}"
     end
 
-    # Generates authentication header for a bearer token request
-    #
-    # @return [String]
-    def bearer_token_credentials_auth_header
-      basic_auth_token = encode_value("#{@consumer_key}:#{@consumer_secret}")
-      "Basic #{basic_auth_token}"
+    # @return [Hash]
+    def credentials
+      {
+        :consumer_key    => consumer_key,
+        :consumer_secret => consumer_secret,
+        :token           => access_token,
+        :token_secret    => access_token_secret,
+      }
     end
 
-    def encode_value(value)
-      [value].pack("m0").gsub("\n", '')
+    # @return [Boolean]
+    def credentials?
+      credentials.values.all?
     end
 
-    def bearer_auth_header
-      if @bearer_token.is_a?(Twitter::Token) && @bearer_token.token_type == "bearer"
-        "Bearer #{@bearer_token.access_token}"
-      else
-        "Bearer #{@bearer_token}"
+  private
+
+    # Ensures that all credentials set during configuration are of a
+    # valid type. Valid types are String and Symbol.
+    #
+    # @raise [Twitter::Error::ConfigurationError] Error is raised when
+    #   supplied twitter credentials are not a String or Symbol.
+    def validate_credential_type!
+      credentials.each do |credential, value|
+        next if value.nil?
+        raise(Error::ConfigurationError, "Invalid #{credential} specified: #{value.inspect} must be a string or symbol.") unless value.is_a?(String) || value.is_a?(Symbol)
       end
     end
 
-    def oauth_auth_header(method, path, params={})
-      uri = URI(@endpoint + path)
+    def oauth_auth_header(method, uri, params={})
+      uri = URI.parse(uri)
       SimpleOAuth::Header.new(method, uri, params, credentials)
     end
+
   end
 end