knu-friendfeed 0.1.1 → 0.1.2

data/bin/tw2ff

@@ -0,0 +1,332 @@
+#!/usr/bin/env ruby
+# -*- mode: ruby -*-
+
+$KCODE = 'u'
+
+require 'pathname'
+
+$LOAD_PATH.unshift(Pathname($0).dirname.parent.join('lib'))
+
+require 'rubygems'
+require 'digest'
+require 'friendfeed'
+require 'friendfeed/unofficial'
+require 'main'
+require 'mechanize'
+require 'uri'
+require 'tempfile'
+require 'twitter'
+require 'yaml'
+require 'yaml/store'
+
+MYNAME = File.basename($0)
+
+TWITTER_URI = URI.parse('http://twitter.com/')
+
+def ConfigDir()
+  $config_dir ||=
+    begin
+      config_dir = File.expand_path('~/.%s' % MYNAME)
+      if !File.directory?(config_dir)
+        Dir.mkdir(config_dir, 0700)
+      end
+      config_dir
+    end
+end
+
+def ConfigFile()
+  $config_file ||= File.join(ConfigDir(), 'config.yml')
+end
+
+def Config(keypath, default = :omitted)
+  $config ||= YAML.load_file(ConfigFile())
+
+  keypath.split('.').inject($config) { |hash, key|
+    hash.is_a?(Hash) or raise TypeError
+    hash.fetch(key)
+  }
+rescue => e
+  return default if default != :omitted
+  
+  STDERR.print <<EOM
+The key "#{keypath}" is missing in #{ConfigFile()}.
+Please edit the file to look like the following:
+
+--- 
+friendfeed: 
+  username: "username"
+  password: "password"
+twitter: 
+  username: "username"
+  password: "password"
+EOM
+  exit 1
+end
+
+def puterror(message)
+  STDERR.puts MYNAME + ': ' + e.to_s
+end
+
+def putinfo(fmt, *args)
+  STDERR.puts sprintf(fmt, *args)
+end
+
+def Status(key)
+  $status ||= YAML::Store.new(File.join(ConfigDir(), 'status.yml'))
+  if block_given?
+    $status.transaction(false) {
+      return $status[key] = yield
+    }
+  else
+    $status.transaction(true) {
+      return $status[key]
+    }
+  end
+end
+
+def friendfeed_client
+  $ff_client ||=
+    begin
+      username = Config('friendfeed.username')
+      password = Config('friendfeed.password')
+      putinfo 'Logging in to FriendFeed as %s', username
+      FriendFeed::Client.new.login(username, password)
+    end
+end
+
+class Twitter::Base
+  def all_friends
+    list = []
+    (1..100).each { |i|
+      slice = friends(:page => i)
+      list.concat(slice)
+      break if slice.size < 100
+    }
+    list
+  end
+end
+
+def twitter_client
+  $tw_client ||=
+    begin
+      username = Config('twitter.username')
+      password = Config('twitter.password')
+      putinfo 'Logging in to Twitter as %s', username
+      Twitter::Base.new(Twitter::HTTPAuth.new(username, password))
+    end
+end
+
+Main {
+  description 'Twitter to FriendFeed migration helper'
+
+  def run
+    print usage.to_s
+  end
+  
+  mode 'sync' do
+    description 'Add imaginary friends for Twitter-only friends'
+
+    def run
+      require 'set'
+
+      ffcli = friendfeed_client()
+
+      subscribed_real = Set[]
+      subscribed_imag = Set[]
+
+      putinfo "Checking real friends in FriendFeed..."
+      ffcli.get_real_friends.each { |profile|
+        profile['services'].each { |service|
+          url = service['profileUrl'] or next
+          if (name = TWITTER_URI.route_to(url).to_s).match(/\A[A-Za-z0-9_]+\z/)
+            putinfo 'Found a Twitter friend %s in FriendFeed', name
+            subscribed_real << name
+          end
+        }
+      }
+
+      putinfo "Checking imaginary friends in FriendFeed..."
+      ffcli.get_imaginary_friends.each { |profile|
+        profile['services'].each { |service|
+          url = service['profileUrl'] or next
+          if (name = TWITTER_URI.route_to(url).to_s).match(/\A[A-Za-z0-9_]+\z/)
+            putinfo 'Found a Twitter friend %s in FriendFeed (imaginary)', name
+            subscribed_imag << name
+          end
+        }
+      }
+
+      putinfo "Checking groups in FriendFeed..."
+      ffcli.get_profile['rooms'].each { |room|
+        ffcli.get_services(room['nickname']).each { |service|
+          url = service['profileUrl'] or next
+          if (name = TWITTER_URI.route_to(url).to_s).match(/\A[A-Za-z0-9_]+\z/)
+            putinfo 'Found a Twitter friend %s in FriendFeed (group)', name
+            subscribed_imag << name
+          end
+        }
+      }
+
+      Status('friends_subscribed_real') { subscribed_real.sort }
+      Status('friends_subscribed_imag') { subscribed_imag.sort }
+
+      (subscribed_real & subscribed_imag).each { |name|
+        putinfo 'Duplicated subscription: %s', name
+      }
+
+      subscribed = subscribed_real + subscribed_imag
+
+      friends = Set[]
+      to_subscribe = Set[]
+      to_watch = Set[]
+      picture_urls = {}
+
+      twitter_client().all_friends.each { |friend|
+        name = friend.screen_name
+        friends << name
+        next if subscribed.include?(name)
+
+        if friend.protected
+          to_watch << name
+        else
+          to_subscribe << name
+          picture_urls[name] = friend.profile_image_url
+        end
+      }
+      friends << Config('twitter.username')
+
+      Status('friends') { friends.sort }
+      Status('friends_to_watch') { to_watch.sort }
+
+      to_watch.each { |name|
+        putinfo 'Skipping a protected user %s', name
+      }
+
+      agent = WWW::Mechanize.new
+
+      to_subscribe.each { |name|
+        putinfo 'Creating an imaginary friend for %s', name
+        id = ffcli.create_imaginary_friend('(%s)' % name)
+        ffcli.add_twitter(id, name)
+        if picture_urls.key?(name)
+          putinfo 'Setting the picture of %s', name
+          t = Tempfile.open("picture")
+          t.write agent.get_file(picture_urls[name])
+          t.close
+          File.open(t.path) { |f|
+            ffcli.change_picture(id, f)
+          }
+        end
+      }
+    end
+  end
+
+  mode 'replies' do
+    description 'Produce an RSS feed for Twitter replies from non-friends'
+
+    argument('filename') {
+      description 'Specifies a flie to write RSS to'
+    }
+
+    def run
+      require 'nokogiri'
+      require 'rss'
+      require 'set'
+      require 'time'
+
+      filename = params['filename'].value
+
+      File.open(filename, 'w') { |w|
+        feed = RSS::Maker.make("2.0") { |rss|
+          rss.channel.title = 'Twitter replies from non-friends'
+          rss.channel.link = 'http://twitter.com/replies'
+          rss.channel.description = 'Twitter replies from non-friends'
+
+          friends = Status('friends').to_set
+
+          twitter_client().replies.each { |reply|
+            user = reply.user
+            next if user.protected
+            name = user.screen_name
+            next if friends.include?(name)
+            text = '%s: %s' % [name, reply.text]
+            url = 'http://twitter.com/%s/statuses/%d' % [name, reply.id]
+            timestamp = Time.parse(reply.created_at)
+            rss.items.new_item { |item|
+              item.title = Nokogiri.HTML(text).inner_text
+              item.link = url
+              item.description = text
+              item.date = timestamp
+            }
+          }
+        }
+        w.print feed.to_s
+      }
+    end
+  end
+
+  mode 'protected' do
+    description 'Produce an RSS feed for Twitter entries from protected friends'
+
+    argument('filename') {
+      description 'Specifies a flie to write RSS to'
+    }
+
+    def run
+      require 'nokogiri'
+      require 'rss'
+      require 'set'
+      require 'time'
+
+      filename = params['filename'].value
+
+      friends = Status('friends').to_set
+      friends_subscribed_real = Status('friends_subscribed_real').to_set
+
+      items = []
+
+      twitter_client().replies.each { |reply|
+        user = reply.user
+        next if !user.protected
+        name = user.screen_name
+        next if friends.include?(name)
+
+        text = '[%s]: %s' % [name, reply.text]
+        url = 'http://twitter.com/%s/statuses/%d' % [name, reply.id]
+        timestamp = Time.parse(reply.created_at)
+        items << [timestamp, text, url]
+      }
+
+      twitter_client().friends_timeline.each { |status| 
+        user = status.user
+        next if !user.protected
+        name = user.screen_name
+        next if friends_subscribed_real.include?(name)
+        text = '[%s]: %s' % [name, status.text]
+        url = 'http://twitter.com/%s/statuses/%d' % [name, status.id]
+        timestamp = Time.parse(status.created_at)
+        items << [timestamp, text, url]
+      }
+
+      File.open(filename, 'w') { |w|
+        feed = RSS::Maker.make("2.0") { |rss|
+          rss.channel.title = 'Twitter entries from protected friends'
+          rss.channel.link = 'http://twitter.com/home'
+          rss.channel.description = 'Twitter entries from protected friends'
+
+          items.sort { |a, b|
+            b.first <=> a.first
+          }.each { |timestamp, text, url|
+            rss.items.new_item { |item|
+              item.title = Nokogiri.HTML(text).inner_text
+              item.link = url
+              item.description = text
+              item.date = timestamp
+            }
+          }
+        }
+        w.print feed.to_s
+      }
+    end
+  end
+}

