rbot 0.9.10 → 0.9.12

data/data/rbot/plugins/grouphug.rb

@@ -1,36 +1,90 @@
-# Plugin for the Ruby IRC bot (http://linuxbrit.co.uk/rbot/)
-# (c) 2005 Mark Kretschmann <markey@web.de>
-# Licensed under GPL V2.
+#-- vim:sw=2:et
+#++
+#
+# :title: Grouphug Plugin for rbot
+#
+# Author:: Mark Kretschmann <markey@web.de>
+# Author:: Casey Link <unnamedrambler@gmail.com>
+# Copyright:: (C) 2005 Mark Kretschmann
+# Copyright:: (C) 2008 Casey Link
+# License:: GPL v2
 
-require "net/http"
+class GrouphugPlugin < Plugin
+  REG  = Regexp.new('<div class="content">\s*<p>(.*?)</p>\s+</div>', Regexp::MULTILINE)
+  REGPOST = Regexp.new('title>(.*?) \| Group Hug')
+  def initialize
+    super
+    @confessions = Array.new
+  end
 
+  def help( plugin, topic="" )
+    return _("Grouphug plugin. Confess! Usage: 'confess' for random confession, 'confess <number>' for specific one, 'confess <confession>' to share your own confession. Confessions must be at least 10 words.")
+  end
 
-class GrouphugPlugin < Plugin
-    def help( plugin, topic="" )
-        "Grouphug plugin. Confess! Usage: 'confess' for random confession, 'confess <number>' for specific one."
+  def post_confession(m, params)
+    c = params[:confession]
+    if c.length < 10
+      diff = 10 - c.length
+      m.reply _("Confession must be at least 10 words. You need %{m} more.") % {:m => diff}
+      return
+    end
+    uri = "http://beta.grouphug.us/confess"
+    form_id = "form_id=confession_node_form"
+    op = "op=Submit"
+    changed = "changed="
+    body = "body=#{c}"
+    msg = [form_id,body,changed,op].join("&")
+
+    response = bot.httputil.post(uri, msg)
+    debug response.body
+    if response.class == Net::HTTPOK
+      num = response.body.scan(REGPOST)
+      m.reply _("Confession posted: http://beta.grouphug.us/confessions/%{n}") % {:n => num}
+    else
+      m.reply _("I couldn't share your confession.")
     end
+  end
 
-    def privmsg( m )
-        path = "/random"
-        path = "/confessions/#{m.params()}" if m.params()
-        begin
-          data = bot.httputil.get(URI.parse("http://grouphug.us/#{path}"))
 
-          reg = Regexp.new( '(<td class="conf-text")(.*?)(<p>)(.*?)(</p>)', Regexp::MULTILINE )
-          confession = reg.match( data )[4]
-          confession.gsub!( /<.*?>/, "" ) # Remove html tags
-          confession.gsub!( "\t", "" ) # Remove tab characters
+  def confess(m, params)
+    opts = { :cache => false }
+    path = "random"
+    begin
+      # Fetch a specific question - separate from cache
+      if params[:num]
+        path = "confessions/#{params[:num]}"
+        opts.delete(:cache)
+        data = @bot.httputil.get("http://grouphug.us/#{path}", opts)
 
-          @bot.say(m.replyto, confession)
-        rescue
-          m.reply "failed to connect to grouphug.us"
+        res = data.scan(REG)
+        confession = res[0][0].ircify_html
+        confession = "no confession ##{params[:num]} found" if confession.empty? and params[:num]
+        m.reply confession
+      else # Cache random confessions
+        if @confessions.empty?
+          data = @bot.httputil.get("http://grouphug.us/#{path}", opts)
+          res = data.scan(REG)
+          res.each do |quote|
+            @confessions << quote[0].ircify_html
+          end
         end
-   end
+        confession = @confessions.pop
+        m.reply confession
+      end
+    rescue
+      m.reply "failed to connect to grouphug.us"
+    end
+  end
 end
 
 
 plugin = GrouphugPlugin.new
 
-plugin.register("grouphug")
-plugin.register("confess")
+plugin.default_auth('create', false)
+
+plugin.map "grouphug [:num]",
+  :thread => true, :action => :confess, :requirements => { :num => /\d+/ }
+plugin.map "confess [:num]",
+  :thread => true, :action => :confess, :requirements => { :num => /\d+/ }
+plugin.map "confess *confession", :thread => true, :action => :post_confession, :auth_path => 'create'
 

