rbot 0.9.10 → 0.9.12

data/data/rbot/plugins/tube.rb

@@ -1,62 +1,50 @@
 #Tube Status Enquiry plugin for rbot
 #Plugin by Colm Linehan
 
-require 'rexml/document'
-require 'uri/common'
-
 class TubePlugin < Plugin
-  include REXML
   def help(plugin, topic="")
-  "tube [district|circle|metropolitan|central|jubilee|bakerloo|waterloo_city|hammersmith_city|victoria|eastlondon|northern|piccadilly] => display tube service status for the specified line(Docklands Light Railway is not currently supported), tube stations => list tube stations (not lines) with problems"
+  "tube [district|circle|metropolitan|central|jubilee|bakerloo|waterlooandcity|hammersmithandcity|victoria|eastlondon|northern|piccadilly] => display tube service status for the specified line(Docklands Light Railway is not currently supported)" # , tube stations => list tube stations (not lines) with problems"
   end
   
   def tube(m, params)
     line = params[:line]
-  begin
-    tube_page = @bot.httputil.get(URI.parse("http://www.tfl.gov.uk/tfl/service_rt_tube.shtml"), 1, 1)
-  rescue URI::InvalidURIError, URI::BadURIError => e
-    m.reply "Cannot contact Tube Service Status page"
-    return
-  end
-  unless tube_page
-    m.reply "Cannot contact Tube Service Status page"
-    return
-  end
-  next_line = false
-  tube_page.each_line {|l|
-    next if l == "\r\n"
-    next if l == "\n"
-    if (next_line)
-      if (l =~ /^<tr valign=top> <td>\s*(.*)<\/td><\/tr>/i)
-        m.reply $1.split(/<[^>]+>|&nbsp;/i).join(" ")
-        return
-      else
-        m.reply "There are problems on the #{line} line, but I didn't understand the page format. You should check out http://www.tfl.gov.uk/tfl/service_rt_tube.shtml for more details."
-        return
-      end
+    tube_page = @bot.httputil.get('http://www.tfl.gov.uk/tfl/livetravelnews/realtime/tube/default.html')
+    unless tube_page
+      m.reply "Cannot contact Tube Service Status page"
+      return
     end
-    next_line = true if (l =~ /class="#{line}"/i)
+    next_line = false
+    tube_page.each_line {|l|
+      next if l == "\r\n"
+      next if l == "\n"
+      if (next_line)
+        if (l =~ /^<p>\s*(.*)<\/p>/i)
+          m.reply $1.split(/<[^>]+>|&nbsp;/i).join(" ")
+          return
+        elsif l =~ /ul|h3|"message"/
+          next
+        else
+          m.reply "There are problems on the #{line} line, but I didn't understand the page format. You should check out http://www.tfl.gov.uk/tfl/livetravelnews/realtime/tube/default.html for more details."
+          return
+        end
+      end
+      next_line = true if (l =~ /li class="#{line}"/i)
     }
-  m.reply "No Problems on the #{line} line."
+    m.reply "No Problems on the #{line} line."
   end
 
   def check_stations(m, params)
-    begin
-      tube_page = @bot.httputil.get(URI.parse("http://www.tfl.gov.uk/tfl/service_rt_tube.shtml"))
-    rescue URI::InvalidURIError, URI::BadURIError => e
-      m.reply "Cannot contact Tube Service Status page"
-      return
-    end
+    tube_page = @bot.httputil.get('http://www.tfl.gov.uk/tfl/service_rt_tube.shtml')
     unless tube_page
       m.reply "Cannot contact Tube Service Status page"
       return
     end
     stations_array = Array.new
     tube_page.each_line {|l|
-        if (l =~ /<tr valign=top> <td valign="middle" class="Station"><b>(.*)<\/b><\/td><\/tr>\s*/i)
-          stations_array.push $1
-        end
-        }
+      if (l =~ /<tr valign=top> <td valign="middle" class="Station"><b>(.*)<\/b><\/td><\/tr>\s*/i)
+        stations_array.push $1
+      end
+    }
     if stations_array.empty? 
       m.reply "There are no station-specific announcements"
       return
@@ -67,5 +55,5 @@ class TubePlugin < Plugin
   end
 end
 plugin = TubePlugin.new
-plugin.map 'tube stations', :action => 'check_stations'
+# plugin.map 'tube stations', :action => 'check_stations'
 plugin.map 'tube :line'

data/data/rbot/plugins/twitter.rb