data/lib/friendfeed/compat.rb

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+#--
+# friendfeed/compat.rb - defines compatibility methods for older Ruby
+#++
+# Copyright (c) 2009 Akinori MUSHA <knu@iDaemons.org>
+#
+# All rights reserved.  You can redistribute and/or modify it under the same
+# terms as Ruby.
+#
+
+class Hash
+  def self.try_convert(obj)
+    return obj if obj.instance_of?(self)
+    return nil if !obj.respond_to?(:to_hash)
+    nobj = obj.to_hash 
+    return nobj if nobj.instance_of?(self)
+    raise TypeError, format("can't convert %s to %s (%s#to_hash gives %s)", obj.class, self.class, obj.class, nobj.class)
+  end unless self.respond_to?(:try_convert)
+end
+
+class IO
+  def self.try_convert(obj)
+    return obj if obj.is_a?(self)
+    return nil if !obj.respond_to?(:to_io)
+    nobj = obj.to_io 
+    return nobj if nobj.instance_of?(self)
+    raise TypeError, format("can't convert %s to %s (%s#to_io gives %s)", obj.class, self.class, obj.class, nobj.class)
+  end unless self.respond_to?(:try_convert)
+end
+
+class String
+  def self.try_convert(obj)
+    return obj if obj.instance_of?(self)
+    return nil if !obj.respond_to?(:to_str)
+    nobj = obj.to_str 
+    return nobj if nobj.instance_of?(self)
+    raise TypeError, format("can't convert %s to %s (%s#to_str gives %s)", obj.class, self.class, obj.class, nobj.class)
+  end unless self.respond_to?(:try_convert)
+end
+
+class Array
+  def self.try_convert(obj)
+    return obj if obj.instance_of?(self)
+    return nil if !obj.respond_to?(:to_ary)
+    nobj = obj.to_ary 
+    return nobj if nobj.instance_of?(self)
+    raise TypeError, format("can't convert %s to %s (%s#to_ary gives %s)", obj.class, self.class, obj.class, nobj.class)
+  end unless self.respond_to?(:try_convert)
+end