data/data/rbot/plugins/hl2.rb

@@ -0,0 +1,97 @@
+#-- vim:sw=2:et
+#++
+#
+# :title: Half-Life 2 plugin for rbot
+#
+# Author:: Ole Christian Rynning <oc@rynning.no>
+# Author:: Andrew Northall <cubehat@gmail.com>
+# Copyright:: (C) 2006 Ole Christian Rynning & Andrew Northall
+# License:: GPL v2
+#
+# Simple Half-Life 2 (Source Engine) plugin to query online
+# servers to see if its online and kicking and how many users.
+#
+# Added 2 seconds timeout to the response. And sockets are now
+# closing properly.
+#
+# Server presets can be added by using 'hl2 add name addr:port'
+# and 'hl2 del name'. Once presets are added they are accessed
+# as 'hl2 name'.
+
+require 'socket'
+require 'timeout'
+
+class HL2Plugin < Plugin
+
+  A2S_INFO = "\xFF\xFF\xFF\xFF\x54\x53\x6F\x75\x72\x63\x65\x20\x45\x6E\x67\x69\x6E\x65\x20\x51\x75\x65\x72\x79\x00"
+
+  TIMEOUT = 2
+
+  def a2s_info(addr, port)
+    socket = UDPSocket.new()
+    begin
+      socket.send(A2S_INFO, 0, addr, port.to_i)
+      response = nil
+
+      timeout(TIMEOUT) do
+        response = socket.recvfrom(1400,0)
+      end
+    rescue Exception => e
+      error e
+    end
+
+    socket.close()
+    response ? response.first.unpack("iACZ*Z*Z*Z*sCCCaaCCZ*") : nil
+  end
+
+  def help(plugin, topic="")
+    case topic
+    when ""
+      return "hl2 'server:port'/'preset name' => show basic information about the given server. See also 'hl2 add' and 'hl2 del'"
+    when "add"
+      return "hl2 add 'name' 'server:port' => add a preset."
+    when "del"
+      return "hl2 del 'name' => remove a preset."
+    end
+  end
+
+  def hl2(m, params)
+    addr, port = params[:conn_str].split(':')
+    if port == nil
+      @registry.each_key do
+        |key|
+        if addr.downcase == key.downcase
+          addr, port = @registry[key]
+        end
+      end
+    end
+    m.reply "invalid server" if port == nil
+    return if port == nil
+    info = a2s_info(addr, port)
+    if info
+      m.reply "#{info[3]} (#{info[6]}): #{info[8]}/#{info[9]} - #{info[4]}"
+    else
+      m.reply "Couldn't connect to #{params[:conn_str]}"
+    end
+  end
+
+  def add_server(m, params)
+    @registry[params[:name]] = params[:conn_str].split(':')
+    m.okay
+  end
+
+  def rem_server(m, params)
+    if @registry.has_key?(params[:name]) == false
+      m.reply "but i don't know it!"
+      return
+    end
+    @registry.delete params[:name]
+    m.okay
+  end
+end
+
+plugin = HL2Plugin.new
+plugin.default_auth('edit', false)
+plugin.map 'hl2 :conn_str', :thread => true
+plugin.map 'hl2 add :name :conn_str', :thread => true, :action => :add_server, :auth_path => 'edit'
+plugin.map 'hl2 del :name', :thread => true, :action => :rem_server, :auth_path => 'edit'

data/data/rbot/plugins/host.rb

@@ -1,13 +1,22 @@
 class HostPlugin < Plugin
+  Config.register Config::StringValue.new('host.path',
+     :default => 'host',
+     :desc => _('Path to the host program'))
+
   def help(plugin, topic="")
     "host <domain> => query nameserver about domain names and zones for <domain>"
   end
+
+  def host_path
+    @bot.config["host.path"]
+  end
+
   def privmsg(m)
     unless(m.params =~ /^(\w|-|\.)+$/)
       m.reply "incorrect usage: " + help(m.plugin)
       return
     end
-    m.reply Utils.safe_exec("host", m.params)
+    m.reply Utils.safe_exec(host_path, m.params)
   end
 end
 plugin = HostPlugin.new

