IRC Framework: accept nil or empty nicks and channel names when looking for a user...

[user/henk/code/ruby/rbot.git] / lib / rbot / irc.rb

#-- vim:sw=2:et\r
# General TODO list\r
# * do we want to handle a Channel list for each User telling which\r
#   Channels is the User on (of those the client is on too)?\r
#   We may want this so that when a User leaves all Channels and he hasn't\r
#   sent us privmsgs, we know remove him from the Server @users list\r
# * Maybe ChannelList and UserList should be HashesOf instead of ArrayOf?\r
#   See items marked as TODO Ho\r
#++\r
# :title: IRC module\r
#\r
# Basic IRC stuff\r
#\r
# This module defines the fundamental building blocks for IRC\r
#\r
# Author:: Giuseppe Bilotta (giuseppe.bilotta@gmail.com)\r
# Copyright:: Copyright (c) 2006 Giuseppe Bilotta\r
# License:: GPLv2\r
\r
require 'singleton'\r
\r
class Object\r
\r
  # We extend the Object class with a method that\r
  # checks if the receiver is nil or empty\r
  def nil_or_empty?\r
    return true unless self\r
    return true if self.respond_to? :empty and self.empty?\r
    return false\r
  end\r
end\r
\r
# The Irc module is used to keep all IRC-related classes\r
# in the same namespace\r
#\r
module Irc\r
\r
\r
  # Due to its Scandinavian origins, IRC has strange case mappings, which\r
  # consider the characters <tt>{}|^</tt> as the uppercase\r
  # equivalents of # <tt>[]\~</tt>.\r
  #\r
  # This is however not the same on all IRC servers: some use standard ASCII\r
  # casemapping, other do not consider <tt>^</tt> as the uppercase of\r
  # <tt>~</tt>\r
  #\r
  class Casemap\r
    @@casemaps = {}\r
\r
    # Create a new casemap with name _name_, uppercase characters _upper_ and\r
    # lowercase characters _lower_\r
    #\r
    def initialize(name, upper, lower)\r
      @key = name.to_sym\r
      raise "Casemap #{name.inspect} already exists!" if @@casemaps.has_key?(@key)\r
      @@casemaps[@key] = {\r
        :upper => upper,\r
        :lower => lower,\r
        :casemap => self\r
      }\r
    end\r
\r
    # Returns the Casemap with the given name\r
    #\r
    def Casemap.get(name)\r
      @@casemaps[name.to_sym][:casemap]\r
    end\r
\r
    # Retrieve the 'uppercase characters' of this Casemap\r
    #\r
    def upper\r
      @@casemaps[@key][:upper]\r
    end\r
\r
    # Retrieve the 'lowercase characters' of this Casemap\r
    #\r
    def lower\r
      @@casemaps[@key][:lower]\r
    end\r
\r
    # Return a Casemap based on the receiver\r
    #\r
    def to_irc_casemap\r
      self\r
    end\r
\r
    # A Casemap is represented by its lower/upper mappings\r
    #\r
    def inspect\r
      "#<#{self.class}:#{'0x%x'% self.object_id}: #{upper.inspect} ~(#{self})~ #{lower.inspect}>"\r
    end\r
\r
    # As a String we return our name\r
    #\r
    def to_s\r
      @key.to_s\r
    end\r
\r
    # Two Casemaps are equal if they have the same upper and lower ranges\r
    #\r
    def ==(arg)\r
      other = arg.to_irc_casemap\r
      return self.upper == other.upper && self.lower == other.lower\r
    end\r
\r
    # Raise an error if _arg_ and self are not the same Casemap\r
    #\r
    def must_be(arg)\r
      other = arg.to_irc_casemap\r
      raise "Casemap mismatch (#{self.inspect} != #{other.inspect})" unless self == other\r
      return true\r
    end\r
\r
  end\r
\r
  # The rfc1459 casemap\r
  #\r
  class RfcCasemap < Casemap\r
    include Singleton\r
\r
    def initialize\r
      super('rfc1459', "\x41-\x5e", "\x61-\x7e")\r
    end\r
\r
  end\r
  RfcCasemap.instance\r
\r
  # The strict-rfc1459 Casemap\r
  #\r
  class StrictRfcCasemap < Casemap\r
    include Singleton\r
\r
    def initialize\r
      super('strict-rfc1459', "\x41-\x5d", "\x61-\x7d")\r
    end\r
\r
  end\r
  StrictRfcCasemap.instance\r
\r
  # The ascii Casemap\r
  #\r
  class AsciiCasemap < Casemap\r
    include Singleton\r
\r
    def initialize\r
      super('ascii', "\x41-\x5a", "\x61-\x7a")\r
    end\r
\r
  end\r
  AsciiCasemap.instance\r
\r
\r
  # This module is included by all classes that are either bound to a server\r
  # or should have a casemap.\r
  #\r
  module ServerOrCasemap\r
\r
    attr_reader :server\r
\r
    # This method initializes the instance variables @server and @casemap\r
    # according to the values of the hash keys :server and :casemap in _opts_\r
    #\r
    def init_server_or_casemap(opts={})\r
      @server = opts.fetch(:server, nil)\r
      raise TypeError, "#{@server} is not a valid Irc::Server" if @server and not @server.kind_of?(Server)\r
\r
      @casemap = opts.fetch(:casemap, nil)\r
      if @server\r
        if @casemap\r
          @server.casemap.must_be(@casemap)\r
          @casemap = nil\r
        end\r
      else\r
        @casemap = (@casemap || 'rfc1459').to_irc_casemap\r
      end\r
    end\r
\r
    # This is an auxiliary method: it returns true if the receiver fits the\r
    # server and casemap specified in _opts_, false otherwise.\r
    #\r
    def fits_with_server_and_casemap?(opts={})\r
      srv = opts.fetch(:server, nil)\r
      cmap = opts.fetch(:casemap, nil)\r
      cmap = cmap.to_irc_casemap unless cmap.nil?\r
\r
      if srv.nil?\r
        return true if cmap.nil? or cmap == casemap\r
      else\r
        return true if srv == @server and (cmap.nil? or cmap == casemap)\r
      end\r
      return false\r
    end\r
\r
    # Returns the casemap of the receiver, by looking at the bound\r
    # @server (if possible) or at the @casemap otherwise\r
    #\r
    def casemap\r
      return @server.casemap if defined?(@server) and @server\r
      return @casemap\r
    end\r
