twitter 4.0.0

data/lib/twitter/base.rb

@@ -0,0 +1,119 @@
+require 'twitter/core_ext/kernel'
+require 'twitter/error/identity_map_key_error'
+
+module Twitter
+  class Base
+    attr_reader :attrs
+    alias to_hash attrs
+
+    # Define methods that retrieve the value from an initialized instance variable Hash, using the attribute as a key
+    #
+    # @overload self.attr_reader(attr)
+    #   @param attr [Symbol]
+    # @overload self.attr_reader(attrs)
+    #   @param attrs [Array<Symbol>]
+    def self.attr_reader(*attrs)
+      attrs.each do |attribute|
+        class_eval do
+          define_method attribute do
+            @attrs[attribute.to_sym]
+          end
+        end
+      end
+    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
+
+    # 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
+      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
+
+    # 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
+
+    # 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
+
+      fetch(attrs) do
+        object = new(attrs)
+        store(object)
+      end
+    end
+
+    # Initializes a new object
+    #
+    # @param attrs [Hash]
+    # @return [Twitter::Base]
+    def initialize(attrs={})
+      @attrs = attrs
+    end
+
+    # Fetches an attribute of an object using hash notation
+    #
+    # @param method [String, Symbol] Message to send to the object
+    def [](method)
+      send(method.to_sym)
+    rescue NoMethodError
+      nil
+    end
+
+    # 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
+    end
+
+  end
+end

data/lib/twitter/basic_user.rb

@@ -0,0 +1,8 @@
+require 'twitter/identity'
+
+module Twitter
+  class BasicUser < Twitter::Identity
+    attr_reader :following, :screen_name
+    alias following? following
+  end
+end

data/lib/twitter/client.rb

@@ -0,0 +1,96 @@
+require 'faraday'
+require 'multi_json'
+require 'twitter/api'
+require 'twitter/configurable'
+require 'twitter/error/client_error'
+require 'twitter/error/decode_error'
+require 'simple_oauth'
+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
+    include Twitter::Configurable
+
+    # 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}"))
+      end
+    end
+
+    # Perform an HTTP DELETE request
+    def delete(path, params={}, options={})
+      request(:delete, path, params, options)
+    end
+
+    # Perform an HTTP GET request
+    def get(path, params={}, options={})
+      request(:get, path, params, options)
+    end
+
+    # Perform an HTTP POST request
+    def post(path, params={}, options={})
+      request(:post, path, params, options)
+    end
+
+    # Perform an HTTP UPDATE request
+    def put(path, params={}, options={})
+      request(:put, path, params, options)
+    end
+
+  private
+
+    # Returns a Faraday::Connection object
+    #
+    # @return [Faraday::Connection]
+    def connection
+      @connection ||= Faraday.new(@endpoint, @connection_options.merge(:builder => @middleware))
+    end
+
+    # Perform an HTTP request
+    #
+    # @raise [Twitter::Error::ClientError, Twitter::Error::DecodeError]
+    def request(method, path, params={}, options={})
+      uri = options[:endpoint] || @endpoint
+      uri = URI(uri) unless uri.respond_to?(:host)
+      uri += path
+      request_headers = {}
+      if credentials?
+        authorization = auth_header(method, uri, params)
+        request_headers[:authorization] = authorization.to_s
+      end
+      connection.url_prefix = options[:endpoint] || @endpoint
+      response = connection.run_request(method.to_sym, path, nil, request_headers) do |request|
+        unless params.empty?
+          case request.method
+          when :post, :put
+            request.body = params
+          else
+            request.params.update(params)
+          end
+        end
+        yield request if block_given?
+      end.env
+      response
+    rescue Faraday::Error::ClientError
+      raise Twitter::Error::ClientError
+    rescue MultiJson::DecodeError
+      raise Twitter::Error::DecodeError
+    end
+
+    def auth_header(method, uri, params={})
+      # When posting a file, don't sign any params
+      signature_params = [:post, :put].include?(method.to_sym) && params.values.any?{|value| value.respond_to?(:to_io)} ? {} : params
+      SimpleOAuth::Header.new(method, uri, signature_params, credentials)
+    end
+
+  end
+end

data/lib/twitter/configurable.rb

@@ -0,0 +1,67 @@
+require 'twitter/default'
+
+module Twitter
+  module Configurable
+    attr_writer :consumer_key, :consumer_secret, :oauth_token, :oauth_token_secret
+    attr_accessor :endpoint, :connection_options, :identity_map, :middleware
+
+    class << self
+
+      def keys
+        @keys ||= [
+          :consumer_key,
+          :consumer_secret,
+          :oauth_token,
+          :oauth_token_secret,
+          :endpoint,
+          :connection_options,
+          :identity_map,
+          :middleware,
+        ]
+      end
+
+    end
+
+    # Convenience method to allow configuration options to be set in a block
+    def configure
+      yield self
+      self
+    end
+
+    # @return [Boolean]
+    def credentials?
+      credentials.values.all?
+    end
+
+    # @return [Fixnum]
+    def cache_key
+      options.hash
+    end
+
+    def reset!
+      Twitter::Configurable.keys.each do |key|
+        instance_variable_set(:"@#{key}", Twitter::Default.options[key])
+      end
+      self
+    end
+    alias setup reset!
+
+  private
+
+    # @return [Hash]
+    def credentials
+      {
+        :consumer_key => @consumer_key,
+        :consumer_secret => @consumer_secret,
+        :token => @oauth_token,
+        :token_secret => @oauth_token_secret,
+      }
+    end
+
+    # @return [Hash]
+    def options
+      Hash[Twitter::Configurable.keys.map{|key| [key, instance_variable_get(:"@#{key}")]}]
+    end
+
+  end
+end

