rhuidean 0.2.7 → 1.0.0

data/README.markdown

@@ -24,10 +24,13 @@ and it also offers clever ways of accomplishing basic and advanced tasks.
 The current active development/maintenance is done by:
 
 - rakaur, Eric Will <rakaur@malkier.net>
+
+Almost all of the testing was also done by me, with help from:
+
 - sycobuny, Stephen Belcher <sycobuny@malkier.net>
+- dKingston, Michael Rodriguez <dkingston@malkier.net>
 
-Almost all of the testing was also done by us. I (rakaur) wrote all of the base
-code, and sycobuny has expanded on it with more in-depth classes.
+And others on irc.malkier.net.
 
 2. INSTALLATION
 ---------------

data/lib/rhuidean.rb

@@ -5,7 +5,16 @@
 # Copyright (c) 2003-2010 Eric Will <rakaur@malkier.net>
 #
 
-# Import required rhuidean modules.
+module Rhuidean
+    # Version number
+    V_MAJOR  = 1
+    V_MINOR  = 0
+    V_PATCH  = 0
+
+    VERSION  = "#{V_MAJOR}.#{V_MINOR}.#{V_PATCH}"
+end
+
+# Import required app modules
 %w(client event methods numeric timer).each do |m|
     require 'rhuidean/' + m
 end

data/lib/rhuidean/client.rb

@@ -5,16 +5,14 @@
 # Copyright (c) 2003-2010 Eric Will <rakaur@malkier.net>
 #
 
-# Import required Ruby modules.
+# Import required Ruby modules
 %w(logger socket).each { |m| require m }
 
 module IRC
 
 # The IRC::Client class acts as an abstract interface to the IRC protocol.
 class Client
-    ##
-    # constants
-    VERSION = '0.2.7'
+    include Rhuidean # Version info and such
 
     ##
     # instance attributes
@@ -22,7 +20,7 @@ class Client
                   :nickname, :username, :realname, :bind_to
 
     # Our TCPSocket.
-    attr_reader   :socket, :channels
+    attr_reader   :socket
 
     # A simple Exeption class.
     class Error < Exception
@@ -58,9 +56,6 @@ class Client
         @dead      = false
         @connected = false
 
-        # List of channels we're on
-        @channels = []
-
         # Received data waiting to be parsed.
         @recvq = []
 
@@ -119,15 +114,6 @@ class Client
         # Track our nickname...
         on(:NICK) { |m| @nickname = m.target if m.origin_nick == @nickname }
 
-        # Track channels
-        on(:JOIN) { |m| @channels << m.target if m.origin_nick == @nickname }
-
-        on(:PART) do |m|
-            @channels.delete(m.target) if m.origin_nick == @nickname
-        end
-
-        on(:KICK) { |m| @channels.delete(m.target) if m.params[0] == @nickname }
-
         self
     end
 
@@ -197,7 +183,7 @@ class Client
             ret = nil # Dead
         end
 
-        unless ret
+        if not ret or ret.empty?
             @eventq.post(:dead)
             return
         end
@@ -236,6 +222,9 @@ class Client
             end
         rescue Errno::EAGAIN
             retry
+        rescue Exception
+            @eventq.post(:dead)
+            return
         end
     end
 
@@ -302,10 +291,53 @@ class Client
         self
     end
 
+    #
+    # Logs a regular message.
+    # ---
+    # message:: the string to log
+    # returns:: +self+
+    #
+    def log(message)
+        @logger.info(caller[0].split('/')[-1]) { message } if @logger
+    end
+
+    #
+    # Logs a debug message.
+    # ---
+    # message:: the string to log
+    # returns:: +self+
+    #
+    def debug(message)
+        return unless @logger
+
+        @logger.debug(caller[0].split('/')[-1]) { message } if @debug
+    end
+
     ######
     public
     ######
 
