cicloid-twitter 0.6.1

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/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/lib/twitter/base.rb

@@ -0,0 +1,165 @@
+module Twitter
+  class Base
+    extend Forwardable
+    
+    def_delegators :client, :get, :post
+    
+    attr_reader :client
+    
+    def initialize(client)
+      @client = client
+    end
+    
+    # Options: since_id, max_id, count, page, since
+    def friends_timeline(query={})
+      perform_get('/statuses/friends_timeline.json', :query => query)
+    end
+    
+    # Options: id, user_id, screen_name, since_id, max_id, page, since
+    def user_timeline(query={})
+      perform_get('/statuses/user_timeline.json', :query => query)
+    end
+    
+    def status(id)
+      perform_get("/statuses/show/#{id}.json")
+    end
+    
+    # Options: in_reply_to_status_id
+    def update(status, query={})
+      perform_post("/statuses/update.json", :body => {:status => status}.merge(query))
+    end
+    
+    # Options: since_id, max_id, since, page
+    def replies(query={})
+      perform_get('/statuses/replies.json', :query => query)
+    end
+    
+    def status_destroy(id)
+      perform_post("/statuses/destroy/#{id}.json")
+    end
+    
+    # Options: id, user_id, screen_name, page
+    def friends(query={})
+      perform_get('/statuses/friends.json', :query => query)
+    end
+    
+    # Options: id, user_id, screen_name, page
+    def followers(query={})
+      perform_get('/statuses/followers.json', :query => query)
+    end
+    
+    def user(id)
+      perform_get("/users/show/#{id}.json")
+    end
+    
+    # Options: since, since_id, page
+    def direct_messages(query={})
+      perform_get("/direct_messages.json", :query => query)
+    end
+    
+    # Options: since, since_id, page
+    def direct_messages_sent(query={})
+      perform_get("/direct_messages/sent.json", :query => query)
+    end
+    
+    def direct_message_create(user, text)
+      perform_post("/direct_messages/new.json", :body => {:user => user, :text => text})
+    end
+    
+    def direct_message_destroy(id)
+      perform_post("/direct_messages/destroy/#{id}.json")
+    end
+    
+    def friendship_create(id, follow=false)
+      body = {}
+      body.merge!(:follow => follow) if follow
+      perform_post("/friendships/create/#{id}.json", :body => body)
+    end
+    
+    def friendship_destroy(id)
+      perform_post("/friendships/destroy/#{id}.json")
+    end
+    
+    def friendship_exists?(a, b)
+      perform_get("/friendships/exists.json", :query => {:user_a => a, :user_b => b})
+    end
+    
+    # Options: id, user_id, screen_name
+    def friend_ids(query={})
+      perform_get("/friends/ids.json", :query => query)
+    end
+    
+    # Options: id, user_id, screen_name
+    def follower_ids(query={})
+      perform_get("/followers/ids.json", :query => query)
+    end
+    
+    def verify_credentials
+      perform_get("/account/verify_credentials.json")
+    end
+    
+    # Device must be sms, im or none
+    def update_delivery_device(device)
+      perform_post('/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('/account/update_profile_colors.json', :body => colors)
+    end
+    
+    def rate_limit_status
+      perform_get('/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('/account/update_profile.json', :body => body)
+    end
+    
+    # Options: id, page
+    def favorites(query={})
+      perform_get('/favorites.json', :query => query)
+    end
+    
+    def favorite_create(id)
+      perform_post("/favorites/create/#{id}.json")
+    end
+    
+    def favorite_destroy(id)
+      perform_post("/favorites/destroy/#{id}.json")
+    end
+    
+    def enable_notifications(id)
+      perform_post("/notifications/follow/#{id}.json")
+    end
+    
+    def disable_notifications(id)
+      perform_post("/notifications/leave/#{id}.json")
+    end
+    
+    def block(id)
+      perform_post("/blocks/create/#{id}.json")
+    end
+    
+    def unblock(id)
+      perform_post("/blocks/destroy/#{id}.json")
+    end
+    
+    def help
+      perform_get('/help/test.json')
+    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
+  end
+end

data/lib/twitter/httpauth.rb

@@ -0,0 +1,26 @@
+module Twitter
+  class HTTPAuth
+    include HTTParty
+    base_uri 'http://twitter.com'
+    format :plain
+    
+    attr_reader :username, :password
+    
+    def initialize(username, password)
+      @username, @password = username, password
+    end
+    
+    def get(uri, headers={})
+      self.class.get(uri, :headers => headers, :basic_auth => basic_auth)
+    end
+    
+    def post(uri, body={}, headers={})
+      self.class.post(uri, :body => body, :headers => headers, :basic_auth => basic_auth)
+    end
+    
+    private
+      def basic_auth
+        @basic_auth ||= {:username => @username, :password => @password}
+      end
+  end
+end

data/lib/twitter/oauth.rb

@@ -0,0 +1,34 @@
+module Twitter
+  class OAuth
+    extend Forwardable
+    def_delegators :access_token, :get, :post
+    
+    attr_reader :ctoken, :csecret
+    
+    def initialize(ctoken, csecret)
+      @ctoken, @csecret = ctoken, csecret
+    end
+    
+    def consumer
+      @consumer ||= ::OAuth::Consumer.new(@ctoken, @csecret, {:site => 'http://twitter.com'})
+    end
+    
+    def request_token
+      @request_token ||= consumer.get_request_token
+    end
+    
+    def authorize_from_request(rtoken, rsecret)
+      request_token = ::OAuth::RequestToken.new(consumer, rtoken, rsecret)
+      access_token = request_token.get_access_token
+      @atoken, @asecret = access_token.token, access_token.secret
+    end
+    
+    def access_token
+      @access_token ||= ::OAuth::AccessToken.new(consumer, @atoken, @asecret)
+    end
+    
+    def authorize_from_access(atoken, asecret)
+      @atoken, @asecret = atoken, asecret
+    end
+  end
+end

data/lib/twitter/request.rb

@@ -0,0 +1,101 @@
+module Twitter
+  class Request
+    extend Forwardable
+    
+    def self.get(client, path, options={})
+      new(client, :get, path, options).perform
+    end
+    
+    def self.post(client, path, options={})
+      new(client, :post, path, options).perform
+    end
+    
+    attr_reader :client, :method, :path, :options
+    
+    def_delegators :client, :get, :post
+    
+    def initialize(client, method, path, options={})
+      @client, @method, @path, @options = client, method, path, options
+    end
+    
+    def uri
+      @uri ||= begin
+        uri = URI.parse(path)
+        
+        if options[:query] && options[:query] != {}
+          uri.query = to_query(options[:query])
+        end
+        
+        uri.to_s
+      end
+    end
+    
+    def perform
+      make_friendly(send("perform_#{method}"))
+    end
+    
+    private
+      def perform_get
+        send(:get, uri, options[:headers])
+      end
+      
+      def perform_post
+        send(:post, uri, options[:body], options[:headers])
+      end
+      
+      def make_friendly(response)
+        raise_errors(response)
+        mash(parse(response))
+      end
+      
+      def 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 parse(response)
+        Crack::JSON.parse(response.body)
+      end
+      
+      def 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 make_mash_with_consistent_hash(obj)
+        m = Mash.new(obj)
+        def m.hash
+          inspect.hash
+        end
+        return m
+      end
+      
+      def to_query(options)
+        options.inject([]) do |collection, opt| 
+          collection << "#{opt[0]}=#{opt[1]}"
+          collection
+        end * '&'
+      end
+  end
+end

data/lib/twitter/search.rb

@@ -0,0 +1,101 @@
+module Twitter
+  class Search
+    include HTTParty
+    include Enumerable
+    
+    attr_reader :result, :query
+    
+    def initialize(q=nil)
+      clear
+      containing(q) if q && q.strip != ''
+    end
+    
+    def from(user)
+      @query[:q] << "from:#{user}"
+      self
+    end
+    
+    def to(user)
+      @query[:q] << "to:#{user}"
+      self
+    end
+    
+    def referencing(user)
+      @query[:q] << "@#{user}"
+      self
+    end
+    alias :references :referencing
+    alias :ref :referencing
+    
+    def containing(word)
+      @query[:q] << "#{word}"
+      self
+    end
+    alias :contains :containing
+    
+    # adds filtering based on hash tag ie: #twitter
+    def hashed(tag)
+      @query[:q] << "##{tag}"
+      self
+    end
+    
+    # lang must be ISO 639-1 code ie: en, fr, de, ja, etc.
+    #
+    # when I tried en it limited my results a lot and took 
+    # out several tweets that were english so i'd avoid 
+    # this unless you really want it
+    def lang(lang)
+      @query[:lang] = lang
+      self
+    end
+    
+    # Limits the number of results per page
+    def per_page(num)
+      @query[:rpp] = num
+      self
+    end
+    
+    # Which page of results to fetch
+    def page(num)
+      @query[:page] = num
+      self
+    end
+    
+    # Only searches tweets since a given id. 
+    # Recommended to use this when possible.
+    def since(since_id)
+      @query[:since_id] = since_id
+      self
+    end
+    
+    # Search tweets by longitude, latitude and a given range.
+    # Ranges like 25km and 50mi work.
+    def geocode(long, lat, range)
+      @query[:geocode] = [long, lat, range].join(',')
+      self
+    end
+    
+    # Clears all the query filters to make a new search
+    def clear
+      @fetch = nil
+      @query = {}
+      @query[:q] = []
+      self
+    end
+    
+    def fetch(force=false)
+      if @fetch.nil? || force
+        query = @query.dup
+        query[:q] = query[:q].join(' ')
+        response = self.class.get('http://search.twitter.com/search.json', :query => query, :format => :json)
+        @fetch = Mash.new(response)
+      end
+      
+      @fetch
+    end
+    
+    def each
+      fetch()['results'].each { |r| yield r }
+    end
+  end
+end