Improve robustness of ArrayOf; fix some inspect methods

[rbot] / 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
#++\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
# TODO User should have associated Server too\r
#\r
# TODO rather than the complex init methods, we should provide a single one (having a String parameter)\r
# and then provide to_irc_netmask(casemap), to_irc_user(server), to_irc_channel(server) etc\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 a string which is the downcased version of the\r
  # receiver, according to IRC rules: due to the Scandinavian origin of IRC,\r
  # the characters <tt>{}|^</tt> are considered the uppercase equivalent of\r
  # <tt>[]\~</tt>.\r
  #\r
  # Since IRC is mostly case-insensitive (the Windows way: case is preserved,\r
  # but it's actually ignored to check equality), this method is rather\r
  # important when checking if two strings refer to the same entity\r
  # (User/Channel)\r
  #\r
  # Modern server allow different casemaps, too, in which some or all\r
  # of the extra characters are not converted\r
  #\r
  def irc_downcase(casemap='rfc1459')\r
    case casemap\r
    when 'rfc1459'\r
      self.tr("\x41-\x5e", "\x61-\x7e")\r
    when 'strict-rfc1459'\r
      self.tr("\x41-\x5d", "\x61-\x7d")\r
    when 'ascii'\r
      self.tr("\x41-\x5a", "\x61-\x7a")\r
    else\r
      raise TypeError, "Unknown casemap #{casemap}"\r
    end\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
    case casemap\r
    when 'rfc1459'\r
      self.tr!("\x41-\x5e", "\x61-\x7e")\r
    when 'strict-rfc1459'\r
      self.tr!("\x41-\x5d", "\x61-\x7d")\r
    when 'ascii'\r
      self.tr!("\x41-\x5a", "\x61-\x7a")\r
    else\r
      raise TypeError, "Unknown casemap #{casemap}"\r
    end\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
    case casemap\r
    when 'rfc1459'\r
      self.tr("\x61-\x7e", "\x41-\x5e")\r
    when 'strict-rfc1459'\r
      self.tr("\x61-\x7d", "\x41-\x5d")\r
    when 'ascii'\r
      self.tr("\x61-\x7a", "\x41-\x5a")\r
    else\r
      raise TypeError, "Unknown casemap #{casemap}"\r
    end\r
  end\r
\r
  # In-place upcasing\r
  #\r
  # See also the discussion about irc_downcase\r
  #\r
  def irc_upcase!(casemap='rfc1459')\r
    case casemap\r
    when 'rfc1459'\r
      self.tr!("\x61-\x7e", "\x41-\x5e")\r
    when 'strict-rfc1459'\r
      self.tr!("\x61-\x7d", "\x41-\x5d")\r
    when 'ascii'\r
      self.tr!("\x61-\x7a", "\x41-\x5a")\r
    else\r
      raise TypeError, "Unknown casemap #{casemap}"\r
    end\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
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
  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
# The Irc module is used to keep all IRC-related classes\r
# in the same namespace\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 this\r
  # form they are used to refer to more than a user or to a user appearing\r
  # under different\r
  # 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
    attr_reader :nick, :user, :host\r
    attr_reader :casemap\r
\r
    # call-seq:\r
    #   Netmask.new(netmask) => new_netmask\r
    #   Netmask.new(hash={}, casemap=nil) => new_netmask\r
    #   Netmask.new("nick!user@host", casemap=nil) => new_netmask\r
    #\r
    # Create a new Netmask in any of these forms\r
    # 1. from another Netmask (does a .dup)\r
    # 2. from a Hash with any of the keys <tt>:nick</tt>, <tt>:user</tt> and\r
    #    <tt>:host</tt>\r
    # 3. from a String in the form <tt>nick!user@host</tt>\r
    #\r
    # In all but the first forms a casemap may be speficied, the default\r
    # being 'rfc1459'.\r
    #\r
    # The nick is downcased following IRC rules and according to the given casemap.\r
    #\r
    # FIXME check if user and host need to be downcased too.\r
    #\r
    # Empty +nick+, +user+ or +host+ are converted to the generic glob pattern\r
    #\r
    def initialize(str={}, casemap=nil)\r
      case str\r
      when Netmask\r
        raise ArgumentError, "Can't set casemap when initializing from other Netmask" if casemap\r
        @casemap = str.casemap.dup\r
        @nick = str.nick.dup\r
        @user = str.user.dup\r
        @host = str.host.dup\r
      when Hash\r
        @casemap = casemap || str[:casemap] || 'rfc1459'\r
        @nick = str[:nick].to_s.irc_downcase(@casemap)\r
        @user = str[:user].to_s\r
        @host = str[:host].to_s\r
      when String\r
        case str\r
        when ""\r
          @casemap = casemap || 'rfc1459'\r
          @nick = nil\r
          @user = nil\r
          @host = nil\r
        when /^(\S+?)(?:!(\S+)@(?:(\S+))?)?$/\r
          @casemap = casemap || 'rfc1459'\r
          @nick = $1.irc_downcase(@casemap)\r
          @user = $2\r
          @host = $3\r
        else\r
          raise ArgumentError, "#{str} is not a valid netmask"\r
        end\r
      else\r
        raise ArgumentError, "#{str} is not a valid netmask"\r
      end\r