+    #
+    # Sets the logging object to use.
+    # If it quacks like a Logger object, it should work.
+    # ---
+    # logger:: the Logger to use
+    # returns:: +self+
+    #
+    def logger=(logger)
+        @logger = logger
+
+        # Set to false/nil to disable logging...
+        return unless @logger
+
+        @logger.progname        = 'irc'
+        @logger.datetime_format = '%b %d %H:%M:%S '
+
+        # We only have 'logging' and 'debugging', so just set the
+        # object to show all levels. I might change this someday.
+        @logger.level = Logger::DEBUG
+    end
+
     #
     # Registers Event handlers with our EventQueue.
     # ---
@@ -327,7 +359,7 @@ class Client
     end
 
     #
-    # Schedules input/output and runs the EventQueue.
+    # Schedules input/output and runs the +EventQueue+.
     # ---
     # returns:: never, thread dies on +:exit+
     #
@@ -409,46 +441,12 @@ class Client
     end
 
     #
-    # Logs a regular message.
+    # Represent ourselves in a string.
     # ---
-    # message:: the string to log
-    # returns:: +self+
+    # returns:: our nickname and object ID
     #
-    def log(message)
-        @logger.info(caller[0].split('/')[-1]) { message } if @logger
-    end
-
-    #
-    # Logs a debug message.
-    # ---
-    # message:: the string to log
-    # returns:: +self+
-    #
-    def debug(message)
-        return unless @logger
-
-        @logger.debug(caller[0].split('/')[-1]) { message } if @debug
-    end
-
-    #
-    # Sets the logging object to use.
-    # If it quacks like a Logger object, it should work.
-    # ---
-    # logger:: the Logger to use
-    # returns:: +self+
-    #
-    def logger=(logger)
-        @logger = logger
-
-        # Set to false/nil to disable logging...
-        return unless @logger
-
-        @logger.progname        = 'irc'
-        @logger.datetime_format = '%b %d %H:%M:%S '
-
-        # We only have 'logging' and 'debugging', so just set the
-        # object to show all levels. I might change this someday.
-        @logger.level = Logger::DEBUG
+    def to_s
+        "#{@nickname}:#{self.object_id}"
     end
 
     #
@@ -479,8 +477,23 @@ class Message
     # style of (char *origin, char *target, char *parv[]) in C.
     #
     def initialize(client, raw, origin, target, params)
-        @client, @ctcp, @origin = client, nil, origin
-        @params, @raw,  @target = params, raw, target
+        # The IRC::Client that processed this message
+        @client = client
+
+        # If this is a CTCP, the type of CTCP
+        @ctcp = nil
+
+        # The originator of the message. Sometimes server, sometimes n!u@h
+        @origin = origin
+
+        # A space-tokenized array of anything after a colon
+        @params = params
+
+        # The full string from the IRC server
+        @raw = raw
+
+        # Usually the intended recipient; usually a user or channel
+        @target = target
 
         # Is the origin a user? Let's make this a little more simple...
         if m = ORIGIN_RE.match(@origin)
@@ -498,19 +511,39 @@ class Message
     public
     ######
 