\r
    # Returns a hash with the current @server and @casemap as values of\r
    # :server and :casemap\r
    #\r
    def server_and_casemap\r
      h = {}\r
      h[:server] = @server if defined?(@server) and @server\r
      h[:casemap] = @casemap if defined?(@casemap) and @casemap\r
      return h\r
    end\r
\r
    # We allow up/downcasing with a different casemap\r
    #\r
    def irc_downcase(cmap=casemap)\r
      self.to_s.irc_downcase(cmap)\r
    end\r
\r
    # Up/downcasing something that includes this module returns its\r
    # Up/downcased to_s form\r
    #\r
    def downcase\r
      self.irc_downcase\r
    end\r
\r
    # We allow up/downcasing with a different casemap\r
    #\r
    def irc_upcase(cmap=casemap)\r
      self.to_s.irc_upcase(cmap)\r
    end\r
\r
    # Up/downcasing something that includes this module returns its\r
    # Up/downcased to_s form\r
    #\r
    def upcase\r
      self.irc_upcase\r
    end\r
\r
  end\r
\r
end\r
\r
\r
# We start by extending the String class\r
# with some IRC-specific methods\r
#\r
class String\r
\r
  # This method returns the Irc::Casemap whose name is the receiver\r
  #\r
  def to_irc_casemap\r
    Irc::Casemap.get(self) rescue raise TypeError, "Unkown Irc::Casemap #{self.inspect}"\r
  end\r
\r
  # This method returns a string which is the downcased version of the\r
  # receiver, according to the given _casemap_\r
  #\r
  #\r
  def irc_downcase(casemap='rfc1459')\r
    cmap = casemap.to_irc_casemap\r
    self.tr(cmap.upper, cmap.lower)\r
  end\r
\r
  # This is the same as the above, except that the string is altered in place\r
  #\r
  # See also the discussion about irc_downcase\r
  #\r
  def irc_downcase!(casemap='rfc1459')\r
    cmap = casemap.to_irc_casemap\r
    self.tr!(cmap.upper, cmap.lower)\r
  end\r
\r
  # Upcasing functions are provided too\r
  #\r
  # See also the discussion about irc_downcase\r
  #\r
  def irc_upcase(casemap='rfc1459')\r
    cmap = casemap.to_irc_casemap\r
    self.tr(cmap.lower, cmap.upper)\r
  end\r
\r
  # In-place upcasing\r
  #\r
  # See also the discussion about irc_downcase\r
  #\r
  def irc_upcase!(casemap='rfc1459')\r
    cmap = casemap.to_irc_casemap\r
    self.tr!(cmap.lower, cmap.upper)\r
  end\r
\r
  # This method checks if the receiver contains IRC glob characters\r
  #\r
  # IRC has a very primitive concept of globs: a <tt>*</tt> stands for "any\r
  # number of arbitrary characters", a <tt>?</tt> stands for "one and exactly\r
  # one arbitrary character". These characters can be escaped by prefixing them\r
  # with a slash (<tt>\\</tt>).\r
  #\r
  # A known limitation of this glob syntax is that there is no way to escape\r
  # the escape character itself, so it's not possible to build a glob pattern\r
  # where the escape character precedes a glob.\r
  #\r
  def has_irc_glob?\r
    self =~ /^[*?]|[^\\][*?]/\r
  end\r
\r
  # This method is used to convert the receiver into a Regular Expression\r
  # that matches according to the IRC glob syntax\r
  #\r
  def to_irc_regexp\r
    regmask = Regexp.escape(self)\r
    regmask.gsub!(/(\\\\)?\\[*?]/) { |m|\r
      case m\r
      when /\\(\\[*?])/\r
        $1\r
      when /\\\*/\r
        '.*'\r
      when /\\\?/\r
        '.'\r
      else\r
        raise "Unexpected match #{m} when converting #{self}"\r
      end\r
    }\r
    Regexp.new(regmask)\r
  end\r
\r
end\r
\r
\r
# ArrayOf is a subclass of Array whose elements are supposed to be all\r
# of the same class. This is not intended to be used directly, but rather\r
# to be subclassed as needed (see for example Irc::UserList and Irc::NetmaskList)\r
#\r
# Presently, only very few selected methods from Array are overloaded to check\r
# if the new elements are the correct class. An orthodox? method is provided\r
# to check the entire ArrayOf against the appropriate class.\r
#\r
class ArrayOf < Array\r
\r
  attr_reader :element_class\r
\r
  # Create a new ArrayOf whose elements are supposed to be all of type _kl_,\r
  # optionally filling it with the elements from the Array argument.\r
  #\r
  def initialize(kl, ar=[])\r
    raise TypeError, "#{kl.inspect} must be a class name" unless kl.kind_of?(Class)\r
    super()\r
    @element_class = kl\r
    case ar\r
    when Array\r
      insert(0, *ar)\r
    else\r
      raise TypeError, "#{self.class} can only be initialized from an Array"\r
    end\r
  end\r
\r
  def inspect\r
    "#<#{self.class}[#{@element_class}]:#{'0x%x' % self.object_id}: #{super}>"\r
  end\r
\r
  # Private method to check the validity of the elements passed to it\r
  # and optionally raise an error\r
  #\r
  # TODO should it accept nils as valid?\r
  #\r
  def internal_will_accept?(raising, *els)\r
    els.each { |el|\r
      unless el.kind_of?(@element_class)\r
        raise TypeError, "#{el.inspect} is not of class #{@element_class}" if raising\r
        return false\r
      end\r
    }\r
    return true\r
  end\r
  private :internal_will_accept?\r
\r
  # This method checks if the passed arguments are acceptable for our ArrayOf\r
  #\r
  def will_accept?(*els)\r
    internal_will_accept?(false, *els)\r
  end\r
\r
  # This method checks that all elements are of the appropriate class\r
  #\r
  def valid?\r
    will_accept?(*self)\r
  end\r
\r
  # This method is similar to the above, except that it raises an exception\r
  # if the receiver is not valid\r
  #\r
  def validate\r
    raise TypeError unless valid?\r
  end\r
\r
  # Overloaded from Array#<<, checks for appropriate class of argument\r
  #\r
  def <<(el)\r
    super(el) if internal_will_accept?(true, el)\r
  end\r
\r
  # Overloaded from Array#&, checks for appropriate class of argument elements\r
  #\r
  def &(ar)\r
    r = super(ar)\r
    ArrayOf.new(@element_class, r) if internal_will_accept?(true, *r)\r
  end\r