data/lib/twitter/configuration.rb

@@ -0,0 +1,20 @@
+require 'twitter/base'
+require 'twitter/size'
+
+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
+
+    # 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)
+        object
+      end
+    end
+
+  end
+end

data/lib/twitter/core_ext/array.rb

@@ -0,0 +1,7 @@
+class Array
+
+  def extract_options!
+    last.is_a?(::Hash) ? pop : {}
+  end unless method_defined?(:extract_options!)
+
+end

data/lib/twitter/core_ext/enumerable.rb

@@ -0,0 +1,11 @@
+module Enumerable
+
+  def threaded_map
+    threads = []
+    each do |object|
+      threads << Thread.new{yield object}
+    end
+    threads.map(&:value)
+  end
+
+end

data/lib/twitter/core_ext/hash.rb

@@ -0,0 +1,100 @@
+class Hash
+
+  # Return a hash that includes everything but the given keys.
+  #
+  # @param keys [Array, Set]
+  # @return [Hash]
+  def except(*keys)
+    self.dup.except!(*keys)
+  end unless method_defined?(:except)
+
+  # Replaces the hash without the given keys.
+  #
+  # @param keys [Array, Set]
+  # @return [Hash]
+  def except!(*keys)
+    keys.each{|key| delete(key)}
+    self
+  end unless method_defined?(:except!)
+
+  # Take a list and merge it into the hash with the correct key
+  #
+  # @param list [Integer, String, Twitter::List] A Twitter list ID, slug, or object.
+  # @return [Hash]
+  def merge_list!(list)
+    case list
+    when Integer
+      self[:list_id] = list
+    when String
+      self[:slug] = list
+    when Twitter::List
+      self[:list_id] = list.id
+      self.merge_owner!(list.user)
+    end
+    self
+  end
+
+  # Take an owner and merge it into the hash with the correct key
+  #
+  # @param user[Integer, String, Twitter::User] A Twitter user ID, screen_name, or object.
+  # @return [Hash]
+  def merge_owner!(user)
+    self.merge_user!(user, "owner")
+    self[:owner_id] = self.delete(:owner_user_id) unless self[:owner_user_id].nil?
+    self
+  end
+
+  # Take a user and merge it into the hash with the correct key
+  #
+  # @param user[Integer, String, Twitter::User] A Twitter user ID, screen_name, or object.
+  # @return [Hash]
+  def merge_user(user, prefix=nil)
+    self.dup.merge_user!(user, prefix)
+  end
+
+  # Take a user and merge it into the hash with the correct key
+  #
+  # @param user[Integer, String, Twitter::User] A Twitter user ID, screen_name, or object.
+  # @return [Hash]
+  def merge_user!(user, prefix=nil)
+    case user
+    when Integer
+      self[[prefix, "user_id"].compact.join("_").to_sym] = user
+    when String
+      self[[prefix, "screen_name"].compact.join("_").to_sym] = user
+    when Twitter::User
+      self[[prefix, "user_id"].compact.join("_").to_sym] = user.id
+    end
+    self
+  end
+
+  # Take a multiple users and merge them into the hash with the correct keys
+  #
+  # @param users [Array<Integer, String, Twitter::User>, Set<Integer, String, Twitter::User>] An array of Twitter user IDs, screen_names, or objects.
+  # @return [Hash]
+  def merge_users(*users)
+    self.dup.merge_users!(*users)
+  end
+
+  # Take a multiple users and merge them into the hash with the correct keys
+  #
+  # @param users [Array<Integer, String, Twitter::User>, Set<Integer, String, Twitter::User>] An array of Twitter user IDs, screen_names, or objects.
+  # @return [Hash]
+  def merge_users!(*users)
+    user_ids, screen_names = [], []
+    users.flatten.each do |user|
+      case user
+      when Integer
+        user_ids << user
+      when String
+        screen_names << user
+      when Twitter::User
+        user_ids << user.id
+      end
+    end
+    self[:user_id] = user_ids.join(',') unless user_ids.empty?
+    self[:screen_name] = screen_names.join(',') unless screen_names.empty?
+    self
+  end
+
+end

data/lib/twitter/core_ext/kernel.rb

@@ -0,0 +1,15 @@
+module Kernel
+
+  def calling_method
+    caller[1][/`([^']*)'/, 1].to_sym
+  end
+
+  # 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)
+
+  # class_eval on an object acts like singleton_class.class_eval.
+  def class_eval(*args, &block)
+    singleton_class.class_eval(*args, &block)
+  end
+
+end