+    #
+    # Was the message sent to a channel?
+    # ---
+    # returns:: +true+ or +false+
+    #
     def to_channel?
         %w(# & !).include?(@target[0])
     end
 
-    def is_ctcp?
+    #
+    # Was the message formatted as a CTCP message?
+    # ---
+    # returns:: +true+ or +false+
+    #
+    def ctcp?
         @ctcp
     end
 
-    def is_action?
+    #
+    # Was the message formatted as a CTCP action?
+    # ---
+    # returns:: +true+ or +false+
+    #
+    def action?
         @ctcp == :action
     end
 
-    def is_dcc?
+    #
+    # Was the message formatted as a DCC notice?
+    # ---
+    # returns:: +true+ or +false+
+    #
+    def dcc?
         @ctcp == :dcc
     end
 end

data/lib/rhuidean/methods.rb

@@ -7,6 +7,12 @@
 
 module IRC
 
+#
+# These methods are shortcuts for sending data to the IRC
+# server. You can use `raw` to do any of them, or even add
+# a string directly to `@sendq` if you really want. I'm sure
+# I haven't thought of everything here.
+#
 class Client
     ######
     public
@@ -68,7 +74,7 @@ class Client
     end
 
     # Sends an IRC MODE command.
-    def mode(target, mode)
+    def mode(target, mode = '')
         @sendq << "MODE #{target} #{mode}"
     end
 

data/lib/rhuidean/numeric.rb

@@ -18,7 +18,7 @@ RPL_WELCOME           = :'001'
 RPL_YOURHOST          = :'002'
 RPL_CREATED           = :'003'
 RPL_MYINFO            = :'004'
-RPL_BOUNCE            = :'005'
+RPL_ISUPPORT          = :'005'
 
 # ERRORS
 ERR_NOSUCHNICK        = :'401'

data/lib/rhuidean/stateful_channel.rb

@@ -0,0 +1,237 @@
+#
+# rhuidean: a small, lightweight IRC client library
+# lib/rhuidean/stateful_channel.rb: state-keeping IRC channel
+#
+# Copyright (c) 2003-2010 Eric Will <rakaur@malkier.net>
+#
+
+# Import required app modules
+%w(stateful_client stateful_user).each { |m| require 'rhuidean/' + m }
+
+module IRC
+
+##
+# Represents a channel on IRC.
+#
+class StatefulChannel
+
+    ##
+    # instance attributes
+    attr_reader :modes, :name, :users
+
+    ##
+    # Creates a new +StatefulChannel+.
+    # The channel has an +EventQueue+, but it really points to the EventQueue of
+    # the +StatefulClient+ that created it. This kind of breaks OOP,
+    # but it allows the Channel to post relevant events back to the client,
+    # like mode changes.
+    # ---
+    # name:: the name of the channel
+    # client:: the +IRC::Client+ that sees us
+    # returns:: +self+
+    #
+    def initialize(name, client)
+        # The Client we belong to
+        @client = client
+
+        # The channel's key
+        @key = nil
+
+        # The channel's user limit
+        @limit = 0
+
+        # The channel's modes
+        @modes = []
+
+        # The name of the channel, including the prefix
+        @name = name
+
+        # The list of StatefulUsers on the channel keyed by nickname
+        @users = IRCHash.new(@client.casemapping)
+    end
+
+    ######
+    public
+    ######
+
+    #
+    # Represent ourselves in a string.
+    # ---
+    # returns:: our name
+    #
+    def to_s
+        @name
+    end
+
+    #
+    # Add a user to our userlist.
+    # This also adds us to the user's channel list.
+    # ---
+    # user:: the +StatefulUser+ to add
+    # returns:: +self+
+    #
+    def add_user(user)
+        @users[user.nickname] = user
+        user.join_channel(self)
+
+        self
+    end
+
+    #
+    # Remove a user from our userlist.
+    # This also removes us from the user's channel list.
+    # ---
+    # user:: a +StatefulUser+ or the name of one
+    # returns:: +self+ (nil on catastrophic failure)
+    #
+    def delete_user(user)
+        if user.class == String
+            @users[user].part_channel(self)
+            @users.delete(user)
+
+            self
+        elsif user.class == StatefulUser
+            user.part_channel(self)
+            @users.delete(user.nickname)
+
+            self
+        else
+            nil
+        end
+    end
+
+    STATUS_MODES = { 'o' => :oper,
+                     'v' => :voice }
+
+    LIST_MODES   = { 'b' => :ban,
+                     'e' => :except,
+                     'I' => :invex }
+
+    PARAM_MODES  = { 'l' => :limited,
+                     'k' => :keyed }
+
+    BOOL_MODES   = { 'i' => :invite_only,
+                     'm' => :moderated,
+                     'n' => :no_external,
+                     'p' => :private,
+                     's' => :secret,
+                     't' => :topic_lock }
+
+    #
+    # Parse a mode string.
+    # Update channel state for modes we know, and fire off events.
+    # ---
+    # m:: the IRC::Message object
+    # modes:: the mode string
+    # params:: an array of the params tokenized by space
+    # returns:: nothing of consequence...
+    #
+    def parse_modes(m, modes, params)
+        mode = nil # :add or :del
+
+        modes.each_char do |c|
+            flag, param = nil
+
+            if c == '+'
+                mode = :add
+                next
+            elsif c == '-'
+                mode = :del
+                next
+            end
+
+            # Status modes
+            if STATUS_MODES.include?(c)
+                flag  = STATUS_MODES[c]
+                param = params.shift
+
+            # Status modes from RPL_ISUPPORT
+            elsif @client.status_modes.keys.include?(c)
+                flag  = c.to_sym
+                param = params.shift
+
+            # List modes
+            elsif LIST_MODES.include?(c)
+                flag  = LIST_MODES[c]
+                param = params.shift
+
+            # List modes from RPL_ISUPPORT
+            elsif @client.channel_modes[:list].include?(c)
+                flag  = c.to_sym
+                param = params.shift
+
+            # Always has a param (some send the key, some send '*')
+            elsif c == 'k'
+                flag  = :keyed
+                param = params.shift
+                @key  = mode == :add ? param : nil
+
+            # Has a param when +, doesn't when -
+            elsif c == 'l'
+                flag   = :limited
+                param  = params.shift if mode == :add
+                @limit = mode == :add ? param : 0
+
+            # Always has a param from RPL_ISUPPORT
+            elsif @client.channel_modes[:always].include?(c)
+                flag  = c.to_sym
+                param = params.shift
+
+            # Has a parm when +, doesn't when - from RPL_ISUPPORT
+            elsif @client.channel_modes[:set].include?(c)
+                flag  = c.to_sym
+                param = params.shift if mode == :add
+
+            # The rest, no param
+            elsif BOOL_MODES.include?(c)
+                flag = BOOL_MODES[c]
+
+            # The rest, no param from RPL_ISUPPORT
+            elsif @client.channel_modes[:bool].include?(c)
+                flag = c.to_sym
+            end
+
+            # Add non-status and non-list modes to the channel's modes
+            unless junk_cmode?(c)
+                if mode == :add
+                    @modes << flag
+                else
+                    @modes.delete(flag)
+                end
+            end
+
+            # Update status modes for users
+            if status_mode?(c)
+                if mode == :add
+                    @users[param].add_status_mode(flag, self)
+                elsif mode == :del
+                    @users[param].delete_status_mode(flag, self)
+                end
+            end
+
+            # And send out events for everything
+            event = "mode_#{flag.to_s}".to_sym
+            @client.eventq.post(event, m, mode, param)
+        end
+    end
+
+    #######
+    private
+    #######
+
+    def status_mode?(modechar)
+        return true if STATUS_MODES.include?(modechar)
+        return true if @client.status_modes.keys.include?(modechar)
+        return false
+    end
+
+    def junk_cmode?(modechar)
+        return true if STATUS_MODES.include?(modechar)
+        return true if LIST_MODES.include?(modechar)
+        return true if @client.channel_modes[:list].include?(modechar)
+        return true if @client.status_modes.keys.include?(modechar)
+        return false
+    end
+end
+
+end # module IRC

data/lib/rhuidean/stateful_client.rb

@@ -0,0 +1,330 @@
+#
+# rhuidean: a small, lightweight IRC client library
+# lib/rhuidean/stateful_client.rb: state-keeping IRC::Client
+#
+# Copyright (c) 2003-2010 Eric Will <rakaur@malkier.net>
+#
+ 
+# Import required app modules
+%w(stateful_channel stateful_user).each { |m| require 'rhuidean/' + m }
+
+module IRC
+
+##
+# A +StatefulClient+ builds on +Client+ and tracks everything
+# it does. This is useful for getting a head start on a bot.
+#
+class StatefulClient < Client
+
+    ##
+    # instance attributes
+    attr_reader :casemapping, :channels, :channel_modes, :eventq, :status_modes
+    attr_reader :users
+
+    ##
+    # Creates a new +StatefulClient+.
+    # ---
+    # returns:: +self+
+    #
+    def initialize
+        # StatefulChannels keyed by channel name
+        @channels = IRCHash.new(:rfc)
+
+        # Known channel types, from RPL_ISUPPORT
+        @channel_types = %w(# &)
+
+        # Additional channel modes from RPL_ISUPPORT
+        @channel_modes = {}
+
+        # Additional status modes we get from RPL_ISUPPORT
+        @status_modes = {}
+
+        # StatefulUsers we know about, keyed by nickname
+        @users = IRCHash.new(:rfc)
+
+        super
+    end
+
+    ######
+    public
+    ######
+
+    #
+    # Adds a +StatefulUser+ to our known-users list.
+    # ---
+    # user:: a +StatefulUser+
+    # returns:: +self+
+    #
+    def add_user(user)
+        @users[user.nickname] = user
+
+        self
+    end
+
+    #
+    # Removes a +StatefulUser+ from our known-users list, usually
+    # so it can die and be eaten by the GC.
+    # ---
+    # user:: either a +StatefulUser+ or the name of one
+    # returns:: +self+ (nil on catestrophic failure)
+    #
+    def delete_user(user)
+        if user.class == String
+            @users.delete(user)
+            self
+        elsif user.class == StatefulUser
+            @users.delete(user.nickname)
+            self
+        else
+            nil
+        end
+    end
+
+    #######
+    private
+    #######
+
+    PREFIX_RE = /^\((\w+)\)(.*)$/
+
+    # Set up our event handlers
+    def set_default_handlers
+        on(:dead) do
+            @channels.clear
+            @users.clear
+        end
+
+        on(Numeric::RPL_ISUPPORT) { |m| do_rpl_isupport(m) }
+
+        on(:JOIN) { |m| do_join(m) }
+        on(:PART) { |m| do_part(m) }
+        on(:NICK) { |m| do_nick(m) }
+        on(:KICK) { |m| do_kick(m) }
+        on(:QUIT) { |m| do_quit(m) }
+
+        # Parse and sync channel modes
+        on(:MODE) do |m|
+            next unless @channel_types.include?(m.target[0])
+            @channels[m.target].parse_modes(m, m.params[0], m.params[1..-1])
+        end
+
+        # Parse reply from MODE
+        on(Numeric::RPL_CHANNELMODEIS) do |m|
+            @channels[m.params[0]].parse_modes(m, m.params[1], m.params[2..-1])
+        end
+
+        # Sync current users in channel
+        on(Numeric::RPL_NAMEREPLY) { |m| do_rpl_namereply(m) }
+
+        super
+    end
+
+    # Parse RPL_ISUPPORT to make us smarter!
+    def do_rpl_isupport(m)
+        supported = []
+
+        m.params.each { |param| supported << param.split('=') }
+
+        supported.each do |name, value|
+            case name
+
+            # CASEMAPPING=rfc1459
+            when 'CASEMAPPING'
+                if value == "rfc1459"
+                    @casemapping = :rfc
+                    @channels    = IRCHash.new(:rfc)
+                    @users       = IRCHash.new(:rfc)
+                elsif value == "ascii"
+                    @casemapping = :ascii
+                    @channels    = IRCHash.new(:ascii)
+                    @users       = IRCHash.new(:ascii)
+                end
+
+            # CHANMODES=eIb,k,l,imnpst
+            # Fields are: list param, always param, param when +, no param
+            when 'CHANMODES'
+                listp, alwaysp, setp, nop = value.split(',')
+
+                @channel_modes[:list]   = listp.split('')
+                @channel_modes[:always] = alwaysp.split('')
+                @channel_modes[:set]    = setp.split('')
+                @channel_modes[:bool]   = nop.split('')
+
+            # CHANTYPES=&#
+            when 'CHANTYPES'
+                @channel_types = value.split('')
+
+            # PREFIX=(ov)@+
+            when 'PREFIX'
+                m = PREFIX_RE.match(value)
+                modes, prefixes = m[1], m[2]
+
+                modes    = modes.split('')
+                prefixes = prefixes.split('')
+
+                modes.each_with_index do |m, i|
+                    @status_modes[m] = prefixes[i]
+                end
+            end
+        end
+    end
+
+    def do_join(m)
+        # Track channels
+        if m.origin_nick == @nickname
+            @channels[m.target] = StatefulChannel.new(m.target, self)
+            mode(m.target) # Get the channel modes
+        else
+            nick = m.origin_nick
+            user = @users[nick] || StatefulUser.new(nick, self)
+            @users[user.nickname] ||= user
+
+            @channels[m.target].add_user(user)
+            debug("join: #{user} -> #{m.target}")
+        end
+    end
+
+    def do_part(m)
+        # Track channels
+        if m.origin_nick == @nickname
+            chan = @channels[m.target]
+
+            # We can't see if they're in the channel we parted
+            chan.users.each { |n, user| user.part_channel(chan) }
+
+            # If we have users in no channels they must die
+            @users.delete_if { |n, user| user.channels.empty? }
+
+            @channels.delete(chan.name)
+
+            debug("parted: #{chan.name}")
+        else
+            user = @users[m.origin_nick]
+
+            @channels[m.target].delete_user(user)
+            debug("part: #{user.nickname} -> #{m.origin_nick}")
+
+            delete_user(user) if user.channels.empty?
+        end
+    end
+
+    def do_nick(m)
+        # Get the user object
+        user = @users[m.origin_nick]
+
+        # Rename it, rekey it, and delete the old one
+        user.nickname = m.target
+        @users[m.target] = user
+        @users.delete(m.origin_nick)
+
+        # We have to rekey it on channel lists, too
+        user.channels.each do |name, channel|
+            channel.users[m.target] = user
+            channel.users.delete(m.origin_nick)
+        end
+
+        debug("nick: #{m.origin_nick} -> #{m.target}")
+    end
+
+    def do_kick(m)
+        # Track channels
+        if m.params[0] == @nickname
+            chan = @channels[m.target]
+
+            # We can't see if they're in the channel we got kicked from
+            chan.users.each { |n, user| user.part_channel(chan) }
+
+            # If we have users in no channels they must die
+            @users.delete_if { |n, user| user.channels.empty? }
+
+            @channels.delete(chan.name)
+
+            debug("kicked: #{chan.name}")
+        else
+            user = @users[m.params[0]]
+
+            @channels[m.target].delete_user(user)
+            debug("kick: #{user.nickname} -> #{m.origin_nick}")
+
+            delete_user(user) if user.channels.empty?
+        end
+    end
+
+    def do_quit(m)
+        if m.origin_nick == @nickname
+            @eventq.post(:dead)
+        else
+            user = @users[m.origin_nick]
+
+            user.channels.each { |name, chan| chan.delete_user(user) }
+
+            delete_user(user)
+            debug("quit: #{user.nickname}")
+        end
+    end
+
+    #
+    # In the case of multiple status modes, we assume the ircd sends only
+    # the uppermost (i.e.: @ when @+). My testing, even with stupid ircds
+    # with a thousand modes, seems to support this.
+    #
+    def do_rpl_namereply(m)
+        chan     = @channels[m.params[1]]
+        names    = m.params[2..-1]
+        names[0] = names[0][1..-1] # Get rid of leading ':'
+        modes    = @status_modes.keys
+        prefixes = @status_modes.values
+        name_re  = /^([#{prefixes}])*(.+)/
+
+        names.each do |name|
+            m      = name_re.match(name)
+            user   = @users[m[2]] || StatefulUser.new(m[2], self)
+            prefix = m[1]
+
+            @users[user.nickname] ||= user
+
+            if prefix == '@'
+                user.add_status_mode(:oper, chan)
+
+            elsif prefix == '+'
+                user.add_status_mode(:voice, chan)
+
+            elsif prefixes.include?(prefix)
+                smode = modes[prefixes.find_index(prefix)]
+                user.add_status_mode(smode.to_sym, chan)
+            end
+
+            chan.add_user(user)
+            debug("names: #{user} -> #{chan}")
+        end
+    end
+end
+
+end # module IRC
+
+# So we don't have to do @channels[irc_downcase(name)] constantly
+class IRCHash < Hash
+    def initialize(casemapping)
+        @casemapping = casemapping
+
+        super()
+    end
+
+    def [](key)
+        key = irc_downcase(key)
+        super(key)
+    end
+
+    def []=(key, value)
+        key = irc_downcase(key)
+        super(key, value)
+    end
+
+    def irc_downcase(string)
+        if @casemapping == :rfc
+            string.downcase.tr('{}|^', '[]\\~')
+        else
+            string
+        end
+    end
+end
+

data/lib/rhuidean/stateful_user.rb

@@ -0,0 +1,117 @@
+#
+# rhuidean: a small, lightweight IRC client library
+# lib/rhuidean/stateful_user.rb: state-keeping IRC user
+#
+# Copyright (c) 2003-2010 Eric Will <rakaur@malkier.net>
+#
+ 
+# Import required app modules
+%w(stateful_client stateful_channel).each { |m| require 'rhuidean/' + m }
+
+module IRC
+
+#
+# Represents a user on IRC. Each nickname should only have one of
+# these objects, no matter how many channels they're in. If we can't
+# see them in any channels they disappear.
+#
+class StatefulUser
+
+    ##
+    # instance attributes
+    attr_reader   :channels, :modes
+    attr_accessor :nickname
+
+    ##
+    # Creates a new +StatefulUser+.
+    # ---
+    # nickname:: the user's nickname, as a string
+    # client:: the +IRC::Client+ that sees us
+    # returns::+ self+
+    #
+    def initialize(nickname, client)
+        # The Client we belong to
+        @client = client
+
+        # StatefulChannels we're on, keyed by name
+        @channels = IRCHash.new(@client.casemapping)
+
+        # Status modes on channels, keyed by channel name (:oper, :voice)
+        @modes = {}
+
+        # The user's nickname
+        @nickname = nickname
+    end
+
+    ######
+    public
+    ######
+
+    #
+    # Represent ourselves in a string.
+    # ---
+    # returns:: our nickname
+    #
+    def to_s
+        @nickname
+    end
+
+    #
+    # Add a channel to our joined-list.
+    # ---
+    # channel:: the +StatefulChannel+ to add
+    # returns:: +self+
+    #
+    def join_channel(channel)
+        @channels[channel.name] = channel
+
+        self
+    end
+
+    #
+    # Remove a channel from our joined-list.
+    # Also clears our status modes for that channel.
+    # ---
+    # channel:: the +StatefulChannel+ to remove
+    # returns:: +self+
+    #
+    def part_channel(channel)
+        @modes.delete(channel.name)
+        @channels.delete(channel.name)
+
+        self
+    end
+
+    #
+    # Give us a status mode on a channel.
+    # ---
+    # flag:: +Symbol+ representing a mode flag
+    # channel:: either a +StatefulChannel+ or the name of one
+    # returns:: +self+
+    #
+    def add_status_mode(flag, channel)
+        if channel.class == StatefulChannel then channel = channel.name end
+        (@modes[channel] ||= []) << flag
+
+        self
+    end
+
+    #
+    # Take away a status mode on a channel.
+    # ---
+    # flag:: +Symbol+ representing a mode flag
+    # channel:: either a +StatefulChannel+ or the name of one
+    # returns:: +self+
+    #
+    def delete_status_mode(flag, channel)
+        if channel.class == StatefulChannel then channel = channel.name end
+        return unless @modes[channel]
+
+        @modes[channel].delete(flag)
+
+        self
+    end
+end
+
+end # module IRC
+

data/rakefile

@@ -10,7 +10,10 @@
     require 'rake/' + m
 end
 
-VER = '0.2.7'
+$: << Dir.getwd
+$: << 'lib'
+
+require 'lib/rhuidean'
 
 #
 # Default task - unit tests.
@@ -20,7 +23,6 @@ VER = '0.2.7'
 task :default => [:test]
 
 Rake::TestTask.new do |t|
-    t.libs << 'test'
     t.test_files = %w(test/ts_rhuidean.rb)
 end
 
@@ -46,7 +48,7 @@ PKG_FILES = FileList['README.markdown', 'rakefile',
 
 Rake::PackageTask.new('package') do |p|
     p.name          = 'rhuidean'
-    p.version       = VER
+    p.version       = Rhuidean::VERSION
     p.need_tar      = false
     p.need_zip      = false
     p.package_files = PKG_FILES
@@ -54,7 +56,7 @@ end
 
 spec = Gem::Specification.new do |s|
     s.name     = 'rhuidean'
-    s.version  = VER
+    s.version  = Rhuidean::VERSION
     s.author   = 'Eric Will'
     s.email    = 'rakaur@malkier.net'
     s.homepage = 'http://github.com/rakaur/rhuidean/'

data/test/tc_client.rb

@@ -51,24 +51,22 @@ class TestClient < Test::Unit::TestCase
         assert_match(/^rhuidean\d+$/,   c.nickname)
         assert_equal('rhuidean',        c.username)
 
-        welcome = false
-        str     = "rhuidean-#{IRC::Client::VERSION} [#{RUBY_PLATFORM}]"
+        worked  = false
+        str     = "rhuidean-#{Rhuidean::VERSION} [#{RUBY_PLATFORM}]"
 
         assert_nothing_raised do
-            c.on(IRC::Numeric::RPL_WELCOME) { welcome = true  }
-
             c.on(IRC::Numeric::RPL_ENDOFMOTD) do
                 c.join('#malkier')
                 c.privmsg('#malkier', str)
+                worked = true
             end
         end
 
-        assert_nothing_raised { c.connect }
+        c.thread = Thread.new { c.io_loop }
 
-        t = Thread.new { c.io_loop }
+        sleep(1) until worked
 
-        sleep(1) until welcome
-        assert(true, welcome)
+        assert(worked)
     end
 end
 

data/test/ts_rhuidean.rb

@@ -5,11 +5,9 @@
 # Copyright (c) 2003-2010 Eric Will <rakaur@malkier.net>
 #
 
-$: << 'lib'
+$: << Dir.getwd
 
 require 'test/unit'
-
-require 'rhuidean'
-
+require 'lib/rhuidean'
 require 'test/tc_client.rb'
 

metadata

@@ -3,10 +3,10 @@ name: rhuidean
 version: !ruby/object:Gem::Version 
   prerelease: false
   segments: 
+  - 1
   - 0
-  - 2
-  - 7
-  version: 0.2.7
+  - 0
+  version: 1.0.0
 platform: ruby
 authors: 
 - Eric Will
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-25 00:00:00 -04:00
+date: 2010-11-10 00:00:00 -05:00
 default_executable: 
 dependencies: []
 
@@ -35,6 +35,9 @@ files:
 - lib/rhuidean/event.rb
 - lib/rhuidean/methods.rb
 - lib/rhuidean/numeric.rb
+- lib/rhuidean/stateful_channel.rb
+- lib/rhuidean/stateful_client.rb
+- lib/rhuidean/stateful_user.rb
 - test/tc_client.rb
 - test/ts_rhuidean.rb
 has_rdoc: true