data/data/rbot/plugins/httpd.rb.disabled

@@ -23,6 +23,7 @@ class HttpPlugin < Plugin
   end
   def cleanup
     @http_server.shutdown
+    super
   end
   def help(plugin, topic="")
     "no help yet"

data/data/rbot/plugins/imdb.rb

@@ -1,92 +1,556 @@
-# IMDB plugin for RubyBot
-# (c) 2005 Arnaud Cornet <arnaud.cornet@gmail.com>
-# Licensed under MIT License.
-
-require 'net/http'
-require 'cgi'
-require 'uri/common'
+#-- vim:sw=2:et
+#++
+#
+# :title: IMDB plugin for rbot
+#
+# Author:: Arnaud Cornet <arnaud.cornet@gmail.com>
+# Author:: Giuseppe "Oblomov" Bilotta <giuseppe.bilotta@gmail.com>
+#
+# Copyright:: (C) 2005 Arnaud Cornet
+# Copyright:: (C) 2007 Giuseppe Bilotta
+#
+# License:: MIT license
 
 class Imdb
+  IMDB = "http://us.imdb.com"
+  TITLE_OR_NAME_MATCH = /<a href="(\/(?:title|name)\/(?:tt|nm)[0-9]+\/?)[^"]*"(?:[^>]*)>([^<]*)<\/a>/
+  TITLE_MATCH = /<a href="(\/title\/tt[0-9]+\/?)[^"]*"(?:[^>]*)>([^<]*)<\/a>/
+  NAME_MATCH = /<a href="(\/name\/nm[0-9]+\/?)[^"]*"(?:[^>]*)>([^<]*)<\/a>/
+  CREDIT_NAME_MATCH = /#{NAME_MATCH}<\/td><td[^>]+> \.\.\. <\/td><td[^>]+>(.+?)<\/td>/
+  FINAL_ARTICLE_MATCH = /, ([A-Z]\S{0,2})$/
+
+  MATCHER = {
+    :title => TITLE_MATCH,
+    :name => NAME_MATCH,
+    :both => TITLE_OR_NAME_MATCH
+  }
+
   def initialize(bot)
     @bot = bot
   end
 
-  def search(rawstr)
-    str = URI.escape(rawstr)
-    @http = @bot.httputil.get_proxy(URI.parse("http://us.imdb.com/find?q=#{str}"))
-    @http.start
+  def search(rawstr, rawopts={})
+    str = CGI.escape(rawstr)
+    str << ";site=aka" if @bot.config['imdb.aka']
+    opts = rawopts.dup
+    opts[:type] = :both unless opts[:type]
+    return do_search(str, opts)
+  end
+
+  def do_search(str, opts={})
+    resp = nil
     begin
-    resp, data = @http.get("/find?q=#{str}", "User-Agent" => "Mozilla/5.0")
-    rescue Net::ProtoRetriableError => detail
-      head = detail.data
-      if head.code == "301" or head.code == "302"
-            return head['location'].gsub(/http:\/\/us.imdb.com/, "").gsub(/\?.*/, "")
-        end
+      resp = @bot.httputil.get_response(IMDB + "/find?q=#{str}",
+                                        :max_redir => -1)
+    rescue Exception => e
+      error e.message
+      warning e.backtrace.join("\n")
+      return nil
     end
+
+
+    matcher = MATCHER[opts[:type]]
+
     if resp.code == "200"