\r
  # Overloaded from Array#+, checks for appropriate class of argument elements\r
  #\r
  def +(ar)\r
    ArrayOf.new(@element_class, super(ar)) if internal_will_accept?(true, *ar)\r
  end\r
\r
  # Overloaded from Array#-, so that an ArrayOf is returned. There is no need\r
  # to check the validity of the elements in the argument\r
  #\r
  def -(ar)\r
    ArrayOf.new(@element_class, super(ar)) # if internal_will_accept?(true, *ar)\r
  end\r
\r
  # Overloaded from Array#|, checks for appropriate class of argument elements\r
  #\r
  def |(ar)\r
    ArrayOf.new(@element_class, super(ar)) if internal_will_accept?(true, *ar)\r
  end\r
\r
  # Overloaded from Array#concat, checks for appropriate class of argument\r
  # elements\r
  #\r
  def concat(ar)\r
    super(ar) if internal_will_accept?(true, *ar)\r
  end\r
\r
  # Overloaded from Array#insert, checks for appropriate class of argument\r
  # elements\r
  #\r
  def insert(idx, *ar)\r
    super(idx, *ar) if internal_will_accept?(true, *ar)\r
  end\r
\r
  # Overloaded from Array#replace, checks for appropriate class of argument\r
  # elements\r
  #\r
  def replace(ar)\r
    super(ar) if (ar.kind_of?(ArrayOf) && ar.element_class <= @element_class) or internal_will_accept?(true, *ar)\r
  end\r
\r
  # Overloaded from Array#push, checks for appropriate class of argument\r
  # elements\r
  #\r
  def push(*ar)\r
    super(*ar) if internal_will_accept?(true, *ar)\r
  end\r
\r
  # Overloaded from Array#unshift, checks for appropriate class of argument(s)\r
  #\r
  def unshift(*els)\r
    els.each { |el|\r
      super(el) if internal_will_accept?(true, *els)\r
    }\r
  end\r
\r
  # Modifying methods which we don't handle yet are made private\r
  #\r
  private :[]=, :collect!, :map!, :fill, :flatten!\r
\r
end\r
\r
\r
module Irc\r
\r
\r
  # A Netmask identifies each user by collecting its nick, username and\r
  # hostname in the form <tt>nick!user@host</tt>\r
  #\r
  # Netmasks can also contain glob patterns in any of their components; in\r
  # this form they are used to refer to more than a user or to a user\r
  # appearing under different forms.\r
  #\r
  # Example:\r
  # * <tt>*!*@*</tt> refers to everybody\r
  # * <tt>*!someuser@somehost</tt> refers to user +someuser+ on host +somehost+\r
  #   regardless of the nick used.\r
  #\r
  class Netmask\r
\r
    # Netmasks have an associated casemap unless they are bound to a server\r
    #\r
    include ServerOrCasemap\r
\r
    attr_reader :nick, :user, :host\r
\r
    # Create a new Netmask from string _str_, which must be in the form\r
    # _nick_!_user_@_host_\r
    #\r
    # It is possible to specify a server or a casemap in the optional Hash:\r
    # these are used to associate the Netmask with the given server and to set\r
    # its casemap: if a server is specified and a casemap is not, the server's\r
    # casemap is used. If both a server and a casemap are specified, the\r
    # casemap must match the server's casemap or an exception will be raised.\r
    #\r
    # Empty +nick+, +user+ or +host+ are converted to the generic glob pattern\r
    #\r
    def initialize(str="", opts={})\r
      # First of all, check for server/casemap option\r
      #\r
      init_server_or_casemap(opts)\r
\r
      # Now we can see if the given string _str_ is an actual Netmask\r
      if str.respond_to?(:to_str)\r
        case str.to_str\r
        when /^(?:(\S+?)(?:!(\S+)@(?:(\S+))?)?)?$/\r
          # We do assignment using our internal methods\r
          self.nick = $1\r
          self.user = $2\r
          self.host = $3\r
        else\r
          raise ArgumentError, "#{str.to_str.inspect} does not represent a valid #{self.class}"\r
        end\r
      else\r
        raise TypeError, "#{str} cannot be converted to a #{self.class}"\r
      end\r
    end\r
\r
    # A Netmask is easily converted to a String for the usual representation\r
    #\r
    def fullform\r
      "#{nick}!#{user}@#{host}"\r
    end\r
    alias :to_s :fullform\r
\r
    # Converts the receiver into a Netmask with the given (optional)\r
    # server/casemap association. We return self unless a conversion\r
    # is needed (different casemap/server)\r
    #\r
    # Subclasses of Netmask will return a new Netmask\r
    #\r
    def to_irc_netmask(opts={})\r
      if self.class == Netmask\r
        return self if fits_with_server_and_casemap?(opts)\r
      end\r
      return self.fullform.to_irc_netmask(server_and_casemap.merge(opts))\r
    end\r
\r
    # Converts the receiver into a User with the given (optional)\r
    # server/casemap association. We return self unless a conversion\r
    # is needed (different casemap/server)\r
    #\r
    def to_irc_user(opts={})\r
      self.fullform.to_irc_user(server_and_casemap.merge(opts))\r
    end\r
\r
    # Inspection of a Netmask reveals the server it's bound to (if there is\r
    # one), its casemap and the nick, user and host part\r
    #\r
    def inspect\r
      str = "<#{self.class}:#{'0x%x' % self.object_id}:"\r
      str << " @server=#{@server}" if defined?(@server) and @server\r
      str << " @nick=#{@nick.inspect} @user=#{@user.inspect}"\r
      str << " @host=#{@host.inspect} casemap=#{casemap.inspect}"\r
      str << ">"\r
    end\r
\r
    # Equality: two Netmasks are equal if they downcase to the same thing\r
    #\r
    # TODO we may want it to try other.to_irc_netmask\r
    #\r
    def ==(other)\r
      return false unless other.kind_of?(self.class)\r
      self.downcase == other.downcase\r
    end\r
\r
    # This method changes the nick of the Netmask, defaulting to the generic\r
    # glob pattern if the result is the null string.\r
    #\r
    def nick=(newnick)\r
      @nick = newnick.to_s\r
      @nick = "*" if @nick.empty?\r
    end\r
\r
    # This method changes the user of the Netmask, defaulting to the generic\r
    # glob pattern if the result is the null string.\r
    #\r
    def user=(newuser)\r
      @user = newuser.to_s\r
      @user = "*" if @user.empty?\r
    end\r