data/lib/friendfeed/unofficial.rb

@@ -0,0 +1,314 @@
+#!/usr/bin/env ruby
+#--
+# friendfeed/unofficial.rb - provides access to FriendFeed unofficial API's
+#++
+# Copyright (c) 2009 Akinori MUSHA <knu@iDaemons.org>
+#
+# All rights reserved.  You can redistribute and/or modify it under the same
+# terms as Ruby.
+#
+
+require 'friendfeed'
+require 'rubygems'
+require 'json'
+require 'mechanize'
+require 'uri'
+
+module FriendFeed
+  class Client
+    #
+    # Unofficial API
+    #
+
+    LOGIN_URI     = ROOT_URI + "/account/login"
+
+    private
+
+    def get_login_agent
+      @login_agent or raise 'login() must be called first to use this feature'
+    end
+
+    public
+
+    # Performs a login with a +nickname+ and +password+ and returns
+    # self.  This enables call of any API, including both official API
+    # and unofficial API.
+    def login(nickname, password)
+      @nickname = nickname
+      @password = password
+      @login_agent = WWW::Mechanize.new
+
+      page = @login_agent.get(LOGIN_URI)
+
+      login_form = page.forms.find { |form|
+        LOGIN_URI + form.action == LOGIN_URI
+      } or raise 'Cannot locate a login form'
+
+      login_form.set_fields(:email => @nickname, :password => @password)
+
+      page = login_form.submit
+
+      login_form = page.forms.find { |form|
+        LOGIN_URI + form.action == LOGIN_URI
+      } and raise 'Login failed'
+
+      page = @login_agent.get(ROOT_URI + "/account/api")
+      remote_key = page.parser.xpath("//td[text()='FriendFeed remote key:']/following-sibling::td[1]/text()").to_s
+
+      api_login(nickname, remote_key)
+    end
+
+    # Posts a request to an internal API of FriendFeed and returns
+    # either a parser object for an HTML response or an object parsed
+    # from a JSON response).  [unofficial]
+    def post(uri, query = {})
+      agent = get_login_agent()
+
+      page = agent.post(uri, {
+          'at' => agent.cookies.find { |cookie|
+            cookie.domain == 'friendfeed.com' && cookie.name == 'AT'
+          }.value
+        }.update(query))
+      if page.respond_to?(:parser)
+        parser = page.parser
+        messages = parser.xpath("//div[@id='errormessage']/text()")
+        messages.empty? or
+          raise messages.map { |message| message.to_s }.join(" ")
+        parser
+      else
+        json = JSON.parse(page.body)
+        message = json['error'] and
+          raise message
+        if html_frag = json['html']
+          html_body = '<html><body>' << html_frag << '</body></html>'
+          json['html_parser'] = WWW::Mechanize.html_parser.parse(html_body)
+        end
+        json
+      end
+    end
+
+    # Gets a list of services of a user or a room of a given
+    # +nickname+, defaulted to the authenticated user.
+    def get_services(nickname = @nickname)
+      agent = get_login_agent()
+
+      services_uri = ROOT_URI + ("/%s/services" % URI.encode(nickname))
+      parser = agent.get(services_uri).parser
+
+      active_servicelist = parser.xpath("//*[@class='active']//ul[@class='servicelist']")
+
+      if !active_servicelist.empty?
+        services = active_servicelist.xpath("./li/a").map { |a|
+          {
+            'service' => a['class'].split.find { |a_class|
+              a_class != 'l_editservice' && a_class != 'service'
+            },
+            'serviceid' => a['serviceid'].to_s,
+          }
+        }
+        profile_uri = ROOT_URI + ("/%s" % URI.encode(nickname))
+        agent.get(profile_uri).parser.xpath("//div[@class='servicespreview']/a").each_with_index { |a, i|
+          href = (profile_uri + a['href'].to_s).to_s
+          break if profile_uri.route_to(href).relative?
+          services[i]['profileUrl'] = href
+        }
+      else
+        services = parser.xpath("//ul[@class='servicelist']/li/a").map { |a|
+          {
+            'service' => a['class'].split.find { |a_class|
+              a_class != 'service'
+            },
+            'profileUrl' => a['href'].to_s,
+          }
+        }
+      end
+      services
+    end
+
+    # Creates a new feed of a given (unique) +nickname+ and display
+    # +name+, and returns a unique ID string on success.  The +type+
+    # can be one of "group", "microblog" and "public".  Like other
+    # methods in general, an exception is raised on
+    # failure. [unofficial]
+    def create_group(nickname, name, type = 'group')
+      post(ROOT_URI + '/a/createfeed', 'nickname' => nickname, 'name' => name, 'type' => type).xpath("(//a[@class='l_feedinvite'])[1]/@sid").to_s
+    end
+
+    EDIT_GROUP_URI = ROOT_URI + '/a/editprofile'
+
+    # Gets profile information of a group specified by a unique
+    # ID. [unofficial]
+    def get_group(id)
+      parser = post(ROOT_URI + '/a/profiledialog', 'stream' => id)['html_parser']
+      form = parser.xpath("//form[1]")
+      hash = { 'stream' => id }
+      form.xpath(".//input").each { |input|
+        case input['type'].downcase
+        when 'text'
+          hash[input['name']] = input['value']
+        when 'radio', 'checkbox'
+          if input['checked']
+            value = input['value']
+            if value && !value.empty?
+              hash[input['name']] = value
+            end
+          end
+        end
+      }
+      form.xpath(".//textarea").each { |input|
+        hash[input['name']] = input.text
+      }
+      hash
+    end
+
+    # Edits profile information of a group specified by a unique ID.
+    # Supported fields are 'nickname', 'name', 'description', 'access'
+    # ('private', 'semipublic' or 'public'), and 'anyoneinvite' (none
+    # or '1').  [unofficial]
+    def edit_group(id, hash)
+      param_hash = get_group(id)
+      param_hash.update(hash)
+      post(EDIT_GROUP_URI, param_hash)
+    end
+
+    # Adds a feed to the authenticated user, a group or an imaginary
+    # friend specified by a unique ID.  Specify 'isstatus' => 'on' to
+    # display entries as messages (no link), and 'importcomment' =>
+    # 'on' to include entry description as a comment. [unofficial]
+    def add_service(id, service, options = nil)
+      params = {
+        'stream' => id,
+        'service' => service,
+      }
+      params.update(options) if options
+      post(ROOT_URI + '/a/configureservice', params)
+    end
+
+    # Edits a service of the authenticated user, a group or an
+    # imaginary friend specified by a unique ID. [unofficial]
+    def edit_service(id, serviceid, service, options = nil)
+      params = {
+        'stream' => id,
+        'service' => service,
+        'serviceid' => serviceid,
+      }
+      params.update(options) if options
+      post(ROOT_URI + '/a/configureservice', params)
+    end
+
+    # Removes a service of the authenticated user, a group or an
+    # imaginary friend specified by a unique ID.  Specify
+    # 'deleteentries' => 'on' to delete entries also. [unofficial]
+    def remove_service(id, serviceid, service, options = nil)
+      params = {
+        'stream' => id,
+        'service' => service,
+        'serviceid' => serviceid,
+      }
+      params.update(options) if options
+      post(ROOT_URI + '/a/removeservice', params)
+    end
+
+    # Refreshes a feed of the authenticated user, a group or an
+    # imaginary friend specified by a unique ID. [unofficial]
+    def refresh_service(id, serviceid, service, options = nil)
+      params = {
+        'refresh' => 1,
+      }
+      params.update(options) if options
+      edit_service(id, serviceid, service, params)
+    end
+
+    # Adds a feed to the authenticated user, a group or an imaginary
+    # friend specified by a unique ID.  Specify 'isstatus' => 'on' to
+    # display entries as messages (no link), and 'importcomment' =>
+    # 'on' to include entry description as a comment. [unofficial]
+    def add_feed(id, url, options = nil)
+      params = { 'url' => url }
+      params.update(options) if options
+      add_service(id, 'feed', options)
+    end
+
+    # Adds a Twitter service to the authenticated user, a group or an
+    # imaginary friend specified by a unique ID. [unofficial]
+    def add_twitter(id, twitter_name)
+      add_service(id, 'twitter', 'username' => twitter_name)
+    end
+
+    # Edits a feed of the authenticated user, a group or an imaginary
+    # friend specified by a unique ID.  Specify 'isstatus' => 'on' to
+    # display entries as messages (no link), and 'importcomment' =>
+    # 'on' to include entry description as a comment. [unofficial]
+    def edit_feed(id, serviceid, url, options = nil)
+      params = { 'url' => url }
+      params.update(options) if options
+      add_service(id, 'feed', options)
+    end
+
+    # Edits a Twitter service of the authenticated user, a group or an
+    # imaginary friend specified by a unique ID.  Specify 'isstatus'
+    # => 'on' to display entries as messages (no link), and
+    # 'importcomment' => 'on' to include entry description as a
+    # comment. [unofficial]
+    def edit_twitter(id, serviceid, twitter_name)
+      edit_service(id, serviceid, 'twitter', 'username' => twitter_name)
+    end
+
+    # Removes a feed from the authenticated user, a group or an
+    # imaginary friend specified by a unique ID.  Specify
+    # 'deleteentries' => 'on' to delete entries also. [unofficial]
+    def remove_feed(id, serviceid, url, options = nil)
+      params = { 'url' => url }
+      params.update(options) if options
+      remove_service(id, serviceid, 'feed', options = nil)
+    end
+
+    # Removes a Twitter service from the authenticated user, a group
+    # or an imaginary friend specified by a unique ID.  Specify
+    # 'deleteentries' => 'on' to delete entries also. [unofficial]
+    def remove_twitter(id, serviceid, twitter_name, options = nil)
+      params = { 'username' => twitter_name }
+      params.update(options) if options
+      remove_service(id, serviceid, 'twitter', options = nil)
+    end
+
+    # Changes the picture of the authenticated user, a group or an
+    # imaginary friend. [unofficial]
+    def change_picture(id, io)
+      post(ROOT_URI + '/a/changepicture', 'stream' => id,
+        'picture' => io)
+    end
+
+    # Unsubscribe from a friend, a group or an imaginary friend
+    # specified by a unique ID. [unofficial]
+    def unsubscribe_from(id)
+      post(ROOT_URI + '/a/unsubscribe', 'stream' => id)
+    end
+
+    # Creates an imaginary friend of a given +nickname+ and returns a
+    # unique ID string on success.  Like other methods in general, an
+    # exception is raised on failure. [unofficial]
+    def create_imaginary_friend(nickname)
+      post(ROOT_URI + '/a/createimaginary', 'name' => nickname).xpath("//*[@id='serviceseditor']/@streamid").to_s
+    end
+
+    # Renames an imaginary friend specified by a unique ID to a given
+    # +nickname+. [unofficial]
+    def rename_imaginary_friend(id, nickname)
+      parser = post(ROOT_URI + '/a/profiledialog', 'stream' => id)['html_parser']
+      form = parser.xpath("//form[1]")
+      hash = { 'stream' => id }
+      form.xpath(".//input").each { |input|
+        case input['type'].downcase
+        when 'text'
+          hash[input['name']] = input['value']
+        end
+      }
+      form.xpath(".//textarea").each { |input|
+        hash[input['name']] = input.text
+      }
+      hash['name'] = nickname
+      post(ROOT_URI + '/a/editprofile', hash)
+    end
+  end
+end