\r
      @nick = "*" if @nick.to_s.empty?\r
      @user = "*" if @user.to_s.empty?\r
      @host = "*" if @host.to_s.empty?\r
    end\r
\r
    def inspect\r
      str = "<#{self.class}:#{'0x%x' % self.object_id}:"\r
      str << " @nick=#{@nick.inspect} @user=#{@user.inspect}"\r
      str << " @host=#{@host.inspect}>"\r
      str\r
    end\r
\r
    # Equality: two Netmasks are equal if they have the same @nick, @user, @host and @casemap\r
    #\r
    def ==(other)\r
      self.class == other.class && @nick == other.nick && @user == other.user && @host == other.host && @casemap == other.casemap\r
    end\r
\r
    # This method changes the nick of the Netmask, downcasing the argument\r
    # following IRC rules and defaulting to the generic glob pattern if\r
    # the result is the null string.\r
    #\r
    def nick=(newnick)\r
      @nick = newnick.to_s.irc_downcase(@casemap)\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
    # This method changes the casemap of a Netmask, which is needed in some\r
    # extreme circumstances. Please use sparingly\r
    #\r
    def casemap=(newcmap)\r
      @casemap = newcmap.to_s\r
      @casemap = "rfc1459" if @casemap.empty?\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
    # A Netmask is easily converted to a String for the usual representation\r
    # \r
    def fullform\r
      return "#{nick}!#{user}@#{host}"\r
    end\r
    alias :to_s :fullform\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 that\r
    # any netmask described by the receiver is also described by the 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 = Netmask.new(arg)\r
      raise TypeError, "#{arg} and #{self} have different casemaps" if @casemap != cmp.casemap\r
      raise TypeError, "#{arg} is not a valid Netmask" unless cmp.kind_of?(Netmask)\r
      [:nick, :user, :host].each { |component|\r
        us = self.send(component)\r
        them = cmp.send(component)\r
        raise NotImplementedError if us.has_irc_glob? && them.has_irc_glob?\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
      Netmask.new(arg).matches?(self)\r
    end\r
\r
    def <=>(arg)\r
      case arg\r
      when Netmask\r
        self.fullform <=> arg.fullform\r
      else\r
        self.to_s <=> arg.to_s\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
    def initialize(ar=[])\r
      super(Netmask, ar)\r
    end\r
  end\r
\r
\r
  # An IRC User is identified by his/her Netmask (which must not have\r
  # globs). In fact, User is just a subclass of Netmask. However,\r
  # a User will not allow one's host or user data to be changed.\r
  #\r
  # Due to the idiosincrasies of the IRC protocol, we allow\r
  # the creation of a user with an unknown mask represented by the\r
  # glob pattern *@*. Only in this case they may be set.\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="", casemap=nil)\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
    # We only allow the user to be changed if it was "*". Otherwise,\r
    # we raise an exception if the new host is different from the old one\r
    #\r
    def user=(newuser)\r
      if user == "*"\r
        super\r
      else\r
        raise "Can't change the username of user #{self}" if user != newuser\r
      end\r
    end\r
\r
    # We only allow the host to be changed if it was "*". Otherwise,\r
    # we raise an exception if the new host is different from the old one\r
    #\r
    def host=(newhost)\r
      if host == "*"\r
        super\r
      else\r
        raise "Can't change the hostname of user #{self}" if host != newhost \r
      end\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 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
  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
    def initialize(ar=[])\r
      super(User, ar)\r
    end\r
  end\r
\r
\r
  # A ChannelTopic represents the topic of a channel. It consists of\r
  # the topic itself, who set it and when\r
  class ChannelTopic\r
    attr_accessor :text, :set_by, :set_on\r
    alias :to_s :text\r
\r
    # Create a new ChannelTopic setting the text, the creator and\r
    # the creation time\r
    def initialize(text="", set_by="", set_on=Time.new)\r
      @text = text\r
      @set_by = set_by\r
      @set_on = Time.new\r
    end\r
\r
    # Replace a ChannelTopic with another one\r
    def replace(topic)\r
      raise TypeError, "#{topic.inspect} is not an Irc::ChannelTopic" unless topic.kind_of?(ChannelTopic)\r
      @text = topic.text.dup\r
      @set_by = topic.set_by.dup\r
      @set_on = topic.set_on.dup\r
    end\r
  end\r
\r
\r
  # Mode on a channel\r
  class ChannelMode\r
    def initialize(ch)\r
      @channel = ch\r
    end\r
  end\r
\r
\r
  # Channel modes of type A manipulate lists\r
  #\r
  class ChannelModeTypeA < ChannelMode\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
  end\r
\r
  # Channel modes of type B need an argument\r
  #\r
  class ChannelModeTypeB < ChannelMode\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
  end\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 ChannelUserMode < ChannelModeTypeB\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
  end\r
\r
  # Channel modes of type C need an argument when set,\r
  # but not when they get reset\r
  #\r
  class ChannelModeTypeC < ChannelMode\r
    def initialize(ch)\r
      super\r
      @arg = false\r
    end\r
\r
    def set(val)\r
      @arg = val\r
    end\r
\r
    def reset\r
      @arg = false\r
    end\r
  end\r
\r
  # Channel modes of type D are basically booleans\r
  class ChannelModeTypeD < ChannelMode\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
  end\r
\r
\r
  # An IRC Channel is identified by its name, and it has a set of properties:\r
  # * a topic\r
  # * a UserList\r
  # * a set of modes\r
  #\r
  class Channel\r
    attr_reader :name, :topic, :mode, :users, :server\r
    alias :to_s :name\r
\r
    def inspect\r
      str = "<#{self.class}:#{'0x%x' % self.object_id}:"\r
      str << " on server #{server}"\r
      str << " @name=#{@name.inspect} @topic=#{@topic.text.inspect}"\r
      str << " @users=<#{@users.sort.join(', ')}>"\r
      str\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
    # FIXME doesn't check if users have the same casemap as the channel yet\r
    #\r
    def initialize(server, name, topic=nil, users=[])\r
      raise TypeError, "First parameter must be an Irc::Server" unless server.kind_of?(Server)\r
      raise ArgumentError, "Channel name cannot be empty" if name.to_s.empty?\r
      raise ArgumentError, "Unknown channel prefix #{name[0].chr}" if name !~ /^[&#+!]/\r
      raise ArgumentError, "Invalid character in #{name.inspect}" if name =~ /[ \x07,]/\r
\r
      @server = server\r
\r
      @name = name.irc_downcase(casemap)\r
\r
      @topic = topic || ChannelTopic.new\r
\r
      case users\r
      when UserList\r
        @users = users\r
      when Array\r
        @users = UserList.new(users)\r
      else\r
        raise ArgumentError, "Invalid user list #{users.inspect}"\r
      end\r
\r
      # Flags\r
      @mode = {}\r
    end\r
\r
    # Returns the casemap of the originating server\r
    def casemap\r
      return @server.casemap\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?(ChannelUserMode)\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 safe 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
  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
    def initialize(ar=[])\r
      super(Channel, ar)\r
    end\r
  end\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
    def channel_names\r
      @channels.map { |ch| ch.name }\r
    end\r
\r
    def user_nicks\r
      @users.map { |u| u.nick }\r
    end\r
\r
    def inspect\r
      chans = @channels.map { |ch|\r
        ch.inspect\r
      }\r
      users = @users.map { |u|\r
        u.inspect\r
      }.sort\r
\r
      str = "<#{self.class}:#{'0x%x' % self.object_id}:"\r
      str << " @channels=#{chans}"\r
      str << " @users=#{users}>"\r
      str\r
    end\r
\r
    # Create a new Server, with all instance variables reset\r
    # to nil (for scalar variables), the channel and user lists\r
    # are empty, and @supports is initialized to the default values\r
    # 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',\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, :network\r
          noval_warn(key, val) {\r
            @supports[key] = val\r
            @users.each { |u|\r
              debug "Resetting casemap of #{u} from #{u.casemap} to #{val}"\r
              u.casemap = val\r
            }\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\r
            }\r
          }\r
        when :maxchannels\r
          noval_warn(key, val) {\r
            reparse += "CHANLIMIT=(chantypes):#{val} "\r
          }\r
        when :maxtargets\r
          noval_warn(key, val) {\r
            @supports[key]['PRIVMSG'] = val.to_i\r
            @supports[key]['NOTICE'] = val.to_i\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 :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] || 'rfc1459'\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
      channel_names.index(name.to_s)\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
      idx = channel_names.index(name.to_s)\r
      channels[idx] if idx\r
    end\r
    alias :get_chan :get_channel\r
\r
    # Create a new Channel object and add it to the list of\r
    # <code>Channel</code>s on the receiver, unless the channel\r
    # was present already. In this case, the default action is\r
    # to raise an exception, unless _fails_ is set to false\r
    #\r
    # The Channel is automatically created with the appropriate casemap\r
    #\r
    def new_channel(name, topic=nil, users=[], fails=true)\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(self, name, topic, users)\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, ChannelUserMode)\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, ChannelModeTypeA)\r
              }\r
            when :typeb\r
              val.each { |mode|\r
                chan.create_mode(mode, ChannelModeTypeB)\r
              }\r
            when :typec\r
              val.each { |mode|\r
                chan.create_mode(mode, ChannelModeTypeC)\r
              }\r
            when :typed\r
              val.each { |mode|\r
                chan.create_mode(mode, ChannelModeTypeD)\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
      user_nicks.index(nick.to_s)\r
    end\r
\r
    # Returns the user with nick _nick_, if available\r
    #\r
    def get_user(nick)\r
      idx = user_nicks.index(nick.to_s)\r
      @users[idx] if idx\r
    end\r
\r
    # Create a new User object and add it to the list of\r
    # <code>User</code>s on the receiver, unless the User\r
    # was present already. In this case, the default action is\r
    # to raise an exception, unless _fails_ is set to false\r
    #\r
    # The User is automatically created with the appropriate casemap\r
    #\r
    def new_user(str, fails=true)\r
      case str\r
      when User\r
        tmp = str\r
      else\r
        tmp = User.new(str, self.casemap)\r
      end\r
      # debug "Creating or selecting user #{tmp.inspect} from #{str.inspect}"\r
      old = get_user(tmp.nick)\r
      if old\r
        # debug "User already existed as #{old.inspect}"\r
        if tmp.known?\r
          if old.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 != tmp\r
            old.user = tmp.user\r
            old.host = tmp.host\r
            # debug "User improved to #{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
      u = new_user(str, false)\r
      debug "Server user #{u.inspect} from #{str.inspect}"\r
      u\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.nick)\r
      raise "Tried to remove unmanaged user #{user}" unless idx\r
      have = self.user(someuser)\r
      raise "User #{someuser.nick} has inconsistent Netmasks! #{self} knows #{have} but access was tried with #{someuser}" if have != someuser && have.user != "*" && have.host != "*"\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
      if str.kind_of?(Netmask )\r
        raise "Wrong casemap for Netmask #{str.inspect}" if str.casemap != self.casemap\r
        return str\r
      end\r
      Netmask.new(str, self.casemap)\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 =~ nm.nick.to_irc_regexp\r
        else\r
          list << user if user.matches?(nm)\r
        end\r
        list\r
      }\r
    end\r
\r
    # Deletes User from Channel\r
    #\r
    def delete_user_from_channel(user, channel)\r
      channel.delete_user(user)\r
    end\r
\r
  end\r
\r
end\r
\r