\r
    # This method changes the hostname of the Netmask, defaulting to the generic\r
    # glob pattern if the result is the null string.\r
    #\r
    def host=(newhost)\r
      @host = newhost.to_s\r
      @host = "*" if @host.empty?\r
    end\r
\r
    # We can replace everything at once with data from another Netmask\r
    #\r
    def replace(other)\r
      case other\r
      when Netmask\r
        nick = other.nick\r
        user = other.user\r
        host = other.host\r
        @server = other.server\r
        @casemap = other.casemap unless @server\r
      else\r
        replace(other.to_irc_netmask(server_and_casemap))\r
      end\r
    end\r
\r
    # This method checks if a Netmask is definite or not, by seeing if\r
    # any of its components are defined by globs\r
    #\r
    def has_irc_glob?\r
      return @nick.has_irc_glob? || @user.has_irc_glob? || @host.has_irc_glob?\r
    end\r
\r
    # This method is used to match the current Netmask against another one\r
    #\r
    # The method returns true if each component of the receiver matches the\r
    # corresponding component of the argument. By _matching_ here we mean\r
    # that any netmask described by the receiver is also described by the\r
    # argument.\r
    #\r
    # In this sense, matching is rather simple to define in the case when the\r
    # receiver has no globs: it is just necessary to check if the argument\r
    # describes the receiver, which can be done by matching it against the\r
    # argument converted into an IRC Regexp (see String#to_irc_regexp).\r
    #\r
    # The situation is also easy when the receiver has globs and the argument\r
    # doesn't, since in this case the result is false.\r
    #\r
    # The more complex case in which both the receiver and the argument have\r
    # globs is not handled yet.\r
    #\r
    def matches?(arg)\r
      cmp = arg.to_irc_netmask(:casemap => casemap)\r
      debug "Matching #{self.fullform} against #{arg.fullform}"\r
      [:nick, :user, :host].each { |component|\r
        us = self.send(component).irc_downcase(casemap)\r
        them = cmp.send(component).irc_downcase(casemap)\r
        if us.has_irc_glob? && them.has_irc_glob?\r
          next if us == them\r
          warn NotImplementedError\r
          return false\r
        end\r
        return false if us.has_irc_glob? && !them.has_irc_glob?\r
        return false unless us =~ them.to_irc_regexp\r
      }\r
      return true\r
    end\r
\r
    # Case equality. Checks if arg matches self\r
    #\r
    def ===(arg)\r
      arg.to_irc_netmask(:casemap => casemap).matches?(self)\r
    end\r
\r
    # Sorting is done via the fullform\r
    #\r
    def <=>(arg)\r
      case arg\r
      when Netmask\r
        self.fullform.irc_downcase(casemap) <=> arg.fullform.irc_downcase(casemap)\r
      else\r
        self.downcase <=> arg.downcase\r
      end\r
    end\r
\r
  end\r
\r
\r
  # A NetmaskList is an ArrayOf <code>Netmask</code>s\r
  #\r
  class NetmaskList < ArrayOf\r
\r
    # Create a new NetmaskList, optionally filling it with the elements from\r
    # the Array argument fed to it.\r
    #\r
    def initialize(ar=[])\r
      super(Netmask, ar)\r
    end\r
\r
  end\r
\r
end\r
\r
\r
class String\r
\r
  # We keep extending String, this time adding a method that converts a\r
  # String into an Irc::Netmask object\r
  #\r
  def to_irc_netmask(opts={})\r
    Irc::Netmask.new(self, opts)\r
  end\r
\r
end\r
\r
\r
module Irc\r
\r
\r
  # An IRC User is identified by his/her Netmask (which must not have globs).\r
  # In fact, User is just a subclass of Netmask.\r
  #\r
  # Ideally, the user and host information of an IRC User should never\r
  # change, and it shouldn't contain glob patterns. However, IRC is somewhat\r
  # idiosincratic and it may be possible to know the nick of a User much before\r
  # its user and host are known. Moreover, some networks (namely Freenode) may\r
  # change the hostname of a User when (s)he identifies with Nickserv.\r
  #\r
  # As a consequence, we must allow changes to a User host and user attributes.\r
  # We impose a restriction, though: they may not contain glob patterns, except\r
  # for the special case of an unknown user/host which is represented by a *.\r
  #\r
  # It is possible to create a totally unknown User (e.g. for initializations)\r
  # by setting the nick to * too.\r
  #\r
  # TODO list:\r
  # * see if it's worth to add the other USER data\r
  # * see if it's worth to add NICKSERV status\r
  #\r
  class User < Netmask\r
    alias :to_s :nick\r
\r
    # Create a new IRC User from a given Netmask (or anything that can be converted\r
    # into a Netmask) provided that the given Netmask does not have globs.\r
    #\r
    def initialize(str="", opts={})\r
      super\r
      raise ArgumentError, "#{str.inspect} must not have globs (unescaped * or ?)" if nick.has_irc_glob? && nick != "*"\r
      raise ArgumentError, "#{str.inspect} must not have globs (unescaped * or ?)" if user.has_irc_glob? && user != "*"\r
      raise ArgumentError, "#{str.inspect} must not have globs (unescaped * or ?)" if host.has_irc_glob? && host != "*"\r
      @away = false\r
    end\r
\r
    # The nick of a User may be changed freely, but it must not contain glob patterns.\r
    #\r
    def nick=(newnick)\r
      raise "Can't change the nick to #{newnick}" if defined?(@nick) and newnick.has_irc_glob?\r
      super\r
    end\r
\r
    # We have to allow changing the user of an Irc User due to some networks\r
    # (e.g. Freenode) changing hostmasks on the fly. We still check if the new\r
    # user data has glob patterns though.\r
    #\r
    def user=(newuser)\r
      raise "Can't change the username to #{newuser}" if defined?(@user) and newuser.has_irc_glob?\r
      super\r
    end\r
\r
    # We have to allow changing the host of an Irc User due to some networks\r
    # (e.g. Freenode) changing hostmasks on the fly. We still check if the new\r
    # host data has glob patterns though.\r
    #\r
    def host=(newhost)\r
      raise "Can't change the hostname to #{newhost}" if defined?(@host) and newhost.has_irc_glob?\r
      super\r
    end\r
\r
    # Checks if a User is well-known or not by looking at the hostname and user\r
    #\r
    def known?\r
      return nick!= "*" && user!="*" && host!="*"\r
    end\r
