pupil 0.0.6 → 0.1.0

data/lib/pupil/account.rb

@@ -0,0 +1,51 @@
+class Pupil
+  # Verify credentials
+  # @return [Pupil::User] User credentials
+  def verify_credentials
+    response = self.get("/account/verify_credentials.json")
+    user = User.new response
+    return user
+  end
+
+  # Rate limit statuses
+  # @return [Hash] Rate limit statuses
+  def rate_limit
+    response = self.get("/account/rate_limit_status.json")
+    return response
+  end
+
+  # End oauth session
+  # @return [Hash] Result
+  def end_session
+    response = self.post("/account/end_session.json")
+    return response
+  end
+
+  # Update profile
+  # @return [Pupil::User] Updated profile
+  # @param [Hash] param
+  # @option param [String] :name
+  # @option param [String] :url
+  # @option param [String] :location
+  # @option param [String] :description
+  # @option param [String] :colors #=> :background
+  # @option param [String] :colors #=> :link
+  # @option param [String] :colors #=> :sidebar_border
+  # @option param [String] :colors #=> :sidebar_fill
+  # @option param [String] :colors #=> :text
+  def update_profile param
+    if param.key? :colors
+      opt = Hash.new
+      opt.update({:profile_background_color => param[:colors][:background]}) if param[:colors][:background]
+      opt.update({:profile_link_color => param[:colors][:link]}) if param[:colors][:link]
+      opt.update({:profile_sidebar_border => param[:colors][:sidebar_border]}) if param[:colors][:sidebar_border]
+      opt.update({:profile_sidebar_fill => param[:colors][:sidebar_fill]}) if param[:colors][:sidebar_fill]
+      oot.update({:profile_text_color => param[:colors][:text]}) if param[:colors][:text]
+      param.delete :colors
+      response = self.post("/account/update_profile_colors.json", opt)
+      return User.new response if param.size <= 0
+    end
+    response2 = self.post("/account/update_profile.json", param)
+    return User.new response2
+  end
+end

data/lib/pupil/base.rb

@@ -0,0 +1,83 @@
+class Pupil
+  attr_reader :screen_name
+  class UnsupportedParameter < StandardError ; end
+  class NetworkError < StandardError ; end
+  
+  TWITTER_API_URL = "http://api.twitter.com"
+
+  # @param [Hash] pupil_key
+  def initialize key
+    @screen_name = key[:screen_name]
+    @client = nil
+    @config = nil
+    
+    @consumer = OAuth::Consumer.new(
+      key[:consumer_key],
+      key[:consumer_secret],
+      :site => TWITTER_API_URL
+    )
+    @access_token = OAuth::AccessToken.new(
+      @consumer,
+      key[:access_token],
+      key[:access_token_secret]
+    )
+  end
+
+  # @param [Hash] parameter
+  # @return [String] URL Serialized parameters
+  def self.param_serializer parameter
+    return "" unless parameter.class == Hash
+    ant = Hash.new
+    parameter.each do |key, value|
+      case key.to_sym
+      when :include
+        if value.class == String || Symbol
+          ant[:"include_#{value}"] = :true
+          break
+        end
+
+        value.each do |element|
+          raise UnsupportedParameter, "include_entities is not supported." if element.to_sym == :entities
+          ant[:"include_#{element}"] = :true
+        end
+      when :exclude
+        if value.class == String || Symbol
+          ant[:"exclude_#{value}"] = :true
+          break
+        end
+
+        value.each do |element|
+          ant[:"exclude_#{element}"] = :true
+        end
+      else
+        ant[key.to_sym] = value.to_s
+      end
+    end
+    param = ant.inject(""){|k,v|k+"&#{v[0]}=#{URI.escape(v[1])}"}.sub!(/^&/,"?")
+    return param ? param : ""
+  end
+  
+  def param_serializer parameter
+    Pupil.param_serializer parameter
+  end
+  
+  def get url, param={}
+    param_s = param_serializer(param)
+    begin
+      response = @access_token.get(url+param_s).body
+    rescue => vars
+      raise NetworkError, vars
+    end
+    return JSON.parse(response)
+  end
+  
+  def post url, param={}
+    param_s = param_serializer(param)
+    begin
+      response = @access_token.post(url+param_s).body
+    rescue => vars
+      raise NetworkError, vars
+    end
+    return JSON.parse(response)
+  end
+end

data/lib/pupil/blocks.rb

