jlind-twitter 0.9.9

data/lib/twitter/geo.rb

@@ -0,0 +1,25 @@
+module Twitter
+  class Geo
+    include HTTParty
+    base_uri "api.twitter.com/#{API_VERSION}/geo"
+    format :json
+
+    def self.place(place_id, query={})
+      Twitter.mash(get("/id/#{place_id}.json", :query => query))
+    end
+
+    def self.search(query={})
+      mashup(get("/search.json", :query => query))
+    end
+
+    def self.reverse_geocode(query={})
+      mashup(get("/reverse_geocode.json", :query => query))
+    end
+
+    private
+
+      def self.mashup(response)
+        response["result"].values.flatten.map{|t| Twitter.mash(t)}
+      end
+  end
+end

data/lib/twitter/httpauth.rb

@@ -0,0 +1,53 @@
+module Twitter
+  class HTTPAuth
+    include HTTParty
+
+    format :plain
+
+    attr_reader :username, :password, :options
+
+    def initialize(username, password, options={})
+      
+      @username, @password = username, password
+      @options = {:ssl => false}.merge(options)
+      options[:api_endpoint] ||= "api.twitter.com"
+
+      if options[:api_version] == false
+        version_path = ''
+      else
+        options[:api_version] ||= API_VERSION
+        version_path = "/#{options[:api_version]}"
+      end
+
+      self.class.base_uri "http#{'s' if options[:ssl]}://#{options[:api_endpoint]}#{version_path}"
+      self.class.default_timeout options[:timeout] if options[:timeout]
+    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
+
+    def put(uri, body={}, headers={})
+      
+      self.class.put(uri, :body => body, :headers => headers, :basic_auth => basic_auth)
+    end
+
+    def delete(uri, body={}, headers={})
+      
+      self.class.delete(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/local_trends.rb

@@ -0,0 +1,30 @@
+module Twitter
+  class LocalTrends
+    include HTTParty
+    base_uri "api.twitter.com/#{API_VERSION}/trends"
+    format :json
+
+    def self.available(query={})
+      before_test(query)
+      query.delete(:api_endpoint)
+      get("/available.json", :query => query).map{|location| Twitter.mash(location)}
+    end
+
+    def self.for_location(woeid,options = {})
+      before_test(options)
+      get("/#{woeid}.json").map{|location| Twitter.mash(location)}
+    end
+
+    private
+    
+    def self.before_test(options)
+      configure_base_uri(options)
+    end
+
+    def self.configure_base_uri(options)
+      new_base_url = options[:api_endpoint]
+      base_uri "#{new_base_url}/#{API_VERSION}/trends" if new_base_url
+    end
+
+  end
+end

data/lib/twitter/oauth.rb

@@ -0,0 +1,85 @@
+module Twitter
+  class OAuth
+
+    def delete(path, headers=nil)
+      access_token.delete(*[api_version + path, headers].compact)
+    end
+
+    def get(path, headers=nil)
+      access_token.get(*[api_version + path, headers].compact)
+    end
+
+    def post(path, data = nil, headers=nil)
+      access_token.post(*[api_version + path, data, headers].compact)
+    end
+
+    def put(path, data = nil, headers=nil)
+      access_token.put(*[api_version + path, data, headers].compact)
+    end
+
+
+    attr_reader :ctoken, :csecret, :consumer_options, :api_endpoint, :api_version, :signing_endpoint
+
+    # Options
+    #   :sign_in => true to just sign in with twitter instead of doing oauth authorization
+    #               (http://apiwiki.twitter.com/Sign-in-with-Twitter)
+    def initialize(ctoken, csecret, options={})
+      @ctoken, @csecret, @consumer_options = ctoken, csecret, {}
+      @api_endpoint = options[:api_endpoint] || 'http://api.twitter.com'
+      @signing_endpoint = options[:signing_endpoint] || 'http://api.twitter.com'
+
+      if options[:api_version]
+        @api_version = "/#{options[:api_version].to_s}"
+      else
+        @api_version = ''
+      end
+
+      if options[:sign_in]
+        @consumer_options[:authorize_path] =  '/oauth/authenticate'
+      end
+    end
+
+    def consumer
+      @consumer ||= ::OAuth::Consumer.new(@ctoken, @csecret, {:site => api_endpoint}.merge(consumer_options))
+    end
+    
+    def signing_consumer
+      @signing_consumer ||= ::OAuth::Consumer.new(@ctoken, @csecret, {:site => signing_endpoint, :request_endpoint => api_endpoint }.merge(consumer_options))
+    end
+
+    def set_callback_url(url)
+      clear_request_token
+      request_token(:oauth_callback => url)
+    end
+
+    # Note: If using oauth with a web app, be sure to provide :oauth_callback.
+    # Options:
+    #   :oauth_callback => String, url that twitter should redirect to
+    def request_token(options={})
+      @request_token ||= signing_consumer.get_request_token(options)
+    end
+
+    # For web apps use params[:oauth_verifier], for desktop apps,
+    # use the verifier is the pin that twitter gives users.
+    def authorize_from_request(rtoken, rsecret, verifier_or_pin)
+      request_token = ::OAuth::RequestToken.new(signing_consumer, rtoken, rsecret)
+      access_token = request_token.get_access_token(:oauth_verifier => verifier_or_pin)
+      @atoken, @asecret = access_token.token, access_token.secret
+    end
+
+    def access_token
+      @access_token ||= ::OAuth::AccessToken.new(signing_consumer, @atoken, @asecret)
+    end
+
+    def authorize_from_access(atoken, asecret)
+      @atoken, @asecret = atoken, asecret
+    end
+
+    private
+
+    def clear_request_token
+      @request_token = nil
+    end
+
+  end
+end

data/lib/twitter/request.rb

@@ -0,0 +1,71 @@
+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
+
+    def self.put(client, path, options={})
+      new(client, :put, path, options).perform
+    end
+
+    def self.delete(client, path, options={})
+      new(client, :delete, path, options).perform
+    end
+
+    attr_reader :client, :method, :path, :options
+
+    def_delegators :client, :get, :post, :put, :delete
+
+    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
+      Twitter.make_friendly(send("perform_#{method}"))
+    end
+
+    private
+
+    def perform_get
+      get(uri, options[:headers])
+    end
+
+    def perform_post
+      post(uri, options[:body], options[:headers])
+    end
+
+    def perform_put
+      put(uri, options[:body], options[:headers])
+    end
+
+    def perform_delete
+      delete(uri, options[:headers])
+    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,163 @@
+require 'pp'
+module Twitter
+  class Search
+    include HTTParty
+    include Enumerable
+    base_uri "search.twitter.com/search"
+    format :json
+
+    attr_reader :result, :query
+
+    def initialize(q=nil, options={})
+      @options = options
+      clear
+      containing(q) if q && q.strip != ""
+      endpoint_url = options[:api_endpoint]
+      endpoint_url = "#{endpoint_url}/search" if endpoint_url && !endpoint_url.include?("/search")
+      self.class.base_uri(endpoint_url) if endpoint_url
+    end
+
+    def user_agent
+      @options[:user_agent] || "Ruby Twitter Gem"
+    end
+
+    def from(user, exclude=false)
+      @query[:q] << "#{exclude ? "-" : ""}from:#{user}"
+      self
+    end
+
+    def to(user, exclude=false)
+      @query[:q] << "#{exclude ? "-" : ""}to:#{user}"
+      self
+    end
+
+    def referencing(user, exclude=false)
+      @query[:q] << "#{exclude ? "-" : ""}@#{user}"
+      self
+    end
+    alias :references :referencing
+    alias :ref :referencing
+
+    def containing(word, exclude=false)
+      @query[:q] << "#{exclude ? "-" : ""}#{word}"
+      self
+    end
+    alias :contains :containing
+
+    # adds filtering based on hash tag ie: #twitter
+    def hashed(tag, exclude=false)
+      @query[:q] << "#{exclude ? "-" : ""}\##{tag}"
+      self
+    end
+
+    # Search for a phrase instead of a group of words
+    def phrase(phrase)
+      @query[:phrase] = phrase
+      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
+
+    # popular|recent
+    def result_type(result_type)
+      @query[:result_type] = result_type
+      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
+
+    # From the advanced search form, not documented in the API
+    # Format YYYY-MM-DD
+    def since_date(since_date)
+      @query[:since] = since_date
+      self
+    end
+
+    # From the advanced search form, not documented in the API
+    # Format YYYY-MM-DD
+    def until_date(until_date)
+      @query[:until] = until_date
+      self
+    end
+
+    # Ranges like 25km and 50mi work.
+    def geocode(lat, long, range)
+      @query[:geocode] = [lat, long, range].join(",")
+      self
+    end
+
+    def max(id)
+      @query[:max_id] = id
+      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(" ")
+        perform_get(query)
+      end
+
+      @fetch
+    end
+
+    def each
+      results = fetch()['results']
+      return if results.nil?
+      results.each {|r| yield r}
+    end
+
+    def next_page?
+      !!fetch()["next_page"]
+    end
+
+    def fetch_next_page
+      if next_page?
+        s = Search.new(nil, :user_agent => user_agent)
+        s.perform_get(fetch()["next_page"][1..-1])
+        s
+      end
+    end
+
+    protected
+
+    def perform_get(query)
+      response = self.class.get("#{self.class.base_uri}.json", :query => query, :format => :json, :headers => {"User-Agent" => user_agent})
+      @fetch = Twitter.mash(response)
+    end
+
+  end
+end

data/lib/twitter/trends.rb

@@ -0,0 +1,55 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), "local_trends")
+
+module Twitter
+  class Trends
+    include HTTParty
+    format :json
+    
+    def self.api_endpoint
+      @api_endpoint ||= "search.twitter.com/trends"
+    end
+    
+    def self.api_endpoint=(value)
+      @api_endpoint = value
+    end
+
+    # :exclude => 'hashtags' to exclude hashtags
+    def self.current(options={})
+      get("/current.json", :query => options)
+    end
+
+    # :exclude => 'hashtags' to exclude hashtags
+    # :date => yyyy-mm-dd for specific date
+    def self.daily(options={})
+      get("/daily.json", :query => options)
+    end
+
+    # :exclude => 'hashtags' to exclude hashtags
+    # :date => yyyy-mm-dd for specific date
+    def self.weekly(options={})
+      get("/weekly.json", :query => options)
+    end
+
+    def self.available(query={})
+      #checking for api_endpoint in local_trends
+      LocalTrends.available(query)
+    end
+
+    def self.for_location(woeid,options={})
+      #checking for api_endpoint in local_trends 
+      LocalTrends.for_location(woeid,options)
+    end
+
+    private
+    
+    def self.get(*args)
+      base_uri api_endpoint
+      mashup(super)
+    end
+
+    def self.mashup(response)
+      response["trends"].values.flatten.map{|t| Twitter.mash(t)}
+    end
+
+  end
+end