\r
    # Is the user away?\r
    #\r
    def away?\r
      return @away\r
    end\r
\r
    # Set the away status of the user. Use away=(nil) or away=(false)\r
    # to unset away\r
    #\r
    def away=(msg="")\r
      if msg\r
        @away = msg\r
      else\r
        @away = false\r
      end\r
    end\r
\r
    # Since to_irc_user runs the same checks on server and channel as\r
    # to_irc_netmask, we just try that and return self if it works.\r
    #\r
    # Subclasses of User will return self if possible.\r
    #\r
    def to_irc_user(opts={})\r
      return self if fits_with_server_and_casemap?(opts)\r
      return self.fullform.to_irc_user(server_and_casemap(opts))\r
    end\r
\r
    # We can replace everything at once with data from another User\r
    #\r
    def replace(other)\r
      case other\r
      when User\r
        self.nick = other.nick\r
        self.user = other.user\r
        self.host = other.host\r
        @server = other.server\r
        @casemap = other.casemap unless @server\r
        @away = other.away?\r
      else\r
        self.replace(other.to_irc_user(server_and_casemap))\r
      end\r
    end\r
\r
  end\r
\r
\r
  # A UserList is an ArrayOf <code>User</code>s\r
  #\r
  class UserList < ArrayOf\r
\r
    # Create a new UserList, optionally filling it with the elements from\r
    # the Array argument fed to it.\r
    #\r
    def initialize(ar=[])\r
      super(User, ar)\r
    end\r
\r
  end\r
\r
end\r
\r
class String\r
\r
  # We keep extending String, this time adding a method that converts a\r
  # String into an Irc::User object\r
  #\r
  def to_irc_user(opts={})\r
    Irc::User.new(self, opts)\r
  end\r
\r
end\r
\r
module Irc\r
\r
  # An IRC Channel is identified by its name, and it has a set of properties:\r
  # * a Channel::Topic\r
  # * a UserList\r
  # * a set of Channel::Modes\r
  #\r
  # The Channel::Topic and Channel::Mode classes are defined within the\r
  # Channel namespace because they only make sense there\r
  #\r
  class Channel\r
\r
\r
    # Mode on a Channel\r
    #\r
    class Mode\r
      def initialize(ch)\r
        @channel = ch\r
      end\r
\r
    end\r
\r
\r
    # Channel modes of type A manipulate lists\r
    #\r
    # Example: b (banlist)\r
    #\r
    class ModeTypeA < Mode\r
      def initialize(ch)\r
        super\r
        @list = NetmaskList.new\r
      end\r
\r
      def set(val)\r
        nm = @channel.server.new_netmask(val)\r
        @list << nm unless @list.include?(nm)\r
      end\r
\r
      def reset(val)\r
        nm = @channel.server.new_netmask(val)\r
        @list.delete(nm)\r
      end\r
\r
    end\r
\r
\r
    # Channel modes of type B need an argument\r
    #\r
    # Example: k (key)\r
    #\r
    class ModeTypeB < Mode\r
      def initialize(ch)\r
        super\r
        @arg = nil\r
      end\r
\r
      def set(val)\r
        @arg = val\r
      end\r
\r
      def reset(val)\r
        @arg = nil if @arg == val\r
      end\r
\r
    end\r
\r
\r
    # Channel modes that change the User prefixes are like\r
    # Channel modes of type B, except that they manipulate\r
    # lists of Users, so they are somewhat similar to channel\r
    # modes of type A\r
    #\r
    class UserMode < ModeTypeB\r
      def initialize(ch)\r
        super\r
        @list = UserList.new\r
      end\r
\r
      def set(val)\r
        u = @channel.server.user(val)\r
        @list << u unless @list.include?(u)\r
      end\r
\r
      def reset(val)\r
        u = @channel.server.user(val)\r
        @list.delete(u)\r
      end\r
\r
    end\r
\r
\r
    # Channel modes of type C need an argument when set,\r
    # but not when they get reset\r
    #\r
    # Example: l (limit)\r
    #\r
    class ModeTypeC < Mode\r
      def initialize(ch)\r
        super\r
        @arg = false\r
      end\r
\r
      def status\r
        @arg\r
      end\r
\r
      def set(val)\r
        @arg = val\r
      end\r
\r
      def reset\r
        @arg = false\r
      end\r
\r
    end\r
\r
\r
    # Channel modes of type D are basically booleans\r
    #\r
    # Example: m (moderate)\r
    #\r
    class ModeTypeD < Mode\r
      def initialize(ch)\r
        super\r
        @set = false\r
      end\r
\r
      def set?\r
        return @set\r
      end\r
\r
      def set\r
        @set = true\r
      end\r
\r
      def reset\r
        @set = false\r
      end\r
\r
    end\r
\r
\r
    # A Topic represents the topic of a channel. It consists of\r
    # the topic itself, who set it and when\r
    #\r
    class Topic\r
      attr_accessor :text, :set_by, :set_on\r
      alias :to_s :text\r
\r
      # Create a new Topic setting the text, the creator and\r
      # the creation time\r
      #\r
      def initialize(text="", set_by="", set_on=Time.new)\r
        @text = text\r
        @set_by = set_by.to_irc_user\r
        @set_on = set_on\r
      end\r
\r
      # Replace a Topic with another one\r
      #\r
      def replace(topic)\r
        raise TypeError, "#{topic.inspect} is not of class #{self.class}" unless topic.kind_of?(self.class)\r
        @text = topic.text.dup\r
        @set_by = topic.set_by.dup\r
        @set_on = topic.set_on.dup\r
      end\r
\r
      # Returns self\r
      #\r
      def to_irc_channel_topic\r
        self\r
      end\r
\r
    end\r
\r
  end\r
\r
end\r
\r
\r
class String\r
\r
  # Returns an Irc::Channel::Topic with self as text\r
  #\r
  def to_irc_channel_topic\r
    Irc::Channel::Topic.new(self)\r
  end\r
\r
end\r
\r
\r
module Irc\r
\r
\r
  # Here we start with the actual Channel class\r
  #\r
  class Channel\r
\r
    include ServerOrCasemap\r
    attr_reader :name, :topic, :mode, :users\r
    alias :to_s :name\r
\r
    def inspect\r
      str = "<#{self.class}:#{'0x%x' % self.object_id}:"\r
      str << " on server #{server}" if server\r
      str << " @name=#{@name.inspect} @topic=#{@topic.text.inspect}"\r
      str << " @users=[#{user_nicks.sort.join(', ')}]"\r
      str << ">"\r
    end\r
