twitter-jruby 0.9.5.2010050701

data/examples/helpers/config_store.rb

@@ -0,0 +1,38 @@
+class ConfigStore
+  attr_reader :file
+
+  def initialize(file)
+    @file = file
+  end
+
+  def load
+    @config ||= YAML::load(open(file))
+    self
+  end
+
+  def [](key)
+    load
+    @config[key]
+  end
+
+  def []=(key, value)
+    @config[key] = value
+  end
+
+  def delete(*keys)
+    keys.each { |key| @config.delete(key) }
+    save
+    self
+  end
+
+  def update(c={})
+    @config.merge!(c)
+    save
+    self
+  end
+
+  def save
+    File.open(file, 'w') { |f| f.write(YAML.dump(@config)) }
+    self
+  end
+end

data/examples/httpauth.rb

@@ -0,0 +1,11 @@
+require File.join(File.dirname(__FILE__), '..', 'lib', 'twitter')
+require File.join(File.dirname(__FILE__), 'helpers', 'config_store')
+require 'pp'
+
+config = ConfigStore.new("#{ENV['HOME']}/.twitter")
+
+httpauth = Twitter::HTTPAuth.new(config['email'], config['password'])
+base = Twitter::Base.new(httpauth)
+
+pp base.user_timeline
+pp base.verify_credentials

data/examples/ids.rb

@@ -0,0 +1,13 @@
+require File.join(File.dirname(__FILE__), '..', 'lib', 'twitter')
+require File.join(File.dirname(__FILE__), 'helpers', 'config_store')
+require 'pp'
+
+config = ConfigStore.new("#{ENV['HOME']}/.twitter")
+
+oauth = Twitter::OAuth.new(config['token'], config['secret'])
+oauth.authorize_from_access(config['atoken'], config['asecret'])
+
+client = Twitter::Base.new(oauth)
+
+puts client.friend_ids
+puts client.follower_ids

data/examples/lists.rb

@@ -0,0 +1,11 @@
+require File.join(File.dirname(__FILE__), '..', 'lib', 'twitter')
+require File.join(File.dirname(__FILE__), 'helpers', 'config_store')
+require 'pp'
+
+config = ConfigStore.new("#{ENV['HOME']}/.twitter")
+
+httpauth = Twitter::HTTPAuth.new(config['email'], config['password'])
+base = Twitter::Base.new(httpauth)
+
+pp base.lists('pengwynn')
+pp base.list_members('pengwynn', 'rubyists')

data/examples/oauth.rb

