words.each do |w|
      next if w.empty?
      s = body
      offset = 0
# <edit was="rex = Regexp.new(Regexp.escape(w), true)">
      rex = Regexp.new(w, true)
# </edit>
      while rex =~ s
# <edit>
        begin
# </edit>
          left = $~.begin(0)
          right = $~.end(0)
          pre = $~.pre_match
          post = $~.post_match
          ok = true
 
          if exact_word_match
            if !pre.empty? && alphabetic?(w.first_char) && alphabetic?(pre.last_char)
              ok = false
            elsif !post.empty? && alphabetic?(w.last_char) && alphabetic?(post.first_char)
              ok = false
            end
          end
 
          if ok
            keywords < < { :pos => offset+left, :len => right-left }
          end
          s = post
          offset += right
# <edit>
        rescue
          next
        end
# </edit>
      end
    end

require 'net/http'
require 'net/https'
 
class Commander < AutumnLeaf
 
  before_filter :authenticate, :only => [ :reload, :sync, :quit, :deploy ]
  $authenticated = []
 
  def authenticate_filter(sender, channel, command, msg, options)
    return true if $authenticated.include?(sender)
    return false
  end
 
  def did_receive_private_message(sender, msg)
    # assumes there is a file at 
    # http://my.svnserver.com/svn/access 
    # whose contents are "granted" 
    Net::HTTP.start('my.svnserver.com') {|http|
      req = Net::HTTP::Get.new('/svn/access');
      req.basic_auth(sender, msg)
      response = http.request(req)
      $authenticated < < sender if response.body == "granted"
    }
  end
 
  def someone_did_quit(sender, msg)
    $authenticated.delete(sender)
  end
 
  def someone_did_leave_channel(sender, channel)
    $authenticated.delete(sender)
  end
 
  def someone_did_join_channel(sender, channel)
    $authenticated.delete(sender)
  end
 
  def deploy_command(sender, channel, text)
    message "deploying..."
    system("sudo /usr/local/bin/deploy.sh 1>/dev/null 2>/dev/null")
   end
 
end

require 'thread'
require 'rss/1.0'
require 'rss/2.0'
require 'open-uri'
require 'fileutils'
require 'digest/md5'
 
class Feeder < AutumnLeaf
 
def watch_feed(url, title, sleepfor=300)
  message "Watching (#{title}) [#{url}] every #{sleepfor} seconds"
  feedid = Digest::MD5.hexdigest(title)
  Thread.new {
    while true
      begin
        content = ""
        open(url) { |s|
          content = s.read
        }
        rss = RSS::Parser.parse(content, false)
        rss.items.each { |entry|
          digest = Digest::MD5.hexdigest(entry.title)
          if !File.exist?("/tmp/.rss.#{feedid}.#{digest}")
            FileUtils.touch("/tmp/.rss.#{feedid}.#{digest}")
            message "#{entry.title} (#{title}) #{entry.link}"
          end
          sleep(2)
        }
      rescue
        sleep(2)
      end
      sleep(sleepfor)
    end
  }
  sleep(1)
end
 
def did_start_up
  watch_feed("http://planet.wordpress.org/rss20.xml", "planet", 600)
  watch_feed("http://wordpress.com/feed/", "wpcom", 300)
end
 
end

require 'socket'
require 'thread'
 
class Announcer < AutumnLeaf
 
        def handle_incoming(sock)
                Thread.new {
                line = sock.gets
                message line
                sock.close
                }
        end
 
        def did_start_up
                Thread.new {
                        listener = TCPServer.new('',22122)
                        while (new_socket = listener.accept)
                                handle_incoming(new_socket)
                        end
                }
        end
 
end