data/lib/friendfeed.rb

@@ -0,0 +1,478 @@
+#!/usr/bin/env ruby
+#--
+# friendfeed.rb - provides access to FriendFeed API's
+#++
+# Copyright (c) 2009 Akinori MUSHA <knu@iDaemons.org>
+#
+# All rights reserved.  You can redistribute and/or modify it under the same
+# terms as Ruby.
+#
+
+require 'rubygems'
+require 'json'
+require 'mechanize'
+require 'uri'
+require 'friendfeed/compat'
+
+module FriendFeed
+  ROOT_URI = URI.parse("https://friendfeed.com/")
+
+  # Client library for FriendFeed API.
+  class Client
+    attr_reader :nickname
+
+    #
+    # Official API
+    #
+
+    API_URI = ROOT_URI + "/api/"
+
+    private
+
+    def get_api_agent
+      @api_agent ||= WWW::Mechanize.new
+    end
+
+    def validate
+      call_api('validate')
+    end
+
+    def require_api_login
+      @nickname or raise 'not logged in'
+    end
+
+    def call_subscription_api(path)
+      require_api_login
+
+      uri = API_URI + path
+
+      agent = WWW::Mechanize.new
+      agent.auth('username', @nickname)
+      JSON.parse(agent.post(uri, { 'apikey' => @remote_key }).body)
+    end
+
+    public
+
+    attr_reader :nickname, :remote_key
+
+    # Performs a login with a +nickname+ and +remote key+ and returns
+    # self.  This enables call of any official API that requires
+    # authentication.  It is not needed to call this method if you
+    # have called login(), which internally obtains a remote key and
+    # calls this method.  An exception is raised if authentication
+    # fails.
+    def api_login(nickname, remote_key)
+      @nickname = nickname
+      @remote_key = remote_key
+      @api_agent = get_api_agent()
+      @api_agent.auth(@nickname, @remote_key)
+      validate
+
+      self
+    end
+
+    # Calls an official API specified by a +path+ with optional
+    # +get_parameters+ and +post_parameters+, and returns an object
+    # parsed from a JSON response.  If +post_parameters+ is given, a
+    # POST request is issued.  A GET request is issued otherwise.
+    def call_api(path, get_parameters = nil, post_parameters = nil, raw = false)
+      api_agent = get_api_agent()
+
+      uri = API_URI + path
+      if get_parameters
+        uri.query = get_parameters.map { |key, value|
+          if array = Array.try_convert(value)
+            value = array.join(',')
+          end
+          URI.encode(key) + "=" + URI.encode(value)
+        }.join('&')
+      end
+
+      if post_parameters
+        body = api_agent.post(uri, post_parameters).body
+      else
+        body = api_agent.get_file(uri)
+      end
+
+      if raw
+        body
+      else
+        JSON.parse(body)
+      end
+    end
+
+    # Gets profile information of a user of a given +nickname+,
+    # defaulted to the authenticated user, in hash.
+    def get_profile(nickname = @nickname)
+      nickname or require_api_login
+      call_api('user/%s/profile' % URI.encode(nickname))
+    end
+
+    # Edits profile information of the authenticated user.  The fields
+    # "name" and "picture" are supported.
+    def edit_profile(hash)
+      nickname or require_api_login
+      call_api('user/%s/profile' % URI.encode(nickname), nil, hash)
+    end
+
+    # Gets an array of profile information of users of given
+    # +nicknames+.
+    def get_profiles(nicknames)
+      call_api('profiles', 'nickname' => nicknames)['profiles']
+    end
+
+    # Gets an array of profile information of friends of a user of a
+    # given +nickname+ (defaulted to the authenticated user) is
+    # subscribing to.
+    def get_real_friends(nickname = @nickname)
+      nickname or require_api_login
+      nicknames = []
+      get_profile(@nickname)['subscriptions'].each { |subscription|
+        if nickname = subscription['nickname']
+          nicknames << nickname
+        end
+      }
+      get_profiles(nicknames)
+    end
+
+    # Gets an array of profile information of the authenticated user's
+    # imaginary friends.
+    def get_imaginary_friends
+      nickname or require_api_login
+      profiles = []
+      get_profile(@nickname)['subscriptions'].each { |subscription|
+        if subscription['nickname'].nil?
+          profiles << get_profile(subscription['id'])
+        end
+      }
+      profiles
+    end
+
+    # Gets profile information of one of the authenticated user's
+    # imaginary friends.
+    def get_imaginary_friend(id)
+      get_profile(id)
+    end
+
+    # Gets an array of the most recent public entries.
+    def get_public_entries()
+      call_api('feed/public')['entries']
+    end
+
+    # Gets an array of the entries the authenticated user would see on
+    # their home page.
+    def get_home_entries()
+      require_api_login
+      call_api('feed/home')['entries']
+    end
+
+    # Gets an array of the entries for the authenticated user's list
+    # of a given +nickname+
+    def get_list_entries(nickname)
+      require_api_login
+      call_api('feed/list/%s' % URI.encode(nickname))['entries']
+    end
+
+    # Gets an array of the most recent entries from a user of a given
+    # +nickname+ (defaulted to the authenticated user).
+    def get_user_entries(nickname = @nickname)
+      nickname or require_api_login
+      call_api('feed/user/%s' % URI.encode(nickname))['entries']
+    end
+
+    # Gets an array of the most recent entries from users of given
+    # +nicknames+.
+    def get_multi_user_entries(nicknames)
+      call_api('feed/user', 'nickname' => nicknames)['entries']
+    end
+
+    # Gets an array of the most recent entries a user of a given
+    # +nickname+ (defaulted to the authenticated user) has commented
+    # on.
+    def get_user_commented_entries(nickname = @nickname)
+      nickname or require_api_login
+      call_api('feed/user/%s/comments' % URI.encode(nickname))['entries']
+    end
+
+    # Gets an array of the most recent entries a user of a given
+    # +nickname+ (defaulted to the authenticated user) has like'd.
+    def get_user_liked_entries(nickname = @nickname)
+      nickname or require_api_login
+      call_api('feed/user/%s/likes' % URI.encode(nickname))['entries']
+    end
+
+    # Gets an array of the most recent entries a user of a given
+    # +nickname+ (defaulted to the authenticated user) has commented
+    # on or like'd.
+    def get_user_discussed_entries(nickname = @nickname)
+      nickname or require_api_login
+      call_api('feed/user/%s/discussion' % URI.encode(nickname))['entries']
+    end
+
+    # Gets an array of the most recent entries from friends of a user
+    # of a given +nickname+ (defaulted to the authenticated user).
+    def get_user_friend_entries(nickname = @nickname)
+      nickname or require_api_login
+      call_api('feed/user/%s/friends' % URI.encode(nickname))['entries']
+    end
+
+    # Gets an array of the most recent entries in a room of a given
+    # +nickname+.
+    def get_room_entries(nickname)
+      call_api('feed/room/%s' % URI.encode(nickname))['entries']
+    end
+
+    # Gets an array of the entries the authenticated user would see on
+    # their rooms page.
+    def get_rooms_entries()
+      call_api('feed/rooms')['entries']
+    end
+
+    # Gets an entry of a given +entryid+.  An exception is raised when
+    # it fails.
+    def get_entry(entryid)
+      call_api('feed/entry/%s' % URI.encode(entryid))['entries'].first
+    end
+
+    # Gets an array of entries of given +entryids+.  An exception is
+    # raised when it fails.
+    def get_entries(entryids)
+      call_api('feed/entry', 'entry_id' => entryids)['entries']
+    end
+
+    # Gets an array of entries that match a given +query+.
+    def search(query)
+      call_api('feed/search', 'q' => query)['entries']
+    end
+
+    # Gets an array of entries that link to a given +url+.
+    def search_for_url(url, options = nil)
+      new_options = { 'url' => url }
+      new_options.merge!(options) if options
+      call_api('feed/url', new_options)['entries']
+    end
+
+    # Gets an array of entries that link to a given +domain+.
+    def search_for_domain(url, options = nil)
+      new_options = { 'url' => url }
+      new_options.merge!(options) if options
+      call_api('feed/domain', new_options)['entries']
+    end
+
+    # Publishes (shares) a given entry.
+    def add_entry(title, options = nil)
+      require_api_login
+      new_options = { 'title' => title }
+      if options
+        options.each { |key, value|
+          case key = key.to_s
+          when 'title', 'link', 'comment', 'room'
+            new_options[key] = value
+          when 'images'
+            value.each_with_index { |value, i|
+              if url = String.try_convert(value)
+                link = nil
+              else
+                if array = Array.try_convert(value)
+                  value1, value2 = *array
+                elsif hash = Hash.try_convert(value)
+                  value1, value2 = *hash.values_at('url', 'link')
+                else
+                  raise TypeError, "Each image must be specified by <image URL>, [<image URL>, <link URL>], or {'url' => <image URL>, 'link' => <link URL>}."
+                end
+                url = String.try_convert(value1) or
+                  raise TypeError, "can't convert #{value1.class} into String"
+                link = String.try_convert(value2) or
+                  raise TypeError, "can't convert #{value2.class} into String"
+              end
+              new_options['image%d_url' % i] = url
+              new_options['image%d_link' % i] = link if link
+            }
+          when 'audios'
+            value.each_with_index { |value, i|
+              if url = String.try_convert(value)
+                link = nil
+              else
+                if array = Array.try_convert(value)
+                  value1, value2 = *array
+                elsif hash = Hash.try_convert(value)
+                  value1, value2 = *hash.values_at('url', 'link')
+                else
+                  raise TypeError, "Each audio must be specified by <audio URL>, [<audio URL>, <link URL>], or {'url' => <audio URL>, 'link' => <link URL>}."
+                end
+                url = String.try_convert(value1) or
+                  raise TypeError, "can't convert #{value1.class} into String"
+                link = String.try_convert(value2) or
+                  raise TypeError, "can't convert #{value2.class} into String"
+              end
+              new_options['audio%d_url' % i] = url
+              new_options['audio%d_link' % i] = link if link
+            }
+          when 'files'
+            value.each_with_index { |value, i|
+              if file = IO.try_convert(value)
+                link = nil
+              else
+                if array = Array.try_convert(value)
+                  value1, value2 = *array
+                elsif hash = Hash.try_convert(value)
+                  value1, value2 = *hash.values_at('file', 'link')
+                else
+                  raise TypeError, "Each file must be specified by <file IO>, [<file IO>, <link URL>], or {'file' => <file IO>, 'link' => <link URL>}."
+                end
+                file = IO.try_convert(value1) or
+                  raise TypeError, "can't convert #{value1.class} into IO"
+                link = String.try_convert(value2) or
+                  raise TypeError, "can't convert #{value2.class} into String"
+              end
+              new_options['file%d' % i] = file
+              new_options['file%d_link' % i] = link if link
+            }
+          end
+        }
+      end
+      call_api('share', nil, new_options)['entries'].first
+    end
+
+    alias publish add_entry
+    alias share add_entry
+
+    # Adds a comment to a given entry.
+    def add_comment(entryid, body)
+      require_api_login
+      call_api('comment', nil, {
+          'entry' => entryid,
+          'body' => body,
+        })
+    end
+
+    # Edits a given comment.
+    def edit_comment(entryid, commentid, body)
+      require_api_login
+      call_api('comment', nil, {
+          'entry' => entryid,
+          'comment' => commentid,
+          'body' => body,
+        })
+    end
+
+    # Deletes a given comment.
+    def delete_comment(entryid, commentid)
+      require_api_login
+      call_api('comment/delete', nil, {
+          'entry' => entryid,
+          'comment' => commentid,
+        })
+    end
+
+    # Undeletes a given comment that is already deleted.
+    def undelete_comment(entryid, commentid)
+      require_api_login
+      call_api('comment/delete', nil, {
+          'entry' => entryid,
+          'comment' => commentid,
+          'undelete' => 'on',
+        })
+    end
+
+    # Adds a "like" to a given entry.
+    def add_like(entryid)
+      require_api_login
+      call_api('like', nil, {
+          'entry' => entryid,
+        })
+    end
+
+    # Deletes an existing "like" from a given entry.
+    def delete_like(entryid)
+      require_api_login
+      call_api('like/delete', nil, {
+          'entry' => entryid,
+        })
+    end
+
+    # Deletes an existing entry of a given +entryid+.
+    def delete_entry(entryid)
+      require_api_login
+      call_api('entry/delete', nil, {
+          'entry' => entryid,
+        })
+    end
+
+    # Undeletes a given entry that is already deleted.
+    def undelete_entry(entryid)
+      require_api_login
+      call_api('entry/delete', nil, {
+          'entry' => entryid,
+          'undelete' => 'on',
+        })
+    end
+
+    # Hides an existing entry of a given +entryid+.
+    def hide_entry(entryid)
+      require_api_login
+      call_api('entry/hide', nil, {
+          'entry' => entryid,
+        })
+    end
+
+    # Unhides a given entry that is already hidden.
+    def unhide_entry(entryid)
+      require_api_login
+      call_api('entry/hide', nil, {
+          'entry' => entryid,
+          'unhide' => 'on',
+        })
+    end
+
+    # Gets a picture of a user of a given +nickname+ (defaulted to the
+    # authenticated user) in blob.  Size can be 'small' (default),
+    # 'medium' or 'large',
+    def get_picture(nickname = @nickname, size = 'small')
+      nickname or require_api_login
+      call_api('/%s/picture' % URI.escape(nickname), { 'size' => size }, nil, true)
+    end
+
+    # Gets a picture of a room of a given +nickname+ in blob.  Size
+    # can be 'small' (default), 'medium' or 'large',
+    def get_room_picture(nickname, size = 'small')
+      call_api('/rooms/%s/picture' % URI.escape(nickname), { 'size' => size }, nil, true)
+    end
+
+    # Gets profile information of a room of a given +nickname+ in
+    # hash.
+    def get_room_profile(nickname)
+      call_api('room/%s/profile' % URI.encode(nickname))
+    end
+
+    # Gets profile information of the authenticated user's list of a
+    # given +nickname+ in hash.
+    def get_list_profile(nickname)
+      call_api('list/%s/profile' % URI.encode(nickname))
+    end
+
+    # Subscribes to a user of a given +nickname+ and returns a status
+    # string.
+    def subscribe_to_user(nickname)
+      call_subscription_api('user/%s/subscribe' % URI.encode(nickname))['status']
+    end
+
+    # Unsubscribes from a user of a given +nickname+ and returns a
+    # status string.
+    def unsubscribe_from_user(nickname)
+      call_subscription_api('user/%s/subscribe?unsubscribe=1' % URI.encode(nickname))['status']
+    end
+
+    # Subscribes to a room of a given +nickname+ and returns a status
+    # string.
+    def subscribe_to_room(nickname)
+      call_subscription_api('room/%s/subscribe' % URI.encode(nickname))['status']
+    end
+
+    # Unsubscribes from a room of a given +nickname+ and returns a
+    # status string.
+    def unsubscribe_from_room(nickname)
+      call_subscription_api('room/%s/subscribe?unsubscribe=1' % URI.encode(nickname))['status']
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: knu-friendfeed
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors: 
 - Akinori MUSHA
@@ -15,14 +15,17 @@ dependencies: []
 
 description: A Ruby module that provides access to FriendFeed API's.
 email: knu@idaemons.org
-executables: []
-
+executables: 
+- tw2ff
 extensions: []
 
 extra_rdoc_files: []
 
-files: []
-
+files: 
+- lib/friendfeed.rb
+- lib/friendfeed/compat.rb
+- lib/friendfeed/unofficial.rb
+- bin/tw2ff
 has_rdoc: true
 homepage: http://github.com/knu/ruby-friendfeed
 post_install_message: