twitter-multi 0.9.8.1

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

data/lib/twitter.rb

@@ -0,0 +1,156 @@
+require "forwardable"
+require "oauth"
+require "hashie"
+require "httparty"
+require "multi_json"
+
+module Twitter
+  include HTTParty
+  API_VERSION = "1".freeze
+  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.api_endpoint
+    @api_endpoint ||= "api.twitter.com/#{API_VERSION}"
+  end
+  
+  def self.api_endpoint=(value)
+    @api_endpoint = value
+  end
+
+  def self.firehose(options = {})
+    perform_get("/statuses/public_timeline.json")
+  end
+
+  def self.user(id,options={})
+    perform_get("/users/show/#{id}.json")
+  end
+
+  def self.status(id,options={})
+    perform_get("/statuses/show/#{id}.json")
+  end
+
+  def self.friend_ids(id,options={})	
+    perform_get("/friends/ids/#{id}.json")
+  end
+
+  def self.follower_ids(id,options={})
+    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 = {})
+    base_uri self.api_endpoint
+    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)
+    MultiJson.decode(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")
+require File.join(directory, "twitter", "geo")