rbot 0.9.14 → 0.9.15

data/lib/rbot/core/utils/utils.rb

@@ -16,15 +16,6 @@ require 'set'
 begin
   require 'htmlentities'
 rescue LoadError
-  gems = nil
-  begin
-    gems = require 'rubygems'
-  rescue LoadError
-    gems = false
-  end
-  if gems
-    retry
-  else
     module ::Irc
       module Utils
         UNESCAPE_TABLE = {
@@ -108,7 +99,6 @@ rescue LoadError
         }
       end
     end
-  end
 end
 
 begin
@@ -121,15 +111,6 @@ begin
     end
   end
 rescue LoadError
-  gems = nil
-  begin
-    gems = require 'rubygems'
-  rescue LoadError
-    gems = false
-  end
-  if gems
-    retry
-  else
     module ::Irc
       module Utils
         # Some regular expressions to manage HTML data
@@ -150,7 +131,6 @@ rescue LoadError
         AFTER_PAR2_REGEX = /<br(?:\s+[^>]*)?\/?>.*?<\/?(?:br|p|div|html|body|table|td|tr)(?:\s+[^>]*)?\/?>/im
       end
     end
-  end
 end
 
 module ::Irc
@@ -169,7 +149,7 @@ module ::Irc
     def Utils.bot=(b)
       debug "initializing utils"
       @@bot = b
-      @@safe_save_dir = "#{@@bot.botclass}/safe_save"
+      @@safe_save_dir = @@bot.path('safe_save')
     end
 
 
@@ -179,10 +159,12 @@ module ::Irc
     SEC_PER_HR = SEC_PER_MIN * 60
     # Seconds per day
     SEC_PER_DAY = SEC_PER_HR * 24
+    # Seconds per week
+    SEC_PER_WK = SEC_PER_DAY * 7
     # Seconds per (30-day) month
     SEC_PER_MNTH = SEC_PER_DAY * 30
-    # Second per (30*12 = 360 day) year
-    SEC_PER_YR = SEC_PER_MNTH * 12
+    # Second per (non-leap) year
+    SEC_PER_YR = SEC_PER_DAY * 365
 
     # Auxiliary method needed by Utils.secs_to_string
     def Utils.secs_to_string_case(array, var, string, plural)
@@ -244,44 +226,54 @@ module ::Irc
     # :date_format, used with <tt>to_formatted_s<tt>, default to :default
     def Utils.timeago(time, options = {})
       start_date = options.delete(:start_date) || Time.new
-      date_format = options.delete(:date_format) || :default
-      delta_minutes = (start_date.to_i - time.to_i).floor / 60
-      if delta_minutes.abs <= (8724*60) # eight weeks? I'm lazy to count days for longer than that
-        distance = Utils.distance_of_time_in_words(delta_minutes);
-        if delta_minutes < 0
+      date_format = options.delete(:date_format) || "%x"
+      delta = (start_date - time).round
+      if delta.abs < 2
+        _("right now")
+      else
+        distance = Utils.age_string(delta)
+        if delta < 0
           _("%{d} from now") % {:d => distance}
         else
           _("%{d} ago") % {:d => distance}
         end
-      else
-        return _("on %{date}") % {:date => system_date.to_formatted_s(date_format)}
       end
     end
-  # Translates a number of minutes into verbal distances.
-  # e.g. 0.5 => less than a minute
-  #      70 => about one hour
-  def Utils.distance_of_time_in_words(minutes)
-    case
-      when minutes < 1
-        _("less than a minute")
-      when minutes < 50
-        _("%{m} minutes") % {:m => minutes}
-      when minutes < 90
-        _("about one hour")
-      when minutes < 1080
-        _("%{m} hours") % {:m => (minutes / 60).round}
-      when minutes < 1440
-        _("one day")
-      when minutes < 2880
-        _("about one day")
+
+    # Converts age in seconds to "nn units". Inspired by previous attempts
+    # but also gitweb's age_string() sub
+    def Utils.age_string(secs)
+      case
+      when secs < 0
+        Utils.age_string(-secs)
+      when secs > 2*SEC_PER_YR
+        _("%{m} years") % { :m => secs/SEC_PER_YR }
+      when secs > 2*SEC_PER_MNTH
+        _("%{m} months") % { :m => secs/SEC_PER_MNTH }
+      when secs > 2*SEC_PER_WK
+        _("%{m} weeks") % { :m => secs/SEC_PER_WK }
+      when secs > 2*SEC_PER_DAY
+        _("%{m} days") % { :m => secs/SEC_PER_DAY }
+      when secs > 2*SEC_PER_HR
+        _("%{m} hours") % { :m => secs/SEC_PER_HR }
+      when (20*SEC_PER_MIN..40*SEC_PER_MIN).include?(secs)
+        _("half an hour")
+      when (50*SEC_PER_MIN..70*SEC_PER_MIN).include?(secs)
+        # _("about one hour")
+        _("an hour")
+      when (80*SEC_PER_MIN..100*SEC_PER_MIN).include?(secs)
+        _("an hour and a half")
+      when secs > 2*SEC_PER_MIN
+        _("%{m} minutes") % { :m => secs/SEC_PER_MIN }
+      when secs > 1
+        _("%{m} seconds") % { :m => secs }
       else