-      m = /<a href="(\/title\/tt[0-9]+\/?)[^"]*"(:?[^>]*)>([^<]*)<\/a>/.match(resp.body)
-      if m
-        url = m[1]
-        title = m[2]
-        return url
+      m = []
+      m << matcher.match(resp.body) if @bot.config['imdb.popular']
+      if resp.body.match(/\(Exact Matches\)<\/b>/) and @bot.config['imdb.exact']
+        m << matcher.match($')
+      end
+      m.compact!
+      unless m.empty?
+        return m.map { |mm|
+          mm[1]
+        }.uniq
       end
     elsif resp.code == "302"
-      return resp['location'].gsub(/http:\/\/us.imdb.com/, "").gsub(/\?.*/, "")
+      debug "automatic redirection"
+      new_loc = resp['location'].gsub(IMDB, "")
+      if new_loc.match(/\/find\?q=(.*)/)
+        return do_search($1, opts)
+      else
+        return [new_loc.gsub(/\?.*/, "")]
+      end
     end
     return nil
   end
 
-  def info(rawstr)
-    sr = search(rawstr)
-    if !sr
+  def info(rawstr, opts={})
+    debug opts.inspect
+    urls = search(rawstr, opts)
+    debug urls
+    if urls.nil_or_empty?
       debug "IMDB: search returned NIL"
       return nil
     end
-    resp, data = @http.get(sr, "User-Agent" =>
-      "Mozilla/5.0 (compatible; Konqueror/3.1; Linux)")
+    results = []
+    urls.each { |sr|
+      type = sr.match(/^\/([^\/]+)\//)[1].downcase.intern rescue nil
+      case type
+      when :title
+        results << info_title(sr, opts)
+      when :name
+        results << info_name(sr, opts)
+      else
+        results << "#{sr}"
+      end
+    }
+    return results
+  end
+
+  def grab_info(info, body)
+    /<div class="info">\s+<h5>#{info}:<\/h5>\s+(.*?)<\/div>/mi.match(body)[1] rescue nil
+  end
+
+  def fix_article(org_tit)
+    title = org_tit.dup
+    debug title.inspect
+    if title.match(/^"(.*)"$/)
+      return "\"#{fix_article($1)}\""
+    end
+    if @bot.config['imdb.fix_article'] and title.gsub!(FINAL_ARTICLE_MATCH, '')
+      art = $1.dup
+      debug art.inspect
+      if art[-1,1].match(/[A-Za-z]/)
+        art << " "
+      end
+      return art + title
+    end
+    return title
+  end
+
+  def info_title(sr, opts={})
+    resp = nil
+    begin
+      resp = @bot.httputil.get_response(IMDB + sr, :max_redir => -1)
+    rescue Exception => e
+      error e.message
+      warning e.backtrace.join("\n")
+      return nil
+    end
+
+    info = []
+
     if resp.code == "200"
       m = /<title>([^<]*)<\/title>/.match(resp.body)
       return nil if !m
-      title = CGI.unescapeHTML(m[1])
+      title_date = m[1]
+      pre_title, date, extra = title_date.scan(/^(.*)\((\d\d\d\d(?:\/[IV]+)?)\)\s*(.+)?$/).first
+      pre_title.strip!
+      title = fix_article(pre_title.ircify_html)
 
-      m = /<b>([0-9.]+)\/10<\/b> \(([0-9,]+) votes?\)/.match(resp.body)
-      return nil if !m
-      score = m[1]
-      votes = m[2]
+      dir = nil
+      data = grab_info(/Directors?/, resp.body)
+      if data
+        dir = data.scan(NAME_MATCH).map { |url, name|
+          name.ircify_html
+        }.join(', ')
+      end
+
+      country = nil
+      data = grab_info(/Country/, resp.body)
+      if data
+        country = data.ircify_html.gsub(' / ','/')
+      end
+
+      info << [title, "(#{country}, #{date})", extra, dir ? "[#{dir}]" : nil, opts[:nourl] ? nil : ": http://www.imdb.com#{sr}"].compact.join(" ")
+
+      return info if opts[:title_only]
+
+      if opts[:characters]
+        info << resp.body.scan(CREDIT_NAME_MATCH).map { |url, name, role|
+          "%s: %s" % [name, role.ircify_html]
+        }.join('; ')
+        return info
+      end
+
+      ratings = "no votes"
+      m = /<b>([0-9.]+)\/10<\/b>\n?\r?\s+<small>\(<a href="ratings">([0-9,]+) votes?<\/a>\)<\/small>/.match(resp.body)
+      if m
+        ratings = "#{m[1]}/10 (#{m[2]} voters)"
+      end
 
       genre = Array.new
       resp.body.scan(/<a href="\/Sections\/Genres\/[^\/]+\/">([^<]+)<\/a>/) do |gnr|
         genre << gnr
       end
-      return ["http://us.imdb.com" + sr, title, score, votes,
-        genre]
+
+      plot = nil
+      data = grab_info(/Plot (?:Outline|Summary)/, resp.body)
+      if data
+        plot = "Plot: " + data.ircify_html.gsub(/\s+more$/,'')
+      end
+
+      info << ["Ratings: " << ratings, "Genre: " << genre.join('/') , plot].compact.join(". ")
+
+      return info
     end
     return nil
   end
+
+  def info_name(sr, opts={})
+    resp = nil
+    begin
+      resp = @bot.httputil.get_response(IMDB + sr, :max_redir => -1)
+    rescue Exception => e
+      error e.message
+      warning e.backtrace.join("\n")
+      return nil
+    end
+
+    info = []
+
+    if resp.code == "200"
+      m = /<title>([^<]*)<\/title>/.match(resp.body)
+      return nil if !m
+      name = m[1]
+
+      info << "#{name}"
+      info.last << " : http://www.imdb.com#{sr}" unless opts[:nourl]
+
+      return info if opts[:name_only]
+
+      if opts[:movies_by_year]
+        filmoyear = @bot.httputil.get(IMDB + sr + "filmoyear")
+        if filmoyear
+          info << filmoyear.scan(/#{TITLE_MATCH} \((\d\d\d\d)\)[^\[\n]*((?:\s+\[[^\]]+\](?:\s+\([^\[<]+\))*)+)\s+</)
+        end
+        return info
+      end
+
+      birth = nil
+      data = grab_info("Date of Birth", resp.body)
+      if data
+        birth = "Birth: #{data.ircify_html.gsub(/\s+more$/,'')}"
+      end
+
+      death = nil
+      data = grab_info("Date of Death", resp.body)
+      if data
+        death = "Death: #{data.ircify_html.gsub(/\s+more$/,'')}"
+      end
+
+      info << [birth, death].compact.join('. ') if birth or death
+
+      movies = {}
+
+      filmorate = nil
+      begin
+        filmorate = @bot.httputil.get(IMDB + sr + "filmorate")
+      rescue Exception
+      end
+
+      if filmorate
+        filmorate.scan(/<div class="filmo">.*?<a href="\/title.*?<\/div>/m) { |str|
+          what = str.match(/<a name="[^"]+">([^<]+)<\/a>/)[1] rescue nil
+          next unless what
+          movies[what] = str.scan(TITLE_MATCH)[0..2].map { |url, tit|
+            fix_article(tit.ircify_html)
+          }
+        }
+      end
+
+      preferred = ['Actor', 'Director']
+      if resp.body.match(/Jump to filmography as:&nbsp;(.*?)<\/div>/)
+        txt = $1
+        preferred = txt.scan(/<a[^>]+>([^<]+)<\/a>/)[0..2].map { |pref|
+          pref.first
+        }
+      end
+
+      unless movies.empty?
+        all_keys = movies.keys.sort
+        debug all_keys.inspect
+        keys = []
+        preferred.each { |key|
+          keys << key if all_keys.include? key
+        }
+        keys = all_keys if keys.empty?
+        ar = []
+        keys.each { |key|
+          ar << key.dup
+          ar.last << ": " + movies[key].join('; ')
+        }
+        info << ar.join('. ')
+      end
+      return info
+
+    end
+    return nil
+  end
+
+  def year_movies(urls, years_txt_org, role_req)
+    years_txt = years_txt_org.dup
+    years_txt.sub!(/^'/,'')
+    years_txt = "9#{years_txt}" if years_txt.match(/^\d\ds?$/)
+    years_txt = "1#{years_txt}" if years_txt.match(/^\d\d\ds?$/)
+
+    years = []
+    case years_txt
+    when /^\d\d\d\d$/
+      years << years_txt
+    when /^(\d\d\d\d)s$/
+      base = $1.to_i
+      base.upto(base+9) { |year|
+        years << year.to_s
+      }
+    end
+
+    urls.map { |url|
+      info = info_name(url, :movies_by_year => true)
+
+      debug info.inspect
+
+      name_url = info.first
+      data = info[1]
+
+      movies = []
+      # Sort by pre-title putting movies before TV series
+      data.sort { |a, b|
+        aclip = a[1][0,5]
+        bclip = b[1][0,5]
+        quot = '&#34;'
+        (aclip == quot ? 1 : -1) <=> (bclip == quot ? 1 : -1)
+      }.each { |url, pre_title, year, pre_roles|
+        next unless years.include?(year)
+        title = fix_article(pre_title.ircify_html)
+        if title[0] == ?" and not @bot.config['imdb.tv_series_in_movies']
+          next
+        end
+        title << " (#{year})" unless years.length == 1
+        role_array = []
+        pre_roles.strip.scan(/\[([^\]]+)\]((?:\s+\([^\[]+\))+)?/) { |txt, comm|
+          role = nil
+          extra = nil
+          if txt.match(/^(.*)\s+\.\.\.\.\s+(.*)$/)
+            role = $1
+            extra = "(#{$2.ircify_html})"
+          else
+            role = txt
+          end
+          next if role_req and not role.match(/^#{role_req}/i)
+          if comm
+            extra ||= ""
+            extra += comm.ircify_html if comm
+          end
+          role_array << [role, extra]
+        }
+        next if role_req and role_array.empty?
+
+        roles = role_array.map { |ar|
+          if role_req
+            ar[1] # works for us both if it's nil and if it's something
+          else
+            ar.compact.join(" ")
+          end
+        }.compact.join(', ')
+        roles = nil if roles.empty?
+        movies << [roles, title].compact.join(": ")
+      }
+
+      if movies.empty?
+        [name_url, nil]
+      else
+        [name_url, movies.join(" | ")]
+      end
+    }
+  end
+
+  def name_in_movie(name_urls, movie_urls)
+    info = []
+    movie_urls.each { |movie|
+      title_info = info_title(movie, :title_only => true)
+      valid = []
+
+      data = @bot.httputil.get(IMDB + movie + "fullcredits")
+      data.scan(CREDIT_NAME_MATCH).each { |url, name, role|
+        valid << [url, name.ircify_html, role.ircify_html] if name_urls.include?(url)
+      }
+      valid.each { |url, name, role|
+        info << "%s : %s was %s in %s" % [name, IMDB + url, role, title_info]
+      }
+    }
+    return info
+  end
+
+
 end
 
 class ImdbPlugin < Plugin
+  Config.register Config::BooleanValue.new('imdb.aka',
+    :default => true,
+    :desc => "Look for IMDB matches also in translated titles and other 'also known as' information")
+  Config.register Config::BooleanValue.new('imdb.popular',
+    :default => true,
+    :desc => "Display info on popular IMDB entries matching the request closely")
+  Config.register Config::BooleanValue.new('imdb.exact',
+    :default => true,
+    :desc => "Display info on IMDB entries matching the request exactly")
+  Config.register Config::BooleanValue.new('imdb.fix_article',
+    :default => false,
+    :desc => "Try to detect an article placed at the end and move it in front of the title")
+  Config.register Config::BooleanValue.new('imdb.tv_series_in_movies',
+    :default => false,
+    :desc => "Whether searching movies by person/year should also return TV series")
+
   def help(plugin, topic="")
-    "imdb <string> => search http://www.imdb.org for <string>"
+    case plugin
+    when "movies"
+      "movies by <who> in <years> [as <role>] => display the movies in the <years> where which <who> was <role>; <role> can be one of actor, actress, director or anything: if it's omitted, the role is defined by the prefix: \"movies by ...\" implies director, \"movies with ...\" implies actor or actress; the years can be specified as \"in the 60s\" or as \"in 1953\""
+    when /characters?/
+      "character played by <who> in <movie> => show the character played by <who> in movie <movie>. characters in <movie> => show the actors and characters in movie <movie>"
+    else
+      "imdb <string> => search http://www.imdb.org for <string>: prefix <string> with 'name' or 'title' if you only want to search for people or films respectively, e.g.: imdb name ed wood. see also movies and characters"
+    end
   end
 
-  def privmsg(m)
-    unless(m.params && m.params.length > 0)
-      m.reply "incorrect usage: " + help(m.plugin)
+  attr_reader :i
+
+  TITLE_URL = %r{^http://(?:[^.]+\.)?imdb.com(/title/tt\d+/)}
+  NAME_URL = %r{^http://(?:[^.]+\.)?imdb.com(/name/nm\d+/)}
+  def imdb_filter(s)
+    loc = Utils.check_location(s, TITLE_URL)
+    if loc
+      sr = loc.first.match(TITLE_URL)[1]
+      extra = $2 # nothign for the time being, could be fullcredits or whatever
+      res = i.info_title(sr, :nourl => true, :characters => (extra == 'fullcredits'))
+      debug res
+      if res
+        return {:title => res.first, :content => res.last}
+      else
+        return nil
+      end
+    end
+    loc = Utils.check_location(s, NAME_URL)
+    if loc
+      sr = loc.first.match(NAME_URL)[1]
+      extra = $2 # nothing for the time being, could be filmoyear or whatever
+      res = i.info_name(sr, :nourl => true, :movies_by_year => (extra == 'filmoyear'))
+      debug res
+      if res
+        name = res.shift
+        return {:title => name, :content => res.join(". ")}
+      else
+        return nil
+      end
+    end
+    return nil
+  end
+
+  def initialize
+    super
+    @i = Imdb.new(@bot)
+    @bot.register_filter(:imdb, :htmlinfo) { |s| imdb_filter(s) }
+  end
+
+  # Find a person or movie on IMDB. A :type (name/title, default both) can be
+  # specified to limit the search to either.
+  #
+  def imdb(m, params)
+    if params[:movie]
+      movie = params[:movie].to_s
+      info = i.info(movie, :type => :title, :characters => true)
+    else
+      what = params[:what].to_s
+      type = params[:type].intern
+      info = i.info(what, :type => type)
+      if !info
+        m.reply "nothing found for #{what}"
+        return nil
+      end
+    end
+    if info.length == 1
+      m.reply Utils.decode_html_entities(info.first.join("\n"))
+    else
+      m.reply info.map { |si|
+        Utils.decode_html_entities si.join(" | ")
+      }.join("\n")
+    end
+  end
+
+  # Find the movies with a participation of :who in the year :year
+  # TODO: allow year to be either a year or a decade ('[in the] 1960s') 
+  #
+  def movies(m, params)
+    who = params[:who].to_s
+    years = params[:years]
+    role = params[:role]
+    if role and role.downcase == 'anything'
+      role = nil
+    elsif not role
+      case params[:prefix].intern
+      when :with
+        role = /actor|actress/i
+      when :by
+        role = 'director'
+      end
+    end
+
+    name_urls = i.search(who, :type => :name)
+    unless name_urls
+      m.reply "nothing found about #{who}, sorry"
       return
     end
 
-    i = Imdb.new(@bot)
-    info = i.info(m.params)
-    if !info
-      m.reply "Nothing found for #{m.params}"
-      return nil
+    movie_urls = i.year_movies(name_urls, years, role)
+    debug movie_urls.inspect
+    debug movie_urls[0][1]
+
+    if movie_urls.length == 1 and movie_urls[0][1]
+      m.reply movie_urls.join("\n")
+    else
+      m.reply movie_urls.map { |si|
+        si[1] = "no movies in #{years}" unless si[1]
+        Utils.decode_html_entities si.join(" | ")
+      }.join("\n")
+    end
+  end
+
+  # Find the character played by :who in :movie
+  #
+  def character(m, params)
+    who = params[:who].to_s
+    movie = params[:movie].to_s
+
+    name_urls = i.search(who, :type => :name)
+    unless name_urls
+      m.reply "nothing found about #{who}, sorry"
+      return
+    end
+
+    movie_urls = i.search(movie, :type => :title)
+    unless movie_urls
+      m.reply "nothing found about #{who}, sorry"
+      return
+    end
+
+    info = i.name_in_movie(name_urls, movie_urls)
+    if info.empty?
+      m.reply "nothing found about #{who} in #{movie}, sorry"
+    else
+      m.reply info.join("\n")
+    end
+  end
+
+  # Report the characters in movie :movie
+  #
+  def characters(m, params)
+    movie = params[:movie].to_s
+
+    urls = i.search(movie, :type => :title)
+    unless urls
+      m.reply "nothing found about #{movie}"
     end
-    m.reply "#{info[1]} : #{info[0]}"
-    m.reply "Ratings: #{info[2]}/10 (#{info[3]} voters). Genre: #{info[4].join('/')}"
+
   end
+
 end
 
 plugin = ImdbPlugin.new
-plugin.register("imdb")
+
+plugin.map "imdb [:type] *what", :requirements => { :type => /name|title/ }, :defaults => { :type => 'both' }
+plugin.map "movies :prefix *who in [the] :years [as :role]", :requirements => { :prefix => /with|by|from/, :years => /'?\d+s?/ }
+plugin.map "character [played] by *who in *movie"
+plugin.map "character of *who in *movie"
+plugin.map "characters in *movie", :action => :imdb