\r
    # Returns self\r
    #\r
    def to_irc_channel\r
      self\r
    end\r
\r
    # TODO Ho\r
    def user_nicks\r
      @users.map { |u| u.downcase }\r
    end\r
\r
    # Checks if the receiver already has a user with the given _nick_\r
    #\r
    def has_user?(nick)\r
      user_nicks.index(nick.irc_downcase(casemap))\r
    end\r
\r
    # Returns the user with nick _nick_, if available\r
    #\r
    def get_user(nick)\r
      idx = has_user?(nick)\r
      @users[idx] if idx\r
    end\r
\r
    # Adds a user to the channel\r
    #\r
    def add_user(user, opts={})\r
      silent = opts.fetch(:silent, false) \r
      if has_user?(user) && !silent\r
        warn "Trying to add user #{user} to channel #{self} again"\r
      else\r
        @users << user.to_irc_user(server_and_casemap)\r
      end\r
    end\r
\r
    # Creates a new channel with the given name, optionally setting the topic\r
    # and an initial users list.\r
    #\r
    # No additional info is created here, because the channel flags and userlists\r
    # allowed depend on the server.\r
    #\r
    def initialize(name, topic=nil, users=[], opts={})\r
      raise ArgumentError, "Channel name cannot be empty" if name.to_s.empty?\r
      warn "Unknown channel prefix #{name[0].chr}" if name !~ /^[&#+!]/\r
      raise ArgumentError, "Invalid character in #{name.inspect}" if name =~ /[ \x07,]/\r
\r
      init_server_or_casemap(opts)\r
\r
      @name = name\r
\r
      @topic = (topic.to_irc_channel_topic rescue Channel::Topic.new)\r
\r
      @users = UserList.new\r
\r
      users.each { |u|\r
        add_user(u)\r
      }\r
\r
      # Flags\r
      @mode = {}\r
    end\r
\r
    # Removes a user from the channel\r
    #\r
    def delete_user(user)\r
      @mode.each { |sym, mode|\r
        mode.reset(user) if mode.kind_of?(UserMode)\r
      }\r
      @users.delete(user)\r
    end\r
\r
    # The channel prefix\r
    #\r
    def prefix\r
      name[0].chr\r
    end\r
\r
    # A channel is local to a server if it has the '&' prefix\r
    #\r
    def local?\r
      name[0] == 0x26\r
    end\r
\r
    # A channel is modeless if it has the '+' prefix\r
    #\r
    def modeless?\r
      name[0] == 0x2b\r
    end\r
\r
    # A channel is safe if it has the '!' prefix\r
    #\r
    def safe?\r
      name[0] == 0x21\r
    end\r
\r
    # A channel is normal if it has the '#' prefix\r
    #\r
    def normal?\r
      name[0] == 0x23\r
    end\r
\r
    # Create a new mode\r
    #\r
    def create_mode(sym, kl)\r
      @mode[sym.to_sym] = kl.new(self)\r
    end\r
\r
  end\r
\r
\r
  # A ChannelList is an ArrayOf <code>Channel</code>s\r
  #\r
  class ChannelList < ArrayOf\r
\r
    # Create a new ChannelList, optionally filling it with the elements from\r
    # the Array argument fed to it.\r
    #\r
    def initialize(ar=[])\r
      super(Channel, ar)\r
    end\r
\r
  end\r
\r
end\r
\r
\r
class String\r
\r
  # We keep extending String, this time adding a method that converts a\r
  # String into an Irc::Channel object\r
  #\r
  def to_irc_channel(opts={})\r
    Irc::Channel.new(self, opts)\r
  end\r
\r
end\r
\r
\r
module Irc\r
\r
\r
  # An IRC Server represents the Server the client is connected to.\r
  #\r
  class Server\r
\r
    attr_reader :hostname, :version, :usermodes, :chanmodes\r
    alias :to_s :hostname\r
    attr_reader :supports, :capabilities\r
\r
    attr_reader :channels, :users\r
\r
    # TODO Ho\r
    def channel_names\r
      @channels.map { |ch| ch.downcase }\r
    end\r
\r
    # TODO Ho\r
    def user_nicks\r
      @users.map { |u| u.downcase }\r
    end\r
\r
    def inspect\r
      chans, users = [@channels, @users].map {|d|\r
        d.sort { |a, b|\r
          a.downcase <=> b.downcase\r
        }.map { |x|\r
          x.inspect\r
        }\r
      }\r
\r
      str = "<#{self.class}:#{'0x%x' % self.object_id}:"\r
      str << " @hostname=#{hostname}"\r
      str << " @channels=#{chans}"\r
      str << " @users=#{users}"\r
      str << ">"\r
    end\r
\r
    # Create a new Server, with all instance variables reset to nil (for\r
    # scalar variables), empty channel and user lists and @supports\r
    # initialized to the default values for all known supported features.\r
    #\r
    def initialize\r
      @hostname = @version = @usermodes = @chanmodes = nil\r
\r
      @channels = ChannelList.new\r
\r
      @users = UserList.new\r
\r
      reset_capabilities\r
    end\r
\r
    # Resets the server capabilities\r
    #\r
    def reset_capabilities\r
      @supports = {\r
        :casemapping => 'rfc1459'.to_irc_casemap,\r
        :chanlimit => {},\r
        :chanmodes => {\r
          :typea => nil, # Type A: address lists\r
          :typeb => nil, # Type B: needs a parameter\r
          :typec => nil, # Type C: needs a parameter when set\r
          :typed => nil  # Type D: must not have a parameter\r
        },\r
        :channellen => 200,\r
        :chantypes => "#&",\r
        :excepts => nil,\r
        :idchan => {},\r
        :invex => nil,\r
        :kicklen => nil,\r
        :maxlist => {},\r
        :modes => 3,\r
        :network => nil,\r
        :nicklen => 9,\r
        :prefix => {\r
          :modes => 'ov'.scan(/./),\r
          :prefixes => '@+'.scan(/./)\r
        },\r
        :safelist => nil,\r
        :statusmsg => nil,\r
        :std => nil,\r
        :targmax => {},\r
        :topiclen => nil\r
      }\r
      @capabilities = {}\r
    end\r
\r
    # Resets the Channel and User list\r
    #\r
    def reset_lists\r
      @users.each { |u|\r
        delete_user(u)\r
      }\r
      @channels.each { |u|\r
        delete_channel(u)\r
      }\r
    end\r
\r
    # Clears the server\r
    #\r
    def clear\r
      reset_lists\r
      reset_capabilities\r
    end\r
\r
    # This method is used to parse a 004 RPL_MY_INFO line\r
    #\r
    def parse_my_info(line)\r
      ar = line.split(' ')\r
      @hostname = ar[0]\r
      @version = ar[1]\r
      @usermodes = ar[2]\r
      @chanmodes = ar[3]\r
    end\r
\r
    def noval_warn(key, val, &block)\r
      if val\r
        yield if block_given?\r
      else\r
        warn "No #{key.to_s.upcase} value"\r
      end\r
    end\r
\r
    def val_warn(key, val, &block)\r
      if val == true or val == false or val.nil?\r
        yield if block_given?\r
      else\r
        warn "No #{key.to_s.upcase} value must be specified, got #{val}"\r
      end\r
    end\r
    private :noval_warn, :val_warn\r
\r
    # This method is used to parse a 005 RPL_ISUPPORT line\r
    #\r
    # See the RPL_ISUPPORT draft[http://www.irc.org/tech_docs/draft-brocklesby-irc-isupport-03.txt]\r
    #\r
    def parse_isupport(line)\r
      debug "Parsing ISUPPORT #{line.inspect}"\r
      ar = line.split(' ')\r
      reparse = ""\r
      ar.each { |en|\r
        prekey, val = en.split('=', 2)\r
        if prekey =~ /^-(.*)/\r
          key = $1.downcase.to_sym\r
          val = false\r
        else\r
          key = prekey.downcase.to_sym\r
        end\r
        case key\r
        when :casemapping\r
          noval_warn(key, val) {\r
            @supports[key] = val.to_irc_casemap\r
          }\r
        when :chanlimit, :idchan, :maxlist, :targmax\r
          noval_warn(key, val) {\r
            groups = val.split(',')\r
            groups.each { |g|\r
              k, v = g.split(':')\r
              @supports[key][k] = v.to_i || 0\r
            }\r
          }\r
        when :chanmodes\r
          noval_warn(key, val) {\r
            groups = val.split(',')\r
            @supports[key][:typea] = groups[0].scan(/./).map { |x| x.to_sym}\r
            @supports[key][:typeb] = groups[1].scan(/./).map { |x| x.to_sym}\r
            @supports[key][:typec] = groups[2].scan(/./).map { |x| x.to_sym}\r
            @supports[key][:typed] = groups[3].scan(/./).map { |x| x.to_sym}\r
          }\r
        when :channellen, :kicklen, :modes, :topiclen\r
          if val\r
            @supports[key] = val.to_i\r
          else\r
            @supports[key] = nil\r
          end\r
        when :chantypes\r
          @supports[key] = val # can also be nil\r
        when :excepts\r
          val ||= 'e'\r
          @supports[key] = val\r
        when :invex\r
          val ||= 'I'\r
          @supports[key] = val\r
        when :maxchannels\r
          noval_warn(key, val) {\r
            reparse += "CHANLIMIT=(chantypes):#{val} "\r
          }\r
        when :maxtargets\r
          noval_warn(key, val) {\r
            @supports[:targmax]['PRIVMSG'] = val.to_i\r
            @supports[:targmax]['NOTICE'] = val.to_i\r
          }\r
        when :network\r
          noval_warn(key, val) {\r
            @supports[key] = val\r
          }\r
        when :nicklen\r
          noval_warn(key, val) {\r
            @supports[key] = val.to_i\r
          }\r
        when :prefix\r
          if val\r
            val.scan(/\((.*)\)(.*)/) { |m, p|\r
              @supports[key][:modes] = m.scan(/./).map { |x| x.to_sym}\r
              @supports[key][:prefixes] = p.scan(/./).map { |x| x.to_sym}\r
            }\r
          else\r
            @supports[key][:modes] = nil\r
            @supports[key][:prefixes] = nil\r
          end\r
        when :safelist\r
          val_warn(key, val) {\r
            @supports[key] = val.nil? ? true : val\r
          }\r
        when :statusmsg\r
          noval_warn(key, val) {\r
            @supports[key] = val.scan(/./)\r
          }\r
        when :std\r
          noval_warn(key, val) {\r
            @supports[key] = val.split(',')\r
          }\r
        else\r
          @supports[key] =  val.nil? ? true : val\r
        end\r
      }\r
      reparse.gsub!("(chantypes)",@supports[:chantypes])\r
      parse_isupport(reparse) unless reparse.empty?\r
    end\r
\r
    # Returns the casemap of the server.\r
    #\r
    def casemap\r
      @supports[:casemapping]\r
    end\r
\r
    # Returns User or Channel depending on what _name_ can be\r
    # a name of\r
    #\r
    def user_or_channel?(name)\r
      if supports[:chantypes].include?(name[0])\r
        return Channel\r
      else\r
        return User\r
      end\r
    end\r
\r
    # Returns the actual User or Channel object matching _name_\r
    #\r
    def user_or_channel(name)\r
      if supports[:chantypes].include?(name[0])\r
        return channel(name)\r
      else\r
        return user(name)\r
      end\r
    end\r
\r
    # Checks if the receiver already has a channel with the given _name_\r
    #\r
    def has_channel?(name)\r
      return false if name.nil_or_empty?\r
      channel_names.index(name.irc_downcase(casemap))\r
    end\r
    alias :has_chan? :has_channel?\r
\r
    # Returns the channel with name _name_, if available\r
    #\r
    def get_channel(name)\r
      return nil if name.nil_or_empty?\r
      idx = has_channel?(name)\r
      channels[idx] if idx\r
    end\r
    alias :get_chan :get_channel\r
\r
    # Create a new Channel object bound to the receiver and add it to the\r
    # list of <code>Channel</code>s on the receiver, unless the channel was\r
    # present already. In this case, the default action is to raise an\r
    # exception, unless _fails_ is set to false.  An exception can also be\r
    # raised if _str_ is nil or empty, again only if _fails_ is set to true;\r
    # otherwise, the method just returns nil\r
    #\r
    def new_channel(name, topic=nil, users=[], fails=true)\r
      if name.nil_or_empty?\r
        raise "Tried to look for empty or nil channel name #{name.inspect}" if fails\r
        return nil\r
      end\r
      ex = get_chan(name)\r
      if ex\r
        raise "Channel #{name} already exists on server #{self}" if fails\r
        return ex\r
      else\r
\r
        prefix = name[0].chr\r
\r
        # Give a warning if the new Channel goes over some server limits.\r
        #\r
        # FIXME might need to raise an exception\r
        #\r
        warn "#{self} doesn't support channel prefix #{prefix}" unless @supports[:chantypes].include?(prefix)\r
        warn "#{self} doesn't support channel names this long (#{name.length} > #{@supports[:channellen]})" unless name.length <= @supports[:channellen]\r
\r
        # Next, we check if we hit the limit for channels of type +prefix+\r
        # if the server supports +chanlimit+\r
        #\r
        @supports[:chanlimit].keys.each { |k|\r
          next unless k.include?(prefix)\r
          count = 0\r
          channel_names.each { |n|\r
            count += 1 if k.include?(n[0])\r
          }\r
          raise IndexError, "Already joined #{count} channels with prefix #{k}" if count == @supports[:chanlimit][k]\r
        }\r
\r
        # So far, everything is fine. Now create the actual Channel\r
        #\r
        chan = Channel.new(name, topic, users, :server => self)\r
\r
        # We wade through +prefix+ and +chanmodes+ to create appropriate\r
        # lists and flags for this channel\r
\r
        @supports[:prefix][:modes].each { |mode|\r
          chan.create_mode(mode, Channel::UserMode)\r
        } if @supports[:prefix][:modes]\r
\r
        @supports[:chanmodes].each { |k, val|\r
          if val\r
            case k\r
            when :typea\r
              val.each { |mode|\r
                chan.create_mode(mode, Channel::ModeTypeA)\r
              }\r
            when :typeb\r
              val.each { |mode|\r
                chan.create_mode(mode, Channel::ModeTypeB)\r
              }\r
            when :typec\r
              val.each { |mode|\r
                chan.create_mode(mode, Channel::ModeTypeC)\r
              }\r
            when :typed\r
              val.each { |mode|\r
                chan.create_mode(mode, Channel::ModeTypeD)\r
              }\r
            end\r
          end\r
        }\r
\r
        @channels << chan\r
        # debug "Created channel #{chan.inspect}"\r
        return chan\r
      end\r
    end\r
\r
    # Returns the Channel with the given _name_ on the server,\r
    # creating it if necessary. This is a short form for\r
    # new_channel(_str_, nil, [], +false+)\r
    #\r
    def channel(str)\r
      new_channel(str,nil,[],false)\r
    end\r
\r
    # Remove Channel _name_ from the list of <code>Channel</code>s\r
    #\r
    def delete_channel(name)\r
      idx = has_channel?(name)\r
      raise "Tried to remove unmanaged channel #{name}" unless idx\r
      @channels.delete_at(idx)\r
    end\r
\r
    # Checks if the receiver already has a user with the given _nick_\r
    #\r
    def has_user?(nick)\r
      return false if nick.nil_or_empty?\r
      user_nicks.index(nick.irc_downcase(casemap))\r
    end\r
\r
    # Returns the user with nick _nick_, if available\r
    #\r
    def get_user(nick)\r
      idx = has_user?(nick)\r
      @users[idx] if idx\r
    end\r
\r
    # Create a new User object bound to the receiver and add it to the list\r
    # of <code>User</code>s on the receiver, unless the User was present\r
    # already. In this case, the default action is to raise an exception,\r
    # unless _fails_ is set to false. An exception can also be raised\r
    # if _str_ is nil or empty, again only if _fails_ is set to true;\r
    # otherwise, the method just returns nil\r
    #\r
    def new_user(str, fails=true)\r
      if str.nil_or_empty?\r
        raise "Tried to look for empty or nil user name #{str.inspect}" if fails\r
        return nil\r
      end\r
      tmp = str.to_irc_user(:server => self)\r
      old = get_user(tmp.nick)\r
      # debug "Tmp: #{tmp.inspect}"\r
      # debug "Old: #{old.inspect}"\r
      if old\r
        # debug "User already existed as #{old.inspect}"\r
        if tmp.known?\r
          if old.known?\r
            # debug "Both were known"\r
            # Do not raise an error: things like Freenode change the hostname after identification\r
            warning "User #{tmp.nick} has inconsistent Netmasks! #{self} knows #{old.inspect} but access was tried with #{tmp.inspect}" if old != tmp\r
            raise "User #{tmp} already exists on server #{self}" if fails\r
          end\r
          if old.fullform.downcase != tmp.fullform.downcase\r
            old.replace(tmp)\r
            # debug "Known user now #{old.inspect}"\r
          end\r
        end\r
        return old\r
      else\r
        warn "#{self} doesn't support nicknames this long (#{tmp.nick.length} > #{@supports[:nicklen]})" unless tmp.nick.length <= @supports[:nicklen]\r
        @users << tmp\r
        return @users.last\r
      end\r
    end\r
\r
    # Returns the User with the given Netmask on the server,\r
    # creating it if necessary. This is a short form for\r
    # new_user(_str_, +false+)\r
    #\r
    def user(str)\r
      new_user(str, false)\r
    end\r
\r
    # Deletes User _user_ from Channel _channel_\r
    #\r
    def delete_user_from_channel(user, channel)\r
      channel.delete_user(user)\r
    end\r
\r
    # Remove User _someuser_ from the list of <code>User</code>s.\r
    # _someuser_ must be specified with the full Netmask.\r
    #\r
    def delete_user(someuser)\r
      idx = has_user?(someuser)\r
      raise "Tried to remove unmanaged user #{user}" unless idx\r
      have = self.user(someuser)\r
      @channels.each { |ch|\r
        delete_user_from_channel(have, ch)\r
      }\r
      @users.delete_at(idx)\r
    end\r
\r
    # Create a new Netmask object with the appropriate casemap\r
    #\r
    def new_netmask(str)\r
      str.to_irc_netmask(:server => self)\r
    end\r
\r
    # Finds all <code>User</code>s on server whose Netmask matches _mask_\r
    #\r
    def find_users(mask)\r
      nm = new_netmask(mask)\r
      @users.inject(UserList.new) {\r
        |list, user|\r
        if user.user == "*" or user.host == "*"\r
          list << user if user.nick.irc_downcase(casemap) =~ nm.nick.irc_downcase(casemap).to_irc_regexp\r
        else\r
          list << user if user.matches?(nm)\r
        end\r
        list\r
      }\r
    end\r
\r
  end\r
\r
end\r
\r