-        _("%{m} days") % {:m => (minutes / 1440).round}
+        _("one second")
+      end
     end
-  end
-
 
     # Execute an external program, returning a String obtained by redirecting
-    # the program's standards errors and output 
+    # the program's standards errors and output
     #
     def Utils.safe_exec(command, *args)
       IO.popen("-") { |p|
@@ -292,15 +284,34 @@ module ::Irc
             $stderr.reopen($stdout)
             exec(command, *args)
           rescue Exception => e
-            puts "exec of #{command} led to exception: #{e.pretty_inspect}"
-            Kernel::exit! 0
+            puts "exception #{e.pretty_inspect} trying to run #{command}"
+            Kernel::exit! 1
           end
           puts "exec of #{command} failed"
-          Kernel::exit! 0
+          Kernel::exit! 1
         end
       }
     end
 
+    # Try executing an external program, returning true if the run was successful
+    # and false otherwise
+    def Utils.try_exec(command, *args)
+      IO.popen("-") { |p|
+        if p.nil?
+          begin
+            $stderr.reopen($stdout)
+            exec(command, *args)
+          rescue Exception => e
+            Kernel::exit! 1
+          end
+          Kernel::exit! 1
+        else
+          debug p.readlines
+        end
+      }
+      debug $?
+      return $?.success?
+    end
 
     # Safely (atomically) save to _file_, by passing a tempfile to the block
     # and then moving the tempfile to its final location when done.
@@ -620,7 +631,7 @@ module ::Irc
     # returns non-nil, its results are merged in _ds_ and returned. Otherwise
     # nil is returned.
     #
-    # The input DataStream shuold have the downloaded HTML as primary key
+    # The input DataStream should have the downloaded HTML as primary key
     # (:text) and possibly a :headers key holding the resonse headers.
     #
     def Utils.try_htmlinfo_filters(ds)