@@ -0,0 +1,27 @@
+require 'pp'
+require 'pathname'
+dir = Pathname(__FILE__).dirname.expand_path
+require (dir + '..' + 'lib' + 'twitter').expand_path
+require dir + 'helpers' + 'config_store'
+
+config  = ConfigStore.new("#{ENV['HOME']}/.twitter")
+oauth   = Twitter::OAuth.new(config['token'], config['secret'])
+rtoken  = oauth.request_token.token
+rsecret = oauth.request_token.secret
+
+puts "> redirecting you to twitter to authorize..."
+%x(open #{oauth.request_token.authorize_url})
+
+print "> what was the PIN twitter provided you with? "
+pin = gets.chomp
+
+begin
+  oauth.authorize_from_request(rtoken, rsecret, pin)
+
+  twitter = Twitter::Base.new(oauth)
+  twitter.user_timeline.each do |tweet|
+    puts "#{tweet.user.screen_name}: #{tweet.text}"
+  end
+rescue OAuth::Unauthorized
+  puts "> FAIL!"
+end

data/examples/search.rb

@@ -0,0 +1,15 @@
+require File.join(File.dirname(__FILE__), '..', 'lib', 'twitter')
+require 'pp'
+
+search = Twitter::Search.new.from('jnunemaker')
+
+puts '*'*50, 'First Run', '*'*50
+search.each { |result| pp result }
+
+puts '*'*50, 'Second Run', '*'*50
+search.each { |result| pp result }
+
+puts '*'*50, 'Parameter Check', '*'*50
+pp Twitter::Search.new('#austineats').fetch().results.first
+pp Twitter::Search.new('#austineats').page(2).fetch().results.first
+pp Twitter::Search.new('#austineats').since(1412737343).fetch().results.first

data/examples/timeline.rb

@@ -0,0 +1,19 @@
+require File.join(File.dirname(__FILE__), '..', 'lib', 'twitter')
+require File.join(File.dirname(__FILE__), 'helpers', 'config_store')
+require 'pp'
+
+config = ConfigStore.new("#{ENV['HOME']}/.twitter")
+
+oauth = Twitter::OAuth.new(config['token'], config['secret'])
+oauth.authorize_from_access(config['atoken'], config['asecret'])
+
+client = Twitter::Base.new(oauth)
+
+pp client.friends_timeline
+puts '*'*50
+
+pp client.user_timeline
+puts '*'*50
+
+pp client.replies
+puts '*'*50

data/examples/tumblr.rb

@@ -0,0 +1,9 @@
+require File.join(File.dirname(__FILE__), '..', 'lib', 'twitter')
+require 'pp'
+
+
+httpauth = Twitter::HTTPAuth.new('email', 'password', :api_endpoint => 'tumblr.com')
+base = Twitter::Base.new(httpauth)
+
+pp base.user_timeline
+pp base.verify_credentials

data/examples/unauthorized.rb

@@ -0,0 +1,16 @@
+require File.join(File.dirname(__FILE__), '..', 'lib', 'twitter')
+require 'pp'
+
+puts 'User', '*'*50
+pp Twitter.user('jnunemaker')
+pp Twitter.user('snitch_test')
+
+puts 'Status', '*'*50
+pp Twitter.status(1533815199)
+
+puts 'Friend Ids', '*'*50
+pp Twitter.friend_ids('jnunemaker')
+
+puts 'Follower Ids', '*'*50
+pp Twitter.follower_ids('jnunemaker')
+

data/examples/update.rb

@@ -0,0 +1,11 @@
+require File.join(File.dirname(__FILE__), '..', 'lib', 'twitter')
+require File.join(File.dirname(__FILE__), 'helpers', 'config_store')
+require 'pp'
+
+config = ConfigStore.new("#{ENV['HOME']}/.twitter")
+
+oauth = Twitter::OAuth.new(config['token'], config['secret'])
+oauth.authorize_from_access(config['atoken'], config['asecret'])
+
+client = Twitter::Base.new(oauth)
+pp client.update('This is an update from the twitter gem')

data/examples/user.rb

@@ -0,0 +1,5 @@
+require File.join(File.dirname(__FILE__), '..', 'lib', 'twitter')
+require 'pp'
+
+pp Twitter.user('jnunemaker')
+pp Twitter.user('snitch_test')

data/lib/twitter.rb

@@ -0,0 +1,146 @@
+require "forwardable"
+require "oauth"
+require "hashie"
+require "httparty"
+
+module Twitter
+  include HTTParty
+  API_VERSION = "1".freeze
+  base_uri "api.twitter.com/#{API_VERSION}"
+  format :json
+
+  class TwitterError < StandardError
+    attr_reader :data
+
+    def initialize(data)
+      @data = data
+      super
+    end
+  end
+
+  class RateLimitExceeded < TwitterError; end
+  class Unauthorized      < TwitterError; end
+  class General           < TwitterError; end
+
+  class Unavailable   < StandardError; end
+  class InformTwitter < StandardError; end
+  class NotFound      < StandardError; end
+
+  def self.firehose
+    perform_get("/statuses/public_timeline.json")
+  end
+
+  def self.user(id)
+    perform_get("/users/show/#{id}.json")
+  end
+
+  def self.status(id)
+    perform_get("/statuses/show/#{id}.json")
+  end
+
+  def self.friend_ids(id)
+    perform_get("/friends/ids/#{id}.json")
+  end
+
+  def self.follower_ids(id)
+    perform_get("/followers/ids/#{id}.json")
+  end
+
+  def self.timeline(id, options={})
+    perform_get("/statuses/user_timeline/#{id}.json", :query => options)
+  end
+
+  # :per_page = max number of statues to get at once
+  # :page = which page of tweets you wish to get
+  def self.list_timeline(list_owner_username, slug, query = {})
+    perform_get("/#{list_owner_username}/lists/#{slug}/statuses.json", :query => query)
+  end
+
+  private
+
+  def self.perform_get(uri, options = {})
+    make_friendly(get(uri, options))
+  end
+
+  def self.make_friendly(response)
+    raise_errors(response)
+    data = parse(response)
+    # Don't mash arrays of integers
+    if data && data.is_a?(Array) && data.first.is_a?(Integer)
+      data
+    else
+      mash(data)
+    end
+  end
+
+  def self.raise_errors(response)
+    case response.code.to_i
+      when 400
+        data = parse(response)
+        raise RateLimitExceeded.new(data), "(#{response.code}): #{response.message} - #{data['error'] if data}"
+      when 401
+        data = parse(response)
+        raise Unauthorized.new(data), "(#{response.code}): #{response.message} - #{data['error'] if data}"
+      when 403
+        data = parse(response)
+        raise General.new(data), "(#{response.code}): #{response.message} - #{data['error'] if data}"
+      when 404
+        raise NotFound, "(#{response.code}): #{response.message}"
+      when 500
+        raise InformTwitter, "Twitter had an internal error. Please let them know in the group. (#{response.code}): #{response.message}"
+      when 502..503
+        raise Unavailable, "(#{response.code}): #{response.message}"
+    end
+  end
+
+  def self.parse(response)
+    JSON.parse(response.body)
+  end
+
+  def self.mash(obj)
+    if obj.is_a?(Array)
+      obj.map{|item| make_mash_with_consistent_hash(item)}
+    elsif obj.is_a?(Hash)
+      make_mash_with_consistent_hash(obj)
+    else
+      obj
+    end
+  end
+
+  # Lame workaround for the fact that mash doesn't hash correctly
+  def self.make_mash_with_consistent_hash(obj)
+    m = Hashie::Mash.new(obj)
+    def m.hash
+      inspect.hash
+    end
+    return m
+  end
+
+end
+
+module Hashie
+  class Mash
+
+    # Converts all of the keys to strings, optionally formatting key name
+    def rubyify_keys!
+      keys.each{|k|
+        v = delete(k)
+        new_key = k.to_s.underscore
+        self[new_key] = v
+        v.rubyify_keys! if v.is_a?(Hash)
+        v.each{|p| p.rubyify_keys! if p.is_a?(Hash)} if v.is_a?(Array)
+      }
+      self
+    end
+
+  end
+end
+
+directory = File.expand_path(File.dirname(__FILE__))
+
+require File.join(directory, "twitter", "oauth")
+require File.join(directory, "twitter", "httpauth")
+require File.join(directory, "twitter", "request")
+require File.join(directory, "twitter", "base")
+require File.join(directory, "twitter", "search")
+require File.join(directory, "twitter", "trends")

data/lib/twitter/base.rb

@@ -0,0 +1,390 @@
+module Twitter
+  class Base
+    extend Forwardable
+
+    def_delegators :client, :get, :post, :put, :delete
+
+    attr_reader :client
+
+    def initialize(client)
+      @client = client
+    end
+
+    # Options: since_id, max_id, count, page
+    def home_timeline(query={})
+      perform_get("/#{API_VERSION}/statuses/home_timeline.json", :query => query)
+    end
+
+    # Options: since_id, max_id, count, page, since
+    def friends_timeline(query={})
+      perform_get("/#{API_VERSION}/statuses/friends_timeline.json", :query => query)
+    end
+
+    # Options: id, user_id, screen_name, since_id, max_id, page, since, count
+    def user_timeline(query={})
+      perform_get("/#{API_VERSION}/statuses/user_timeline.json", :query => query)
+    end
+
+    def status(id)
+      perform_get("/#{API_VERSION}/statuses/show/#{id}.json")
+    end
+
+    # Options: count
+    def retweets(id, query={})
+      perform_get("/#{API_VERSION}/statuses/retweets/#{id}.json", :query => query)
+    end
+
+    # Options: in_reply_to_status_id
+    def update(status, query={})
+      perform_post("/#{API_VERSION}/statuses/update.json", :body => {:status => status}.merge(query))
+    end
+
+    # DEPRECATED: Use #mentions instead
+    #
+    # Options: since_id, max_id, since, page
+    def replies(query={})
+      warn("DEPRECATED: #replies is deprecated by Twitter; use #mentions instead")
+      perform_get("/#{API_VERSION}/statuses/replies.json", :query => query)
+    end
+
+    # Options: since_id, max_id, count, page
+    def mentions(query={})
+      perform_get("/#{API_VERSION}/statuses/mentions.json", :query => query)
+    end
+
+    # Options: since_id, max_id, count, page
+    def retweeted_by_me(query={})
+      perform_get("/#{API_VERSION}/statuses/retweeted_by_me.json", :query => query)
+    end
+
+    # Options: since_id, max_id, count, page
+    def retweeted_to_me(query={})
+      perform_get("/#{API_VERSION}/statuses/retweeted_to_me.json", :query => query)
+    end
+
+    # Options: since_id, max_id, count, page
+    def retweets_of_me(query={})
+      perform_get("/#{API_VERSION}/statuses/retweets_of_me.json", :query => query)
+    end
+
+    # options: count, page, ids_only
+    def retweeters_of(id, options={})
+      ids_only = !!(options.delete(:ids_only))
+      perform_get("/#{API_VERSION}/statuses/#{id}/retweeted_by#{"/ids" if ids_only}.json", :query => options)
+    end
+
+    def status_destroy(id)
+      perform_post("/#{API_VERSION}/statuses/destroy/#{id}.json")
+    end
+
+    def retweet(id)
+      perform_post("/#{API_VERSION}/statuses/retweet/#{id}.json")
+    end
+
+    # Options: id, user_id, screen_name, page
+    def friends(query={})
+      perform_get("/#{API_VERSION}/statuses/friends.json", :query => query)
+    end
+
+    # Options: id, user_id, screen_name, page
+    def followers(query={})
+      perform_get("/#{API_VERSION}/statuses/followers.json", :query => query)
+    end
+
+    def user(id, query={})
+      perform_get("/#{API_VERSION}/users/show/#{id}.json", :query => query)
+    end
+
+    def users(*ids_or_usernames)
+      ids, usernames = [], []
+      ids_or_usernames.each do |id_or_username|
+        if id_or_username.is_a?(Integer)
+          ids << id_or_username
+        elsif id_or_username.is_a?(String)
+          usernames << id_or_username
+        end
+      end
+      query = {}
+      query[:user_id] = ids.join(",") unless ids.empty?
+      query[:screen_name] = usernames.join(",") unless usernames.empty?
+      perform_get("/#{API_VERSION}/users/lookup.json", :query => query)
+    end
+
+    # Options: page, per_page
+    def user_search(q, query={})
+      q = URI.escape(q)
+      perform_get("/#{API_VERSION}/users/search.json", :query => ({:q => q}.merge(query)))
+    end
+
+    # Options: since, since_id, page
+    def direct_messages(query={})
+      perform_get("/#{API_VERSION}/direct_messages.json", :query => query)
+    end
+
+    # Options: since, since_id, page
+    def direct_messages_sent(query={})
+      perform_get("/#{API_VERSION}/direct_messages/sent.json", :query => query)
+    end
+
+    def direct_message_create(user, text)
+      perform_post("/#{API_VERSION}/direct_messages/new.json", :body => {:user => user, :text => text})
+    end
+
+    def direct_message_destroy(id)
+      perform_post("/#{API_VERSION}/direct_messages/destroy/#{id}.json")
+    end
+
+    def friendship_create(id, follow=false)
+      body = {}
+      body.merge!(:follow => follow) if follow
+      perform_post("/#{API_VERSION}/friendships/create/#{id}.json", :body => body)
+    end
+
+    def friendship_destroy(id)
+      perform_post("/#{API_VERSION}/friendships/destroy/#{id}.json")
+    end
+
+    def friendship_exists?(a, b)
+      perform_get("/#{API_VERSION}/friendships/exists.json", :query => {:user_a => a, :user_b => b})
+    end
+
+    def friendship_show(query)
+      perform_get("/#{API_VERSION}/friendships/show.json", :query => query)
+    end
+
+    # Options: id, user_id, screen_name
+    def friend_ids(query={})
+      perform_get("/#{API_VERSION}/friends/ids.json", :query => query)
+    end
+
+    # Options: id, user_id, screen_name
+    def follower_ids(query={})
+      perform_get("/#{API_VERSION}/followers/ids.json", :query => query)
+    end
+
+    def verify_credentials
+      perform_get("/#{API_VERSION}/account/verify_credentials.json")
+    end
+
+    # Device must be sms, im or none
+    def update_delivery_device(device)
+      perform_post("/#{API_VERSION}/account/update_delivery_device.json", :body => {:device => device})
+    end
+
+    # One or more of the following must be present:
+    #   profile_background_color, profile_text_color, profile_link_color,
+    #   profile_sidebar_fill_color, profile_sidebar_border_color
+    def update_profile_colors(colors={})
+      perform_post("/#{API_VERSION}/account/update_profile_colors.json", :body => colors)
+    end
+
+    # file should respond to #read and #path
+    def update_profile_image(file)
+      perform_post("/#{API_VERSION}/account/update_profile_image.json", build_multipart_bodies(:image => file))
+    end
+
+    # file should respond to #read and #path
+    def update_profile_background(file, tile = false)
+      perform_post("/#{API_VERSION}/account/update_profile_background_image.json", build_multipart_bodies(:image => file).merge(:tile => tile))
+    end
+
+    def rate_limit_status
+      perform_get("/#{API_VERSION}/account/rate_limit_status.json")
+    end
+
+    # One or more of the following must be present:
+    #   name, email, url, location, description
+    def update_profile(body={})
+      perform_post("/#{API_VERSION}/account/update_profile.json", :body => body)
+    end
+
+    # Options: id, page
+    def favorites(query={})
+      perform_get("/#{API_VERSION}/favorites.json", :query => query)
+    end
+
+    def favorite_create(id)
+      perform_post("/#{API_VERSION}/favorites/create/#{id}.json")
+    end
+
+    def favorite_destroy(id)
+      perform_post("/#{API_VERSION}/favorites/destroy/#{id}.json")
+    end
+
+    def enable_notifications(id)
+      perform_post("/#{API_VERSION}/notifications/follow/#{id}.json")
+    end
+
+    def disable_notifications(id)
+      perform_post("/#{API_VERSION}/notifications/leave/#{id}.json")
+    end
+
+    def block(id)
+      perform_post("/#{API_VERSION}/blocks/create/#{id}.json")
+    end
+
+    def unblock(id)
+      perform_post("/#{API_VERSION}/blocks/destroy/#{id}.json")
+    end
+    
+    # When reporting a user for spam, specify one or more of id, screen_name, or user_id
+    def report_spam(options)
+      perform_post("/#{API_VERSION}/report_spam.json", :body => options)
+    end
+    
+    def help
+      perform_get("/#{API_VERSION}/help/test.json")
+    end
+
+    def list_create(list_owner_username, options)
+      perform_post("/#{API_VERSION}/#{list_owner_username}/lists.json", :body => {:user => list_owner_username}.merge(options))
+    end
+
+    def list_update(list_owner_username, slug, options)
+      perform_put("/#{API_VERSION}/#{list_owner_username}/lists/#{slug}.json", :body => options)
+    end
+
+    def list_delete(list_owner_username, slug)
+      perform_delete("/#{API_VERSION}/#{list_owner_username}/lists/#{slug}.json")
+    end
+
+    def lists(list_owner_username = nil, query = {})
+      path = case list_owner_username
+      when nil, Hash
+        query = list_owner_username
+        "/#{API_VERSION}/lists.json"
+      else
+        "/#{API_VERSION}/#{list_owner_username}/lists.json"
+      end
+      perform_get(path, :query => query)
+    end
+
+    def list(list_owner_username, slug)
+      perform_get("/#{API_VERSION}/#{list_owner_username}/lists/#{slug}.json")
+    end
+
+    # :per_page = max number of statues to get at once
+    # :page = which page of tweets you wish to get
+    def list_timeline(list_owner_username, slug, query = {})
+      perform_get("/#{API_VERSION}/#{list_owner_username}/lists/#{slug}/statuses.json", :query => query)
+    end
+
+    def memberships(list_owner_username, query={})
+      perform_get("/#{API_VERSION}/#{list_owner_username}/lists/memberships.json", :query => query)
+    end
+
+    def subscriptions(list_owner_username, query = {})
+      perform_get("/#{API_VERSION}/#{list_owner_username}/lists/subscriptions.json", :query => query)
+    end
+
+    def list_members(list_owner_username, slug, query = {})
+      perform_get("/#{API_VERSION}/#{list_owner_username}/#{slug}/members.json", :query => query)
+    end
+
+    def list_add_member(list_owner_username, slug, new_id)
+      perform_post("/#{API_VERSION}/#{list_owner_username}/#{slug}/members.json", :body => {:id => new_id})
+    end
+
+    def list_remove_member(list_owner_username, slug, id)
+      perform_delete("/#{API_VERSION}/#{list_owner_username}/#{slug}/members.json", :query => {:id => id})
+    end
+
+    def is_list_member?(list_owner_username, slug, id)
+      perform_get("/#{API_VERSION}/#{list_owner_username}/#{slug}/members/#{id}.json").error.nil?
+    end
+
+    def list_subscribers(list_owner_username, slug)
+      perform_get("/#{API_VERSION}/#{list_owner_username}/#{slug}/subscribers.json")
+    end
+
+    def list_subscribe(list_owner_username, slug)
+      perform_post("/#{API_VERSION}/#{list_owner_username}/#{slug}/subscribers.json")
+    end
+
+    def list_unsubscribe(list_owner_username, slug)
+      perform_delete("/#{API_VERSION}/#{list_owner_username}/#{slug}/subscribers.json")
+    end
+
+    def blocked_ids
+      perform_get("/#{API_VERSION}/blocks/blocking/ids.json", :mash => false)
+    end
+
+    def blocking(options={})
+      perform_get("/#{API_VERSION}/blocks/blocking.json", options)
+    end
+
+    def saved_searches
+      perform_get("/#{API_VERSION}/saved_searches.json")
+    end
+
+    def saved_search(id)
+      perform_get("/#{API_VERSION}/saved_searches/show/#{id}.json")
+    end
+
+    def saved_search_create(query)
+      perform_post("/#{API_VERSION}/saved_searches/create.json", :body => {:query => query})
+    end
+
+    def saved_search_destroy(id)
+      perform_delete("/#{API_VERSION}/saved_searches/destroy/#{id}.json")
+    end
+
+    protected
+
+    def self.mime_type(file)
+      case
+        when file =~ /\.jpg/ then 'image/jpg'
+        when file =~ /\.gif$/ then 'image/gif'
+        when file =~ /\.png$/ then 'image/png'
+        else 'application/octet-stream'
+      end
+    end
+
+    def mime_type(f) self.class.mime_type(f) end
+
+    CRLF = "\r\n"
+
+    def self.build_multipart_bodies(parts)
+      boundary = Time.now.to_i.to_s(16)
+      body = ""
+      parts.each do |key, value|
+        esc_key = CGI.escape(key.to_s)
+        body << "--#{boundary}#{CRLF}"
+        if value.respond_to?(:read)
+          body << "Content-Disposition: form-data; name=\"#{esc_key}\"; filename=\"#{File.basename(value.path)}\"#{CRLF}"
+          body << "Content-Type: #{mime_type(value.path)}#{CRLF*2}"
+          body << value.read
+        else
+          body << "Content-Disposition: form-data; name=\"#{esc_key}\"#{CRLF*2}#{value}"
+        end
+        body << CRLF
+      end
+      body << "--#{boundary}--#{CRLF*2}"
+      {
+        :body => body,
+        :headers => {"Content-Type" => "multipart/form-data; boundary=#{boundary}"}
+      }
+    end
+
+    def build_multipart_bodies(parts) self.class.build_multipart_bodies(parts) end
+
+    private
+
+    def perform_get(path, options={})
+      Twitter::Request.get(self, path, options)
+    end
+
+    def perform_post(path, options={})
+      Twitter::Request.post(self, path, options)
+    end
+
+    def perform_put(path, options={})
+      Twitter::Request.put(self, path, options)
+    end
+
+    def perform_delete(path, options={})
+      Twitter::Request.delete(self, path, options)
+    end
+
+  end
+end