@@ -0,0 +1,187 @@
+#-- vim:sw=2:et
+#++
+#
+# :title: Twitter Status Update for rbot
+#
+# Author:: Carter Parks (carterparks) <carter@carterparks.com>
+# Author:: Giuseppe "Oblomov" Bilotta <giuseppe.bilotta@gmail.com>
+#
+# Copyright:: (C) 2007 Carter Parks
+# Copyright:: (C) 2007 Giuseppe Bilotta
+#
+# Users can setup their twitter username and password and then begin updating
+# twitter whenever
+
+require 'rexml/rexml'
+require 'cgi'
+
+class TwitterPlugin < Plugin
+  Config.register Config::IntegerValue.new('twitter.status_count',
+    :default => 1, :validate => Proc.new { |v| v > 0 && v <= 10},
+    :desc => "Maximum number of status updates shown by 'twitter status'")
+  Config.register Config::IntegerValue.new('twitter.friends_status_count',
+    :default => 3, :validate => Proc.new { |v| v > 0 && v <= 10},
+    :desc => "Maximum number of status updates shown by 'twitter friends status'")
+
+  def initialize
+    super
+
+    class << @registry
+      def store(val)
+        val
+      end
+      def restore(val)
+        val
+      end
+    end
+
+    @header = {
+      'X-Twitter-Client' => 'rbot twitter plugin'
+    }
+  end
+
+  # return a help string when the bot is asked for help on this plugin
+  def help(plugin, topic="")
+    return "twitter status [nick] => show nick's (or your) status, use 'twitter friends status [nick]' to also show the friends' timeline | twitter update [status] => updates your status on twitter | twitter identify [username] [password] => ties your nick to your twitter username and password | twitter actions [on|off] => enable/disable twitting of actions (/me does ...)"
+  end
+
+  # update the status on twitter
+  def get_status(m, params)
+
+    nick = params[:nick] || @registry[m.sourcenick + "_username"]
+
+    if not nick
+      m.reply "you should specify the username of the twitter touse, or identify using 'twitter identify [username] [password]'"
+      return false
+    end
+
+    user = URI.escape(nick)
+
+    count = @bot.config['twitter.status_count']
+    unless params[:friends]
+      uri = "http://twitter.com/statuses/user_timeline/#{user}.xml?count=#{count}"
+    else
+      count = @bot.config['twitter.friends_status_count']
+      uri = "http://twitter.com/statuses/friends_timeline/#{user}.xml"
+    end
+
+    response = @bot.httputil.get(uri, :headers => @header, :cache => false)
+    debug response
+
+    texts = []
+
+    if response
+      begin
+        rex = REXML::Document.new(response)
+        rex.root.elements.each("status") { |st|
+          # month, day, hour, min, sec, year = st.elements['created_at'].text.match(/\w+ (\w+) (\d+) (\d+):(\d+):(\d+) \S+ (\d+)/)[1..6]
+          # debug [year, month, day, hour, min, sec].inspect
+          # time = Time.local(year.to_i, month, day.to_i, hour.to_i, min.to_i, sec.to_i)
+          time = Time.parse(st.elements['created_at'].text)
+          now = Time.now
+          # Sometimes, time can be in the future; invert the relation in this case
+          delta = ((time > now) ? time - now : now - time)
+          msg = st.elements['text'].to_s + " (#{Utils.secs_to_string(delta.to_i)} ago via #{st.elements['source'].to_s})"
+          author = ""
+          if params[:friends]
+            author = Utils.decode_html_entities(st.elements['user'].elements['name'].text) + ": " rescue ""
+          end
+          texts << author+Utils.decode_html_entities(msg).ircify_html
+        }
+        if params[:friends]
+          # friends always return the latest 20 updates, so we clip the count
+          texts[count..-1]=nil
+        end
+      rescue
+        error $!
+        m.reply "could not parse status for #{nick}"
+        return false
+      end
+      m.reply texts.reverse.join("\n")
+      return true
+    else
+      m.reply "could not get status for #{nick}"
+      return false
+    end
+  end
+
+  # update the status on twitter
+  def update_status(m, params)
+
+
+    unless @registry.has_key?(m.sourcenick + "_password") && @registry.has_key?(m.sourcenick + "_username")
+      m.reply "you must identify using 'twitter identify [username] [password]'"
+      return false
+    end
+
+    user = URI.escape(@registry[m.sourcenick + "_username"])
+    pass = URI.escape(@registry[m.sourcenick + "_password"])
+    uri = "http://#{user}:#{pass}@twitter.com/statuses/update.xml"
+
+    msg = params[:status].to_s
+
+    if msg.length > 160
+      m.reply "your status message update is too long, please keep it under 140 characters if possible, 160 characters maximum"
+      return
+    end
+
+    if msg.length > 140
+      m.reply "your status message is longer than 140 characters, which is not optimal, but I'm going to update anyway"
+    end
+
+    source = "source=rbot"
+    msg = "status=#{CGI.escape(msg)}"
+    body = [source,msg].join("&")
+
+    response = @bot.httputil.post(uri, body, :headers => @header)
+    debug response
+
+    reply_method = params[:notify] ? :notify : :reply
+    if response.class == Net::HTTPOK
+      m.__send__(reply_method, "status updated")
+    else
+      m.__send__(reply_method, "could not update status")
+    end
+  end
+
+  # ties a nickname to a twitter username and password
+  def identify(m, params)
+    @registry[m.sourcenick + "_username"] = params[:username].to_s
+    @registry[m.sourcenick + "_password"] = params[:password].to_s
+    m.reply "you're all setup!"
+  end
+
+  # update on ACTION if the user has enabled the option
+  def ctcp_listen(m)
+    return unless m.action?
+    return unless @registry[m.sourcenick + "_actions"]
+    update_status(m, :status => m.message, :notify => true)
+  end
+
+  # show or toggle action twitting
+  def actions(m, params)
+    case params[:toggle]
+    when 'on'
+      @registry[m.sourcenick + "_actions"] = true
+      m.okay
+    when 'off'
+      @registry.delete(m.sourcenick + "_actions")
+      m.okay
+    else
+      if @registry[m.sourcenick + "_actions"]
+        m.reply _("actions will be twitted")
+      else
+        m.reply _("actions will not be twitted")
+      end
+    end
+  end
+end
+
+# create an instance of our plugin class and register for the "length" command
+plugin = TwitterPlugin.new
+plugin.map 'twitter identify :username :password', :action => "identify", :public => false
+plugin.map 'twitter update *status', :action => "update_status", :threaded => true
+plugin.map 'twitter status [:nick]', :action => "get_status", :threaded => true
+plugin.map 'twitter actions [:toggle]', :action => "actions", :requirements => { :toggle => /^on|off$/ }
+plugin.map 'twitter :friends [status] [:nick]', :action => "get_status", :requirements => { :friends => /^friends?$/ }, :threaded => true
+