@@ -629,7 +640,7 @@ module ::Irc
       cur = nil
       # TODO filter priority
       filters.each { |n|
-        debug "testing filter #{n}"
+        debug "testing htmlinfo filter #{n}"
         cur = @@bot.filter(@@bot.global_filter_name(n, :htmlinfo), ds)
         debug "returned #{cur.pretty_inspect}"
         break if cur
@@ -711,6 +722,20 @@ module ::Irc
       return retval
     end
 
+    # Returns a comma separated list except for the last element
+    # which is joined in with specified conjunction
+    #
+    def Utils.comma_list(words, options={})
+      defaults = { :join_with => ", ", :join_last_with => _(" and ") }
+      opts = defaults.merge(options)
+
+      if words.size < 2
+        words.last
+      else
+        [words[0..-2].join(opts[:join_with]), words.last].join(opts[:join_last_with])
+      end
+    end
+
   end
 end
 

data/lib/rbot/core/utils/wordlist.rb

@@ -0,0 +1,66 @@
+#-- vim:sw=2:et
+#++
+#
+# :title: rbot wordlist provider
+#
+# Author:: Raine Virta <rane@kapsi.fi>
+
+require "find"
+
+module ::Irc
+class Bot
+class Wordlist
+  def self.wordlist_base
+    @@wordlist_base ||= Utils.bot.path 'wordlists'
+  end
+
+  def self.get(path, options={})
+    opts = { :spaces => false }.merge(options)
+
+    wordlist_path = File.join(wordlist_base, path)
+    raise "wordlist not found: #{wordlist_path}" unless File.exist?(wordlist_path)
+
+    # Location is a directory -> combine all lists beneath it
+    wordlist = if File.directory?(wordlist_path)
+      wordlists = []
+      Find.find(wordlist_path) do |path|
+        next if path == wordlist_path
+        wordlists << path unless File.directory?(path)
+      end
+
+      wordlists.map { |list| File.readlines(list) }.flatten
+    else
+      File.readlines(wordlist_path)
+    end
+
+    # wordlists are assumed to be UTF-8, but we need to strip the BOM, if present
+    wordlist.map! { |l| l.sub("\xef\xbb\xbf",'').strip }
+    wordlist.reject do |word|
+      word =~ /\s/ && !opts[:spaces] ||
+      word.empty?
+    end
+  end
+
+  # Return an array with the list of available wordlists.
+  # Available options:
+  # pattern:: pattern that should be matched by the wordlist filename
+  def self.list(options={})
+    pattern = options[:pattern] || "**"
+    # refuse patterns that contain ../
+    return [] if pattern =~ /\.\.\//
+    striplen = self.wordlist_base.length+1
+    Dir.glob(File.join(self.wordlist_base, pattern)).map { |name|
+      name[striplen..-1]
+    }
+  end
+
+  def self.exist?(path)
+    fn = path.to_s
+    # refuse to check outside of the wordlist base directory
+    return false if fn =~ /\.\.\//
+    File.exist?(File.join(self.wordlist_base, fn))
+  end
+
+end
+end
+end

data/lib/rbot/core/wordlist_ui.rb

@@ -0,0 +1,27 @@
+#-- vim:sw=2:et
+#++
+#
+# :title: wordlist management from IRC
+#
+# Author:: Giuseppe "Oblomov" Bilotta <giuseppe.bilotta@gmail.com>
+
+class WordlistModule < CoreBotModule
+  def help(plugin, topic="")
+    _("wordlist list [<pattern>] => list wordlists (matching <pattern>)")
+  end
+
+  def do_list(m, p)
+    found = Wordlist.list(p)
+    if found.empty?
+      m.reply _("no wordlist found")
+    else
+      m.reply _("Wordlists: %{found}") % {
+        :found => found.sort.join(', ')
+      }
+    end
+  end
+end
+
+plugin = WordlistModule.new
+
+plugin.map "wordlist list [:pattern]", :action => :do_list

data/lib/rbot/irc.rb

@@ -21,6 +21,21 @@
 
 require 'singleton'
 
+# The following monkeypatch is to fix a bug in Singleton where marshaling would
+# fail when trying to restore a marshaled Singleton due to _load being declared
+# private.
+if RUBY_VERSION < '1.9'
+module ::Singleton
+  public :_dump
+end
+
+class << Singleton
+  module SingletonClassMethods
+    public :_load
+  end
+end
+end
+
 class Object
 
   # We extend the Object class with a method that
@@ -33,7 +48,7 @@ class Object
 
   # We alias the to_s method to __to_s__ to make
   # it accessible in all classes
-  alias :__to_s__ :to_s 
+  alias :__to_s__ :to_s
 end
 
 # The Irc module is used to keep all IRC-related classes
@@ -129,7 +144,7 @@ module Irc
     include Singleton
 
     def initialize
-      super('rfc1459', "\x41-\x5e", "\x61-\x7e")
+      super('rfc1459', "\x41-\x5a\x7b-\x7e", "\x61-\x7a\x5b-\x5e")
     end
 
   end
@@ -141,7 +156,7 @@ module Irc
     include Singleton
 
     def initialize
-      super('strict-rfc1459', "\x41-\x5d", "\x61-\x7d")
+      super('strict-rfc1459', "\x41-\x5a\x7b-\x7d", "\x61-\x7a\x5b-\x5d")
     end
 
   end
@@ -258,7 +273,13 @@ class String
   # This method returns the Irc::Casemap whose name is the receiver
   #
   def to_irc_casemap
-    Irc::Casemap.get(self) rescue raise TypeError, "Unkown Irc::Casemap #{self.inspect}"
+    begin
+      Irc::Casemap.get(self)
+    rescue
+      # raise TypeError, "Unkown Irc::Casemap #{self.inspect}"
+      error "Unkown Irc::Casemap #{self.inspect} requested, defaulting to rfc1459"
+      Irc::Casemap.get('rfc1459')
+    end
   end
 
   # This method returns a string which is the downcased version of the
@@ -542,7 +563,7 @@ class Regexp
     GEN_HOST = /#{HOSTNAME}|#{HOSTADDR}/
 
     # # FreeNode network replaces the host of affiliated users with
-    # # 'virtual hosts' 
+    # # 'virtual hosts'
     # # FIXME we need the true syntax to match it properly ...
     # PDPC_HOST_PART = /[0-9A-Za-z.-]+/
     # PDPC_HOST = /#{PDPC_HOST_PART}(?:\/#{PDPC_HOST_PART})+/
@@ -550,7 +571,7 @@ class Regexp
     # # NOTE: the final optional and non-greedy dot is needed because some
     # # servers (e.g. FreeNode) send the hostname of the services as "services."
     # # which is not RFC compliant, but sadly done.
-    # GEN_HOST_EXT = /#{PDPC_HOST}|#{GEN_HOST}\.??/ 
+    # GEN_HOST_EXT = /#{PDPC_HOST}|#{GEN_HOST}\.??/
 
     # Sadly, different networks have different, RFC-breaking ways of cloaking
     # the actualy host address: see above for an example to handle FreeNode.
@@ -1308,6 +1329,13 @@ module Irc
   #
   class Channel
 
+    # Return the non-prefixed part of a channel name.
+    # Also works with ## channels found on some networks
+    # (e.g. FreeNode)
+    def self.npname(str)
+      return str.to_s.sub(/^[&#+!]+/,'')
+    end
+
     include ServerOrCasemap
     attr_reader :name, :topic, :mode, :users
     alias :to_s :name
@@ -1350,7 +1378,7 @@ module Irc
     # Adds a user to the channel
     #
     def add_user(user, opts={})
-      silent = opts.fetch(:silent, false) 
+      silent = opts.fetch(:silent, false)
       if has_user?(user)
         warn "Trying to add user #{user} to channel #{self} again" unless silent
       else
@@ -1366,7 +1394,7 @@ module Irc
     #
     def initialize(name, topic=nil, users=[], opts={})
       raise ArgumentError, "Channel name cannot be empty" if name.to_s.empty?
-      warn "Unknown channel prefix #{name[0].chr}" if name !~ /^[&#+!]/
+      warn "Unknown channel prefix #{name[0,1]}" if name !~ /^[&#+!]/
       raise ArgumentError, "Invalid character in #{name.inspect}" if name =~ /[ \x07,]/
 
       init_server_or_casemap(opts)
@@ -1403,31 +1431,31 @@ module Irc
     # The channel prefix
     #
     def prefix
-      name[0].chr
+      name[0,1]
     end
 
     # A channel is local to a server if it has the '&' prefix
     #
     def local?
-      name[0] == 0x26
+      name[0,1] == '&'
     end
 
     # A channel is modeless if it has the '+' prefix
     #
     def modeless?
-      name[0] == 0x2b
+      name[0,1] == '+'
     end
 
     # A channel is safe if it has the '!' prefix
     #
     def safe?
-      name[0] == 0x21
+      name[0,1] == '!'
     end
 
     # A channel is normal if it has the '#' prefix
     #
     def normal?
-      name[0] == 0x23
+      name[0,1] == '#'
     end
 
     # Create a new mode
@@ -1646,7 +1674,7 @@ module Irc
     def parse_isupport(line)
       debug "Parsing ISUPPORT #{line.inspect}"
       ar = line.split(' ')
-      reparse = ""
+      reparse = []
       ar.each { |en|
         prekey, val = en.split('=', 2)
         if prekey =~ /^-(.*)/
@@ -1658,7 +1686,15 @@ module Irc
         case key
         when :casemapping
           noval_warn(key, val) {
-            @supports[key] = val.to_irc_casemap
+            if val == 'charset'
+              reparse << "CASEMAPPING=(charset)"
+            else
+              # TODO some servers offer non-standard CASEMAPPINGs in the form
+              # locale.charset[-options], which indicate an extended set of
+              # allowed characters (mostly for nicks). This might be supported
+              # with hooks for the unicode core module
+              @supports[key] = val.to_irc_casemap
+            end
           }
         when :chanlimit, :idchan, :maxlist, :targmax
           noval_warn(key, val) {
@@ -1696,7 +1732,7 @@ module Irc
           @supports[key] = val
         when :maxchannels
           noval_warn(key, val) {
-            reparse += "CHANLIMIT=(chantypes):#{val} "
+            reparse << "CHANLIMIT=(chantypes):#{val} "
           }
         when :maxtargets
           noval_warn(key, val) {
@@ -1737,8 +1773,12 @@ module Irc
           @supports[key] =  val.nil? ? true : val
         end
       }
-      reparse.gsub!("(chantypes)",@supports[:chantypes])
-      parse_isupport(reparse) unless reparse.empty?
+      unless reparse.empty?
+        reparse_str = reparse.join(" ")
+        reparse_str.gsub!("(chantypes)",@supports[:chantypes])
+        reparse_str.gsub!("(charset)",@supports[:charset] || 'rfc1459')
+        parse_isupport(reparse_str)
+      end
     end
 
     # Returns the casemap of the server.
@@ -1803,7 +1843,7 @@ module Irc
         return ex
       else
 
-        prefix = name[0].chr
+        prefix = name[0,1]
 
         # Give a warning if the new Channel goes over some server limits.
         #