net-irc2 0.0.10

data/examples/tig.rb

@@ -0,0 +1,2712 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+$KCODE = "u" unless defined? ::Encoding # json use this
+=begin
+
+# tig.rb
+
+Ruby version of TwitterIrcGateway
+<http://www.misuzilla.org/dist/net/twitterircgateway/>
+
+## Launch
+
+  $ ruby tig.rb
+
+If you want to help:
+
+  $ ruby tig.rb --help
+
+## Configuration
+
+Options specified by after IRC realname.
+
+Configuration example for Tiarra <http://coderepos.org/share/wiki/Tiarra>.
+
+  general {
+    server-in-encoding: utf8
+    server-out-encoding: utf8
+    client-in-encoding: utf8
+    client-out-encoding: utf8
+  }
+
+  networks {
+    name: tig
+  }
+
+  tig {
+    server: localhost 16668
+    password: password on Twitter
+    # Recommended
+    name: username mentions tid
+  }
+
+### athack
+
+If `athack` client option specified,
+all nick in join message is leading with @.
+
+So if you complemente nicks (e.g. Irssi),
+it's good for Twitter like reply command (@nick).
+
+In this case, you will see torrent of join messages after connected,
+because NAMES list can't send @ leading nick (it interpreted op.)
+
+### tid[=<color:10>[,<bgcolor>]]
+
+Apply ID to each message for make favorites by CTCP ACTION.
+
+  /me fav [ID...]
+
+<color> and <bgcolor> can be
+
+  0  => white
+  1  => black
+  2  => blue         navy
+  3  => green
+  4  => red
+  5  => brown        maroon
+  6  => purple
+  7  => orange       olive
+  8  => yellow
+  9  => lightgreen   lime
+  10 => teal
+  11 => lightcyan    cyan aqua
+  12 => lightblue    royal
+  13 => pink         lightpurple fuchsia
+  14 => grey
+  15 => lightgrey    silver
+
+### ratio=<timeline>:<dm>[:<mentions>] (obsolete)
+
+"121:6:20" by default.
+
+  /me ratios
+
+     Ratio | Timeline |   DM  | Mentions |
+  ---------+----------+-------+----------|
+         1 |      24s |   N/A |      N/A |
+     141:6 |      26s |   10m OR N/A     |
+    135:12 |      27s |    5m OR N/A     |
+   135:6:6 |      27s |   10m |      10m |
+  ---------+----------+-------+----------|
+  121:6:20 |      30s |   10m |       3m |
+  ---------+----------+-------+----------|
+       4:1 |      31s |  2m1s |      N/A |
+   50:5:12 |      49s | 8m12s |    3m25s |
+    20:5:6 |      57s | 3m48s |    3m10s |
+   30:5:12 |      58s | 5m45s |    2m24s |
+     1:1:1 |    1m13s | 1m13s |    1m13s |
+  ---------------------------------------+
+                      (Hourly limit: 150)
+
+### dm[=<ratio>]
+
+### mentions[=<ratio>]
+
+### maxlimit=<hourly_limit>
+
+### clientspoofing
+
+### httpproxy=[<user>[:<password>]@]<address>[:<port>]
+
+### main_channel=<channel:#twitter>
+
+### api_source=<source>
+
+### check_friends_interval=<seconds:3600>
+
+### check_updates_interval=<seconds:86400>
+
+Set 0 to disable checking.
+
+### old_style_reply
+
+### tmap_size=<number:10404>
+
+### strftime=<format:%m-%d %H:%M>
+
+### untiny_whole_urls
+
+### bitlify=<username>:<apikey>:<minlength:20>
+
+### unuify
+
+### shuffled_tmap
+
+### ll=<lat>,<long>
+
+### with_retweets
+
+### without_lists
+
+## Extended commands through the CTCP ACTION
+
+### list (ls)
+
+  /me list NICK [NUMBER]
+
+### fav (favorite, favourite, unfav, unfavorite, unfavourite)
+
+  /me fav [ID...]
+  /me unfav [ID...]
+  /me fav! [ID...]
+  /me fav NICK
+
+### link (ln, url, u)
+
+  /me link ID [ID...]
+
+### destroy (del, delete, miss, oops, remove, rm)
+
+  /me destroy [ID...]
+
+### in (location)
+
+  /me in Sugamo, Tokyo, Japan
+
+### reply (re, mention)
+
+  /me reply ID blah, blah...
+
+### retweet (rt)
+
+  /me retweet ID (blah, blah...)
+
+### utf7 (utf-7)
+
+  /me utf7
+
+### name
+
+  /me name My Name
+
+### description (desc)
+
+  /me description blah, blah...
+
+### spoof
+
+  /me spoof
+  /me spoo[o...]f
+  /me spoof tigrb twitterircgateway twitt web mobileweb
+
+### bot (drone)
+
+  /me bot NICK [NICK...]
+
+### spam
+report user as spammer
+
+  /me spam <NICK>|<ID>
+
+## Feed
+
+<http://coderepos.org/share/log/lang/ruby/net-irc/trunk/examples/tig.rb?limit=100&mode=stop_on_copy&format=rss>
+
+## License
+
+Ruby's by cho45
+
+=end
+
+case
+when File.directory?("lib")
+  $LOAD_PATH << "lib"
+when File.directory?(File.expand_path("lib", ".."))
+  $LOAD_PATH << File.expand_path("lib", "..")
+end
+
+require "pp"
+require "rubygems"
+require "net/irc"
+require "net/https"
+require "uri"
+require "time"
+require "logger"
+require "yaml"
+require "pathname"
+require "ostruct"
+require "json"
+require "oauth"
+
+begin
+  require "iconv"
+  require "punycode"
+rescue LoadError
+end
+
+module Net::IRC::Constants; RPL_WHOISBOT = "335"; RPL_CREATEONTIME = "329"; end
+
+class TwitterIrcGateway < Net::IRC::Server::Session
+  CONFIG_DIR = Pathname.new("~/.tig.rb").expand_path
+
+  CONSUMER_KEY    = 'ZxRg3rGeqE68Tqkz9nhmA'
+  CONSUMER_SECRET = 'GaJsr2jfjUYIHaPc01UqiqMlvUJPCL5z5uPQM5T418'
+
+  class UnauthorizedException < Exception; end
+
+  @@ctcp_action_commands = []
+
+  class << self
+    def ctcp_action(*commands, &block)
+      name = "+ctcp_action_#{commands.inspect}"
+      define_method(name, block)
+      commands.each do |command|
+        @@ctcp_action_commands << [command, name]
+      end
+    end
+  end
+
+  def server_name
+    "twittergw"
+  end
+
+  def server_version
+    @server_version ||= instance_eval {
+      head = `git rev-parse HEAD 2>/dev/null`.chomp
+      head.empty?? "unknown" : head
+    }
+  end
+
+  def available_user_modes
+    "o"
+  end
+
+  def available_channel_modes
+    "mntiovah"
+  end
+
+  def main_channel
+    @opts.main_channel || "#twitter"
+  end
+
+  def api_base(secure = true)
+    URI("http#{"s" if secure}://api.twitter.com/")
+  end
+
+  def api_source
+    "#{@opts.api_source || "tigrb"}"
+  end
+
+  def hourly_limit
+    150
+  end
+
+  class APIFailed < StandardError; end
+
+  MAX_MODE_PARAMS = 3
+  WSP_REGEX       = Regexp.new("\\r\\n|[\\r\\n\\t#{"\\u00A0\\u1680\\u180E\\u2002-\\u200D\\u202F\\u205F\\u2060\\uFEFF" if "\u0000" == "\000"}]")
+
+  def initialize(*args)
+    super
+    @channels      = {}
+    @nicknames     = {}
+    @drones        = []
+    @etags         = {}
+    @consums       = []
+    @follower_ids  = []
+    @limit         = hourly_limit
+    @friends       =
+    @sources       =
+    @rsuffix_regex =
+    @im            =
+    @im_thread     =
+    @utf7          =
+    @httpproxy     = nil
+    @ratelimit     = RateLimit.new(150)
+    @cert_store = OpenSSL::X509::Store.new
+    @cert_store.set_default_paths
+  end
+
+  def config(&block)
+    # merge local (user) config and global config
+    merged = {}
+    global = {}
+    local  = {}
+
+    global_config = CONFIG_DIR + "config"
+    begin
+      global = eval(global_config.read) || {}
+    rescue Errno::ENOENT
+    end
+
+    local_config  = @real ? CONFIG_DIR + "#{@real}/config" : nil
+    if local_config
+      begin
+        local = eval(local_config.read) || {}
+      rescue Errno::ENOENT
+      end
+    end
+
+    merged.update(global)
+    merged.update(local)
+
+    if block
+      merged.instance_eval(&block)
+      merged.each do |k, v|
+        unless global[k] == v
+          local[k] = v
+        end
+      end
+
+      if local_config
+        local_config.parent.mkpath
+        local_config.open('w') do |f|
+          PP.pp(local, f)
+        end
+      end
+    end
+
+    merged
+  end
+
+  def on_user(m)
+    super
+
+    @real, *@opts = (@opts.name || @real).split(" ")
+    @opts = @opts.inject({}) do |r, i|
+      key, value = i.split("=", 2)
+      key = "mentions" if key == "replies" # backcompat
+      r.update key => case value
+        when nil                      then true
+        when /\A\d+\z/                then value.to_i
+        when /\A(?:\d+\.\d*|\.\d+)\z/ then value.to_f
+        else                               value
+      end
+    end
+    @opts = OpenStruct.new(@opts)
+    @opts.httpproxy.sub!(/\A(?:([^:@]+)(?::([^@]+))?@)?([^:]+)(?::(\d+))?\z/) do
+      @httpproxy = OpenStruct.new({
+        :user => $1, :password => $2, :address => $3, :port => $4.to_i,
+      })
+      $&.sub(/[^:@]+(?=@)/, "********")
+    end if @opts.httpproxy
+
+    @timeline = TypableMap.new(@opts.tmap_size     || 200,
+                               @opts.shuffled_tmap || false)
+
+    @consumer = OAuth::Consumer.new(
+      CONSUMER_KEY,
+      CONSUMER_SECRET,
+      :site => 'https://api.twitter.com'
+    )
+
+    @log.debug config.inspect
+    if config['access_token']
+      @access_token = OAuth::AccessToken.new(@consumer, config['access_token'], config['access_token_secret'])
+      on_authorized
+    else
+      begin
+        @access_token = @consumer.get_access_token(nil, {}, {
+          :x_auth_mode     => "client_auth",
+          :x_auth_username => @real,
+          :x_auth_password => @pass,
+        })
+        on_authorized
+      rescue OAuth::Unauthorized
+        log 'Failed trying xAuth'
+        oauth_request
+      end
+    end 
+  end
+
+  def oauth_request
+    @request_token = @consumer.get_request_token
+    log 'Access following URL: %s' % @request_token.authorize_url
+    log 'and send /me oauth <PIN>'
+  end
+
+  def on_authorized
+    retry_count = 0
+    begin
+      @me = api("account/update_profile") #api("account/verify_credentials")
+    rescue APIFailed => e
+      @log.error e.inspect
+      sleep 1
+      retry_count += 1
+      retry if retry_count < 3
+      log "Failed to access API 3 times." <<
+          " Please retry oauth verification or" <<
+          " Twitter Status <http://status.twitter.com/> and try again later."
+      oauth_request
+    end
+
+    @prefix = prefix(@me)
+    @user   = @prefix.user
+    @host   = @prefix.host
+
+    #post NICK, @me.screen_name if @nick != @me.screen_name
+    post server_name, MODE, @nick, "+o"
+    post @prefix, JOIN, main_channel
+    post server_name, MODE, main_channel, "+mto", @nick
+    post server_name, MODE, main_channel, "+q", @nick
+    if @me.status
+      post @prefix, TOPIC, main_channel, generate_status_message(@me.status.text)
+    end
+
+    log "Client options: #{@opts.marshal_dump.inspect}"
+    @log.info "Client options: #{@opts.inspect}"
+
+    @opts.tid = begin
+      c = @opts.tid # expect: 0..15, true, "0,1"
+      b = nil
+      c, b = c.split(",", 2).map {|i| i.to_i } if c.respond_to? :split
+      c = 10 unless (0 .. 15).include? c # 10: teal
+      if (0 .. 15).include?(b)
+        "\003%.2d,%.2d[%%s]\017" % [c, b]
+      else
+        "\003%.2d[%%s]\017"      % c
+      end
+    end if @opts.tid
+
+    check_friends
+    @ratelimit.register(:check_friends, 3600)
+    @check_friends_thread = Thread.start do
+      loop do
+        sleep @ratelimit.interval(:check_friends)
+        begin
+          check_friends
+        rescue APIFailed => e
+          @log.error e.inspect
+        rescue Exception => e
+          @log.error e.inspect
+          e.backtrace.each do |l|
+            @log.error "\t#{l}"
+          end
+        end
+      end
+    end
+
+    if @opts.clientspoofing
+      update_sources
+    else
+      @sources = [api_source]
+    end
+
+    start_timeline_thread(@opts.chirp)
+
+    update_redundant_suffix
+    @check_updates_thread = Thread.start do
+      sleep 30
+
+      loop do
+        begin
+          @log.info "check_updates"
+          update_redundant_suffix
+          check_updates
+        rescue Exception => e
+          @log.error e.inspect
+          e.backtrace.each do |l|
+            @log.error "\t#{l}"
+          end
+        end
+        sleep 0.01 * (90 + rand(21)) *
+              (@opts.check_updates_interval || 86400) # 0.9 ... 1.1 day
+      end
+
+      sleep @opts.check_updates_interval || 86400
+    end
+
+    @ratelimit.register(:dm, 600)
+    @check_dms_thread = Thread.start do
+      loop do
+        begin
+          if check_direct_messages
+            @ratelimit.incr(:dm)
+          else
+            @ratelimit.decr(:dm)
+          end
+        rescue APIFailed => e
+          @log.error e.inspect
+        rescue Exception => e
+          @log.error e.inspect
+          e.backtrace.each do |l|
+            @log.error "\t#{l}"
+          end
+        end
+        sleep @ratelimit.interval(:dm)
+      end
+    end if @opts.dm
+
+    @ratelimit.register(:mentions, 180)
+    @check_mentions_thread = Thread.start do
+      sleep @ratelimit.interval(:timeline)
+
+      loop do
+        begin
+          if check_mentions
+            @ratelimit.incr(:mentions)
+          else
+            @ratelimit.decr(:mentions)
+          end
+        rescue APIFailed => e
+          @log.error e.inspect
+        rescue Exception => e
+          @log.error e.inspect
+          e.backtrace.each do |l|
+            @log.error "\t#{l}"
+          end
+        end
+        sleep @ratelimit.interval(:mentions)
+      end
+    end if @opts.mentions
+
+    @ratelimit.register(:lists, 60 * 60)
+    @check_lists_thread = Thread.start do
+      sleep 60
+      Thread.current[:last_updated] = Time.at(0)
+      loop do
+        begin
+          @log.info "LISTS update now..."
+          if check_lists
+            @ratelimit.incr(:lists)
+          else
+            @ratelimit.decr(:lists)
+          end
+          Thread.current[:last_updated] = Time.now
+
+          sleep @ratelimit.interval(:lists)
+        rescue Exception => e
+          @log.error e.inspect
+          e.backtrace.each do |l|
+            @log.error "\t#{l}"
+          end
+          sleep 60
+        end
+      end
+    end unless @opts.without_lists
+
+    @ratelimit.register(:lists_status, 60 * 5)
+    @check_lists_status_thread = Thread.start do
+      Thread.current[:last_updated] = Time.at(0)
+      loop do
+        begin
+          @log.info "lists/status update now... #{@channels.size}"
+          ## TODO 各リストにつき limit が必要
+          if check_lists_status
+            @ratelimit.incr(:lists_status)
+          else
+            @ratelimit.decr(:lists_status)
+          end
+          Thread.current[:last_updated] = Time.now
+        rescue Exception => e
+          @log.error e.inspect
+          e.backtrace.each do |l|
+            @log.error "\t#{l}"
+          end
+        end
+        sleep @ratelimit.interval(:lists_status)
+      end
+    end unless @opts.without_lists
+  end
+
+  def start_timeline_thread(chirp=false)
+    @log.info "start_timeline_thread: chirp=#{chirp}"
+    @check_timeline_thread.kill rescue nil
+    @chirp_thread.kill rescue nil
+    if chirp
+      @chirp_thread = Thread.start do
+        retry_count = 0
+        begin
+          uri = URI.parse('https://userstream.twitter.com/2/user.json?replies=all')
+
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = true
+          http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+          http.cert_store = @cert_store
+          req = Net::HTTP::Get.new(uri.request_uri)
+          req.oauth!(http, @consumer, @access_token)
+
+          @chirp_timer_thread.kill rescue nil
+          @chirp_timer_thread = Thread.start do
+            loop do
+              @log.info "check unresponsive_time"
+              unresponsive_time = Time.now - Thread.current[:timer]
+              if unresponsive_time > 90
+                @log.info "stream api timeout: re-start_timeline_thread"
+                start_timeline_thread(true)
+              else
+                sleep 90 - unresponsive_time
+              end
+            end
+          end
+          @chirp_timer_thread[:timer] = Time.now
+
+          http.request(req) do |res|
+            raise UnauthorizedException if res.code.to_i == 401
+            raise res.code unless res.code.to_i == 200
+
+            buf = ""
+            res.read_body do |str|
+              @chirp_timer_thread[:timer] = Time.now # update timer
+              buf << str
+              buf.gsub!(/[\s\S]+?\r\n/) do |chunk|
+                data = JSON.parse(chunk) rescue {}
+                struct = TwitterStruct.make(data)
+
+                begin
+                  case
+                  when data['text']
+                    status = struct
+                    id = @latest_id = status.id
+                    unless @timeline.any? {|tid, s| s.id == id }
+                      user = status.user
+                      tid  = @timeline.push(status)
+                      tid  = nil unless @opts.tid
+
+                      if user.id == @me.id
+                        mesg = generate_status_message(status.text)
+                        mesg << " " << @opts.tid % tid if tid
+                        post @prefix, TOPIC, main_channel, mesg
+
+                        @me = user
+                      else
+                        if @friends
+                          @friends.each_with_index do |friend, i|
+                            if friend.id == user.id
+                              if friend.screen_name != user.screen_name
+                                post prefix(friend), NICK, user.screen_name
+                              end
+                              @friends[i] = user
+                              break
+                            end
+                          end
+                        end
+
+                        message(status, main_channel, tid, nil, PRIVMSG)
+                      end
+                      @channels.each do |name, channel|
+                        if channel[:members].find{|m| m.screen_name == user.screen_name }
+                          message(status, name, tid, nil, (user.id == @me.id) ? NOTICE : PRIVMSG)
+                        end
+                      end
+                    end
+                  when data['friends']
+                  when data['delete']
+                    # TODO
+                  when data['event'] == 'follow'
+                    message(struct, main_channel, nil, "\00311follow\017 => @%s http://twitter.com/%s" % [
+                      data['target']['screen_name'],
+                      data['target']['screen_name']
+                    ])
+                  when data['event'] == 'retweet'
+                    # status event include this event
+                  when data['event'] == 'favorite'
+                    next if data['source']['screen_name'] == "amachang" # CAY (countermeasures against youpy)
+                    message(struct, main_channel, nil, "\00311favorite\017 => @%s : %s http://twitter.com/%s" % [
+                      data['target_object']['user']['screen_name'],
+                      data['target_object']['text'],
+                      data['target_object']['user']['screen_name']
+                    ])
+                  when data['event'] == 'unfavorite'
+                    message(struct, main_channel, nil, "\00305unfavorite =>\017 @%s : %s http://twitter.com/%s" % [
+                      data['target_object']['user']['screen_name'],
+                      data['target_object']['text'],
+                      data['target_object']['user']['screen_name']
+                    ])
+                  else
+                  end
+                rescue Exception => e
+                  @log.error e.inspect
+                  e.backtrace.each do |l|
+                    @log.error "\t#{l}"
+                  end
+                end
+                ''
+              end
+            end
+          end
+        rescue TimeoutError => e
+          @log.info "stream api timeout: retry"
+          retry
+        rescue Exception => e
+          @log.error e.inspect
+          e.backtrace.each do |l|
+            @log.error "\t#{l}"
+          end
+          sleep 1
+          retry_count += 1
+          if retry_count < 3
+            retry
+          else
+            @chirp_thread = nil
+            on_disconnected
+            on_authorized
+          end
+        end
+      end
+    else
+      @ratelimit.register(:timeline, 30)
+      @check_timeline_thread = Thread.start do
+        sleep 2 * (@me.friends_count / 100.0).ceil
+        sleep 10
+
+        loop do
+          begin
+            if check_timeline
+              @ratelimit.incr(:timeline)
+            else
+              @ratelimit.decr(:timeline)
+            end
+          rescue APIFailed => e
+            @log.error e.inspect
+          rescue Exception => e
+            @log.error e.inspect
+            e.backtrace.each do |l|
+              @log.error "\t#{l}"
+            end
+          end
+          sleep @ratelimit.interval(:timeline)
+        end
+      end
+    end
+  end
+
+  def on_disconnected
+    @check_friends_thread.kill      rescue nil
+    @check_timeline_thread.kill     rescue nil
+    @check_mentions_thread.kill     rescue nil
+    @check_dms_thread.kill          rescue nil
+    @check_updates_thread.kill      rescue nil
+    @check_lists_thread.kill        rescue nil
+    @check_lists_status_thread.kill rescue nil
+    @chirp_thread.kill              rescue nil
+    @chirp_timer_thread.kill        rescue nil
+  end
+
+  def on_privmsg(m)
+    target, mesg = *m.params
+    m.ctcps.each {|ctcp| on_ctcp(target, ctcp) } if m.ctcp?
+
+    return if mesg.empty?
+    return on_ctcp_action(target, mesg) if mesg.sub!(/\A +/, "") #and @opts.direct_action
+
+    if include_ngword?(mesg)
+      log "The message includes NG words, was ignored."
+      return
+    end
+
+
+    command, params = mesg.split(" ", 2)
+    case command.downcase # TODO: escape recursive
+    when "d", "dm"
+      screen_name, mesg = params.split(" ", 2)
+      unless screen_name or mesg
+        log 'Send "d NICK message" to send a direct (private) message.' <<
+            " You may reply to a direct message the same way."
+        return
+      end
+      m.params[0] = screen_name.sub(/\A@/, "")
+      m.params[1] = mesg #.rstrip
+      return on_privmsg(m)
+    # TODO
+    #when "f", "follow"
+    #when "on"
+    #when "off" # BUG if no args
+    #when "g", "get"
+    #when "w", "whois"
+    #when "n", "nudge" # BUG if no args
+    #when "*", "fav"
+    #when "delete"
+    #when "stats" # no args
+    #when "leave"
+    #when "invite"
+    end unless command.nil?
+
+    mesg = escape_http_urls(mesg)
+    mesg = @opts.unuify ? unuify(mesg) : bitlify(mesg)
+    mesg = Iconv.iconv("UTF-7", "UTF-8", mesg).join.encoding!("ASCII-8BIT") if @utf7
+
+    ret         = nil
+    retry_count = 3
+    begin
+      case
+      when target.ch?
+        previous = @me.status
+        if previous and
+           ((Time.now - Time.parse(previous.created_at)).to_i < 60 rescue true) and
+           mesg.strip == previous.text
+          log "You can't submit the same status twice in a row."
+          return
+        end
+
+        q = { :status => mesg }
+
+        if @opts.old_style_reply and mesg[/\A@(?>([A-Za-z0-9_]{1,15}))[^A-Za-z0-9_]/]
+          if user = friend($1) || api("users/show/#{$1}")
+            unless user.status
+              user = api("users/show/#{user.id}", {},
+                     { :authenticate => user.protected })
+            end
+            if user.status
+              q.update :in_reply_to_status_id => user.status.id
+            end
+          end
+        end
+        if @opts.ll
+          lat, long = @opts.ll.split(",", 2)
+          q.update :lat  => lat.to_f
+          q.update :long => long.to_f
+        end
+
+        ret = api("statuses/update", q)
+        log oops(ret) if ret.truncated
+        ret.user.status = ret
+        @me = ret.user
+        log "Status updated"
+      when target.screen_name? # Direct message
+        ret = api("direct_messages/new", { :screen_name => target, :text => mesg })
+        post server_name, NOTICE, @nick, "Your direct message has been sent to #{target}."
+      else
+        post server_name, ERR_NOSUCHNICK, target, "No such nick/channel"
+      end
+    rescue => e
+      @log.error [retry_count, e.inspect, e.backtrace].inspect
+      if retry_count > 0
+        retry_count -= 1
+        @log.debug "Retry to setting status..."
+        retry
+      end
+      log "Some Error Happened on Sending #{mesg}. #{e}"
+    end
+  end
+
+  def on_whois(m)
+    nick = m.params[0]
+    unless nick.screen_name?
+      post server_name, ERR_NOSUCHNICK, nick, "No such nick/channel"
+      return
+    end
+
+    unless user = user(nick)
+      if api("users/username_available", { :username => nick }).valid
+      # TODO: 404 suspended
+        post server_name, ERR_NOSUCHNICK, nick, "No such nick/channel"
+        return
+      end
+      user = api("users/show/#{nick}", {}, { :authenticate => false })
+    end
+
+    prefix    = prefix(user)
+    desc      = user.name
+    desc      = "#{desc} / #{user.description}".gsub(/\s+/, " ") if user.description and not user.description.empty?
+    signon_at = Time.parse(user.created_at).to_i rescue 0
+    idle_sec  = (Time.now - (user.status ? Time.parse(user.status.created_at) : signon_at)).to_i rescue 0
+    location  = user.location
+    location  = "SoMa neighborhood of San Francisco, CA" if location.nil? or location.empty?
+    post server_name, RPL_WHOISUSER,   @nick, nick, prefix.user, prefix.host, "*", desc
+    post server_name, RPL_WHOISSERVER, @nick, nick, api_base.host, location
+    post server_name, RPL_WHOISIDLE,   @nick, nick, "#{idle_sec}", "#{signon_at}", "seconds idle, signon time"
+    post server_name, RPL_ENDOFWHOIS,  @nick, nick, "End of WHOIS list"
+    if @drones.include?(user.id)
+      post server_name, RPL_WHOISBOT, @nick, nick, "is a \002Bot\002 on #{server_name}"
+    end
+  end
+
+  def on_who(m)
+    channel  = m.params[0]
+    whoreply = Proc.new do |ch, user|
+      #     "<channel> <user> <host> <server> <nick>
+      #         ( "H" / "G" > ["*"] [ ( "@" / "+" ) ]
+      #             :<hopcount> <real name>"
+      prefix = prefix(user)
+      server = api_base.host
+      mode   = case prefix.nick
+        when @nick                     then "~"
+        #when @drones.include?(user.id) then "%" # FIXME
+        else                                "+"
+      end
+      hop  = prefix.host.count("/")
+      real = user.name
+      post server_name, RPL_WHOREPLY, @nick,
+           ch, prefix.user, prefix.host, server, prefix.nick, "H*#{mode}", "#{hop} #{real}"
+    end
+
+    case
+    when channel.casecmp(main_channel).zero?
+      users = [@me]
+      users.concat @friends.reverse if @friends
+      users.each {|friend| whoreply.call channel, friend }
+      post server_name, RPL_ENDOFWHO, @nick, channel
+    when (@channels.key?(channel) and @friends)
+      @channels[channel][:members].each do |user|
+        whoreply.call channel, user
+      end
+      post server_name, RPL_ENDOFWHO, @nick, channel
+    else
+      post server_name, ERR_NOSUCHNICK, @nick, "No such nick/channel"
+    end
+  end
+
+  def on_join(m)
+    channels = m.params[0].split(/ *, */)
+    channels.each do |channel|
+      channel = channel.split(" ", 2).first
+      next if channel.casecmp(main_channel).zero?
+
+# auto rejoin のとき勝手に作って困るのでコメントアウト。
+# create するまえに、必ず check_lists するようにしないと。
+#      name = channel[1..-1]
+#      unless @channels.find{|c| c.slug == name }
+#        @log.info "create list: #{name}"
+#        api("1/#{@me.screen_name}/lists",{'name' => name })
+#      end
+#      post @prefix, JOIN, channel
+#      post server_name, MODE, channel, "+mtio", @nick
+#      post server_name, MODE, channel, "+q", @nick
+    end
+  end
+
+  def on_part(m)
+    channel = m.params[0]
+    return if channel.casecmp(main_channel).zero?
+
+# いきなり delete とか危険なのでコメントアウト
+# IRC Gateway 側に流れない、という挙動にし、delete するには ctcp を必要に
+#    name = channel[1..-1]
+#    @log.info "delete list: #{name}"
+#    api("1/#{@me.screen_name}/lists/#{name}",{'_method' => 'DELETE' }) rescue nil
+#    post @prefix, PART, channel, "Ignore group #{channel}, but setting is alive yet."
+  end
+
+  def on_invite(m)
+    nick, channel = *m.params
+    if not nick.screen_name? or @nick.casecmp(nick).zero?
+      post server_name, ERR_NOSUCHNICK, nick, "No such nick/channel" # or yourself
+      return
+    end
+
+    friend = friend(nick)
+
+    case
+    when channel.casecmp(main_channel).zero?
+      case
+      when friend #TODO
+      when api("users/username_available", { :username => nick }).valid
+        post server_name, ERR_NOSUCHNICK, nick, "No such nick/channel"
+      else
+        user = api("friendships/create/#{nick}")
+        join main_channel, [user]
+        @friends << user if @friends
+        @me.friends_count += 1
+      end
+    when friend
+      slug = channel[1..-1]
+      api("/1/#{@me.screen_name}/#{slug}/members",{'id'=>friend.id})
+      @channels[channel][:members] << friend
+      join(channel, [friend])
+    else
+      post server_name, ERR_NOSUCHNICK, nick, "No such nick/channel"
+    end
+  end
+
+  def on_kick(m)
+    channel, nick, msg = *m.params
+
+    if channel.casecmp(main_channel).zero?
+      @friends.delete_if do |friend|
+        if friend.screen_name.casecmp(nick).zero?
+          user = api("friendships/destroy/#{friend.id}")
+          post prefix(user), PART, main_channel, "Removed: #{msg}"
+          @me.friends_count -= 1
+        end
+      end if @friends
+    else
+      friend = friend(nick)
+      if friend
+        slug = channel[1..-1]
+        api("/1/#{@me.screen_name}/#{slug}/members",{'id'=>friend.id, '_method'=>'DELETE'})
+        @channels[channel][:members].delete_if{|u| u.screen_name == friend.screen_name }
+        post prefix(friend), PART, channel, "Removed: #{msg}"
+      else
+        post server_name, ERR_NOSUCHNICK, nick, "No such nick/channel"
+      end
+    end
+  end
+
+  #def on_nick(m)
+  #  @nicknames[@nick] = m.params[0]
+  #end
+
+  def on_topic(m)
+    channel = m.params[0]
+    return if not channel.casecmp(main_channel).zero? or @me.status.nil?
+
+    return if not @opts.mesautofix
+    begin
+      require "levenshtein"
+      topic    = m.params[1]
+      previous = @me.status
+      return unless previous
+
+      distance = Levenshtein.normalized_distance(previous.text, topic)
+      return if distance.zero?
+
+      status = api("statuses/update", { :status => topic, :source => source })
+      log oops(ret) if status.truncated
+      status.user.status = status
+      @me = status.user
+
+      if distance < 0.5
+        deleted = api("statuses/destroy/#{previous.id}")
+        @timeline.delete_if {|tid, s| s.id == deleted.id }
+        log "Similar update in previous. Conclude that it has error."
+        log "And overwrite previous as new status: #{status.text}"
+      else
+        log "Status updated"
+      end
+    rescue LoadError
+    end
+  end
+
+  def on_mode(m)
+    channel = m.params[0]
+
+    unless m.params[1]
+      case
+      when channel.ch?
+        mode = "+mt"
+        mode += "i" unless channel.casecmp(main_channel).zero?
+        post server_name, RPL_CHANNELMODEIS, @nick, channel, mode
+        #post server_name, RPL_CREATEONTIME, @nick, channel, 0
+      when channel.casecmp(@nick).zero?
+        post server_name, RPL_UMODEIS, @nick, @nick, "+o"
+      end
+    end
+  end
+
+  private
+  def on_ctcp(target, mesg)
+    type, mesg = mesg.split(" ", 2)
+    method = "on_ctcp_#{type.downcase}".to_sym
+    send(method, target, mesg) if respond_to? method, true
+  end
+
+  def on_ctcp_action(target, mesg)
+    #return unless main_channel.casecmp(target).zero?
+    command, *args = mesg.split(" ")
+    if command
+      command.downcase!
+
+      @@ctcp_action_commands.each do |define, name|
+        if define === command
+          send(name, target, mesg, Regexp.last_match || command, args)
+          break
+        end
+      end
+    else
+      commands = @@ctcp_action_commands.map {|define, name|
+        define
+      }.select {|define|
+        define.is_a? String
+      }
+
+      log "[tig.rb] CTCP ACTION COMMANDS:"
+      commands.each_slice(5) do |c|
+        log c.join(" ")
+      end
+    end
+
+  rescue APIFailed => e
+    log e.inspect
+  rescue Exception => e
+    log e.inspect
+    e.backtrace.each do |l|
+      @log.error "\t#{l}"
+    end
+  end
+
+  def include_ngword?(msg)
+    msg = msg.dup.encoding!("UTF-8")
+    if config['ngword'] && config['ngword'].size > 0
+      msg =~ /#{config['ngword'].map {|i| Regexp.quote(i) }.join('|')}/
+    else
+      false
+    end
+  end
+
+  ctcp_action "oauth" do |target, mesg, command, args|
+    if args.length == 1
+      pin = args.first
+      begin
+        access_token = @request_token.get_access_token(
+          :oauth_verifier => pin
+        )
+        config {
+          self['access_token'] = access_token.token
+          self['access_token_secret'] = access_token.secret
+        }
+        log "Congrats! OAuth Verified: #{access_token.params[:screen_name]}"
+        @access_token = access_token
+        on_authorized
+      rescue OAuth::Unauthorized
+        log "Invalid PIN was input. Please retry"
+        oauth_request
+      end
+    else
+      oauth_request
+    end
+  end
+
+  ctcp_action "ngword" do |target, mesg, command, args|
+    meth, word = *args
+    case meth
+    when 'add'
+      config {
+        (self['ngword'] ||= []) << word
+      }
+    when 'del'
+      config {
+        (self['ngword'] ||= []).reject! {|w| w == word }
+      }
+    when 'inc?'
+      if word =~ /#{(config['ngword'] || []).map {|i| Regexp.quote(i) }.join('|')}/
+        log "#{word} is included"
+      else
+        log "#{word} is not included"
+      end
+    end
+  end
+
+  ctcp_action "tl_method" do |target, mesg, command, args|
+    @opts.chirp = !@opts.chirp
+    log "Changed Timeline retrieving method: Using ChripUserStream: #{@opts.chirp}"
+    start_timeline_thread(@opts.chirp)
+  end
+
+  ctcp_action "reload" do |target, mesg, command, args|
+    load File.expand_path(__FILE__)
+    current = server_version
+    @server_version = nil
+    log "Reloaded tig.rb. New: #{server_version} <- Old: #{current}"
+    initial_message
+  end
+
+  ctcp_action "call" do |target, mesg, command, args|
+    if args.size < 2
+      log "/me call <Twitter_screen_name> as <IRC_nickname>"
+      return
+    end
+    screen_name = args[0]
+    nickname    = args[2] || args[1] # allow omitting "as"
+    if nickname == "is" and
+       deleted_nick = @nicknames.delete(screen_name)
+      log %Q{Removed the nickname "#{deleted_nick}" for #{screen_name}}
+    else
+      @nicknames[screen_name] = nickname
+      log "Call #{screen_name} as #{nickname}"
+    end
+  end
+
+  ctcp_action "debug" do |target, mesg, command, args|
+    code = args.join(" ")
+    begin
+      log instance_eval(code).inspect
+    rescue Exception => e
+      log e.inspect
+    end
+  end
+
+  ctcp_action "utf-7", "utf7" do |target, mesg, command, args|
+    unless defined? ::Iconv
+      log "Can't load iconv."
+      return
+    end
+    @utf7 = !@utf7
+    log "UTF-7 mode: #{@utf7 ? 'on' : 'off'}"
+  end
+
+  ctcp_action "list", "ls" do |target, mesg, command, args|
+    if args.empty?
+      log "/me list <NICK> [<NUM>]"
+      return
+    end
+    nick = args.first
+    if not nick.screen_name? or
+       api("users/username_available", { :username => nick }).valid
+      post server_name, ERR_NOSUCHNICK, nick, "No such nick/channel"
+      return
+    end
+    id           = nick
+    authenticate = false
+    if user = friend(nick)
+      id           = user.id
+      nick         = user.screen_name
+      authenticate = user.protected
+    end
+    unless (1..200).include?(count = args[1].to_i)
+      count = 20
+    end
+    begin
+      res = api("statuses/user_timeline/#{id}",
+            { :count => count }, { :authenticate => authenticate })
+    rescue APIFailed
+      #log "#{nick} has protected their updates."
+      return
+    end
+    res.reverse_each do |s|
+      message(s, target, nil, nil, NOTICE)
+    end
+  end
+
+  ctcp_action %r/\A(un)?fav(?:ou?rite)?(!)?\z/ do |target, mesg, command, args|
+    # fav, unfav, favorite, unfavorite, favourite, unfavourite
+    method   = command[1].nil? ? "create" : "destroy"
+    force    = !!command[2]
+    entered  = command[0].capitalize
+    statuses = []
+    if args.empty?
+      if method == "create"
+        if status = @timeline.last
+          statuses << status
+        else
+          #log ""
+          return
+        end
+      else
+        @favorites ||= api("favorites").reverse
+        if @favorites.empty?
+          log "You've never favorite yet. No favorites to unfavorite."
+          return
+        end
+        statuses.push @favorites.last
+      end
+    else
+      args.each do |tid_or_nick|
+        case
+        when status = @timeline[tid = tid_or_nick]
+          statuses.push status
+        when friend = friend(nick = tid_or_nick)
+          if friend.status
+            statuses.push friend.status
+          else
+            log "#{tid_or_nick} has no status."
+          end
+        else
+          # PRIVMSG: fav nick
+          log "No such ID/NICK #{@opts.tid % tid_or_nick}"
+        end
+      end
+    end
+    @favorites ||= []
+    statuses.each do |s|
+      if not force and method == "create" and
+         @favorites.find {|i| i.id == s.id }
+        log "The status is already favorited! <#{permalink(s)}>"
+        next
+      end
+      res = api("favorites/#{method}", { :id => s.id })
+      log "#{entered}: #{res.user.screen_name}: #{generate_status_message(res.text)}"
+      if method == "create"
+        @favorites.push res
+      else
+        @favorites.delete_if {|i| i.id == res.id }
+      end
+    end
+  end
+
+  ctcp_action "link", "ln", /\Au(?:rl)?\z/ do |target, mesg, command, args|
+    args.each do |tid|
+      if status = @timeline[tid]
+        log "#{@opts.tid % tid}: #{permalink(status)}"
+      else
+        log "No such ID #{@opts.tid % tid}"
+      end
+    end
+  end
+
+  ctcp_action "ratio", "ratios" do |target, mesg, command, args|
+    log "Intervals: #{@ratelimit.inspect}"
+  end
+
+  ctcp_action "rm", %r/\A(?:de(?:stroy|l(?:ete)?)|miss|oops|r(?:emove|m))\z/ do |target, mesg, command, args|
+  # destroy, delete, del, remove, rm, miss, oops
+    statuses = []
+    if args.empty? and @me.status
+      statuses.push @me.status
+    else
+      args.each do |tid|
+        if status = @timeline[tid]
+          if status.user.id == @me.id
+            statuses.push status
+          else
+            log "The status you specified by the ID #{@opts.tid % tid} is not yours."
+          end
+        else
+          log "No such ID #{@opts.tid % tid}"
+        end
+      end
+    end
+    b = false
+    statuses.each do |st|
+      res = api("statuses/destroy/#{st.id}")
+      @timeline.delete_if {|tid, s| s.id == res.id }
+      b = @me.status && @me.status.id == res.id
+      log "Destroyed: #{res.text}"
+    end
+    Thread.start do
+      sleep 2
+      @me = api("account/update_profile") #api("account/verify_credentials")
+      if @me.status
+        @me.status.user = @me
+        msg = generate_status_message(@me.status.text)
+        @timeline.any? do |tid, s|
+          if s.id == @me.status.id
+            msg << " " << @opts.tid % tid
+          end
+        end
+        post @prefix, TOPIC, main_channel, msg
+      end
+    end if b
+  end
+
+  ctcp_action "name" do |target, mesg, command, args|
+    name = mesg.split(" ", 2)[1]
+    unless name.nil?
+      @me = api("account/update_profile", { :name => name })
+      @me.status.user = @me if @me.status
+      log "You are named #{@me.name}."
+    end
+  end
+
+  ctcp_action "email" do |target, mesg, command, args|
+    # FIXME
+    email = args.first
+    unless email.nil?
+      @me = api("account/update_profile", { :email => email })
+      @me.status.user = @me if @me.status
+    end
+  end
+
+  ctcp_action "url" do |target, mesg, command, args|
+    # FIXME
+    url = args.first || ""
+    @me = api("account/update_profile", { :url => url })
+    @me.status.user = @me if @me.status
+  end
+
+  ctcp_action "in", "location" do |target, mesg, command, args|
+    location = mesg.split(" ", 2)[1] || ""
+    @me = api("account/update_profile", { :location => location })
+    @me.status.user = @me if @me.status
+    location = (@me.location and @me.location.empty?) ? "nowhere" : "in #{@me.location}"
+    log "You are #{location} now."
+  end
+
+  ctcp_action %r/\Adesc(?:ription)?\z/ do |target, mesg, command, args|
+    # FIXME
+    description = mesg.split(" ", 2)[1] || ""
+    @me = api("account/update_profile", { :description => description })
+    @me.status.user = @me if @me.status
+  end
+
+  ctcp_action %r/\A(?:mention|re(?:ply)?)\z/ do |target, mesg, command, args|
+    # reply, re, mention
+    tid = args.first
+    if status = @timeline[tid]
+      text = mesg.split(" ", 3)[2]
+      screen_name = "@#{status.user.screen_name}"
+      if text.nil? or not text.include?(screen_name)
+        text = "#{screen_name} #{text}"
+      end
+      ret = api("statuses/update", {
+        :status => text,
+        :source => source,
+        :in_reply_to_status_id => status.id
+      })
+      log oops(ret) if ret.truncated
+      msg = generate_status_message(status.text)
+      url = permalink(status)
+      log "Status updated (In reply to #{@opts.tid % tid}: #{msg} <#{url}>)"
+      ret.user.status = ret
+      @me = ret.user
+    end
+  end
+
+  ctcp_action %r/\Aspoo(o+)?f\z/ do |target, mesg, command, args|
+    if args.empty?
+      Thread.start do
+        update_sources(command[1].nil?? 0 : command[1].size)
+      end
+      return
+    end
+    names = []
+    @sources = args.map do |arg|
+      names << "=#{arg}"
+      case arg.upcase
+      when "WEB" then ""
+      when "API" then nil
+      else            arg
+      end
+    end
+    log(names.inject([]) do |r, name|
+      s = r.join(", ")
+      if s.size < 400
+        r << name
+      else
+        log s
+        [name]
+      end
+    end.join(", "))
+  end
+
+  ctcp_action "bot", "drone" do |target, mesg, command, args|
+    if args.empty?
+      log "/me bot <NICK> [<NICK>...]"
+      return
+    end
+    args.each do |bot|
+      user = friend(bot)
+      unless user
+        post server_name, ERR_NOSUCHNICK, bot, "No such nick/channel"
+        next
+      end
+      if @drones.delete(user.id)
+        mode = "-#{mode}"
+        log "#{bot} is no longer a bot."
+      else
+        @drones << user.id
+        mode = "+#{mode}"
+        log "Marks #{bot} as a bot."
+      end
+    end
+  end
+
+  ctcp_action "home", "h" do |target, mesg, command, args|
+    if args.empty?
+      log "/me home <NICK>"
+      return
+    end
+    nick = args.first
+    if not nick.screen_name? or
+       api("users/username_available", { :username => nick }).valid
+      post server_name, ERR_NOSUCHNICK, nick, "No such nick/channel"
+      return
+    end
+    log "http://twitter.com/#{nick}"
+  end
+
+  ctcp_action "retweet", "rt" do |target, mesg, command, args|
+    if args.empty?
+      log "/me #{command} <ID> blah blah"
+      return
+    end
+    tid = args.first
+    if status = @timeline[tid]
+      if args.size >= 2
+        comment = mesg.split(" ", 3)[2] + " "
+      else
+        comment = ""
+      end
+      screen_name = "@#{status.user.screen_name}"
+      rt_message = generate_status_message(status.text)
+      text = "#{comment}RT #{screen_name}: #{rt_message}"
+      ret = api("statuses/update", { :status => text, :source => source })
+      log oops(ret) if ret.truncated
+      log "Status updated (RT to #{@opts.tid % tid}: #{text})"
+      ret.user.status = ret
+      @me = ret.user
+    end
+  end
+
+  ctcp_action "o_retweet", "ort" do |target, mesg, command, args|
+    if args.empty?
+      log "/me #{command} <ID>"
+      return
+    end
+    tid = args.first
+    if status = @timeline[tid]
+      ret = api("statuses/retweet/#{status.id}",{ :source => source })
+      log oops(ret) if ret.truncated
+      log "Status updated (RT to #{@opts.tid % tid}: #{status.text})"
+      ret.user.status = ret
+      @me = ret.user
+    end
+  end
+
+
+  ctcp_action "spam" do |target, mesg, command, args|
+    if args.empty?
+      log "/me spam <NICK>|<ID>"
+      return
+    end
+    nick_or_tid = args.first
+    if status = @timeline[nick_or_tid]
+      screen_name = status.user.screen_name
+    else
+      if not nick.screen_name? or
+         api("users/username_available", { :username => nick }).valid
+        post server_name, ERR_NOSUCHNICK, nick, "No such nick"
+        return
+      end
+      screen_name = nick_or_tid
+    end
+    api("report_spam", { :screen_name => screen_name })
+    log "reported user \"#{screen_name}\" as spammer"
+  end
+
+  def on_ctcp_clientinfo(target, msg)
+    if user = user(target)
+      post prefix(user), NOTICE, @nick, ctcp_encode("CLIENTINFO :CLIENTINFO USERINFO VERSION TIME")
+    end
+  end
+
+  def on_ctcp_userinfo(target, msg)
+    user = user(target)
+    if user and not user.description.empty?
+      post prefix(user), NOTICE, @nick, ctcp_encode("USERINFO :#{user.description}")
+    end
+  end
+
+  def on_ctcp_version(target, msg)
+    user = user(target)
+    if user and user.status
+      source = user.status.source
+      version = source.gsub(/<[^>]*>/, "").strip
+      version << " <#{$1}>" if / href="([^"]+)/ === source
+      post prefix(user), NOTICE, @nick, ctcp_encode("VERSION :#{version}")
+    end
+  end
+
+  def on_ctcp_time(target, msg)
+    if user = user(target)
+      offset = user.utc_offset
+      post prefix(user), NOTICE, @nick, ctcp_encode("TIME :%s%s (%s)" % [
+        (Time.now + offset).utc.iso8601[0, 19],
+        "%+.2d:%.2d" % (offset/60).divmod(60),
+        user.time_zone,
+      ])
+    end
+  end
+
+  def check_lists
+    updated = false
+    until @friends
+      @log.debug "waiting retrieving friends..."
+      sleep 1
+    end
+
+    lists = page("1/#{@me.screen_name}/lists", :lists, true)
+
+    # expend lists.size API count
+    channels = {}
+    lists.each do |list|
+      begin
+        name = (list.user.screen_name == @me.screen_name) ?
+             "##{list.slug}" : 
+             "##{list.user.screen_name}^#{list.slug}"
+        members = page("1/#{@me.screen_name}/#{list.slug}/members", :users, true)
+        @log.debug "Miss match member_count '%s', lists:%d vs members:%s" % [ list.slug, list.member_count, members.size ] unless list.member_count == members.size
+        if list.member_count - members.size > 10
+          @log.debug "Miss match count is over 10. skip this list: #{list.slug}"
+          next
+        end
+
+        channel = {
+          :name      => name,
+          :list      => list,
+          :members   => members,
+          :inclusion => (members - @friends).empty?
+        }
+
+        new = channel[:members]
+        old = @channels.fetch(channel[:name], { :members => [] })[:members]
+
+        # deleted user
+        (old - new).each do|user|
+          post prefix(user), PART, name, "Removed: #{user.screen_name}"
+          updated = true
+        end
+
+        # new user
+        joined = join(name, new - old)
+        updated = true unless joined.empty?
+
+        channels[name] = channel
+      rescue APIFailed => e
+        log e.inspect
+      end
+    end
+
+    # unfollowed
+    (@channels.keys - channels.keys).each do |name|
+      post @prefix, PART, name, "No longer follow the list #{name}"
+      updated = true
+    end
+
+    # followed
+    (channels.keys - @channels.keys).each do |name|
+      post @prefix, JOIN, name
+      post server_name, MODE, name, "+mtio", @nick
+      post server_name, MODE, name, "+q", @nick
+      updated = true
+    end
+
+    @channels = channels
+    updated
+  end
+
+  def check_lists_status
+    friends = @friends || []
+    @channels.each do |name, channel|
+      # タイムラインに全員含まれているならとってこなくてもよいが
+      # そうでなければ個別にとってくる必要がある。
+      next if channel[:inclusion]
+
+      list = channel[:list]
+      @log.debug "retrieve #{name} statuses"
+      res = api("1/#{list.user.screen_name}/lists/#{list.id}/statuses", {
+        :since_id => channel[:last_id]
+      })
+      res.reverse_each do |s|
+        next if channel[:members].include? s.user
+        command = (s.user.id == @me.id) ?  NOTICE : PRIVMSG
+        command = channel[:last_id]     ? command : NOTICE
+        # TODO tid
+        message(s, name, nil, nil, command)
+      end
+      channel[:last_id] = res.first.id if res.first
+    end
+  end
+
+  def check_friends
+    @follower_ids = page("followers/ids/#{@me.id}", :ids)
+
+    if @friends.nil?
+      @friends = page("statuses/friends/#{@me.id}", :users)
+      if @opts.athack
+        join main_channel, @friends
+      else
+        rest = @friends.map do |i|
+          prefix = "+" #@drones.include?(i.id) ? "%" : "+" # FIXME ~&%
+          "#{prefix}#{i.screen_name}"
+        end.reverse.inject("~#{@nick}") do |r, nick|
+          if r.size < 400
+            r << " " << nick
+          else
+            post server_name, RPL_NAMREPLY, @nick, "=", main_channel, r
+            nick
+          end
+        end
+        post server_name, RPL_NAMREPLY, @nick, "=", main_channel, rest
+        post server_name, RPL_ENDOFNAMES, @nick, main_channel, "End of NAMES list"
+      end
+    else
+      @me = api("account/update_profile") #api("account/verify_credentials")
+      if @me.friends_count != @friends.size
+        new_ids    = page("friends/ids/#{@me.id}", :ids)
+        friend_ids = @friends.reverse.map {|friend| friend.id }
+
+        (friend_ids - new_ids).each do |id|
+          @friends.delete_if do |friend|
+            if friend.id == id
+              post prefix(friend), PART, main_channel, ""
+            end
+          end
+        end
+
+        new_ids -= friend_ids
+        unless new_ids.empty?
+          new_friends = page("statuses/friends/#{@me.id}", :users)
+          join main_channel, new_friends.delete_if {|friend|
+            @friends.any? {|i| i.id == friend.id }
+          }.reverse
+          @friends.concat new_friends
+        end
+      end
+    end
+  end
+
+  def check_timeline
+    updated = false
+
+    cmd  = PRIVMSG
+    path = "statuses/#{@opts.with_retweets ? "home" : "friends"}_timeline"
+    q    = { :count => 200 }
+    @latest_id ||= nil
+
+    case
+    when @latest_id
+      q.update(:since_id => @latest_id)
+    when is_first_retrieve = !@me.statuses_count.zero? && !@me.friends_count.zero?
+    #  cmd = NOTICE # デバッグするときめんどくさいので
+      q.update(:count => 20)
+    end
+
+    api(path, q).reverse_each do |status|
+      id = @latest_id = status.id
+      next if @timeline.any? {|tid, s| s.id == id }
+
+      user = status.user
+      tid  = @timeline.push(status)
+      tid  = nil unless @opts.tid
+
+      @log.debug [id, user.screen_name, status.text].inspect
+
+      if user.id == @me.id
+        mesg = generate_status_message(status.text)
+        mesg << " " << @opts.tid % tid if tid
+        post @prefix, TOPIC, main_channel, mesg
+
+        @me = user
+      else
+        if @friends
+          @friends.each_with_index do |friend, i|
+            if friend.id == user.id
+              if friend.screen_name != user.screen_name
+                post prefix(friend), NICK, user.screen_name
+              end
+              @friends[i] = user
+              break
+            end
+          end
+        end
+
+        message(status, main_channel, tid, nil, cmd)
+      end
+      @channels.each do |name, channel|
+        if channel[:members].find{|m| m.screen_name == user.screen_name }
+          message(status, name, tid, nil, (user.id == @me.id) ? NOTICE : cmd)
+        end
+      end
+      updated = true
+    end
+
+    updated
+  end
+
+  def check_direct_messages
+    updated = false
+    @prev_dm_id ||= nil
+    q = @prev_dm_id ? { :count => 200, :since_id => @prev_dm_id } \
+                    : { :count => 1 }
+    api("direct_messages", q).reverse_each do |mesg|
+      unless @prev_dm_id &&= mesg.id
+        @prev_dm_id = mesg.id
+        next
+      end
+
+      id   = mesg.id
+      user = mesg.sender
+      tid  = nil
+      text = mesg.text
+      @log.debug [id, user.screen_name, text].inspect
+      message(user, @nick, tid, text)
+      updated = true
+    end
+    updated
+  end
+
+  def check_mentions
+    updated = false
+
+    return if @timeline.empty?
+    @prev_mention_id ||= @timeline.last.id
+    api("statuses/mentions", {
+      :count    => 200,
+      :since_id => @prev_mention_id
+    }).reverse_each do |mention|
+      id = @prev_mention_id = mention.id
+      next if @timeline.any? {|tid, s| s.id == id }
+
+      mention.user.status = mention
+      user = mention.user
+      tid  = @timeline.push(mention)
+      tid  = nil unless @opts.tid
+
+      @log.debug [id, user.screen_name, mention.text].inspect
+      message(mention, main_channel, tid)
+
+      @friends.each_with_index do |friend, i|
+        if friend.id == user.id
+          @friends[i] = user
+          break
+        end
+      end if @friends
+      updated = true
+    end
+    updated
+  end
+
+  def check_updates
+    uri = URI("https://api.github.com/repos/cho45/net-irc/commits/master")
+    @log.debug uri.inspect
+    res = http(uri).request(http_req(:get, uri))
+
+    latest = JSON.parse(res.body)['sha']
+
+    raise "github API changed?" unless latest
+
+    is_in_local_repos = system("git rev-parse --verify #{latest} > /dev/null 2>&1")
+    unless is_in_local_repos
+      log "\002New version is available.\017 run 'git pull'."
+    end
+  rescue Errno::ECONNREFUSED, Timeout::Error => e
+    @log.error "Failed to get the latest revision of tig.rb from #{uri.host}: #{e.inspect}"
+  end
+
+  def join(channel, users)
+    params = []
+    users.each do |user|
+      prefix = prefix(user)
+      post prefix, JOIN, channel
+      case
+      when user.protected
+        params << ["v", prefix.nick]
+      when ! @follower_ids.include?(user.id)
+        params << ["o", prefix.nick]
+      end
+      next if params.size < MAX_MODE_PARAMS
+
+      post server_name, MODE, channel, "+#{params.map {|m,_| m }.join}", *params.map {|_,n| n}
+      params = []
+    end
+    post server_name, MODE, channel, "+#{params.map {|m,_| m }.join}", *params.map {|_,n| n} unless params.empty?
+    users
+  end
+
+  def require_post?(path, query)
+    case path.sub(/\.json$/, '')
+    when %r{
+      \A/
+      (?: 1/ | 1\.1/ )?
+      (?: status(?:es)?/update \z
+        | direct_messages/new \z
+        | friendships/create/
+        | account/(?: end_session \z | update_ )
+        | favou?ri(?: ing | tes )/create
+        | notifications/
+                          | statuses/retweet/
+        | blocks/create/
+        | report_spam )
+    }x
+      true
+    when %r{
+      \A/
+      (?: 1(\.1)?/#{@me.screen_name} )
+    }x
+      query.key? 'name' or query.key? '_method' or query.key? 'id'
+    end
+  end
+
+  #def require_put?(path)
+  #  %r{ \A status(?:es)?/retweet (?:/|\z) }x === path
+  #end
+
+  def api(path, query = {}, opts = {})
+    path.sub!(%r{\A/+}, "")
+
+    authenticate = opts.fetch(:authenticate, true)
+
+    path  = '/1.1/' + path
+    path += ".json" if path != "users/username_available"
+
+    header      = {}
+    credentials = authenticate ? [@real, @pass] : nil
+
+    ret = nil
+    begin
+      case
+        when path.include?("/destroy/")
+          path += '?' + query.to_query_str unless query.empty?
+          @log.debug [:delete, path]
+          ret = @access_token.delete(path, header)
+        when require_post?(path, query)
+          @log.debug [:post, path]
+          ret = @access_token.post(path, query, header)
+        else
+          path += '?' + query.to_query_str unless query.empty?
+          @log.debug [:get, path]
+          ret = @access_token.get(path, header)
+      end
+    rescue OpenSSL::SSL::SSLError => e
+      @log.error e.inspect
+      log "Fatal SSL error was happened #{e.inspect}"
+      raise e.inspect
+    end
+
+    #@etags[uri.to_s] = ret["ETag"]
+
+    case
+    when authenticate
+      hourly_limit = ret["X-RateLimit-Limit"].to_i
+      unless hourly_limit.zero?
+        if @limit != hourly_limit
+          msg = "The rate limit per hour was changed: #{@limit} to #{hourly_limit}"
+          @log.info msg
+          @limit = hourly_limit
+        end
+
+        #if req.is_a?(Net::HTTP::Get) and not %w{
+        if not %w{
+          statuses/friends_timeline
+          direct_messages
+          statuses/mentions
+        }.include?(path) and not ret.is_a?(Net::HTTPServerError)
+          expired_on = Time.parse(ret["Date"]) rescue Time.now
+          expired_on += 3636 # 1.01 hours in seconds later
+          @consums << expired_on
+        end
+      end
+    when ret["X-RateLimit-Remaining"]
+      @limit_remaining_for_ip = ret["X-RateLimit-Remaining"].to_i
+      @log.debug "IP based limit: #{@limit_remaining_for_ip}"
+    end
+
+    case ret
+    when Net::HTTPOK # 200
+      # Avoid Twitter's invalid JSON
+      json = ret.body.strip.sub(/\A(?:false|true)\z/, "[\\&]")
+
+      res = JSON.parse(json)
+      if res.is_a?(Hash) && res["error"] # and not res["response"]
+        if @error != res["error"]
+          @error = res["error"]
+          log @error
+        end
+        raise APIFailed, res["error"]
+      end
+
+      TwitterStruct.make(res)
+    when Net::HTTPNoContent,  # 204
+         Net::HTTPNotModified # 304
+      []
+    when Net::HTTPBadRequest # 400: exceeded the rate limitation
+      if ret.key?("X-RateLimit-Reset")
+        s = ret["X-RateLimit-Reset"].to_i - Time.now.to_i
+        if s > 0
+          log "RateLimit: #{(s / 60.0).ceil} min remaining to get timeline"
+          sleep (s > 60 * 10) ? 60 * 10 : s # 10 分に一回はとってくるように
+        end
+      end
+      raise APIFailed, "#{ret.code}: #{ret.message}"
+    when Net::HTTPUnauthorized # 401
+      raise APIFailed, "#{ret.code}: #{ret.message}"
+    else
+      raise APIFailed, "Server Returned #{ret.code} #{ret.message}"
+    end
+  rescue Errno::ETIMEDOUT, JSON::ParserError, IOError, Timeout::Error, Errno::ECONNRESET => e
+    raise APIFailed, e.inspect
+  end
+
+  def page(path, name, authenticate = false, &block)
+    @limit_remaining_for_ip ||= 52
+    limit = 0.98 * @limit_remaining_for_ip # 98% of IP based rate limit
+    r     = []
+    cursor = -1
+    1.upto(limit) do |num|
+      # next_cursor にアクセスするとNot found が返ってくることがあるので，その時はbreak
+      ret = api(path, { :cursor => cursor }, { :authenticate => authenticate }) rescue break
+      arr = ret[name.to_s]
+      r.concat arr
+      cursor = ret[:next_cursor]
+      break if cursor.zero?
+    end
+    r
+  end
+
+  def generate_status_message(mesg)
+    mesg = decode_utf7(mesg)
+    mesg.delete!("\000\001")
+    mesg.gsub!("&gt;", ">")
+    mesg.gsub!("&lt;", "<")
+    mesg.gsub!(WSP_REGEX, " ")
+    mesg = untinyurl(mesg)
+    mesg.sub!(@rsuffix_regex, "") if @rsuffix_regex
+    mesg.strip
+  end
+
+  def friend(id)
+    return nil unless @friends
+    if id.is_a? String
+      @friends.find {|i| i.screen_name.casecmp(id).zero? }
+    else
+      @friends.find {|i| i.id == id }
+    end
+  end
+
+  def user(id)
+    if id.is_a? String
+      @nick.casecmp(id).zero? ? @me : friend(id)
+    else
+      @me.id == id ? @me : friend(id)
+    end
+  end
+
+  def prefix(u)
+    nick = u.screen_name
+    nick = "@#{nick}" if @opts.athack
+    user = "id=%.9d" % u.id
+    host = api_base.host
+    host += "/protected" if u.protected
+    host += "/bot"       if @drones.include?(u.id)
+
+    Prefix.new("#{nick}!#{user}@#{host}")
+  end
+
+  def message(struct, target, tid = nil, str = nil, command = PRIVMSG)
+    unless str
+      status = struct.status || struct
+      str = status.text
+                        str  = "\00310♺ \017" + str if status.retweeted_status
+      if command != PRIVMSG
+        time = Time.parse(status.created_at) rescue Time.now
+        str  = "#{time.strftime(@opts.strftime || "%m-%d %H:%M")} #{str}" # TODO: color
+      end
+    end
+    user        = struct.user || (struct.source && struct.source.screen_name && struct.source)|| struct
+    screen_name = user.screen_name
+
+    user.screen_name = @nicknames[screen_name] || screen_name
+    prefix = prefix(user)
+    str    = generate_status_message(str)
+    str    = "#{str} #{@opts.tid % tid}" if tid
+
+    post prefix, command, target, str
+  end
+
+  def log(str)
+    post server_name, NOTICE, main_channel, str.gsub(/\r\n|[\r\n]/, " ")
+  end
+
+  def decode_utf7(str)
+    return str unless defined? ::Iconv and str.include?("+")
+
+    str.sub!(/\A(?:.+ > |.+\z)/) { Iconv.iconv("UTF-8", "UTF-7", $&).join }
+    #FIXME str = "[utf7]: #{str}" if str =~ /[^a-z0-9\s]/i
+    str
+  rescue Iconv::IllegalSequence
+    str
+  rescue => e
+    @log.error e
+    str
+  end
+
+  def untinyurl(text)
+    text.gsub(@opts.untiny_whole_urls ? URI.regexp(%w[http https]) : %r{
+      http:// (?:
+        (?: bit\.ly | (?: tin | rub) yurl\.com | j\.mp
+          | is\.gd | cli\.gs | tr\.im | u\.nu | airme\.us
+          | ff\.im | twurl.nl | bkite\.com | tumblr\.com
+          | pic\.gd | sn\.im | digg\.com | t\.co)
+        / [0-9a-z=-]+ |
+        blip\.fm/~ (?> [0-9a-z]+) (?! /) |
+        flic\.kr/[a-z0-9/]+
+      )
+    }ix) {|url|
+      expanded = resolve_http_redirect(URI(url))
+      if %w|http https|.include? expanded.scheme 
+        expanded.to_s
+      else
+        "#{expanded.scheme}: #{url}"
+      end
+    }
+  end
+
+  def bitlify(text)
+    login, key, len = @opts.bitlify.split(":", 3) if @opts.bitlify
+    len      = (len || 20).to_i
+    longurls = URI.extract(text, %w[http https]).uniq.map do |url|
+      URI.rstrip url
+    end.reject do |url|
+      url.size < len || url =~ %r{http://(?:bit\.ly)}
+    end
+    return text if longurls.empty?
+
+    bitly = URI("http://api.bit.ly/v3/shorten")
+    if login and key
+      bitly.query = {
+        :format => "json", :longUrl => longurls,
+      }.to_query_str(";")
+      @log.debug bitly
+      req = http_req(:get, bitly, {}, [login, key])
+      res = http(bitly, 5, 10).request(req)
+      res = JSON.parse(res.body)
+      res = res["results"]
+
+      longurls.each do |longurl|
+        text.gsub!(longurl) do
+          res[$&] && res[$&]["shortUrl"] || $&
+        end
+      end
+    end
+
+    text
+  rescue => e
+    @log.error e
+    text
+  end
+
+  def unuify(text)
+    unu_url = "http://u.nu/"
+    unu     = URI("#{unu_url}unu-api-simple")
+    size    = unu_url.size
+
+    text.gsub(URI.regexp(%w[http https])) do |url|
+      url = URI.rstrip url
+      if url.size < size + 5 or url[0, size] == unu_url
+        return url
+      end
+
+      unu.query = { :url => url }.to_query_str
+      @log.debug unu
+
+      res = http(unu, 5, 5).request(http_req(:get, unu)).body
+
+      if res[0, 12] == unu_url
+        res
+      else
+        raise res.split("|")
+      end
+    end
+  rescue => e
+    @log.error e
+    text
+  end
+
+  def escape_http_urls(text)
+    original_text = text.encoding!("UTF-8").dup
+
+    if defined? ::Punycode
+      # TODO: Nameprep
+      text.gsub!(%r{(https?://)([^\x00-\x2C\x2F\x3A-\x40\x5B-\x60\x7B-\x7F]+)}) do
+        domain = $2
+        # Dots:
+        #   * U+002E (full stop)           * U+3002 (ideographic full stop)
+        #   * U+FF0E (fullwidth full stop) * U+FF61 (halfwidth ideographic full stop)
+        # => /[.\u3002\uFF0E\uFF61] # Ruby 1.9 /x
+        $1 + domain.split(/\.|\343\200\202|\357\274\216|\357\275\241/).map do |label|
+          break [domain] if /\A-|[\x00-\x2C\x2E\x2F\x3A-\x40\x5B-\x60\x7B-\x7F]|-\z/ === label
+          next label unless /[^-A-Za-z0-9]/ === label
+          punycode = Punycode.encode(label)
+          break [domain] if punycode.size > 59
+          "xn--#{punycode}"
+        end.join(".")
+      end
+      if text != original_text
+        log "Punycode encoded: #{text}"
+        original_text = text.dup
+      end
+    end
+
+    urls = []
+    text.split(/[\s<>]+/).each do |str|
+      next if /%[0-9A-Fa-f]{2}/ === str
+      # URI::UNSAFE + "#"
+      escaped_str = URI.escape(str, %r{[^-_.!~*'()a-zA-Z0-9;/?:@&=+$,\[\]#]})
+      URI.extract(escaped_str, %w[http https]).each do |url|
+        uri = URI(URI.rstrip(url))
+        if not urls.include?(uri.to_s) and exist_uri?(uri)
+          urls << uri.to_s
+        end
+      end if escaped_str != str
+    end
+    urls.each do |url|
+      unescaped_url = URI.unescape(url).encoding!("UTF-8")
+      text.gsub!(unescaped_url, url)
+    end
+    log "Percent encoded: #{text}" if text != original_text
+
+    text.encoding!("ASCII-8BIT")
+  rescue => e
+    @log.error e
+    text
+  end
+
+  def exist_uri?(uri, limit = 1)
+    ret = nil
+    #raise "Not supported." unless uri.is_a?(URI::HTTP)
+    return ret if limit.zero? or uri.nil? or not uri.is_a?(URI::HTTP)
+    @log.debug uri.inspect
+
+    req = http_req :head, uri
+    http(uri, 3, 2).request(req) do |res|
+      ret = case res
+        when Net::HTTPSuccess
+          true
+        when Net::HTTPRedirection
+          uri = resolve_http_redirect(uri)
+          exist_uri?(uri, limit - 1)
+        when Net::HTTPClientError
+          false
+        #when Net::HTTPServerError
+        #  nil
+        else
+          nil
+      end
+    end
+
+    ret
+  rescue => e
+    @log.error e.inspect
+    ret
+  end
+
+  def resolve_http_redirect(uri, limit = 3)
+    return uri if limit.zero? or uri.nil?
+    @log.debug uri.inspect
+
+    req = http_req :head, uri
+    http(uri, 3, 2).request(req) do |res|
+      break if not res.is_a?(Net::HTTPRedirection) or
+               not res.key?("Location")
+      begin
+        location = URI(res["Location"])
+      rescue URI::InvalidURIError
+      end
+      unless location.is_a? URI::HTTP
+        begin
+          location = URI.join(uri.to_s, res["Location"])
+        rescue URI::InvalidURIError, URI::BadURIError
+          # FIXME
+        end
+      end
+      uri = resolve_http_redirect(location, limit - 1)
+    end
+
+    uri
+  rescue => e
+    @log.error e.inspect
+    uri
+  end
+
+  def update_sources(n = 0)
+    if @sources and @sources.size > 1 and n.zero?
+      log "tig.rb"
+      @sources = [api_source]
+      return @sources
+    end
+
+    uri = URI("http://wedata.net/databases/TwitterSources/items.json")
+    @log.debug uri.inspect
+    json    = http(uri).request(http_req(:get, uri)).body
+    sources = JSON.parse json
+    sources.map! {|item| [item["data"]["source"], item["name"]] }
+    sources.push ["", "web"]
+    sources.push [nil, "API"]
+
+    sources = Array.new(n) do
+      sources.delete_at(rand(sources.size))
+    end if (1 ... sources.size).include?(n)
+
+    log(sources.inject([]) do |r, src|
+      s = r.join(", ")
+      if s.size < 400
+        r << src[1]
+      else
+        log s
+        [src[1]]
+      end
+    end.join(", ")) if @sources
+
+    @sources = sources.map {|src| src[0] }
+  rescue => e
+    @log.error e.inspect
+    log "An error occured while loading #{uri.host}."
+    @sources ||= [api_source]
+  end
+
+  def update_redundant_suffix
+    uri = URI("http://svn.coderepos.org/share/platform/twitterircgateway/suffixesblacklist.txt")
+    @log.debug uri.inspect
+    res = http(uri).request(http_req(:get, uri))
+    @etags[uri.to_s] = res["ETag"]
+    return if res.is_a? Net::HTTPNotModified
+    source = res.body
+    source.encoding!("UTF-8") if source.respond_to?(:encoding) and source.encoding == Encoding::BINARY
+    @rsuffix_regex = /#{Regexp.union(*source.split)}\z/
+  rescue Errno::ECONNREFUSED, Timeout::Error => e
+    @log.error "Failed to get the redundant suffix blacklist from #{uri.host}: #{e.inspect}"
+  end
+
+  def http(uri, open_timeout = nil, read_timeout = 60)
+    http = case
+      when @httpproxy
+        Net::HTTP.new(uri.host, uri.port, @httpproxy.address, @httpproxy.port,
+                                          @httpproxy.user, @httpproxy.password)
+      when ENV["HTTP_PROXY"], ENV["http_proxy"]
+        proxy = URI(ENV["HTTP_PROXY"] || ENV["http_proxy"])
+        Net::HTTP.new(uri.host, uri.port, proxy.host, proxy.port,
+                                          proxy.user, proxy.password)
+      else
+        Net::HTTP.new(uri.host, uri.port)
+    end
+    http.open_timeout = open_timeout if open_timeout # nil by default
+    http.read_timeout = read_timeout if read_timeout # 60 by default
+    if uri.is_a? URI::HTTPS
+      http.use_ssl     = true
+      http.cert_store = @cert_store
+      http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+    end
+    http
+  rescue => e
+    @log.error e
+  end
+
+  def http_req(method, uri, header = {}, credentials = nil)
+    accepts = ["*/*"]
+    #require "mime/types"; accepts.unshift MIME::Types.of(uri.path).first.simplified
+    types   = { "json" => "application/json", "txt" => "text/plain" }
+    ext     = uri.path[/[^.]+\z/]
+    accepts.unshift types[ext] if types.key?(ext)
+    user_agent = "#{self.class}/#{server_version} (#{File.basename(__FILE__)}; net-irc) Ruby/#{RUBY_VERSION} (#{RUBY_PLATFORM})"
+
+    header["User-Agent"]      ||= user_agent
+    header["Accept"]          ||= accepts.join(",")
+    header["Accept-Charset"]  ||= "UTF-8,*;q=0.0" if ext != "json"
+    #header["Accept-Language"] ||= @opts.lang # "en-us,en;q=0.9,ja;q=0.5"
+    header["If-None-Match"]   ||= @etags[uri.to_s] if @etags[uri.to_s]
+
+    req = case method.to_s.downcase.to_sym
+    when :get
+      Net::HTTP::Get.new    uri.request_uri, header
+    when :head
+      Net::HTTP::Head.new   uri.request_uri, header
+    when :post
+      Net::HTTP::Post.new   uri.path,        header
+    when :put
+      Net::HTTP::Put.new    uri.path,        header
+    when :delete
+      Net::HTTP::Delete.new uri.request_uri, header
+    else # raise ""
+    end
+    if req.request_body_permitted?
+      req["Content-Type"] ||= "application/x-www-form-urlencoded"
+      req.body = uri.query
+    end
+    req.basic_auth(*credentials) if credentials
+    req
+  rescue => e
+    @log.error e
+  end
+
+  def oops(status)
+    "Oops! Your update was over 140 characters. We sent the short version" <<
+    " to your friends (they can view the entire update on the Web <" <<
+    permalink(status) << ">)."
+  end
+
+  def permalink(struct)
+    "http://twitter.com/#{struct.user.screen_name}/statuses/#{struct.id}"
+  end
+
+  def source
+    @sources[rand(@sources.size)]
+  end
+
+  def initial_message
+    super
+    post server_name, RPL_ISUPPORT, @nick,
+         "PREFIX=(qaohv)~&@%+", "CHANTYPES=#", "CHANMODES=,,,mnti",
+         "MODES=#{MAX_MODE_PARAMS}", "NICKLEN=15", "TOPICLEN=420", "CHANNELLEN=50",
+         "NETWORK=Twitter",
+         "are supported by this server"
+  end
+
+  class TwitterStruct
+    def self.make(obj)
+      case obj
+      when Hash
+        obj = obj.dup
+        obj.each do |k, v|
+          obj[k] = TwitterStruct.make(v)
+        end
+        TwitterStruct.new(obj)
+      when Array
+        obj.map {|i| TwitterStruct.make(i) }
+      else
+        obj
+      end
+    end
+
+    def initialize(obj)
+      @obj = obj
+    end
+
+    def id
+      @obj["id"]
+    end
+
+    def [](name)
+      @obj[name.to_s]
+    end
+
+    def hash
+      self.id ? self.id.hash : super
+    end
+
+    def eql?(other)
+      self.hash == other.hash
+    end
+
+    def ==(other)
+      self.hash == other.hash
+    end
+
+    def method_missing(sym, *args)
+      # XXX
+      @obj[sym.to_s]
+    end
+  end
+
+  class TypableMap < Hash
+    #Roman = %w[
+    #  k g ky gy s z sh j t d ch n ny h b p hy by py m my y r ry w v q
+    #].unshift("").map do |consonant|
+    #  case consonant
+    #  when "h", "q"  then %w|a i   e o|
+    #  when /[hy]$/   then %w|a   u   o|
+    #  else                %w|a i u e o|
+    #  end.map {|vowel| "#{consonant}#{vowel}" }
+    #end.flatten
+    Roman = %w[
+        a   i   u   e   o  ka  ki  ku  ke  ko  sa shi  su  se  so
+       ta chi tsu  te  to  na  ni  nu  ne  no  ha  hi  fu  he  ho
+       ma  mi  mu  me  mo  ya      yu      yo  ra  ri  ru  re  ro
+       wa              wo   n
+       ga  gi  gu  ge  go  za  ji  zu  ze  zo  da          de  do
+       ba  bi  bu  be  bo  pa  pi  pu  pe  po
+      kya     kyu     kyo sha     shu     sho cha     chu     cho
+      nya     nyu     nyo hya     hyu     hyo mya     myu     myo
+      rya     ryu     ryo
+      gya     gyu     gyo  ja      ju      jo bya     byu     byo
+      pya     pyu     pyo
+    ].freeze
+
+    def initialize(size = nil, shuffle = false)
+      if shuffle
+        @seq = Roman.dup
+        if @seq.respond_to?(:shuffle!)
+          @seq.shuffle!
+        else
+          @seq = Array.new(@seq.size) { @seq.delete_at(rand(@seq.size)) }
+        end
+        @seq.freeze
+      else
+        @seq = Roman
+      end
+      @n    = 0
+      @size = size || @seq.size
+    end
+
+    def generate(n)
+      ret = []
+      begin
+        n, r = n.divmod(@seq.size)
+        ret << @seq[r]
+      end while n > 0
+      ret.reverse.join #.gsub(/n(?=[bmp])/, "m")
+    end
+
+    def push(obj)
+      id = generate(@n)
+      self[id] = obj
+      @n += 1
+      @n %= @size
+      id
+    end
+    alias :<< :push
+
+    def clear
+      @n = 0
+      super
+    end
+
+    def first
+      @size.times do |i|
+        id = generate((@n + i) % @size)
+        return self[id] if key? id
+      end unless empty?
+      nil
+    end
+
+    def last
+      @size.times do |i|
+        id = generate((@n - 1 - i) % @size)
+        return self[id] if key? id
+      end unless empty?
+      nil
+    end
+
+    private :[]=
+  end
+
+  class RateLimit
+    def initialize(limit)
+      @limit = limit
+      @rates = {}
+    end
+
+    def register(name, init_second=60)
+      @rates[name.to_sym] = {
+        :init => init_second.to_f,
+        :rate => init_second.to_f,
+      }
+    end
+
+    def unregister(name)
+      @rates.delete(name)
+    end
+
+    def inspect
+      "#<%s:0x%08x %s>" % [self.class, self.__id__,
+        @rates.keys.map {|name| "#{name}:#{interval(name)}" }.join(' ')
+      ]
+    end
+
+    def interval(name)
+      rate  = (3600.0 / @rates[name][:rate]) / @rates.values.inject(0) {|r,i| r + 3600.0 / i[:rate] }
+      count = @limit * rate
+      (3600 / count).to_i
+    end
+
+    def incr(name)
+      @rates[name][:rate] /= 2
+      @rates[name][:rate]  = 10   if @rates[name][:rate] < 10
+    end
+
+    def decr(name)
+      @rates[name][:rate] *= 2
+      @rates[name][:rate]  = 3600 if @rates[name][:rate] > 3600
+    end
+  end
+
+end
+
+class Hash
+  # { :f  => "v" }    #=> "f=v"
+  # { "f" => [1, 2] } #=> "f=1&f=2"
+  # { "f" => "" }     #=> "f="
+  # { "f" => nil }    #=> "f"
+  def to_query_str separator = "&"
+    inject([]) do |r, (k, v)|
+      k = URI.encode_component k.to_s
+      (v.is_a?(Array) ? v : [v]).each do |i|
+        if i.nil?
+          r << k
+        else
+          r << "#{k}=#{URI.encode_component i.to_s}"
+        end
+      end
+      r
+    end.join separator
+  end
+end
+
+class String
+  def ch?
+    /\A[&#+!][^ \007,]{1,50}\z/ === self
+  end
+
+  def screen_name?
+    /\A[A-Za-z0-9_]{1,15}\z/ === self
+  end
+
+  def encoding! enc
+    return self unless respond_to? :force_encoding
+    force_encoding enc
+  end
+end
+
+module URI::Escape
+#  alias :_orig_escape :escape
+#
+#  if defined? ::RUBY_REVISION and RUBY_REVISION < 24544
+#    # URI.escape("あ１") #=> "%E3%81%82\xEF\xBC\x91"
+#    # URI("file:///４")  #=> #<URI::Generic:0x9d09db0 URL:file:/４>
+#    #   "\\d" -> "[0-9]" for Ruby 1.9
+#    def escape str, unsafe = %r{[^-_.!~*'()a-zA-Z0-9;/?:@&=+$,\[\]]}
+#      _orig_escape(str, unsafe)
+#    end
+#    alias :encode :escape
+#  end
+
+  def encode_component str, unsafe = /[^-_.!~*'()a-zA-Z0-9 ]/
+    escape(str, unsafe).tr(" ", "+")
+  end
+
+  def rstrip str
+    str.sub(%r{
+      (?: ( / [^/?#()]* (?: \( [^/?#()]* \) [^/?#()]* )* ) \) [^/?#()]*
+        | \.
+      ) \z
+    }x, "\\1")
+  end
+end
+
+if __FILE__ == $0
+  require "optparse"
+
+  opts = {
+    :port  => 16668,
+    :host  => "localhost",
+    :log   => nil,
+    :debug => false,
+    :foreground => false,
+  }
+
+  OptionParser.new do |parser|
+    parser.instance_eval do
+      self.banner = <<-EOB.gsub(/^\t+/, "")
+        Usage: #{$0} [opts]
+
+      EOB
+
+      separator ""
+
+      separator "Options:"
+      on("-p", "--port [PORT=#{opts[:port]}]", "port number to listen") do |port|
+        opts[:port] = port
+      end
+
+      on("-h", "--host [HOST=#{opts[:host]}]", "host name or IP address to listen") do |host|
+        opts[:host] = host
+      end
+
+      on("-l", "--log LOG", "log file") do |log|
+        opts[:log] = log
+      end
+
+      on("--debug", "Enable debug mode") do |debug|
+        opts[:log]   = $stdout
+        opts[:debug] = true
+      end
+
+      on("-f", "--foreground", "run foreground") do |foreground|
+        opts[:log]        = $stdout
+        opts[:foreground] = true
+      end
+
+      on("-n", "--name [user name or email address]") do |name|
+        opts[:name] = name
+      end
+
+      parse!(ARGV)
+    end
+  end
+
+  opts[:logger] = Logger.new(opts[:log], "daily")
+  opts[:logger].level = opts[:debug] ? Logger::DEBUG : Logger::INFO
+  opts[:logger].level = Logger::INFO
+
+  #def daemonize(foreground = false)
+  #  [:INT, :TERM, :HUP].each do |sig|
+  #    Signal.trap sig, "EXIT"
+  #  end
+  #  return yield if $DEBUG or foreground
+  #  Process.fork do
+  #    Process.setsid
+  #    Dir.chdir "/"
+  #    STDIN.reopen  "/dev/null"
+  #    STDOUT.reopen "/dev/null", "a"
+  #    STDERR.reopen STDOUT
+  #    yield
+  #  end
+  #  exit! 0
+  #end
+
+  #daemonize(opts[:debug] || opts[:foreground]) do
+    Net::IRC::Server.new(opts[:host], opts[:port], TwitterIrcGateway, opts).start
+  #end
+end
+