data/data/rbot/plugins/urban.rb

@@ -1,71 +1,80 @@
-require 'cgi'
-begin
-  require 'rubyful_soup'
-rescue
-  warning "could not load rubyful_soup, urban dictionary disabled"
-  warning "please get it from http://www.crummy.com/software/RubyfulSoup/"
-  warning "or install it via gem"
-  return
-end
-require 'uri/common'
-
 class UrbanPlugin < Plugin
+  URBAN = 'http://www.urbandictionary.com/define.php?term='
 
   def help( plugin, topic="")
-    "urban [word] [n]. Give the [n]th definition of [word] from urbandictionary.com."
+    "urban [word] [n]: give the [n]th definition of [word] from urbandictionary.com. urbanday: give the word-of-the-day at urban"
   end
 
-  def privmsg( m )
+  def format_definition(total, num, word, desc, ex)
+    "#{Bold}#{word} (#{num}/#{total})#{Bold}: " +
+    desc.ircify_html(:limit => 300) + " " +
+    "<i>#{ex}</i>".ircify_html(:limit => 100)
+  end
 
-    unless(m.params && m.params.length > 0)
-      m.reply "incorrect usage: " + help(m.plugin)
-      return
+  def get_def(m, word, n = nil)
+    n = n ? n.to_i : 1
+    p = (n-1)/7 + 1
+    u = URBAN + URI.escape(word)
+    u += '&page=' + p.to_s if p > 1
+    s = @bot.httputil.get(u)
+    return m.reply "Couldn't get the urban dictionary definition for #{word}" if s.nil?
+
+    notfound = s.match %r{<div style="color: #669FCE"><i>.*?</i> isn't defined}
+
+    numpages = s[%r{<div id='paginator'>.*?</div>}m].scan(/\d+/).collect {|x| x.to_i}.max || 1
+
+    rv = Array.new
+    s.scan(%r{<td class='index'[^>]*>.*?(\d+)\..*?</td>.*?<td class='word'>(?:<a.*?>)?([^>]+)(?:</a>)?</td>.*?<div class='definition'>(.+?)</div>.*?<div class='example'>(.+?)</div>}m) do |num, wrd, desc, ex|
+      rv << [num.to_i, wrd.strip, desc.strip, ex.strip]
     end
 
-    paramArray = m.params.split(' ')
-    definitionN = 0
-    if m.params == 'random' then
-      uri = URI.parse( "http://www.urbandictionary.com/random.php" )
-    else 
-      if( paramArray.last.to_i != 0 ) then
-        definitionN = paramArray.last.to_i - 1
-        query = m.params.chomp( paramArray.last )
-        query.rstrip!
-      else
-        query = m.params
-      end
-      uri = URI.parse( "http://www.urbandictionary.com/define.php?term=#{ URI.escape query}" )
+    maxnum = rv.collect {|x| x[0]}.max || 0
+    return m.reply("#{Bold}#{word}#{Bold} not found") if rv.empty?
+
+    if notfound
+      suggestions = rv.map { |s| Underline + s[1] + Underline }.uniq.join ', '
+      m.reply "#{Bold}#{word}#{Bold} not found. maybe you mean #{suggestions}?"
+      return
     end
 
-    soup = BeautifulSoup.new( @bot.httputil.get_cached( uri ) )
-    if titleNavi = soup.find_all( 'td', :attrs => { 'class' => 'def_word' } )[0] then
-      title = titleNavi.contents
-      results = soup.find_all( 'div', :attrs => { 'class' => 'def_p' } )
-      # debug PP.pp(results,'')
-      output = Array.new
-      if results[definitionN] then
-        results[definitionN].p.contents.each { |s| output.push( strip_tags( s.to_s ) ) }
-        m.reply "\002#{title}\002 - #{output}"
-      else
-        m.reply "#{query} does not have #{definitionN + 1} definitions."
+    answer = rv.find { |a| a[0] == n }
+    answer ||= (n > maxnum ? rv.last : rv.first)
+    m.reply format_definition((p == numpages ? maxnum : "#{(numpages-1)*7 + 1}+"), *answer)
+  end
+
+  def urban(m, params)
+    words = params[:words].to_s
+    if words.empty?
+      resp = @bot.httputil.head('http://www.urbandictionary.com/random.php',
+                               :max_redir => -1,
+                               :cache => false)
+      return m.reply "Couldn't get a random urban dictionary word" if resp.nil?
+      if resp.code == "302" && (loc = resp['location'])
+        words = URI.unescape(loc.match(/define.php\?term=(.*)$/)[1]) rescue nil
       end
-    else
-      m.reply "#{m.params} not found."
     end
-
+    get_def(m, words, params[:n])
   end
 
-  def strip_tags(html)
-    html.gsub(/<.+?>/,'').
-    gsub(/&amp;/,'&').
-    gsub(/&quot;/,'"').
-    gsub(/&lt;/,'<').
-    gsub(/&gt;/,'>').
-    gsub(/&ellip;/,'...').
-    gsub(/&apos;/, "'").
-    gsub("\n",'')
+  def uotd(m, params)
+    home = @bot.httputil.get("http://www.urbandictionary.com/daily.php")
+    if home.nil?
+      m.reply "Couldn't get the urban dictionary word of the day"
+      return
+    end
+    home.match(%r{href="/define.php\?term=.*?">(.*?)<})
+    wotd = $1
+    debug "Urban word of the day: #{wotd}"
+    if !wotd
+      m.reply "Couldn't get the urban dictionary word of the day"
+      return
+    end
+    get_def(m, wotd, 1)
   end
 end
 
 plugin = UrbanPlugin.new
-plugin.register( "urban" )
+plugin.map "urban *words :n", :requirements => { :n => /^-?\d+$/ }, :action => 'urban'
+plugin.map "urban [*words]", :action => 'urban'
+plugin.map "urbanday", :action => 'uotd'
+

data/data/rbot/plugins/url.rb

@@ -1,434 +1,218 @@
-require 'net/http'
-require 'uri'
-require 'cgi'
-
-Url = Struct.new("Url", :channel, :nick, :time, :url)
-TITLE_RE = /<\s*?title\s*?>(.+?)<\s*?\/title\s*?>/im
-
-UNESCAPE_TABLE = {
-    'raquo' => '>>',
-    'quot' => '"',
-    'micro' => 'u',
-    'copy' => '(c)',
-    'trade' => '(tm)',
-    'reg' => '(R)',
-    '#174' => '(R)',
-    '#8220' => '"',
-    '#8221' => '"',
-    '#8212' => '--',
-    '#39' => '\'',
-=begin
-    # extras codes, for future use...
-    'zwnj' => '&#8204;',
-    'aring' => '\xe5',
-    'gt' => '>',
-    'yen' => '\xa5',
-    'ograve' => '\xf2',
-    'Chi' => '&#935;',
-    'bull' => '&#8226;',
-    'Egrave' => '\xc8',
-    'Ntilde' => '\xd1',
-    'upsih' => '&#978;',
-    'Yacute' => '\xdd',
-    'asymp' => '&#8776;',
-    'radic' => '&#8730;',
-    'otimes' => '&#8855;',
-    'nabla' => '&#8711;',
-    'aelig' => '\xe6',
-    'oelig' => '&#339;',
-    'equiv' => '&#8801;',
-    'Psi' => '&#936;',
-    'auml' => '\xe4',
-    'circ' => '&#710;',
-    'Acirc' => '\xc2',
-    'Epsilon' => '&#917;',
-    'Yuml' => '&#376;',
-    'Eta' => '&#919;',
-    'lt' => '<',
-    'Icirc' => '\xce',
-    'Upsilon' => '&#933;',
-    'ndash' => '&#8211;',
-    'there4' => '&#8756;',
-    'Prime' => '&#8243;',
-    'prime' => '&#8242;',
-    'psi' => '&#968;',
-    'Kappa' => '&#922;',
-    'rsaquo' => '&#8250;',
-    'Tau' => '&#932;',
-    'darr' => '&#8595;',
-    'ocirc' => '\xf4',
-    'lrm' => '&#8206;',
-    'zwj' => '&#8205;',
-    'cedil' => '\xb8',
-    'Ecirc' => '\xca',
-    'not' => '\xac',
-    'amp' => '&',
-    'AElig' => '\xc6',
-    'oslash' => '\xf8',
-    'acute' => '\xb4',
-    'lceil' => '&#8968;',
-    'laquo' => '\xab',
-    'shy' => '\xad',
-    'rdquo' => '&#8221;',
-    'ge' => '&#8805;',
-    'Igrave' => '\xcc',
-    'Ograve' => '\xd2',
-    'euro' => '&#8364;',
-    'dArr' => '&#8659;',
-    'sdot' => '&#8901;',
-    'nbsp' => '\xa0',
-    'lfloor' => '&#8970;',
-    'lArr' => '&#8656;',
-    'Auml' => '\xc4',
-    'larr' => '&#8592;',
-    'Atilde' => '\xc3',
-    'Otilde' => '\xd5',
-    'szlig' => '\xdf',
-    'clubs' => '&#9827;',
-    'diams' => '&#9830;',
-    'agrave' => '\xe0',
-    'Ocirc' => '\xd4',
-    'Iota' => '&#921;',
-    'Theta' => '&#920;',
-    'Pi' => '&#928;',
-    'OElig' => '&#338;',
-    'Scaron' => '&#352;',
-    'frac14' => '\xbc',
-    'egrave' => '\xe8',
-    'sub' => '&#8834;',
-    'iexcl' => '\xa1',
-    'frac12' => '\xbd',
-    'sbquo' => '&#8218;',
-    'ordf' => '\xaa',
-    'sum' => '&#8721;',
-    'prop' => '&#8733;',
-    'Uuml' => '\xdc',
-    'ntilde' => '\xf1',
-    'sup' => '&#8835;',
-    'theta' => '&#952;',
-    'prod' => '&#8719;',
-    'nsub' => '&#8836;',
-    'hArr' => '&#8660;',
-    'rlm' => '&#8207;',
-    'THORN' => '\xde',
-    'infin' => '&#8734;',
-    'yuml' => '\xff',
-    'Mu' => '&#924;',
-    'le' => '&#8804;',
-    'Eacute' => '\xc9',
-    'thinsp' => '&#8201;',
-    'ecirc' => '\xea',
-    'bdquo' => '&#8222;',
-    'Sigma' => '&#931;',
-    'fnof' => '&#402;',
-    'Aring' => '\xc5',
-    'tilde' => '&#732;',
-    'frac34' => '\xbe',
-    'emsp' => '&#8195;',
-    'mdash' => '&#8212;',
-    'uarr' => '&#8593;',
-    'permil' => '&#8240;',
-    'Ugrave' => '\xd9',
-    'rarr' => '&#8594;',
-    'Agrave' => '\xc0',
-    'chi' => '&#967;',
-    'forall' => '&#8704;',
-    'eth' => '\xf0',
-    'rceil' => '&#8969;',
-    'iuml' => '\xef',
-    'gamma' => '&#947;',
-    'lambda' => '&#955;',
-    'harr' => '&#8596;',
-    'rang' => '&#9002;',
-    'xi' => '&#958;',
-    'dagger' => '&#8224;',
-    'divide' => '\xf7',
-    'Ouml' => '\xd6',
-    'image' => '&#8465;',
-    'alefsym' => '&#8501;',
-    'igrave' => '\xec',
-    'otilde' => '\xf5',
-    'Oacute' => '\xd3',
-    'sube' => '&#8838;',
-    'alpha' => '&#945;',
-    'frasl' => '&#8260;',
-    'ETH' => '\xd0',
-    'lowast' => '&#8727;',
-    'Nu' => '&#925;',
-    'plusmn' => '\xb1',
-    'Euml' => '\xcb',
-    'real' => '&#8476;',
-    'sup1' => '\xb9',
-    'sup2' => '\xb2',
-    'sup3' => '\xb3',
-    'Oslash' => '\xd8',
-    'Aacute' => '\xc1',
-    'cent' => '\xa2',
-    'oline' => '&#8254;',
-    'Beta' => '&#914;',
-    'perp' => '&#8869;',
-    'Delta' => '&#916;',
-    'loz' => '&#9674;',
-    'pi' => '&#960;',
-    'iota' => '&#953;',
-    'empty' => '&#8709;',
-    'euml' => '\xeb',
-    'brvbar' => '\xa6',
-    'iacute' => '\xed',
-    'para' => '\xb6',
-    'micro' => '\xb5',
-    'cup' => '&#8746;',
-    'weierp' => '&#8472;',
-    'uuml' => '\xfc',
-    'part' => '&#8706;',
-    'icirc' => '\xee',
-    'delta' => '&#948;',
-    'omicron' => '&#959;',
-    'upsilon' => '&#965;',
-    'Iuml' => '\xcf',
-    'Lambda' => '&#923;',
-    'Xi' => '&#926;',
-    'kappa' => '&#954;',
-    'ccedil' => '\xe7',
-    'Ucirc' => '\xdb',
-    'cap' => '&#8745;',
-    'mu' => '&#956;',
-    'scaron' => '&#353;',
-    'lsquo' => '&#8216;',
-    'isin' => '&#8712;',
-    'Zeta' => '&#918;',
-    'supe' => '&#8839;',
-    'deg' => '\xb0',
-    'and' => '&#8743;',
-    'tau' => '&#964;',
-    'pound' => '\xa3',
-    'hellip' => '&#8230;',
-    'curren' => '\xa4',
-    'int' => '&#8747;',
-    'ucirc' => '\xfb',
-    'rfloor' => '&#8971;',
-    'ensp' => '&#8194;',
-    'crarr' => '&#8629;',
-    'ugrave' => '\xf9',
-    'notin' => '&#8713;',
-    'exist' => '&#8707;',
-    'uArr' => '&#8657;',
-    'cong' => '&#8773;',
-    'Dagger' => '&#8225;',
-    'oplus' => '&#8853;',
-    'times' => '\xd7',
-    'atilde' => '\xe3',
-    'piv' => '&#982;',
-    'ni' => '&#8715;',
-    'Phi' => '&#934;',
-    'lsaquo' => '&#8249;',
-    'Uacute' => '\xda',
-    'Omicron' => '&#927;',
-    'ang' => '&#8736;',
-    'ne' => '&#8800;',
-    'iquest' => '\xbf',
-    'eta' => '&#951;',
-    'yacute' => '\xfd',
-    'Rho' => '&#929;',
-    'uacute' => '\xfa',
-    'Alpha' => '&#913;',
-    'zeta' => '&#950;',
-    'Omega' => '&#937;',
-    'nu' => '&#957;',
-    'sim' => '&#8764;',
-    'sect' => '\xa7',
-    'phi' => '&#966;',
-    'sigmaf' => '&#962;',
-    'macr' => '\xaf',
-    'minus' => '&#8722;',
-    'Ccedil' => '\xc7',
-    'ordm' => '\xba',
-    'epsilon' => '&#949;',
-    'beta' => '&#946;',
-    'rArr' => '&#8658;',
-    'rho' => '&#961;',
-    'aacute' => '\xe1',
-    'eacute' => '\xe9',
-    'omega' => '&#969;',
-    'middot' => '\xb7',
-    'Gamma' => '&#915;',
-    'Iacute' => '\xcd',
-    'lang' => '&#9001;',
-    'spades' => '&#9824;',
-    'rsquo' => '&#8217;',
-    'uml' => '\xa8',
-    'thorn' => '\xfe',
-    'ouml' => '\xf6',
-    'thetasym' => '&#977;',
-    'or' => '&#8744;',
-    'raquo' => '\xbb',
-    'acirc' => '\xe2',
-    'ldquo' => '&#8220;',
-    'hearts' => '&#9829;',
-    'sigma' => '&#963;',
-    'oacute' => '\xf3',
-=end
-}
+#-- vim:sw=2:et
+#++
+#
+# :title: Url plugin
+
+define_structure :Url, :channel, :nick, :time, :url, :info
 
 class UrlPlugin < Plugin
-  BotConfig.register BotConfigIntegerValue.new('url.max_urls',
+  LINK_INFO = "[Link Info]"
+  OUR_UNSAFE = Regexp.new("[^#{URI::PATTERN::UNRESERVED}#{URI::PATTERN::RESERVED}%# ]", false, 'N')
+
+  Config.register Config::IntegerValue.new('url.max_urls',
     :default => 100, :validate => Proc.new{|v| v > 0},
     :desc => "Maximum number of urls to store. New urls replace oldest ones.")
-  BotConfig.register BotConfigBooleanValue.new('url.display_link_info',
-    :default => false, 
-    :desc => "Get the title of any links pasted to the channel and display it (also tells if the link is broken or the site is down)")
-  
+  Config.register Config::IntegerValue.new('url.display_link_info',
+    :default => 0,
+    :desc => "Get the title of links pasted to the channel and display it (also tells if the link is broken or the site is down). Do it for at most this many links per line (set to 0 to disable)")
+  Config.register Config::BooleanValue.new('url.titles_only',
+    :default => false,
+    :desc => "Only show info for links that have <title> tags (in other words, don't display info for jpegs, mpegs, etc.)")
+  Config.register Config::BooleanValue.new('url.first_par',
+    :default => false,
+    :desc => "Also try to get the first paragraph of a web page")
+  Config.register Config::BooleanValue.new('url.info_on_list',
+    :default => false,
+    :desc => "Show link info when listing/searching for urls")
+  Config.register Config::ArrayValue.new('url.no_info_hosts',
+    :default => ['localhost', '^192\.168\.', '^10\.', '^127\.', '^172\.(1[6-9]|2\d|31)\.'],
+    :on_change => Proc.new { |bot, v| bot.plugins['url'].reset_no_info_hosts },
+    :desc => "A list of regular expressions matching hosts for which no info should be provided")
+
+
   def initialize
     super
     @registry.set_default(Array.new)
+    unless @bot.config['url.display_link_info'].kind_of?(Integer)
+      @bot.config.items[:'url.display_link_info'].set_string(@bot.config['url.display_link_info'].to_s)
+    end
+    reset_no_info_hosts
   end
 
-  def help(plugin, topic="")
-    "urls [<max>=4] => list <max> last urls mentioned in current channel, urls search [<max>=4] <regexp> => search for matching urls. In a private message, you must specify the channel to query, eg. urls <channel> [max], urls search <channel> [max] <regexp>"
+  def reset_no_info_hosts
+    @no_info_hosts = Regexp.new(@bot.config['url.no_info_hosts'].join('|'), true)
+    debug "no info hosts regexp set to #{@no_info_hosts}"
   end
 
-  def unescape_title(htmldata)
-    # first pass -- let CGI try to attack it...
-    htmldata = CGI::unescapeHTML htmldata
-    
-    # second pass -- destroy the remaining bits...
-    htmldata.gsub(/(&(.+?);)/) {
-        symbol = $2
-        
-        # remove the 0-paddng from unicode integers
-        if symbol =~ /#(.+)/
-            symbol = "##{$1.to_i.to_s}"
-        end
-        
-        # output the symbol's irc-translated character, or a * if it's unknown
-        UNESCAPE_TABLE[symbol] || '*'
-    }
+  def help(plugin, topic="")
+    "url info <url> => display link info for <url> (set url.display_link_info > 0 if you want the bot to do it automatically when someone writes an url), urls [<max>=4] => list <max> last urls mentioned in current channel, urls search [<max>=4] <regexp> => search for matching urls. In a private message, you must specify the channel to query, eg. urls <channel> [max], urls search <channel> [max] <regexp>"
   end
 
   def get_title_from_html(pagedata)
-    return unless TITLE_RE.match(pagedata)
-    title = $1.strip.gsub(/\s*\n+\s*/, " ")
-    title = unescape_title title
-    title = title[0..255] if title.length > 255
-    "[Link Info] title: #{title}"
+    return pagedata.ircify_html_title
   end
 
-  def read_data_from_response(response, amount)
-    
-    amount_read = 0
-    chunks = []
-    
-    response.read_body do |chunk|   # read body now
-      
-      amount_read += chunk.length
-      
-      if amount_read > amount
-        amount_of_overflow = amount_read - amount
-        chunk = chunk[0...-amount_of_overflow]
+  def get_title_for_url(uri_str, opts = {})
+
+    url = uri_str.kind_of?(URI) ? uri_str : URI.parse(uri_str)
+    return if url.scheme !~ /https?/
+
+    # also check the ip, the canonical name and the aliases
+    begin
+      checks = TCPSocket.gethostbyname(url.host)
+      checks.delete_at(-2)
+    rescue => e
+      return "Unable to retrieve info for #{url.host}: #{e.message}"
+    end
+
+    checks << url.host
+    checks.flatten!
+
+    unless checks.grep(@no_info_hosts).empty?
+      return "Sorry, info retrieval for #{url.host} (#{checks.first}) is disabled"
+    end
+
+    logopts = opts.dup
+
+    title = nil
+    extra = []
+
+    begin
+      debug "+ getting info for #{url.request_uri}"
+      info = @bot.filter(:htmlinfo, url)
+      debug info
+      resp = info[:headers]
+
+      logopts[:title] = title = info[:title]
+
+      if info[:content]
+        logopts[:extra] = info[:content]
+        extra << "#{Bold}text#{Bold}: #{info[:content]}" if @bot.config['url.first_par']
+      else
+        logopts[:extra] = String.new
+        logopts[:extra] << "Content Type: #{resp['content-type']}"
+        extra << "#{Bold}type#{Bold}: #{resp['content-type']}" unless title
+        if enc = resp['content-encoding']
+          logopts[:extra] << ", encoding: #{enc}"
+          extra << "#{Bold}encoding#{Bold}: #{enc}" if @bot.config['url.first_par'] or not title
+        end
+
+        size = resp['content-length'].first.gsub(/(\d)(?=\d{3}+(?:\.|$))(\d{3}\..*)?/,'\1,\2') rescue nil
+        if size
+          logopts[:extra] << ", size: #{size} bytes"
+          extra << "#{Bold}size#{Bold}: #{size} bytes" if @bot.config['url.first_par'] or not title
+        end
       end
-      
-      chunks << chunk
+    rescue Exception => e
+      case e
+      when UrlLinkError
+        raise e
+      else
+        error e
+        raise "connecting to site/processing information (#{e.message})"
+      end
+    end
 
-      break if amount_read >= amount
-      
+    call_event(:url_added, url.to_s, logopts)
+    if title
+      extra.unshift("#{Bold}title#{Bold}: #{title}")
     end
-    
-    chunks.join('')
-    
+    return extra.join(", ") if title or not @bot.config['url.titles_only']
   end
 
+  def handle_urls(m, urls, display_info=@bot.config['url.display_link_info'])
+    return if urls.empty?
+    debug "found urls #{urls.inspect}"
+    list = m.public? ? @registry[m.target] : nil
+    debug "display link info: #{display_info}"
+    urls_displayed = 0
+    urls.each do |urlstr|
+      debug "working on #{urlstr}"
+      next unless urlstr =~ /^https?:/
+      title = nil
+      debug "Getting title for #{urlstr}..."
+      reply = nil
+      begin
+        title = get_title_for_url(urlstr,
+                                  :nick => m.source.nick,
+                                  :channel => m.channel,
+                                  :ircline => m.message)
+        debug "Title #{title ? '' : 'not '} found"
+        reply = "#{LINK_INFO} #{title}" if title
+      rescue => e
+        debug e
+        # we might get a 404 because of trailing punctuation, so we try again
+        # with the last character stripped. this might generate invalid URIs
+        # (e.g. because "some.url" gets chopped to some.url%2, so catch that too
+        if e.message =~ /\(404 - Not Found\)/i or e.kind_of?(URI::InvalidURIError)
+          # chop off last character, and retry if we still have enough string to
+          # look like a minimal URL
+          retry if urlstr.chop! and urlstr =~ /^https?:\/\/./
+        end
+        reply = "Error #{e.message}"
+      end
+
+      if display_info > urls_displayed
+        if reply
+          m.plainreply(reply, :overlong => :truncate)
+          urls_displayed += 1
+        end
+      end
+
+      next unless list
 
-  def get_title_for_url(uri_str, depth=10)
-    # This god-awful mess is what the ruby http library has reduced me to.
-    # Python's HTTP lib is so much nicer. :~(
-    
-    if depth == 0
-        raise "Error: Maximum redirects hit."
+      # check to see if this url is already listed
+      next if list.find {|u| u.url == urlstr }
+
+      url = Url.new(m.target, m.sourcenick, Time.new, urlstr, title)
+      debug "#{list.length} urls so far"
+      list.pop if list.length > @bot.config['url.max_urls']
+      debug "storing url #{url.url}"
+      list.unshift url
+      debug "#{list.length} urls now"
     end
-    
-    debug "+ Getting #{uri_str}"
-    url = URI.parse(uri_str)
-    return if url.scheme !~ /https?/
+    @registry[m.target] = list
+  end
 
-    title = nil
-    
-    debug "+ connecting to #{url.host}:#{url.port}"
-    http = @bot.httputil.get_proxy(url)
-    http.start { |http|
-      url.path = '/' if url.path == ''
-
-      http.request_get(url.path, "User-Agent" => "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 1.1.4322)") { |response|
-        
-        case response
-          when Net::HTTPRedirection, Net::HTTPMovedPermanently then
-            # call self recursively if this is a redirect
-            redirect_to = response['location']  || './'
-            debug "+ redirect location: #{redirect_to.inspect}"
-            url = URI.join url.to_s, redirect_to
-            debug "+ whee, redirecting to #{url.to_s}!"
-            return get_title_for_url(url.to_s, depth-1)
-          when Net::HTTPSuccess then
-            if response['content-type'] =~ /^text\//
-              # since the content is 'text/*' and is small enough to
-              # be a webpage, retrieve the title from the page
-              debug "+ getting #{url.request_uri}"
-              data = read_data_from_response(response, 50000)
-              return get_title_from_html(data)
-            else
-              # content doesn't have title, just display info.
-              size = response['content-length'].gsub(/(\d)(?=\d{3}+(?:\.|$))(\d{3}\..*)?/,'\1,\2')
-              return "[Link Info] type: #{response['content-type']}#{size ? ", size: #{size} bytes" : ""}"
-            end
-          when Net::HTTPClientError then
-            return "[Link Info] Error getting link (#{response.code} - #{response.message})"
-          when Net::HTTPServerError then
-            return "[Link Info] Error getting link (#{response.code} - #{response.message})"
-          else
-            return nil
-        end # end of "case response"
-          
-      } # end of request block
-    } # end of http start block
-
-    return title
-    
-  rescue SocketError => e
-    return "[Link Info] Error connecting to site (#{e.message})"
+  def info(m, params)
+    escaped = URI.escape(params[:urls].to_s, OUR_UNSAFE)
+    urls = URI.extract(escaped)
+    Thread.new { handle_urls(m, urls, params[:urls].length) }
   end
 
-  def listen(m)
-    return unless m.kind_of?(PrivMessage)
+  def message(m)
     return if m.address?
-    # TODO support multiple urls in one line
-    if m.message =~ /(f|ht)tps?:\/\//
-      if m.message =~ /((f|ht)tps?:\/\/.*?)(?:\s+|$)/
-        urlstr = $1
-        list = @registry[m.target]
-
-        if @bot.config['url.display_link_info']
-          debug "Getting title for #{urlstr}..."
-          title = get_title_for_url urlstr
-          if title
-            m.reply title
-            debug "Title found!"
-          else
-            debug "Title not found!"
-          end        
-        end
-    
-        # check to see if this url is already listed
-        return if list.find {|u| u.url == urlstr }
-        
-        url = Url.new(m.target, m.sourcenick, Time.new, urlstr)
-        debug "#{list.length} urls so far"
-        if list.length > @bot.config['url.max_urls']
-          list.pop
+
+    escaped = URI.escape(m.message, OUR_UNSAFE)
+    urls = URI.extract(escaped, ['http', 'https'])
+    return if urls.empty?
+    Thread.new { handle_urls(m, urls) }
+  end
+
+  def reply_urls(opts={})
+    list = opts[:list]
+    max = opts[:max]
+    channel = opts[:channel]
+    m = opts[:msg]
+    return unless list and max and m
+    list[0..(max-1)].each do |url|
+      disp = "[#{url.time.strftime('%Y/%m/%d %H:%M:%S')}] <#{url.nick}> #{url.url}"
+      if @bot.config['url.info_on_list']
+        title = url.info ||
+          get_title_for_url(url.url,
+                            :nick => url.nick, :channel => channel) rescue nil
+        # If the url info was missing and we now have some, try to upgrade it
+        if channel and title and not url.info
+          ll = @registry[channel]
+          debug ll
+          if el = ll.find { |u| u.url == url.url }
+            el.info = title
+            @registry[channel] = ll
+          end
         end
-        debug "storing url #{url.url}"
-        list.unshift url
-        debug "#{list.length} urls now"
-        @registry[m.target] = list
+        disp << " --> #{title}" if title
       end
+      m.reply disp, :overlong => :truncate
     end
   end
 
@@ -441,9 +225,7 @@ class UrlPlugin < Plugin
     if list.empty?
       m.reply "no urls seen yet for channel #{channel}"
     else
-      list[0..(max-1)].each do |url|
-        m.reply "[#{url.time.strftime('%Y/%m/%d %H:%M:%S')}] <#{url.nick}> #{url.url}"
-      end
+      reply_urls :msg => m, :channel => channel, :list => list, :max => max
     end
   end
 
@@ -455,18 +237,20 @@ class UrlPlugin < Plugin
     max = 1 if max < 1
     regex = Regexp.new(string, Regexp::IGNORECASE)
     list = @registry[channel].find_all {|url|
-      regex.match(url.url) || regex.match(url.nick)
+      regex.match(url.url) || regex.match(url.nick) ||
+        (@bot.config['url.info_on_list'] && regex.match(url.info))
     }
     if list.empty?
       m.reply "no matches for channel #{channel}"
     else
-      list[0..(max-1)].each do |url|
-        m.reply "[#{url.time.strftime('%Y/%m/%d %H:%M:%S')}] <#{url.nick}> #{url.url}"
-      end
+      reply_urls :msg => m, :channel => channel, :list => list, :max => max
     end
   end
 end
+
 plugin = UrlPlugin.new
+plugin.map 'urls info *urls', :action => 'info'
+plugin.map 'url info *urls', :action => 'info'
 plugin.map 'urls search :channel :limit :string', :action => 'search',
                           :defaults => {:limit => 4},
                           :requirements => {:limit => /^\d+$/},