@@ -0,0 +1,45 @@
+class Pupil
+  # @param [Fixnum] id id
+  # @return [Hash] response
+  def block param
+    case param.keys[0].to_sym
+    when :screen_name
+      response = self.post("/blocks/create.json", {:screen_name => param.values[0]})
+    when :id
+      response = self.post("/blocks/create.json", {:user_id => param.values[0]})
+    end
+    
+    if response.class == Hash && response["id"]
+      return User.new response
+    end
+    return false
+  end
+
+  # @param [Fixnum] id id
+  # @return [Hash] response
+  def unblock param
+    case param.keys[0].to_sym
+    when :screen_name
+      response = self.post("/blocks/destroy.json", {:screen_name => param.values[0]})
+    when :id
+      response = self.post("/blocks/destroy.json", {:user_id => param.values[0]})
+    end
+    
+    if response.class == Hash && response["id"]
+      return User.new response
+    end
+    return false
+  end
+
+  # @return [Hash] list of blocking users
+  def blocking
+    response = self.get("/blocks/blocking.json")
+    p response
+    users = Array.new
+    response["users"].each do |element|
+      user = User.new element
+      users << user
+    end
+    return users
+  end
+end

data/lib/pupil/direct_messages.rb

@@ -0,0 +1,57 @@
+class Pupil
+  # Returning direct messages
+  # @param [Hash] param
+  # @return [Hash] directmessages
+  def dm(param = {})
+    param_s = param_serializer(param)
+    begin
+      response = @access_token.get("http://api.twitter.com/1/direct_messages.xml"+param_s)
+    rescue
+      return false
+    end
+    doc = REXML::Document.new(response.body)
+    return false if doc.is_error?
+    directmessages = Array.new
+
+    doc.get_elements('/direct-messages/direct_message').each{|element|
+      dm = DirectMessage.new(element)
+      directmessages << dm
+    }
+
+    return directmessages
+  end
+
+  # Returning direct messages you sent
+  # @param [Hash] param
+  # @return [Hash] directmessage you sent
+  def dm_sent(param = {})
+    param_s = param_serializer(param)
+    begin
+      response = @access_token.get("http://api.twitter.com/1/direct_messages/sent.xml"+param_s)
+    rescue
+      return false
+    end
+    doc = REXML::Document.new(response.body)
+    return false if doc.is_error?
+    directmessages = Array.new
+
+    doc.get_elements('/direct-messages/direct_message').each{|element|
+      dm = DirectMessage.new(element)
+      directmessages << dm
+    }
+
+    return directmessages
+  end
+
+  # Delete direct message
+  # @param [Fixnum] dm_id message id that you want to delete
+  # @return [Hash] response
+  def dm_destroy(dm_id)
+    begin
+      response = @access_token.post("http://api.twitter.com/1/direct_messages/destroy/#{dm_id}.xml")
+    rescue
+      return false
+    end
+    return response
+  end
+end

data/lib/pupil/friendships.rb

@@ -0,0 +1,70 @@
+class Pupil
+  def friends_ids name
+    response = self.get("/friends/ids/#{name}.json")
+    ids = Array.new
+    response.each do |element|
+      ids << element
+    end
+    return ids
+  end
+
+  def followers_ids name=@screen_name
+    response = self.get("/1/followers/ids/#{name}.json")
+    ids = Array.new
+    response.each do |element|
+      ids << element
+    end
+    return ids
+  end
+  
+  # Check friendships
+  # @param [String] src source screen_name
+  # @param [String] dst destination screen_name
+  # @return [Boolean] return true if paired users have friendship, or ruturn false
+  def friendship?(src, dst)
+    param = {:source_screen_name => src, :target_screen_name => dst}
+    response = self.get("/friendships/show.json", param)
+    if response["relationship"]["source"]["following"] == true && response["relationship"]["target"]["following"] == true then
+      return true
+    else
+      return false
+    end
+  end
+  
+  alias_method "relationship?", "friendship?"
+  alias_method "friendships_exists?", "friendship?"
+
+  # Follow user for screen_name
+  # @param [String] name screen_name
+  # @return [Hash] response
+  def follow param
+    case param.keys[0].to_sym
+    when :screen_name
+      response = self.post("/friendships/create.json", {:screen_name => param.values[0]})
+    when :id
+      response = self.post("/friendships/create.json", {:user_id => param.values[0]})
+    end
+    
+    if response.class == Hash && response["id"]
+      return User.new response
+    end
+    return false
+  end
+
+  # Unfollow user for screen_name
+  # @param [String] name screen_name
+  # @return [Hash] response
+  def unfollow param
+    case param.keys[0].to_sym
+    when :screen_name
+      response = self.post("/friendships/destroy.json", {:screen_name => param.values[0]})
+    when :id
+      response = self.post("/friendships/destroy.json", {:user_id => param.values[0]})
+    end
+    
+    if response.class == Hash && response["id"]
+      return User.new response
+    end
+    return false
+  end
+end

data/lib/pupil/lists.rb

@@ -0,0 +1,34 @@
+class Pupil
+  # @param [Fixnum] id list id
+  # @param [String] ids id comma separated
+  # @return [Hash] response
+  def addlist(listid,ids)
+    response = @access_token.post("http://api.twitter.com/1/#{@username}/#{listid}/create_all.xml?user_id=#{ids}")
+    return response
+  end
+
+  # @return [Hash] lists
+  def lists
+    response = @access_token.get("http://api.twitter.com/1/#{@username}/lists.xml")
+    doc = REXML::Document.new(response.body)
+    return false if doc.is_error?
+    lists = Array.new
+    doc.get_elements('/lists_list/lists/list').each{|element|
+      list = List.new(element)
+      lists << list
+    }
+    return lists
+  end
+
+  def lists_member_create(listid,id)
+    begin
+      response = @access_token.post("http://api.twitter.com/1/#{@username}/#{listid}/members.xml?id=#{id}")
+    rescue
+      return false
+    else
+      return response
+    end
+  end
+  
+  
+end

data/lib/pupil/schemes.rb

@@ -0,0 +1,220 @@
+class Pupil
+  class User
+    attr_reader :contributors_enabled
+    attr_reader :created_at
+    attr_reader :default_profile
+    attr_reader :default_profile_image
+    attr_reader :description
+    attr_reader :favourites_count
+    attr_reader :follow_request_sent
+    attr_reader :followers_count
+    attr_reader :following
+    attr_reader :friends_count
+    attr_reader :geo_enabled
+    attr_reader :id
+    attr_reader :id_str
+    attr_reader :is_translator
+    attr_reader :lang
+    attr_reader :listed_count
+    attr_reader :location
+    attr_reader :name
+    attr_reader :notifications
+    attr_reader :profile_background_color
+    attr_reader :profile_background_image_url
+    attr_reader :profile_background_image_url_https
+    attr_reader :profile_background_tile
+    attr_reader :profile_image_url
+    attr_reader :profile_image_url_https
+    attr_reader :profile_link_color
+    attr_reader :profile_sidebar_border_color
+    attr_reader :profile_sidebar_fill_color
+    attr_reader :profile_text_color
+    attr_reader :profile_use_background_image
+    attr_reader :protected
+    attr_reader :screen_name
+    attr_reader :show_all_inline_media
+    attr_reader :status
+    attr_reader :statuses_count
+    attr_reader :time_zone
+    attr_reader :url
+    attr_reader :utc_offset
+    attr_reader :verified
+
+    def initialize j
+      @contributors_enabled = j["contributors_enabled"] rescue nil
+      @created_at = j["created_at"]
+      @default_profile = j["default_profile"]
+      @default_profile_image = j["default_profile_image"]
+      @description = j["description"]
+      @favourites_count = j["favourites_count"]
+      @follow_request_sent = j["follow_request_sent"]
+      @followers_count = j["followers_count"]
+      @following = j["following"]
+      @friends_count = j["friends_count"]
+      @geo_enabled = j["geo_enabled"]
+      @id = j["id"]
+      @id_str = j["id_str"]
+      @is_translator = j["is_translator"]
+      @lang = j["lang"]
+      @listed_count = j["listed_count"]
+      @location = j["location"]
+      @name = j["name"]
+      @notifications = j["notifications"]
+      @profile_background_color = j["profile_background_color"]
+      @profile_background_image_url = j["profile_background_image_url"]
+      @profile_background_image_url_https = j["profile_background_image_url_https"]
+      @profile_background_tile = j["profile_background_tile"]
+      @profile_image_url = j["profile_image_url"]
+      @profile_image_url_https = j["profile_image_url_https"]
+      @profile_link_color = j["profile_link_color"]
+      @profile_sidebar_border_color = j["profile_sidebar_border_color"]
+      @profile_sidebar_fill_color = j["profile_sidebar_fill_color"]
+      @profile_text_color = j["profile_text_color"]
+      @profile_use_background_image = j["profile_use_background_image"]
+      @protected = j["protected"]
+      @screen_name = j["screen_name"]
+      @show_all_inline_media = j["show_all_inline_media"]
+      @status = Status.new j["status"]
+      @statuses_count = j["statuses_count"]
+      @time_zone = j["time_zone"]
+      @url = j["url"]
+      @utc_offset = j["utc_offset"]
+      @verified = j["verified"]
+    end
+  end
+  
+  class URL
+    attr_reader :url
+    attr_reader :expanded_url
+    attr_reader :start
+    attr_reader :end
+
+    def initialize(element)
+      @url = element.elements['url'].text()
+      @expanded_url = element.elements['expanded_url'].text()
+      @start = element.attributes['start']
+      @end = element.attributes['end']
+    end
+  end
+  
+  class Status
+    attr_reader :contributors
+    attr_reader :coordinates
+    attr_reader :created_at
+    attr_reader :favorited
+    attr_reader :geo
+    attr_reader :id
+    attr_reader :id_str
+    attr_reader :in_reply_to_screen_name
+    attr_reader :in_reply_to_status_id
+    attr_reader :in_reply_to_status_id_str
+    attr_reader :in_reply_to_user_id
+    attr_reader :in_reply_to_user_id_str
+    attr_reader :place
+    attr_reader :retweet_count
+    attr_reader :retweeted
+    attr_reader :source
+    attr_reader :text
+    attr_reader :truncated
+    attr_reader :user
+
+    def initialize j
+      @contributors = j["contributors"]
+      @coordinates = j["coordinates"]
+      @created_at = j["created_at"]
+      @favorited = j["favorited"]
+      @geo = j["geo"]
+      @id = j["id"]
+      @id_str = j["id_str"]
+      @in_reply_to_screen_name = j["in_reply_to_screen_name"]
+      @in_reply_to_status_id = j["in_reply_to_status_id"]
+      @in_reply_to_status_id_str = j["in_reply_to_status_id_str"]
+      @in_reply_to_user_id = j["in_reply_to_user_id"]
+      @in_reply_to_user_id_str = j["in_reply_to_user_id_str"]
+      @place = j["place"]
+      @retweet_count = j["retweet_count"]
+      @retweeted = j["retweeted"]
+      j["source"] =~ /href=\"(.+?)\".+?>(.+?)</
+      @source = {:url => $1, :name => $2}
+      @text = j["text"]
+      @truncated = j["truncated"]
+      @user = User.new j["user"]  rescue nil
+    end
+  end
+  
+  class List
+    attr_reader :id
+    attr_reader :name
+    attr_reader :full_name
+    attr_reader :slug
+    attr_reader :description
+    attr_reader :subscriber_count
+    attr_reader :member_count
+    attr_reader :uri
+    attr_reader :following
+    attr_reader :mode
+    attr_reader :user
+
+    def initialize(element)
+      @id = element.elements['id'].text()
+      @name = element.elements['name'].text()
+      @full_name = element.elements['full_name'].text()
+      @slug = element.elements['slug'].text()
+      @description = element.elements['description'].text()
+      @subscriber_count = element.elements['subscriber_count'].text()
+      @member_count = element.elements['member_count'].text()
+      @uri = element.elements['uri'].text()
+      @following = element.elements['following'].text()
+      @mode = element.elements['mode'].text()
+      @user = User.new(element.elements['user'])
+    end
+  end
+  
+  class Entities
+    attr_reader :user_mentions
+    attr_reader :urls
+    attr_reader :hashtags
+
+    def initialize(element)
+      @user_mentions = UserMention.new(element.elements['user_mention'])
+      @urls = URL.new(element.elements['urls'])
+      @hashtags = Hashtag.new(element.elements['hashtags'])
+    end
+  end
+  
+  class Hashtag
+    attr_reader :text
+    attr_reader :start
+    attr_reader :end
+
+    def initialize(element)
+      @text = element.elements['text'].text()
+      @start = element.attributes['start']
+      @end = element.attributes['end']
+    end
+  end
+  
+  class DirectMessage
+    attr_reader :id
+    attr_reader :sender_id
+    attr_reader :text
+    attr_reader :recipient_id
+    attr_reader :created_at
+    attr_reader :sender_screen_name
+    attr_reader :recipient_screen_name
+    attr_reader :sender
+    attr_reader :recipient
+
+    def initialize(element)
+      @id = element.elements['id'].text()
+      @sender_id = element.elements['sender_id'].text()
+      @text = element.elements['text'].text()
+      @recipient_id = element.elements['recipient_id'].text()
+      @created_at = element.elements['created_at'].text()
+      @sender_screen_name = element.elements['sender_screen_name'].text()
+      @recipient_screen_name= element.elements['recipient_screen_name'].text()
+      @sender = User.new(element.elements['sender'])
+      @recipient = User.new(element.elements['recipient'])
+    end
+  end
+end