rbot 0.9.10 → 0.9.12

data/data/rbot/plugins/dict.rb

@@ -0,0 +1,243 @@
+#-- vim:sw=2:et
+#++
+#
+# :title: Dictionary lookup plugin for rbot
+#
+# Author:: Giuseppe "Oblomov" Bilotta <giuseppe.bilotta@gmail.com>
+# Copyright:: (C) 2006-2007 Giuseppe Bilotta
+# License:: GPL v2
+#
+# Provides a link to the definition of a word in one of the supported
+# dictionaries. Currently available are
+#   * the Oxford dictionary for (British) English
+#   * the De Mauro/Paravia dictionary for Italian
+#   * the Chambers dictionary for English (accepts both US and UK)
+#   * the Littré dictionary for French
+#
+# Other plugins can use this one to check if a given word is valid in italian
+# or english or french by using the is_italian?, is_british?, is_english?,
+# is_french? methods
+#
+# TODO: cache results and reuse them if get_cached returns a cache copy
+
+DEMAURO_LEMMA = /<anchor>(.*?)(?: - (.*?))<go href="lemma.php\?ID=(\d+)"\/><\/anchor>/
+CHAMBERS_LEMMA = /<p><span class="hwd">(.*?)<\/span> <span class="psa">(.*?)<\/span>(.*?)<\/p>/
+
+class DictPlugin < Plugin
+  Config.register Config::IntegerValue.new('dict.hits',
+    :default => 3,
+    :desc => "Number of hits to return from a dictionary lookup")
+  Config.register Config::IntegerValue.new('dict.first_par',
+    :default => 0,
+    :desc => "When set to n > 0, the bot will return the first paragraph from the first n dictionary hits")
+
+  def demauro_filter(s)
+    # check if it's a page we can handle
+    loc = Utils.check_location(s, @dmurlrx)
+    # the location might be not good, but we might still be able to handle the
+    # page
+    if !loc and s[:text] !~ /<!-- Il dizionario della lingua italiana Paravia: /
+      debug "not our business"
+      return
+    end
+    # we want to grab the content from the WAP page, since it's in a much
+    # cleaner HTML, so first try to get the word ID
+    if s[:text] !~ %r{<li><a href="(\d+)" title="vai al lemma precedente" accesskey="p">lemma precedente</a></li>}
+      return
+    end
+    id = $1.to_i + 1
+    title = s[:text].ircify_html_title
+    content = @bot.filter(:htmlinfo, URI.parse(@dmwaplemma % id))[:content]
+    return {:title => title, :content => content.sub(/^\S+\s+-\s+/,'')}
+  end
+
+  def initialize
+    super
+    @dmurl = "http://www.demauroparavia.it/"
+    @dmurlrx = %r{http://(?:www\.)?demauroparavia\.it/(\d+)}
+    @dmwapurl = "http://wap.demauroparavia.it/index.php?lemma=%s"
+    @dmwaplemma = "http://wap.demauroparavia.it/lemma.php?ID=%s"
+    @oxurl = "http://www.askoxford.com/concise_oed/%s"
+    @chambersurl = "http://www.chambersharrap.co.uk/chambers/features/chref/chref.py/main?query=%s&title=21st"
+    @littreurl = "http://francois.gannaz.free.fr/Littre/xmlittre.php?requete=%s"
+
+    @bot.register_filter(:demauro, :htmlinfo) { |s| demauro_filter(s) }
+  end
+
+
+  def help(plugin, topic="")
+    case topic
+    when "demauro"
+      return "demauro <word> => provides a link to the definition of <word> from the De Mauro/Paravia dictionary"
+    when "oxford"
+      return "oxford <word> => provides a link to the definition of <word> (it can also be an expression) from the Concise Oxford dictionary"
+    when "chambers"
+      return "chambers <word> => provides a link to the definition of <word> (it can also be an expression) from the Chambers 21st Century Dictionary"
+    when "littre"
+      return "littre <word> => provides a link to the definition of <word> (it can also be an expression) from the Littré online dictionary"
+    end
+    return "<dictionary> <word>: check for <word> on <dictionary> where <dictionary> can be one of: demauro, oxford, chambers, littre"
+  end
+
+  def demauro(m, params)
+    justcheck = params[:justcheck]
+
+    word = params[:word].downcase
+    url = @dmwapurl % CGI.escape(word)
+    xml = nil
+    info = @bot.httputil.get_response(url) rescue nil
+    xml = info.body if info
+    if xml.nil?
+      info = info ? " (#{info.code} - #{info.message})" : ""
+      return false if justcheck
+      m.reply "An error occurred while looking for #{word}#{info}"
+      return
+    end
+    if xml=~ /Non ho trovato occorrenze per/
+      return false if justcheck
+      m.reply "Nothing found for #{word}"
+      return
+    end
+    entries = xml.scan(DEMAURO_LEMMA)
+    text = word
+    urls = []
+    if not entries.transpose.first.grep(/\b#{word}\b/)
+      return false if justcheck
+      text += " not found. Similar words"
+    end
+    return true if justcheck
+    text += ": "
+    n = 0
+    hits = @bot.config['dict.hits']
+    text += entries[0...hits].map { |ar|
+      n += 1
+      urls << @dmwaplemma % ar[2]
+      "#{n}. #{Bold}#{ar[0]}#{Bold} - #{ar[1].gsub(/<\/?em>/,'')}: #{@dmurl}#{ar[2]}"
+    }.join(" | ")
+    m.reply text
+
+    first_pars = @bot.config['dict.first_par']
+
+    return unless first_pars > 0
+
+    Utils.get_first_pars urls, first_pars, :message => m,
+      :strip => /^.+?\s+-\s+/
+
+  end
+
+  def is_italian?(word)
+    return demauro(nil, :word => word, :justcheck => true)
+  end
+
+
+  def oxford(m, params)
+    justcheck = params[:justcheck]
+
+    word = params[:word].join
+    [word, word + "_1"].each { |check|
+      url = @oxurl % CGI.escape(check)
+      if params[:british]
+        url << "?view=uk"
+      end
+      h = @bot.httputil.get(url, :max_redir => 5)
+      if h and h.match(/<h2>#{word}<\/h2>(.*)Perform/m)
+        m.reply("#{word} : #{url}") unless justcheck
+        defn = $1
+        m.reply("#{Bold}%s#{Bold}: %s" % [word, defn.ircify_html(:nbsp => :space)], :overlong => :truncate)
+        return true
+      end
+    }
+    return false if justcheck
+    m.reply "#{word} not found"
+  end
+
+  def is_british?(word)
+    return oxford(nil, :word => word, :justcheck => true, :british => true)
+  end
+
+
+  def chambers(m, params)
+    justcheck = params[:justcheck]
+
+    word = params[:word].to_s.downcase
+    url = @chambersurl % CGI.escape(word)
+    xml = nil
+    info = @bot.httputil.get_response(url) rescue nil
+    xml = info.body if info
+    case xml
+    when nil
+      info = info ? " (#{info.code} - #{info.message})" : ""
+      return false if justcheck
+      m.reply "An error occurred while looking for #{word}#{info}"
+      return
+    when /Sorry, no entries for <b>.*?<\/b> were found./
+      return false if justcheck
+      m.reply "Nothing found for #{word}"
+      return
+    when /No exact matches for <b>.*?<\/b>, but the following may be helpful./
+      return false if justcheck
+      m.reply "Nothing found for #{word}, but see #{url} for possible suggestions"
+      return
+    end
+    # Else, we have a hit
+    return true if justcheck
+    m.reply "#{word}: #{url}"
+    entries = xml.scan(CHAMBERS_LEMMA)
+    hits = @bot.config['dict.hits']
+    entries[0...hits].map { |ar|
+      m.reply(("#{Bold}%s#{Bold} #{Underline}%s#{Underline}%s" % ar).ircify_html, :overlong => :truncate)
+    }
+  end
+
+  def is_english?(word)
+    return chambers(nil, :word => word, :justcheck => true)
+  end
+
+  def littre(m, params)
+    justcheck = params[:justcheck]
+
+    word = params[:word].to_s.downcase
+    url = @littreurl % CGI.escape(word)
+    xml = nil
+    info = @bot.httputil.get_response(url) rescue nil
+    xml = info.body if info
+    head ||= xml.match(/<div class="entree">(.*?)<\/div>/)[1] rescue nil
+    case xml
+    when nil
+      info = info ? " (#{info.code} - #{info.message})" : ""
+      return false if justcheck
+      m.reply "An error occurred while looking for #{word}#{info}"
+      return
+    when /Erreur : le mot <STRONG>.*?<\/STRONG> n'a pas./
+      return false if justcheck
+      if head
+        m.reply "Nothing found for #{word}, I'll assume you meant #{head}"
+      else
+        m.reply "Nothing found for #{word}"
+        return
+      end
+    end
+    return true if justcheck
+    entete = xml.match(/<div class="entete">(.*?)<\/div>/m)[1] rescue nil
+    m.reply "#{head}: #{url} : #{entete.ircify_html rescue nil}"
+    entries = xml.scan(/<span class="variante">(.*?)<\!--variante-->/m)
+    hits = @bot.config['dict.hits']
+    n = 0
+    entries[0...hits].map { |ar|
+      n += 1
+      m.reply(("#{Bold}#{n}#{Bold} %s" % ar).ircify_html, :overlong => :truncate)
+    }
+  end
+
+  def is_french?(word)
+    return littre(nil, :word => word, :justcheck => true)
+  end
+
+end
+
+plugin = DictPlugin.new
+plugin.map 'demauro :word', :action => 'demauro', :thread => true
+plugin.map 'oxford *word', :action => 'oxford', :thread => true
+plugin.map 'chambers *word', :action => 'chambers', :thread => true
+plugin.map 'littre *word', :action => 'littre', :thread => true
+

data/data/rbot/plugins/dictclient.rb

@@ -0,0 +1,211 @@
+#-- vim:sw=2:et
+#++
+#
+# :title: DICT (RFC 2229) Protocol Client Plugin for rbot
+#
+# Author:: Yaohan Chen <yaohan.chen@gmail.com>
+# Copyright:: (C) 2007 Yaohan Chen
+# License:: GPL v2
+#
+# Looks up words on a DICT server. DEFINE and MATCH commands, as well as listing of
+# databases and strategies are supported.
+#
+# TODO
+# Improve output format
+
+
+# requires Ruby/DICT <http://www.caliban.org/ruby/ruby-dict.shtml>
+require 'dict'
+
+class ::String
+  # Returns a new string truncated to length 'to'
+  # If ellipsis is not given, that will just be the first n characters,
+  # Else it will return a string in the form <head><ellipsis><tail>
+  # The total length of that string will not exceed 'to'.
+  # If tail is an Integer, the tail will be exactly 'tail' characters,
+  # if it is a Float/Rational tails length will be (to*tail).ceil.
+  #
+  # Contributed by apeiros
+  def truncate(to=32, ellipsis='…', tail=0.3)
+    str  = split(//)
+    return str.first(to).join('') if !ellipsis or str.length <= to
+    to  -= ellipsis.split(//).length
+    tail = (tail*to).ceil unless Integer === tail
+    to  -= tail
+    "#{str.first(to)}#{ellipsis}#{str.last(tail)}"
+  end
+end
+
+class ::Definition
+  def headword
+    definition[0].strip
+  end
+
+  def body
+    # two or more consecutive newlines are replaced with double spaces, while single
+    # newlines are replaced with single spaces
+    lb = /\r?\n/
+    definition[1..-1].join.
+      gsub(/\s*(:#{lb}){2,}\s*/, '  ').
+      gsub(/\s*#{lb}\s*/, ' ').strip
+  end
+end
+
+class DictClientPlugin < Plugin
+  Config.register Config::StringValue.new('dictclient.server',
+    :default => 'dict.org',
+    :desc => _('Hostname or hostname:port of the DICT server used to lookup words'))
+  Config.register Config::IntegerValue.new('dictclient.max_defs_before_collapse',
+    :default => 4,
+    :desc => _('When multiple databases reply a number of definitions that above this limit, only the database names will be listed. Otherwise, the full definitions from each database are replied'))
+  Config.register Config::IntegerValue.new('dictclient.max_length_per_def',
+    :default => 200,
+    :desc => _('Each definition is truncated to this length'))
+  Config.register Config::StringValue.new('dictclient.headword_format',
+    :default => "#{Bold}<headword>#{Bold}",
+    :desc => _('Format of headwords; <word> will be replaced with the actual word'))
+  Config.register Config::StringValue.new('dictclient.database_format',
+    :default => "#{Underline}<database>#{Underline}",
+    :desc => _('Format of database names; <database> will be replaced with the database name'))
+  Config.register Config::StringValue.new('dictclient.definition_format',
+    :default => '<headword>: <definition> -<database>',
+    :desc => _('Format of definitions. <word> will be replaced with the formatted headword, <def> will be replaced with the truncated definition, and <database> with the formatted database name'))
+  Config.register Config::StringValue.new('dictclient.match_format',
+    :default => '<matches>––<database>',
+    :desc => _('Format of match results. <matches> will be replaced with the formatted headwords, <database> with the formatted database name'))
+  
+  def initialize
+    super
+  end
+  
+  # create a DICT object, which is passed to the block. after the block finishes,
+  # the DICT object is automatically disconnected. the return value of the block
+  # is returned from this method.
+  # if an IRC message argument is passed, the error message will be replied
+  def with_dict(m=nil &block)
+    server, port = @bot.config['dictclient.server'].split ':' if @bot.config['dictclient.server']
+    server ||= 'dict.org'
+    port ||= DICT::DEFAULT_PORT
+    ret = nil
+    begin
+      dict = DICT.new(server, port)
+      ret = yield dict
+      dict.disconnect
+    rescue ConnectError
+      m.reply _('An error occured connecting to the DICT server. Check the dictclient.server configuration or retry later') if m
+    rescue ProtocolError
+      m.reply _('A protocol error occured') if m
+    rescue DICTError
+      m.reply _('An error occured') if m
+    end
+    ret
+  end
+  
+  def format_headword(w)
+    @bot.config['dictclient.headword_format'].gsub '<headword>', w
+  end
+    
+  def format_database(d)
+    @bot.config['dictclient.database_format'].gsub '<database>', d
+  end
+  
+  def cmd_define(m, params)
+    phrase = params[:phrase].to_s
+    results = with_dict(m) {|d| d.define(params[:database], params[:phrase])}
+    m.reply(
+      if results
+        # only list database headers if definitions come from different databases and
+        # the number of definitions is above dictclient.max_defs_before_collapse
+        if results.any? {|r| r.database != results[0].database} &&
+           results.length > @bot.config['dictclient.max_defs_before_collapse']
+          _("Many definitions for %{phrase} were found in %{databases}. Use 'define <phrase> from <database> to view a definition.") % 
+          { :phrase => format_headword(phrase),
+            :databases => results.collect {|r| r.database}.uniq.
+                                  collect {|d| format_database d}.join(', ') }
+        # otherwise display the definitions
+        else
+          results.collect {|r|
+            @bot.config['dictclient.definition_format'].gsub(
+              '<headword>', format_headword(r.headword)
+            ).gsub(
+              '<database>', format_database(r.database)
+            ).gsub(
+              '<definition>', r.body.truncate(@bot.config['dictclient.max_length_per_def'])
+            )
+          }.join ' | '
+        end
+      else
+        _("No definition for %{phrase} found from %{database}.") % 
+          { :phrase => format_headword(phrase),
+            :database => format_database(params[:database]) }
+      end
+    )
+  end
+  
+  def cmd_match(m, params)
+    phrase = params[:phrase].to_s
+    results = with_dict(m) {|d| d.match(params[:database],
+                                        params[:strategy], phrase)}
+    m.reply(
+      if results
+        results.collect {|database, matches|
+          @bot.config['dictclient.match_format'].gsub(
+            '<matches>', matches.collect {|m| format_headword m}.join(', ')
+          ).gsub(
+            '<database>', format_database(database)
+          )
+        }.join ' '
+      else
+        _("Nothing matched %{query} from %{database} using %{strategy}") % 
+        { :query => format_headword(phrase),
+          :database => format_database(params[:database]),
+          :strategy => params[:strategy] }
+      end
+    )
+  end
+    
+  def cmd_databases(m, params)
+    with_dict(m) do |d|
+      m.reply _("Databases: %{list}") % {
+        :list => d.show_db.collect {|db, des| "#{format_database db}: #{des}"}.join(' | ')
+      }
+    end
+  end
+  
+  def cmd_strategies(m, params)
+    with_dict(m) do |d|
+      m.reply _("Strategies: %{list}") % {
+        :list => d.show_strat.collect {|s, des| "#{s}: #{des}"}.join(' | ')
+      }
+    end
+  end
+    
+  def help(plugin, topic='')
+    case topic
+    when 'define'
+      _('define <phrase> [from <database>] => Show definition of a phrase')
+    when 'match'
+      _('match <phrase> [using <strategy>] [from <database>] => Show phrases matching the given pattern')
+    when 'server information'
+      _('dictclient databases => List databases; dictclient strategies => List strategies')
+    else
+      _('look up phrases on the configured DICT server. topics: define, match, server information')
+    end
+  end
+end
+
+plugin = DictClientPlugin.new
+
+plugin.map 'define *phrase [from :database]',
+           :action => 'cmd_define',
+           :defaults => {:database => DICT::ALL_DATABASES},
+           :threaded => true
+
+plugin.map 'match *phrase [using :strategy] [from :database]',
+           :action => 'cmd_match',
+           :defaults => {:database => DICT::ALL_DATABASES,
+                         :strategy => DICT::DEFAULT_MATCH_STRATEGY },
+           :threaded => true
+
+plugin.map 'dictclient databases', :action => 'cmd_databases', :thread => true
+plugin.map 'dictclient strategies', :action => 'cmd_strategies', :thread => true