twitter 4.8.1 → 5.0.0

data/Rakefile

@@ -7,5 +7,11 @@ RSpec::Core::RakeTask.new(:spec)
 task :test => :spec
 task :default => :spec
 
+task :erd do
+  `bundle exec ruby ./etc/erd.rb > ./etc/erd.dot`
+  `dot -Tpng ./etc/erd.dot -o ./etc/erd.png`
+  `open ./etc/erd.png`
+end
+
 require 'yard'
 YARD::Rake::YardocTask.new

data/lib/twitter/arguments.rb

@@ -0,0 +1,14 @@
+module Twitter
+  class Arguments < Array
+    attr_reader :options
+
+    # Initializes a new Arguments object
+    #
+    # @return [Twitter::Arguments]
+    def initialize(args)
+      @options = args.last.is_a?(::Hash) ? args.pop : {}
+      super(args)
+    end
+
+  end
+end

data/lib/twitter/base.rb

@@ -1,75 +1,116 @@
-require 'twitter/error/identity_map_key_error'
+require 'forwardable'
+require 'memoizable'
+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
-    #
-    # @param attrs [Array, Set, 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
+    extend Forwardable
+    include Memoizable
+    attr_reader :attrs
+    alias to_h attrs
+    alias to_hash attrs
+    alias to_hsh attrs
+
+    class << self
+
+      # Construct an object from a response hash
+      #
+      # @param response [Hash]
+      # @return [Twitter::Base]
+      def from_response(response={})
+        new(response[:body])
+      end
+
+      # Define methods that retrieve the value from attributes
+      #
+      # @param attrs [Array, Symbol]
+      def attr_reader(*attrs)
+        attrs.each do |attr|
+          define_attribute_method(attr)
+          define_predicate_method(attr)
         end
       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
-    end
+      # Define object methods from attributes
+      #
+      # @param klass [Symbol]
+      # @param key1 [Symbol]
+      # @param key2 [Symbol]
+      def 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.
-    #
-    # @param attrs [Hash]
-    # @return [Twitter::Base]
-    def self.fetch(attrs)
-      return unless identity_map
-      if object = identity_map.fetch(Marshal.dump(attrs))
-        return object
+      # Define URI methods from attributes
+      #
+      # @param attrs [Array, Symbol]
+      def 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)
+          alias_method(url_key, uri_key)
+          define_predicate_method(uri_key, url_key)
+          alias_method(:"#{url_key}?", :"#{uri_key}?")
+        end
       end
-      return yield if block_given?
-      raise Twitter::Error::IdentityMapKeyError, "key not found"
-    end
 
-    # Stores an object in the identity map.
-    #
-    # @param object [Object]
-    # @return [Twitter::Base]
-    def self.store(object)
-      return object unless identity_map
-      identity_map.store(Marshal.dump(object.attrs), object)
-    end
+      # Define display_uri attribute methods
+      def display_uri_attr_reader
+        define_attribute_method(:display_url)
+        alias_method(:display_uri, :display_url)
+        define_predicate_method(:display_uri, :display_url)
+        alias_method(:display_url?, :display_uri?)
+      end
 
-    # Returns a new object based on the response hash
-    #
-    # @param response [Hash]
-    # @return [Twitter::Base]
-    def self.from_response(response={})
-      fetch_or_new(response[:body])
-    end
+    private
 
-    # Retrieves an object from the identity map, or stores it in the
-    # identity map if it doesn't already exist.
-    #
-    # @param attrs [Hash]
-    # @return [Twitter::Base]
-    def self.fetch_or_new(attrs={})
-      return unless attrs
-      return new(attrs) unless identity_map
+      # Dynamically define a method for a URI
+      #
+      # @param key1 [Symbol]
+      # @param key2 [Symbol]
+      def define_uri_method(key1, key2)
+        define_method(key1) do ||
+          URI.parse(@attrs[key2]) if @attrs[key2]
+        end
+        memoize(key1)
+      end
+
+      # Dynamically define a method for an attribute
+      #
+      # @param key1 [Symbol]
+      # @param klass [Symbol]
+      # @param key2 [Symbol]
+      def define_attribute_method(key1, klass=nil, key2=nil)
+        define_method(key1) do ||
+          if klass.nil?
+            @attrs[key1]
+          else
+            if @attrs[key1]
+              attrs = attrs_for_object(key1, key2)
+              Twitter.const_get(klass).new(attrs)
+            else
+              NullObject.new
+            end
+          end
+        end
+        memoize(key1)
+      end
 
-      fetch(attrs) do
-        object = new(attrs)
-        store(object)
+      # Dynamically define a predicate method for an attribute
+      #
+      # @param key1 [Symbol]
+      # @param key2 [Symbol]
+      def define_predicate_method(key1, key2=key1)
+        define_method(:"#{key1}?") do ||
+          !!@attrs[key2]
+        end
+        memoize(:"#{key1}?")
       end
+
     end
 
     # Initializes a new object
@@ -77,7 +118,7 @@ module Twitter
     # @param attrs [Hash]
     # @return [Twitter::Base]
     def initialize(attrs={})
-      @attrs = attrs
+      @attrs = attrs || {}
     end
 
     # Fetches an attribute of an object using hash notation
@@ -89,36 +130,15 @@ module Twitter
       nil
     end
 
-    # Retrieve the attributes of an object
-    #
-    # @return [Hash]
-    def attrs
-      @attrs
-    end
-    alias to_hash attrs
+  private
 
-    # Update the attributes of an object
-    #
-    # @param attrs [Hash]
-    # @return [Twitter::Base]
-    def update(attrs)
-      @attrs.update(attrs)
-      self
-    end
-
-  protected
-
-    # @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)
-    end
-
-    # @param other [Twitter::Base]
-    # @return [Boolean]
-    def attrs_equal(other)
-      self.class == other.class && !other.attrs.empty? && attrs == other.attrs
+    def attrs_for_object(key1, key2=nil)
+      if key2.nil?
+        @attrs[key1]
+      else
+        attrs = @attrs.dup
+        attrs.delete(key1).merge(key2 => attrs)
+      end
     end
 
   end

data/lib/twitter/client.rb

@@ -1,147 +1,70 @@
-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_accessor :access_token, :access_token_secret, :consumer_key, :consumer_secret
+    alias oauth_token access_token
+    alias oauth_token= access_token=
+    alias oauth_token_secret access_token_secret
+    alias oauth_token_secret= access_token_secret=
 
     # Initializes a new Client object
     #
     # @param options [Hash]
     # @return [Twitter::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)
+    # @return [Boolean]
+    def user_token?
+      !!(access_token && access_token_secret)
     end
 
-    # Perform an HTTP GET request
-    def get(path, params={})
-      request(:get, path, params)
+    # @return [String]
+    def user_agent
+      @user_agent ||= "Twitter Ruby Gem #{Twitter::Version}"
     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 [Hash]
+    def credentials
+      {
+        :consumer_key    => consumer_key,
+        :consumer_secret => consumer_secret,
+        :token           => access_token,
+        :token_secret    => access_token_secret,
+      }
     end
 
-    # Perform an HTTP PUT request
-    def put(path, params={})
-      request(:put, path, params)
+    # @return [Boolean]
+    def credentials?
+      credentials.values.all?
     end
 
   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
-      end
-    end
-
-    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
-    end
-
-    # Returns a Faraday::Connection object
-    #
-    # @return [Faraday::Connection]
-    def connection
-      @connection ||= Faraday.new(@endpoint, @connection_options.merge(:builder => @middleware))
-    end
-
-    # Generates authentication header for a bearer token request
+    # Ensures that all credentials set during configuration are of a
+    # valid type. Valid types are String and Symbol.
     #
-    # @return [String]
-    def bearer_token_credentials_auth_header
-      basic_auth_token = encode_value("#{@consumer_key}:#{@consumer_secret}")
-      "Basic #{basic_auth_token}"
-    end
-
-    def encode_value(value)
-      [value].pack("m0").gsub("\n", '')
-    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}"
+    # @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

data/lib/twitter/configuration.rb

@@ -4,16 +4,19 @@ module Twitter
   class Configuration < Twitter::Base
     attr_reader :characters_reserved_per_media, :max_media_per_upload,
       :non_username_paths, :photo_size_limit, :short_url_length, :short_url_length_https
+    alias short_uri_length short_url_length
+    alias short_uri_length_https short_url_length_https
 
     # Returns an array of photo sizes
     #
     # @return [Array<Twitter::Size>]
     def photo_sizes
-      @photo_sizes ||= Array(@attrs[:photo_sizes]).inject({}) do |object, (key, value)|
-        object[key] = Twitter::Size.fetch_or_new(value)
+      Array(@attrs[:photo_sizes]).inject({}) do |object, (key, value)|
+        object[key] = Size.new(value)
         object
       end
     end
+    memoize :photo_sizes
 
   end
 end

data/lib/twitter/core_ext/kernel.rb

@@ -1,6 +1,10 @@
 module Kernel
 
   # Returns the object's singleton class (exists in Ruby 1.9.2)
-  def singleton_class; class << self; self; end; end unless method_defined?(:singleton_class)
+  def singleton_class
+    class << self
+      self
+    end
+  end unless method_defined?(:singleton_class)
 
 end

data/lib/twitter/creatable.rb

@@ -1,20 +1,23 @@
 require 'time'
+require 'memoizable'
 
 module Twitter
   module Creatable
+    include Memoizable
 
     # Time when the object was created on Twitter
     #
     # @return [Time]
     def created_at
-      @created_at ||= Time.parse(@attrs[:created_at]) if created?
+      Time.parse(@attrs[:created_at]) if @attrs[:created_at]
     end
+    memoize :created_at
 
-  private
-
+    # @return [Boolean]
     def created?
-      !@attrs[:created_at].nil?
+      !!@attrs[:created_at]
     end
+    memoize :created?
 
   end
 end

data/lib/twitter/cursor.rb

@@ -3,62 +3,62 @@ require 'twitter/core_ext/kernel'
 module Twitter
   class Cursor
     include Enumerable
-    attr_reader :attrs, :collection
+    attr_reader :attrs
+    alias to_h attrs
     alias to_hash attrs
+    alias to_hsh attrs
+
+    class << self
+
+      # Construct a new Cursor object from a response hash
+      #
+      # @param response [Hash]
+      # @param key [String, Symbol] The key to fetch the data from the response
+      # @param klass [Class] The class to instantiate objects in the response
+      # @param client [Twitter::REST::Client]
+      # @param request_method [String, Symbol]
+      # @param path [String]
+      # @param options [Hash]
+      # @return [Twitter::Cursor]
+      def from_response(response, key, klass, client, request_method, path, options)
+        new(response[:body], key, klass, client, request_method, path, options)
+      end
 
-    # Initializes a new Cursor object
-    #
-    # @param response [Hash]
-    # @param collection_name [String, Symbol] The name of the method to return the collection
-    # @param klass [Class] The class to instantiate object in the collection
-    # @param client [Twitter::Client]
-    # @param method_name [String, Symbol]
-    # @param method_options [Hash]
-    # @return [Twitter::Cursor]
-    def self.from_response(response, collection_name, klass, client, method_name, method_options)
-      new(response[:body], collection_name, klass, client, method_name, method_options)
     end
 
     # Initializes a new Cursor
     #
     # @param attrs [Hash]
-    # @param collection_name [String, Symbol] The name of the method to return the collection
-    # @param klass [Class] The class to instantiate object in the collection
-    # @param client [Twitter::Client]
-    # @param method_name [String, Symbol]
-    # @param method_options [Hash]
+    # @param key [String, Symbol] The key to fetch the data from the response
+    # @param klass [Class] The class to instantiate objects in the response
+    # @param client [Twitter::REST::Client]
+    # @param request_method [String, Symbol]
+    # @param path [String]
+    # @param options [Hash]
     # @return [Twitter::Cursor]
-    def initialize(attrs, collection_name, klass, client, method_name, method_options)
-      @attrs = attrs
+    def initialize(attrs, key, klass, client, request_method, path, options)
+      @key = key.to_sym
+      @klass = klass
       @client = client
-      @method_name = method_name
-      @method_options = method_options
-      @collection = Array(attrs[collection_name.to_sym]).map do |item|
-        if klass
-          klass.fetch_or_new(item)
-        else
-          item
-        end
-      end
-      singleton_class.class_eval do
-        alias_method(collection_name.to_sym, :collection)
-      end
-    end
-
-    # @param collection [Array]
-    # @param cursor [Integer]
-    # @return [Array]
-    def all(collection=collection, cursor=next_cursor)
-      cursor = @client.send(@method_name.to_sym, @method_options.merge(:cursor => cursor))
-      collection += cursor.collection
-      cursor.last? ? collection.flatten : all(collection, cursor.next_cursor)
+      @request_method = request_method.to_sym
+      @path = path
+      @options = options
+      @collection = []
+      set_attrs(attrs)
     end
 
-    # @return [Enumerable]
-    def each
-      all(collection, next_cursor).each do |element|
+    # @return [Enumerator]
+    def each(start = 0, &block)
+      return to_enum(:each) unless block_given?
+      Array(@collection[start..-1]).each do |element|
         yield element
       end
+      unless last?
+        start = [@collection.size, start].max
+        fetch_next_page
+        each(start, &block)
+      end
+      self
     end
 
     def next_cursor
@@ -75,13 +75,25 @@ module Twitter
     def first?
       previous_cursor.zero?
     end
-    alias first first?
 
     # @return [Boolean]
     def last?
       next_cursor.zero?
     end
-    alias last last?
+
+  private
+
+    def fetch_next_page
+      response = @client.send(@request_method, @path, @options.merge(:cursor => next_cursor))
+      set_attrs(response[:body])
+    end
+
+    def set_attrs(attrs)
+      @attrs = attrs
+      Array(attrs[@key]).each do |element|
+        @collection << (@klass ? @klass.new(element) : element)
+      end
+    end
 
   end
 end

data/lib/twitter/direct_message.rb

@@ -6,16 +6,7 @@ module Twitter
     include Twitter::Creatable
     attr_reader :text
     alias full_text text
-
-    # @return [Twitter::User]
-    def recipient
-      @recipient ||= Twitter::User.fetch_or_new(@attrs[:recipient])
-    end
-
-    # @return [Twitter::User]
-    def sender
-      @sender ||= Twitter::User.fetch_or_new(@attrs[:sender])
-    end
-
+    object_attr_reader :User, :recipient
+    object_attr_reader :User, :sender
   end
 end

data/lib/twitter/entity/uri.rb

@@ -0,0 +1,14 @@
+require 'twitter/entity'
+
+module Twitter
+  class Entity
+    class URI < Twitter::Entity
+      display_uri_attr_reader
+      uri_attr_reader :expanded_uri, :uri
+    end
+
+    Uri = URI
+    URL = URI
+    Url = URI
+  end
+end