mod_spox 0.0.1

data/lib/mod_spox/handlers/Handler.rb

@@ -0,0 +1,31 @@
+module ModSpox
+    module Handlers
+    
+        class Handler
+        
+            def process(data)
+                raise Exceptions::NotImplemented.new('Method has not been implemented')
+            end
+            
+            protected
+            
+            def find_model(string)
+                if(string =~ /^[A-Za-z\|\\\{\}\[\]\^`~_\-]+$/)
+                    Logger.log("Model: #{string} -> Nick")
+                    return Models::Nick.find_or_create(:nick => string)
+                elsif(string =~ /^[&#+!]/)
+                    Logger.log("Model: #{string} -> Channel")
+                    return Models::Channel.find_or_create(:name => string)
+                elsif(model = Models::Server.filter(:host => string, :connected => true).first)
+                    Logger.log("Model: #{string} -> Server")
+                    return model
+                else
+                    Logger.log("FAIL Model: #{string} -> No match")
+                    return string
+                end
+            end
+        
+        end
+        
+    end
+end

data/lib/mod_spox/handlers/Invite.rb

@@ -0,0 +1,19 @@
+module ModSpox
+    module Handlers
+        class Invite < Handler
+            def initialize(handlers)
+                handlers[:INVITE] = self
+            end
+            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(string, source, target, channel)
+                else
+                    Logger.log('Failed to parse INVITE message')
+                end
+            end
+        end
+    end
+end

data/lib/mod_spox/handlers/Join.rb

@@ -0,0 +1,30 @@
+module ModSpox
+    module Handlers
+        class Join < Handler
+            def initialize(handlers)
+                handlers[:JOIN] = self
+            end
+            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
+                        channel = find_model(chan)
+                        channel.nick_add(nick)
+                        return Messages::Incoming::Join.new(string, channel, nick)
+                    else
+                        Logger.log('Failed to parse source on JOIN message')
+                    end
+                else
+                    Logger.log('Failed to parse JOIN message')
+                end
+            end
+        end
+    end
+end

data/lib/mod_spox/handlers/Kick.rb

@@ -0,0 +1,24 @@
+module ModSpox
+    module Handlers
+        class Kick < Handler
+            def initialize(handlers)
+                handlers[:KICK] = self
+            end
+            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(string, channel, kicker, kickee, reason)
+                else
+                    Logger.log('Failed to process KICK message')
+                end
+            end
+        end
+    end
+end

data/lib/mod_spox/handlers/LuserChannels.rb

@@ -0,0 +1,16 @@
+module ModSpox
+    module Handlers
+        class LuserChannels < Handler
+            def initialize(handlers)
+                handlers[RPL_LUSERCHANNELS] = self
+            end
+            def process(string)
+                if(string =~ /(\d+)\s:channels/)
+                    return Messages::Incoming::LuserChannels.new(string, $1.to_i)
+                else
+                    Logger.log('Failed to match RPL_LUSERCHANNELS message')
+                end
+            end
+        end
+    end
+end

data/lib/mod_spox/handlers/LuserClient.rb

@@ -0,0 +1,16 @@
+module ModSpox
+    module Handlers
+        class LuserClient < Handler
+            def initialize(handlers)
+                handlers[RPL_LUSERCLIENT] = self
+            end
+            def process(string)
+                users = string =~ /(\d+) users/ ? $1 : 0
+                invis = string =~ /(\d+) invisible/ ? $1 : 0
+                servs = string =~ /(\d+) servers/ ? $1 : 0
+                services = string =~ /(\d+) services/ ? $1 : 0
+                return Messages::Incoming::LuserClient.new(string, users, invis, servs, services)
+            end
+        end
+    end
+end

data/lib/mod_spox/handlers/LuserMe.rb

@@ -0,0 +1,14 @@
+module ModSpox
+    module Handlers
+        class LuserMe < Handler
+            def initialize(handlers)
+                handlers[RPL_LUSERME] = self
+            end
+            def process(string)
+                clients = string =~ /(\d+) clients/ ? $1.to_i : 0
+                servers = string =~ /(\d+) server/ ? $1.to_i : 0
+                return Messages::Incoming::LuserMe.new(string, clients, servers)
+            end
+        end
+    end
+end

data/lib/mod_spox/handlers/LuserOp.rb

@@ -0,0 +1,16 @@
+module ModSpox
+    module Handlers
+        class LuserOp < Handler
+            def initialize(handlers)
+                handlers[RPL_LUSEROP] = self
+            end
+            def process(string)
+                if(string =~ /(\d+) :.*?\s*[oO]perators/)
+                    return Messages::Incoming::LuserOp(string, $1.to_i)
+                else
+                    Logger.log('Failed to match RPL_LUSEROP message')
+                end
+            end
+        end
+    end
+end

data/lib/mod_spox/handlers/LuserUnknown.rb

@@ -0,0 +1,16 @@
+module ModSpox
+    module Handlers
+        class LuserUnknown < Handler
+            def initialize(handlers)
+                handlers[RPL_LUSERUNKNOWN] = self
+            end
+            def process(string)
+                if(string =~ /(\d+) :.*[Uu]nknown/)
+                    return Messages::Incoming::LuserUnknown(string, $1.to_i)
+                else
+                    Logger.log('Failed to match RPL_LUSERUNKNOWN message')
+                end
+            end
+        end
+    end
+end

data/lib/mod_spox/handlers/Mode.rb

@@ -0,0 +1,47 @@
+module ModSpox
+    module Handlers
+        class Mode < Handler
+            def initialize(handlers)
+                handlers[:MODE] = self
+            end
+            
+            def process(string)
+                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!
+                        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
+                    # implement later #
+                elsif(string =~ /^:([^!]+)!.+MODE\s(\S+)\s(\S+)\s(.+)$/)
+                    source = find_model($1)
+                    channel = find_model($2)
+                    full_modes = $3
+                    targets = $4
+                    action = full_mode[0].chr
+                    nicks = Array.new
+                    full_mode.slice(0).length.times{|i|
+                        nick = find_model(targets.scan(/\S+/)[i])
+                        nicks << nick
+                        mode = full_mode[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(string, full_mode, source, nicks, channel)
+                else
+                    Logger.log('Failed to parse MODE message')
+                end
+            end
+        end
+    end
+end

data/lib/mod_spox/handlers/Motd.rb

@@ -0,0 +1,30 @@
+module ModSpox
+    module Handlers
+        class Motd < Handler
+            def initialize(handlers)
+                handlers[RPL_MOTDSTART] = self
+                handlers[RPL_MOTD] = self
+                handlers[RPL_ENDOFMOTD] = self
+                @motds = Hash.new
+                @raw = Hash.new
+            end
+            def process(string)
+                if(string =~ /^:(\S+) #{RPL_MOTDSTART.to_s}.*?:-\s?(\S+)/)
+                    @motds[$1] = Array.new
+                    @raw[$1] = [string]
+                    return
+                elsif(string =~ /^:(\S+) #{RPL_MOTD.to_s}.*?:-\s?(.+)$/)
+                    @motds[$1] << $2
+                    @raw[$1] << string
+                    return
+                elsif(string =~ /^:(\S+) #{RPL_ENDOFMOTD.to_s}/)
+                    @raw[$1] << string
+                    message = Messages::Incoming::Motd.new(@raw[$1].join("\n"), @motds[$1].join("\n"), $1)
+                    @motds.delete($1)
+                    @raw.delete($1)
+                    return message
+                end
+            end
+        end
+    end
+end

data/lib/mod_spox/handlers/MyInfo.rb

@@ -0,0 +1,21 @@
+module ModSpox
+    module Handlers
+        class MyInfo < Handler
+            def initialize(handlers)
+                handlers[RPL_MYINFO] = self
+            end
+
+            def process(string)
+                if(string =~ /^:\S+ \S+ \S+ (\S+) (\S+) (\S+) (\S+)/)
+                    servername = $1
+                    version = $2
+                    usermodes = $3
+                    channelmodes = $4
+                    return Messages::Incoming::MyInfo.new(string, servername, version, usermodes, channelmodes)
+                else
+                    Logger.log('Failed to match My Info message')
+                end
+            end
+        end
+    end
+end

data/lib/mod_spox/handlers/Names.rb

@@ -0,0 +1,54 @@
+module ModSpox
+    module Handlers
+        class Names < Handler
+            def initialize(handlers)
+                handlers[RPL_NAMREPLY] = self
+                handlers[RPL_ENDOFNAMES] = self
+                @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]
+                    if(@raw[chan])
+                        @raw[chan] << string
+                    else
+                        @raw[chan] = [string]
+                    end
+                    @names[chan] += nicks.split(' ')
+                    return nil
+                elsif(string =~ /#{RPL_ENDOFNAMES}.*?(\S+) :/)
+                    chan = $1
+                    @raw[chan] << string
+                    channel = find_model(chan)
+                    nicks = Array.new
+                    ops = Array.new
+                    voice = Array.new
+                    raw = @raw[chan].join(' ')
+                    @names[chan].each{|n|
+                        nick = Models::Nick.find_or_create(:nick => 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
+                            }
+                        end
+                        channel.nick_add(nick)
+                    }
+                    @names.delete(chan)
+                    @raw.delete(chan)
+                    return Messages::Incoming::Names.new(raw, channel, nicks, ops, voice)
+                end
+            end
+        end
+    end
+end

data/lib/mod_spox/handlers/Nick.rb

@@ -0,0 +1,24 @@
+module ModSpox
+    module Handlers
+        class Nick < Handler
+            def initialize(handlers)
+                handlers[:NICK] = self
+            end
+            def process(string)
+                if(string =~ /^:([^!]+)!\S+\sNICK\s:(.+)$/)
+                    old_nick = find_model($1)
+                    new_nick = find_model($2)
+                    if(old_nick.botnick == true)
+                        old_nick.botnick = false
+                        old_nick.save
+                        new_nick.botnick = true
+                        new_nick.save
+                    end
+                    return Messages::Incoming::Nick.new(string, old_nick, new_nick)
+                else
+                    Logger.log('Failed to parse NICK message')
+                end
+            end
+        end
+    end
+end

data/lib/mod_spox/handlers/NickInUse.rb

@@ -0,0 +1,16 @@
+module ModSpox
+    module Handlers
+        class NickInUse < Handler
+            def initialize(handlers)
+                handlers[:RPL_NICKNAMEINUSE] = self
+            end
+            def process(string)
+                if(string =~ /#{RPL_NICKNAMEINUSE}\s\S+\s(\S+)\s:/)
+                    return Messages::Incoming::NickInUse.new(string, $1)
+                else
+                    Logger.log('Failed to parse RPL_NICKNAMEINUSE message')
+                end
+            end
+        end
+    end
+end

data/lib/mod_spox/handlers/Notice.rb

@@ -0,0 +1,32 @@
+module ModSpox
+    module Handlers
+        class Notice < Handler
+            def initialize(handlers)
+                handlers[:NOTICE] = self
+            end
+            
+            def process(string)
+                if(string =~ /:(\S+)\sNOTICE\s(\S+)\s:(.+)$/)
+                    base_source = $1
+                    target = $2
+                    message = $3
+                    if(base_source =~ /\!/)
+                        source = find_model(base_source.gsub(/!.+$/, ''))
+                        if(base_source =~ /!(.+)@(.+)$/)
+                            source.username = $1
+                            source.address = $2
+                            source.source = base_source
+                            source.save
+                        end
+                        target = find_model(target)
+                    else
+                        source = base_source
+                    end
+                    return Messages::Incoming::Notice.new(string, source, target, message)
+                else
+                    Logger.log('Failed to match NOTICE message')
+                end
+            end
+        end
+    end
+end

data/lib/mod_spox/handlers/Part.rb

@@ -0,0 +1,19 @@
+module ModSpox
+    module Handlers
+        class Part < Handler
+            def initialize(handlers)
+                handlers[:PART] = self
+            end
+            def process(string)
+                if(string =~ /^:(\S+) PART (\S+) :(.*)$/)
+                    channel = find_model($2)
+                    nick = find_model($1.gsub(/!.+$/, ''))
+                    channel.nick_remove(nick)
+                    return Messages::Incoming::Part.new(string, channel, nick, $3)
+                else
+                    Logger.log('Failed to parse PART message')
+                end
+            end
+        end
+    end
+end

data/lib/mod_spox/handlers/Ping.rb

@@ -0,0 +1,16 @@
+module ModSpox
+    module Handlers
+        class Ping < Handler
+            def initialize(handlers)
+                handlers[:PING] = self
+            end
+            def process(string)
+                if(string =~ /^PING\s:(.+)$/)
+                    return Messages::Incoming::Ping.new(string, $1, nil)
+                else
+                    Logger.log('Failed to match PING message')
+                end
+            end
+        end
+    end
+end

data/lib/mod_spox/handlers/Pong.rb

@@ -0,0 +1,16 @@
+module ModSpox
+    module Handlers
+        class Pong < Handler
+            def initialize(handlers)
+                handlers[:PONG] = self
+            end
+            def process(string)
+                if(string =~ /^:\S+\sPONG\s(\S+)\s:(.+)$/)
+                    return Messages::Incoming::Pong.new(string, $1, $2)
+                else
+                    Logger.log('Failed to parse PONG message')
+                end
+            end
+        end
+    end
+end

data/lib/mod_spox/handlers/Privmsg.rb

@@ -0,0 +1,27 @@
+module ModSpox
+    module Handlers
+        class Privmsg < Handler
+            def initialize(handlers)
+                handlers[:PRIVMSG] = self
+            end
+            
+            def process(string)
+                if(string =~ /^:(\S+)\sPRIVMSG\s(\S+)\s:(.+)$/)
+                    message = $3
+                    target = find_model($2)
+                    base_source = $1
+                    source = find_model(base_source.gsub(/!.+$/, ''))
+                    if(base_source =~ /!(.+)@(.+)$/)
+                        source.username = $1
+                        source.address = $2
+                        source.source = base_source
+                        source.save
+                    end
+                    return Messages::Incoming::Privmsg.new(string, source, target, message)
+                else
+                    Logger.log('Failed to match PRIVMSG message')
+                end
+            end
+        end
+    end
+end

data/lib/mod_spox/handlers/Quit.rb

@@ -0,0 +1,21 @@
+module ModSpox
+    module Handlers
+        class Quit < Handler
+            def initialize(handlers)
+                handlers[:QUIT] = self
+            end
+            def process(string)
+                if(string =~ /^:(\S+)\sQUIT\s:(.+)$/)
+                    reason = $2
+                    nick = find_model($1.gsub(/!.+$/, ''))
+                    nick.clear_channels
+                    nick.visible = false
+                    nick.save
+                    return Messages::Incoming::Quit.new(string, nick, reason)
+                else
+                    Logger.log('Failed to parse KICK message')
+                end
+            end
+        end
+    end
+end

data/lib/mod_spox/handlers/Topic.rb

@@ -0,0 +1,29 @@
+module ModSpox
+    module Handlers
+        class Topic < Handler
+            def initialize(handlers)
+                handlers[RPL_TOPIC] = self
+                handlers[RPL_NOTOPIC] = self
+                handlers[RPL_TOPICINFO] = self
+                @topics = Hash.new
+            end
+            def process(string)
+                if(string =~ /#{RPL_TOPIC}.+?(\S+)\s:(.+)$/)
+                    channel = find_model($1)
+                    return Messages::Incoming::Topic.new(string, channel, $2)
+                elsif(string =~ /#{RPL_NOTOPIC}.+?(\S+)\s:/)
+                    channel = find_model($1)
+                    return Messages::Incoming::Topic.new(string, channel, nil)
+                elsif(string =~ /#{RPL_TOPICINFO}\s\S+\s(\S+)\s(\S+)\s(.+)$/)
+                    channel = find_model($1)
+                    nick = find_model($1)
+                    time = Time.at($3.to_i)
+                    return Messages::Incoming::TopicInfo.new(string, channel, nick, time)
+                else
+                    Logger.log('Failed to parse TOPIC type string')
+                end                    
+            end
+        end
+    end
+end
+        

data/lib/mod_spox/handlers/Welcome.rb

@@ -0,0 +1,34 @@
+module ModSpox
+    module Handlers
+        class Welcome < Handler
+            def initialize(handlers)
+                handlers[RPL_WELCOME] = self
+            end
+            
+            def process(string)
+                if(string =~ /:(\S+)\s(\S+).+?(\S+)$/)
+                    server = $1
+                    message = $2
+                    userstring = $3
+                    if(userstring =~ /^(.+?)!(.+?)@(.+?)$/)
+                        Models::Nick.filter(:botnick => true).each{|n| n.botnick = false; n.save}
+                        nick = $1
+                        username = $2
+                        hostname = $3
+                        nick = Models::Nick.find_or_create(:nick => nick)
+                        nick.botnick = true
+                        nick.username = username
+                        nick.address = hostname
+                        nick.source = userstring
+                        nick.save
+                        return Messages::Incoming::Welcome.new(string, server, message, nick, username, hostname)
+                    else
+                        Logger.log('Failed to match user string in welcome message')
+                    end
+                else
+                    Logger.log('Failed to match welcome message')
+                end
+            end
+        end
+    end
+end

data/lib/mod_spox/handlers/Who.rb

@@ -0,0 +1,60 @@
+module ModSpox
+    module Handlers
+        class Who < Handler
+            def initialize(handlers)
+                handlers[RPL_WHOREPLY] = self
+                handlers[RPL_ENDOFWHO] = self
+                @cache = Hash.new
+                @raw_cache = Hash.new
+            end
+            def process(string)
+                if(string =~ /#{RPL_WHOREPLY}\s\S+\s(\S+|\*|\*\s\S+)\s(\S+)\s(\S+)\s(\S+)\s(\S+)\s(\S+)\s:(\d)\s(.+)$/)
+                    # Items matched are as follows:
+                    # 1: location
+                    # 2: username
+                    # 3: host
+                    # 4: server
+                    # 5: nick
+                    # 6: info
+                    # 7: hops
+                    # 8: realname
+                    location = $1 unless location.include?('*')
+                    location = $5 if location == '*'
+                    location = $1.gsub(/\*\s/, '') if location.include?('* ')
+                    info = $6
+                    nick = find_model($5)
+                    nick.username = $2
+                    nick.address = $3
+                    nick.real_name = $8
+                    nick.connected_to = $4
+                    nick.away = info =~ /G/ ? true : false
+                    nick.save
+                    @cache[location] = Array.new unless @cache[location]
+                    @cache[location] << nick
+                    @raw_cache[location] = Array.new unless @raw_cache[location]
+                    @raw_cache[location] << string
+                    if(location[0].chr !~ /[A-Za-z]/)
+                        channel = find_model(location)
+                        if(info.include?('+'))
+                            Models::NickMode.find_or_create(:channel_id => channel.pk, :nick_id => nick.pk, :mode => 'v')
+                        elsif(info.include?('@'))
+                            Models::NickMode.find_or_create(:channel_id => channel.pk, :nick_id => nick.pk, :mode => 'o')
+                        else
+                            Models::NickMode.filter(:channel_id => channel.pk, :nick_id => nick.pk).each{|m| m.destroy}
+                        end
+                    end
+                elsif(string =~ /#{RPL_ENDWHO}\s\S+\s(\S+)\s/)
+                    location = $1
+                    loc = find_model(location)
+                    @raw_cache[location] << string
+                    message = Messages::Incoming::Who.new(@raw_cache.join("\n"), loc, @cache[location])
+                    @raw_cache.delete(location)
+                    @cache.delete(location)
+                    return message
+                else
+                    Logger.log('Failed to match RPL_WHO type message')
+                end
+            end
+        end
+    end
+end