mod_spox 0.2.0 → 0.3.0

data/lib/mod_spox/handlers/Created.rb

@@ -1,16 +1,24 @@
 require 'mod_spox/handlers/Handler'
+require 'time'
 module ModSpox
     module Handlers
         class Created < Handler
             def initialize(handlers)
                 handlers[RPL_CREATED] = self
             end
+            # :not.configured 003 spox :This server was created Tue Mar 24 2009 at 15:42:36 PDT'
             def process(string)
-                if(string =~ /#{RPL_CREATED.to_s}.+?:created\s(.+)$/)
-                    return Messages::Incoming::Created.new(string, $1)
-                else
-                    Logger.warn('Failed to parse RPL_CREATED message')
-                    return nil
+                string = string.dup
+                begin
+                    orig = string.dup
+                    2.times{string.slice!(0..string.index(':'))}
+                    4.times{string.slice!(0..string.index(' '))}
+                    time = Time.parse(string)
+                    time = nil if Time.now == time
+                    return time.nil? ? nil : Messages::Incoming::Created.new(orig, time)
+                rescue Object => boom
+                    Logger.error("Failed to parse RPL_CREATED message: #{orig}")
+                    raise boom
                 end
             end
         end

data/lib/mod_spox/handlers/Handler.rb

@@ -1,12 +1,19 @@
 require 'mod_spox/rfc2812'
+require 'mod_spox/Helpers'
 module ModSpox
     module Handlers
     
         class Handler
-        
+
+            # handlers:: array of handlers
+            # initialize handler and add self to available
+            # handlers
             def initialize(handlers)
+                raise Exceptions::NotImplemented.new('Method has not been implemented')
             end
-        
+
+            # data:: string of data
+            # Process the string and create the proper object
             def process(data)
                 raise Exceptions::NotImplemented.new('Method has not been implemented')
             end
@@ -18,7 +25,9 @@ module ModSpox
             end
             
             protected
-            
+
+            # deprecated. here basically so old handlers
+            # don't break
             def find_model(string)
                 Helpers.find_model(string)
             end

data/lib/mod_spox/handlers/Invite.rb

@@ -5,15 +5,21 @@ module ModSpox
             def initialize(handlers)
                 handlers[:INVITE] = self
             end
+            # :spax!~spox@host INVITE spox :#m
             def process(string)
-                if(string =~ /^(.+?)!.*?INVITE\s(\S+)\s(.+)$/)
-                    source = find_model($1)
-                    target = find_model($2)
-                    channel = find_model($3)
-                    return Messages::Incoming::Invite.new(string, source, target, channel)
-                else
-                    Logger.warn('Failed to parse INVITE message')
-                    return nil
+                orig = string.dup
+                string = string.dup
+                begin
+                    string.slice!(0)
+                    source = find_model(string.slice!(0..string.index('!')-1))
+                    2.times{ string.slice!(0..string.index(' ')) }
+                    target = find_model(string.slice!(0..string.index(' ')-1))
+                    string.slice!(0..string.index(':'))
+                    channel = find_model(string.strip)
+                    return Messages::Incoming::Invite.new(orig, source, target, channel)
+                rescue Object => boom
+                    Logger.error("Failed to parse INVITE message: #{orig}")
+                    raise boom
                 end
             end
         end

data/lib/mod_spox/handlers/Join.rb

@@ -5,27 +5,31 @@ module ModSpox
             def initialize(handlers)
                 handlers[:JOIN] = self
             end
+
+            # :mod_spox!~mod_spox@host JOIN :#m
+            
             def process(string)
-                if(string =~ /^:(\S+)\sJOIN :(\S+)$/)
-                    source = $1
-                    chan = $2
-                    if(source =~ /^(.+?)!(.+?)@(.+)$/)
-                        nick = find_model($1)
-                        nick.username == $2
-                        nick.address = $3
-                        nick.source = source
-                        nick.visible = true
-                        nick.save_changes
-                        channel = find_model(chan)
-                        channel.nick_add(nick)
-                        return Messages::Incoming::Join.new(string, channel, nick)
-                    else
-                        Logger.warn('Failed to parse source on JOIN message')
-                        return nil
-                    end
-                else
-                    Logger.warn('Failed to parse JOIN message')
-                    return nil
+                orig = string.dup
+                string = string.dup
+                begin
+                    string.slice!(0)
+                    source = string.slice!(0..string.index(' ')-1)
+                    string.slice!(0..string.index(':'))
+                    channel = find_model(string.strip)
+                    nick = find_model(source.slice(0..source.index('!')-1))
+                    nick.source = source.dup
+                    source.slice!(0..source.index('!'))
+                    nick.username = source.slice!(0..source.index('@')-1)
+                    source.slice!(0)
+                    nick.address = source.slice!(0..source.size)
+                    nick.visible = true
+                    nick.save_changes
+                    channel.add_nick(nick)
+                    channel.save
+                    return Messages::Incoming::Join.new(orig, channel, nick)
+                rescue Object => boom
+                    Logger.warn("Failed to parse JOIN message: #{orig}")
+                    raise boom
                 end
             end
         end

data/lib/mod_spox/handlers/Kick.rb

@@ -5,20 +5,29 @@ module ModSpox
             def initialize(handlers)
                 handlers[:KICK] = self
             end
+            # :spax!~spox@host KICK #m spox :foo
             def process(string)
-                if(string =~ /^:(\S+)\sKICK\s(\S+)\s(\S+)\s:(.+)$/)
-                    source = $1
-                    chan = $2
-                    kicked = $3
-                    reason = $4
-                    kicker = find_model(source.gsub(/!.+$/, ''))
-                    channel = find_model(chan)
-                    kickee = find_model(kicked)
-                    channel.nick_remove(kickee)
-                    return Messages::Incoming::Kick.new(string, channel, kicker, kickee, reason)
-                else
-                    Logger.warn('Failed to process KICK message')
-                    return nil
+                orig = string.dup
+                string = string.dup
+                begin
+                    string.slice!(0)
+                    source = string.slice!(0..string.index(' ')-1)
+                    2.times{string.slice!(0..string.index(' '))}
+                    channel = string.slice!(0..string.index(' ')-1)
+                    string.slice!(0)
+                    kickee = string.slice!(0..string.index(' ')-1)
+                    string.slice!(0..string.index(':'))
+                    kicker = find_model(source[0..source.index('!')-1])
+                    channel = find_model(channel)
+                    kickee = find_model(kickee)
+                    channel.remove_nick(kickee)
+                    kickee.visible = false if kickee.channels.empty?
+                    kickee.save_changes
+                    channel.save_changes
+                    return Messages::Incoming::Kick.new(orig, channel, kicker, kickee, string)
+                rescue Object => boom
+                    Logger.warn("Failed to parse KICK message: #{orig}")
+                    raise boom
                 end
             end
         end

data/lib/mod_spox/handlers/Mode.rb

@@ -5,50 +5,56 @@ module ModSpox
             def initialize(handlers)
                 handlers[:MODE] = self
             end
-            
+
+            # :spax!~spox@host MODE #m +o spax 
+            # :spax MODE spax :+iw
             def process(string)
+                orig = string.dup
+                string = string.dup
                 begin
-                    if(string =~ /^:([^!]+)!.+?MODE\s(\S+)\s(\S+)$/) # this is for modes applied to the channel
-                        source = find_model($1)
-                        channel = find_model($2)
-                        full_mode = $3
-                        action = full_mode[0].chr
-                        full_mode.slice(0).each_char{|c|
-                            Models::ChannelMode.find_or_create(:channel_id => channel.pk, :mode => c) if action == '+'
-                            if(action == '-' && model = Models::ChannelMode.filter(:channel_id => channel.pk, :mode => c).first)
-                                model.destroy
+                    string.slice!(0)
+                    if(string.index('!').nil?) # looks like self mode
+                        source = find_model(string.slice!(0..string.index(' ')-1))
+                        2.times{string.slice!(0..string.index(' '))}
+                        target = find_model(string.slice!(0..string.index(' ')-1))
+                        string.slice!(0..string.index(':'))
+                        action = string.slice!(0)
+                        action == '+' ? target.set_mode(string) : target.unset_mode(string)
+                        return Messages::Incoming::Mode.new(orig, "#{action}#{string}", source, target, nil)
+                    else
+                        source = find_model(string.slice!(0..string.index('!')-1))
+                        2.times{string.slice!(0..string.index(' '))}
+                        channel = find_model(string.slice!(0..string.index(' ')-1))
+                        string.slice!(0)
+                        modes = string.index(' ').nil? ? string.dup : string.slice!(0..string.index(' ')-1)
+                        string[0] == ' ' ? string.slice!(0) : string = ''
+                        action = modes.slice!(0)
+                        if(string.size > 0) #nick modes
+                            nicks = []
+                            string.split.each do |n|
+                                ni = find_model(n)
+                                ni.add_channel(channel)
+                                nicks << ni
+                            end
+                            i = 0
+                            modes.each_char do |m|
+                                nm = Models::NickMode.find_or_create(:channel_id => channel.pk, :nick_id => nicks[i].pk)
+                                action == '+' ? nm.set_mode(m) : nm.unset_mode(m)
+                                i += 1
                             end
-                        }
-                        return Messages::Incoming::Mode.new(string, full_mode, source, nil, channel)
-                    #elsif(string =~ /^:([^!]+)!.+MODE\s(\S+)\s(.+)$/) # this is for modes applied to nick
-                     #   raise Exceptions::BotException.new("Matched unimplemented mode string")
-                    elsif(string =~ /^:([^!]+)!.+MODE\s(\S+)\s(\S+)\s(.+)$/)
-                        source = find_model($1)
-                        channel = find_model($2)
-                        full_modes = $3
-                        targets = $4
-                        action = full_modes[0].chr
-                        nicks = Array.new
-                        full_modes.sub(/^./, '').length.times do |i|
-                            nick = find_model(targets.scan(/\S+/)[i])
-                            nicks << nick
-                            if(nick.is_a?(Models::Nick))
-                                mode = full_modes[i + 1].chr
-                                Models::NickMode.find_or_create(:channel_id => channel.pk, :nick_id => nick.pk, :mode => mode) if action == '+'
-                                if(action == '-' && model = Models::NickMode.filter(:channel_id => channel.pk, :nick_id => nick.pk, :mode => mode).first)
-                                    model.destroy
-                                end
+                            nicks = nicks[0] if nicks.size == 1
+                            return Messages::Incoming::Mode.new(orig, "#{action}#{modes}", source, nicks, channel)
+                        else #channel modes
+                            modes.each_char do |m|
+                                action == '+' ? channel.set_mode(m) : channel.unset_mode(c)
                             end
+                            return Messages::Incoming::Mode.new(orig, "#{action}#{modes}", source, nil, channel)
                         end
-                        nicks = nicks[0] if nicks.size == 1
-                        return Messages::Incoming::Mode.new(string, full_modes, source, nicks, channel)
-                    else
-                        Logger.warn('Failed to parse MODE message')
                     end
                 rescue Object => boom
-                    Logger.warn("Failed to process MODE message. Reason: #{boom}")
+                    Logger.warn("Failed to parse MODE message: #{orig}")
+                    raise boom
                 end
-                return nil
             end
         end
     end

data/lib/mod_spox/handlers/Motd.rb

@@ -15,10 +15,14 @@ module ModSpox
                     @raw[$1] = [string]
                     return nil
                 elsif(string =~ /^:(\S+) #{RPL_MOTD.to_s}.*?:-\s?(.+)$/)
+                    @motds[$1] ||= []
+                    @raw[$1] ||= []
                     @motds[$1] << $2
                     @raw[$1] << string
                     return nil
                 elsif(string =~ /^:(\S+) #{RPL_ENDOFMOTD.to_s}/)
+                    @raw[$1] ||= []
+                    @motds[$1] ||= []
                     @raw[$1] << string
                     message = Messages::Incoming::Motd.new(@raw[$1].join("\n"), @motds[$1].join("\n"), $1)
                     @motds.delete($1)

data/lib/mod_spox/handlers/Names.rb

@@ -8,49 +8,76 @@ module ModSpox
                 @names = Hash.new
                 @raw = Hash.new
             end
-            
+     
             def process(string)
-                if(string =~ /#{RPL_NAMREPLY}.*?(\S+) :(.+)$/)
-                    chan = $1
-                    nicks = $2
-                    @names[chan] = Array.new unless @names[chan]
-                    @raw[chan] = Array.new unless @raw[chan]
-                    if(@raw[chan])
-                        @raw[chan] << string
+                orig = string.dup
+                string = string.dup
+                begin
+                    string.slice!(0..string.index(' '))
+                    type = string.slice!(0..string.index(' ')-1)
+                    if(type == RPL_NAMREPLY)
+                        3.times{ string.slice!(0..string.index(' ')) }
+                        chan = string.slice!(0..string.index(' ')-1)
+                        string.slice!(0..string.index(':'))
+                        @names[chan] = Array.new unless @names[chan]
+                        @raw[chan] = Array.new unless @raw[chan]
+                        @raw[chan] << orig
+                        @names[chan] += string.split
+                        return nil
                     else
-                        @raw[chan] = [string]
+                        2.times{ string.slice!(0..string.index(' ')) }
+                        chan = string.slice!(0..string.index(' ')-1)
+                        channel = find_model(chan)
+                        @raw[chan] << orig if @raw[chan]
+                        nicks = Array.new
+                        ops = Array.new
+                        voice = Array.new
+                        raw = @raw[chan].dup if @raw[chan]
+                        @names[chan] = [] unless @names[chan].is_a?(Array)
+                        @names[chan].each do |n|
+                            nick = Models::Nick.find_or_create(:nick => n.gsub(/^[@+]/, ''))
+                            nick.visible = true
+                            nicks << nick
+                            if(n[0] == '@')
+                                ops << nick
+                                m = Models::NickMode.find_or_create(:nick_id => nick.pk, :channel_id => channel.pk)
+                                m.set_mode('o')
+                            elsif(n[0] == '+')
+                                voice << nick
+                                m = Models::NickMode.find_or_create(:nick_id => nick.pk, :channel_id => channel.pk)
+                                m.set_mode('v')
+                            else
+                                m = Models::NickMode.find_or_create(:nick_id => nick.pk, :channel_id => channel.pk)
+                                m.clear_modes
+                            end
+                            nick.add_channel(channel)
+                            nick.refresh
+                            channel.refresh
+                        end
+                        check_visibility(nicks, channel)
+                        @names.delete(chan)
+                        @raw.delete(chan)
+                        return Messages::Incoming::Names.new(raw, channel, nicks, ops, voice)
                     end
-                    @names[chan] += nicks.split(' ')
-                    return nil
-                elsif(string =~ /#{RPL_ENDOFNAMES}.*?(\S+) :/)
-                    chan = $1
-                    @raw[chan] << string if @raw.has_key?(chan)
-                    channel = find_model(chan)
-                    nicks = Array.new
-                    ops = Array.new
-                    voice = Array.new
-                    raw = @raw[chan]
-                    @names[chan].each{|n|
-                        nick = Models::Nick.locate(n.gsub(/^[@+]/, ''))
-                        nicks << nick
-                        if(n[0].chr == '@')
-                            ops << nick
-                            Models::NickMode.find_or_create(:nick_id => nick.pk, :channel_id => channel.pk, :mode => 'o')
-                        elsif(n[0].chr == '+')
-                            voice << nick
-                            Models::NickMode.find_or_create(:nick_id => nick.pk, :channel_id => channel.pk, :mode => 'v')
-                        else
-                            Models::NickMode.filter(:nick_id => nick.pk, :channel_id => channel.pk).each{|m|
-                                m.destroy
-                            }
+                rescue Object => boom
+                    Logger.error("Failed to parse NAMES message: #{orig}")
+                    raise boom
+                end
+            end
+
+            # nicks:: list of nicks in channel
+            # channel:: channel nicks are in
+            # Remove visibility from any nicks that aren't really
+            # in the channel
+            def check_visibility(nicks, channel)
+                channel.nicks.each do |nick|
+                    unless(nicks.include?(nick))
+                        channel.remove_nick(nick)
+                        unless(nick.botnick)
+                            nick.refresh
+                            nick.update(:visible => false) if (Models::Nick.filter(:botnick => true).first.channels & nick.channels).empty?
                         end
-                        channel.nick_add(nick)
-                    }
-                    @names.delete(chan)
-                    @raw.delete(chan)
-                    return Messages::Incoming::Names.new(raw, channel, nicks, ops, voice)
-                else
-                    return nil
+                    end
                 end
             end
         end

data/lib/mod_spox/handlers/Nick.rb

@@ -5,16 +5,23 @@ module ModSpox
             def initialize(handlers)
                 handlers[:NICK] = self
             end
+            # :spox!~spox@some.random.host NICK :flock_of_deer
             def process(string)
-                if(string =~ /^:([^!]+)!\S+\sNICK\s:(.+)$/)
-                    old_nick = find_model($1)
-                    new_nick = find_model($2)
-                    new_nick.visible = true
+                orig = string.dup
+                string = string.dup
+                begin
+                    string.slice!(0)
+                    old_nick = find_model(string.slice!(0..string.index('!')-1))
+                    string.slice!(0..string.index(':'))
+                    new_nick = find_model(string)
                     old_nick.channels.each do |channel|
-                        new_nick.channel_add(channel)
-                        Models::NickMode.find_or_create(:nick_id => new_nick.pk, :channel_id => channel.pk, :mode => 'o') if old_nick.is_op?(channel)
-                        Models::NickMode.find_or_create(:nick_id => new_nick.pk, :channel_id => channel.pk, :mode => 'v') if old_nick.is_voice?(channel)
-                        Models::NickMode.filter(:nick_id => old_nick.pk, :channel_id => channel.pk).destroy
+                        channel.remove_nick(old_nick)
+                        channel.add_nick(new_nick)
+                        m = Models::NickMode.filter(:nick_id => old_nick.pk, :channel_id => channel.pk).first
+                        if(m)
+                            m.nick_id = new_nick.pk
+                            m.save
+                        end
                     end
                     new_nick.username = old_nick.username
                     new_nick.address = old_nick.address
@@ -23,19 +30,18 @@ module ModSpox
                     new_nick.away = old_nick.away
                     new_nick.visible = true
                     new_nick.save_changes
-                    Models::Nick.transfer_groups(old_nick, new_nick)
                     old_nick.visible = false
-                    old_nick.clear_channels
+                    old_nick.remove_all_channels
                     if(old_nick.botnick == true)
                         old_nick.botnick = false
                         new_nick.botnick = true
                     end
                     new_nick.save
                     old_nick.save
-                    return Messages::Incoming::Nick.new(string, old_nick, new_nick)
-                else
-                    Logger.warn('Failed to parse NICK message')
-                    return nil
+                    return Messages::Incoming::Nick.new(orig, old_nick, new_nick)
+                rescue Object => boom
+                    Logger.error("Failed to parse NICK message: #{orig}")
+                    raise boom
                 end
             end
         end