mod_spox 0.0.4 → 0.0.5

data/data/mod_spox/plugins/Banner.rb

@@ -23,12 +23,25 @@ class Banner < ModSpox::Plugin
             :description => 'List all currently active bans generated from the bot')
         Signature.find_or_create(:signature => 'banlist remove (\d+)', :plugin => name, :method => 'ban_remove', :group_id => admin.pk,
             :description => 'Remove a current ban').params = [:id]
+        Signature.find_or_create(:signature => 'exempt mode ([ov]) ?(\S+)?', :plugin => name, :method => 'exempt_mode', :group_id => admin.pk,
+            :description => 'Exempt given modes from kick. Apply to all channels if one is not provided').params = [:mode, :channel]
+        Signature.find_or_create(:signature => 'exempt nick (\S+) ?(\S+)?', :plugin => name, :method => 'exempt_nick', :group_id => admin.pk,
+            :description => 'Exempt a nick from kicks globally or per channel').params = [:nick, :channel]
+        Signature.find_or_create(:signature => 'exempt source (\S+)', :plugin => name, :method => 'exempt_source', :group_id => admin.pk,
+            :description => 'Exempt a source from kicks globally or per channel').params = [:source, :channel]
+        Signature.find_or_create(:signature => 'exempt list (nick|mode|source)', :plugin => name, :method => 'exempt_list', :group_id => admin.pk,
+            :description => 'List current exemptions of given type').params = [:type]
+        Signature.find_or_create(:signature => 'exempt remove (nick|mode|source) (\d+)', :plugin => name, :method => 'exempt_remove', :group_id => admin.pk,
+            :description => 'Remove exemption from given type').params = [:type, :id]
         @pipeline.hook(self, :mode_check, :Incoming_Mode)
         @pipeline.hook(self, :join_check, :Incoming_Join)
         @pipeline.hook(self, :who_check, :Incoming_Who)
         @pipeline.hook(self, :get_action, :Internal_TimerResponse)
         BanRecord.create_table unless BanRecord.table_exists?
         BanMask.create_table unless BanMask.table_exists?
+        BanNickExempt.create_table unless BanNickExempt.table_exists?
+        BanModeExempt.create_table unless BanModeExempt.table_exists?
+        BanSourceExempt.create_table unless BanSourceExempt.table_exists?
         @actions = []
         @up_sync = Mutex.new
         @timer_sync = Mutex.new
@@ -60,7 +73,7 @@ class Banner < ModSpox::Plugin
     # params:: parameters
     # Ban nick in given channel for given time providing given message
     def full_ban(message, params)
-        nick = Models::Nick.filter(:nick => params[:nick]).first
+        nick = Helpers.find_model(params[:nick], false)
         channel = Channel.filter(:name => params[:channel]).first
         if(!me.is_op?(message.target))
             reply(message.replyto, "Error: I'm not a channel operator")
@@ -86,6 +99,8 @@ class Banner < ModSpox::Plugin
             raise NotOperator.new("I am not an operator in #{channel.name}")
         elsif(!nick.channels.include?(channel))
             raise NotInChannel.new("#{nick.nick} is not in channel: #{channel.name}")
+        elsif(check_exempt(nick, channel))
+            raise BanExemption.new("This nick is exempt from bans: #{nick.nick}")
         else
             mask = nick.source.nil? || nick.source.empty? ? "#{nick.nick}!*@*" : "*!*@#{nick.address}"
             BanRecord.new(:nick_id => nick.pk, :bantime => time.to_i, :remaining => time.to_i,
@@ -332,6 +347,144 @@ class Banner < ModSpox::Plugin
         end
     end
     
+    # message:: ModSpox::Messages::Incoming::Privmsg
+    # params:: parameters
+    # Add ban exemption for a given mode
+    def exempt_mode(message, params)
+        response = nil
+        if(params[:channel])
+            channel = Helpers.find_model(params[:channel])
+            if(channel.is_a?(Models::Channel))
+                BanModeExempt.find_or_create(:channel_id => channel.pk, :mode => params[:mode])
+                response = 'Mode exemption has been added'
+            else
+                response = "Failed to find given channel: #{params[:channel]}"
+            end
+        else
+            BanModeExempt.find_or_create(:channel_id => nil, :mode => params[:mode])
+            response = 'Mode exemption has been added'
+        end
+        reply message.replyto, response
+    end
+    
+    # message:: ModSpox::Messages::Incoming::Privmsg
+    # params:: parameters
+    # Add ban exemption for a given nick
+    def exempt_nick(message, params)
+        response = ''
+        nick = Helpers.find_model(params[:nick])
+        unless(nick.is_a?(Models::Nick))
+            reply message.replyto, "\2Error:\2 Failed to find record of: #{params[:nick]}"
+            return 
+        end
+        channel = params[:channel] ? Helpers.find_model(params[:channel]) : nil
+        if(channel)
+            if(channel.is_a?(Models::Channel))
+                BanNickExempt.find_or_create(:channel_id => channel.pk, :nick_id => nick.pk)
+                response = "Nick exemption for \2#{params[:nick]}\2 has been added to channel: \2#{params[:channel]}\2"
+            else
+                response = "Failed to find given channel: #{params[:channel]}"
+            end
+        else
+            BanNickExempt.find_or_create(:nick_id => nick.pk)
+            response = "Nick exemption for \2#{params[:nick]}\2 has been added for all channels"
+        end
+        reply message.replyto, response
+    end
+
+    # message:: ModSpox::Messages::Incoming::Privmsg
+    # params:: parameters
+    # Add ban exemption for sources matching a given mask
+    def exempt_source(message, params)
+        channel = params[:channel] ? Helpers.find_model(params[:channel]) : nil
+        response = ''
+        if(channel)
+            if(channel.is_a?(Models::Channel))
+                BanSourceExempt.find_or_create(:channel_id => channel.pk, :source => params[:source])
+                reponse = "Added exempt source: #{params[:source]} to channel: #{params[:channel]}"
+            else
+                response = "Failed to find given channel: #{params[:channel]}"
+            end
+        else
+            BanSourceExempt.find_or_create(:channel_id => nil, :source => params[:source])
+            response = "Added global exemption for source: #{params[:source]}"
+        end
+        reply message.replyto, response
+    end
+    
+    # message:: ModSpox::Messages::Incoming::Privmsg
+    # params:: parameters
+    # List given type of current ban exemptions    
+    def exempt_list(message, params)
+        output = []
+        if(params[:type] == 'nick')
+            output << 'Current nick exemptions:'
+            BanNickExempt.all.each do |record|
+                if(record.channel)
+                    output << "\2#{record.pk}:\2 \2#{record.nick.nick}\2 is exempt in \2#{record.channel.name}\2"
+                else
+                    output << "\2#{record.pk}:\2 \2#{record.nick.nick}\2 is exempt in \2all\2 channels"
+                end
+            end
+        elsif(params[:type] == 'mode')
+            output << 'Current mode exemptions:'
+            BanModeExempt.all.each do |record|
+                mode = record.mode == 'o' ? 'operator' : 'voice'
+                if(record.channel)
+                    output << "\2#{record.pk}:\2 mode: \2#{mode}\2 is exempt in \2#{record.channel.name}\2"
+                else
+                    output << "\2#{record.pk}:\2 mode: \2#{mode}\2 is exempt in \2all\2 channels"
+                end
+            end
+        elsif(params[:type] == 'source')
+            output << 'Current source exemptions:'
+            BanSourceExempt.all.each do |record|
+                if(record.channel)
+                    output << "\2#{record.pk}:\2 sources matching: #{record.source} are exempt in \2#{record.channel.name}\2"
+                else
+                    output << "\2#{record.pk}:\2 sources matching: #{record.source} are exempt in \2all\2 channels"
+                end
+            end
+        end
+        reply message.replyto, output
+    end
+
+    # message:: ModSpox::Messages::Incoming::Privmsg
+    # params:: parameters
+    # Remove given exemption from given list
+    def exempt_remove(message, params)
+        response = 'Exemption has been removed'
+        record = nil
+        case params[:type]
+            when 'nick'
+                record = BanNickExempt[params[:id].to_i]
+            when 'mode'
+                record = BanModeExempt[params[:id].to_i]
+            when 'source'
+                record = BanSourceExempt[params[:id].to_i]
+        end
+        if(record)
+            record.destroy
+        else
+            response = "Failed to find exemption of type: #{params[:type]} with ID: #{params[:id]}"
+        end
+        reply message.replyto, response
+    end
+    
+    # nick:: ModSpox::Models::Nick
+    # channel:: ModSpox::Models::Channel
+    # Check if nick is currently exempt from bans
+    def check_exempt(nick, channel)
+        return true unless BanNickExempt.filter('nick_id = ? AND (channel_id = ? OR channel_id is null)', nick.pk, channel.pk).first.nil?
+        return true if !BanModeExempt.filter("mode = 'o' AND (channel_id = ? OR channel_id is null)", channel.pk).first.nil? && nick.is_op?(channel)
+        return true if !BanModeExempt.filter("mode = 'v' AND (channel_id = ? OR channel_id is null)", channel.pk).first.nil? && nick.is_voice?(channel)
+        BanSourceExempt.filter('channel_id = ? OR channel_id is null', channel.pk).each do |record|
+            regex = Regexp.new(record.source)
+            return true unless regex.match(nick.source).nil?
+        end
+        return false
+    end
+    
     class BanRecord < Sequel::Model
         set_schema do
             primary_key :id
@@ -346,7 +499,7 @@ class Banner < ModSpox::Plugin
         end
         
         before_create do
-            set :stamp => Time.now
+            update_values(:stamp => Time.now)
         end
         
         def channel
@@ -383,10 +536,62 @@ class Banner < ModSpox::Plugin
         end
     end
     
+    class BanNickExempt < Sequel::Model
+        set_schema do
+            primary_key :id
+            foreign_key :nick_id, :table => :nicks, :null => false
+            foreign_key :channel_id, :table => :channels
+        end
+        
+        def nick
+            return Models::Nick[nick_id]
+        end
+        
+        def channel
+            return Models::Channel[channel_id]
+        end
+    end
+    
+    class BanSourceExempt < Sequel::Model
+        set_schema do
+            primary_key :id
+            varchar :source, :null => false
+            foreign_key :channel_id, :table => :channels
+        end
+        
+        def channel
+            return Models::Channel[channel_id]
+        end
+        
+        def mask
+            return values[:source] ? Marshal.load(values[:source].unpack('m')[0]) : nil
+        end
+        
+        def mask=(val)
+            update_values(:source => [Marshal.dump(val)].pack('m'))
+        end
+        
+    end
+    
+    class BanModeExempt < Sequel::Model
+        set_schema do
+            primary_key :id
+            varchar :mode, :null => false
+            foreign_key :channel_id, :table => :channels, :unique => true
+        end
+        
+        def channel
+            return Models::Channel[channel_id]
+        end        
+    end
+    
     class NotOperator < Exceptions::BotException
     end
     
     class NotInChannel < Exceptions::BotException
     end
+    
+    class BanExemption < Exceptions::BotException
+    end
 
 end

data/data/mod_spox/plugins/Helper.rb

@@ -11,7 +11,7 @@ class Helper < ModSpox::Plugin
     end
     
     def default_help(message, params)
-        plugins = Signature.map(:plugin)
+        plugins = Signature.select(:plugin).map(:plugin)
         plugins.uniq!
         reply message.replyto, "Plugins currently available for help: #{plugins.join(', ')}"
         reply message.replyto, "Request help on a plugin: !help Plugin"

data/data/mod_spox/plugins/PluginLoader.rb

@@ -11,8 +11,8 @@ class PluginLoader < ModSpox::Plugin
             :group_id => admin.pk, :description => 'Load the given plugin').params = [:plugin]
         Models::Signature.find_or_create(:signature => 'plugins unload (\S+)', :plugin => name, :method => 'unload_plugin',
             :group_id => admin.pk, :description => 'Unload given plugin').params = [:plugin]
-        Models::Signature.find_or_create(:signature => 'plugins reload', :plugin => name, :method => 'reload_plugin',
-            :group_id => admin.pk, :description => 'Reload plugins')
+        Models::Signature.find_or_create(:signature => 'plugins reload ?(\S+)?', :plugin => name, :method => 'reload_plugin',
+            :group_id => admin.pk, :description => 'Reload single plugin or all plugins if names not provided').params = [:plugin]
         @pipeline.hook(self, :get_module, :Internal_PluginModuleResponse)
         @plugins_mod = nil
     end
@@ -21,10 +21,11 @@ class PluginLoader < ModSpox::Plugin
     # params:: matching signature params
     # Output currently available plugins for loading
     def available_plugins(message, params)
-        @pipeline << Messages::Outgoing::Privmsg.new(message.replyto, "\2Currently available plugins:\2")
+        output = ["\2Currently available plugins:\2"]
         find_plugins.each_pair do | plugin, path |
-            @pipeline << Messages::Outgoing::Privmsg.new(message.replyto, "\2#{plugin}:\2 #{path}")
+            output << "\2#{plugin}:\2 #{path}"
         end
+        reply message.replyto, output
     end
     
     # message:: ModSpox::Messages::Incoming::Privmsg
@@ -65,8 +66,23 @@ class PluginLoader < ModSpox::Plugin
     # params:: matching signature params
     # Reloads plugins    
     def reload_plugin(message, params)
-        @pipeline << Messages::Internal::PluginReload.new
-        @pipeline << Messages::Outgoing::Privmsg.new(message.replyto, 'Okay')
+        if(params[:plugin])
+            users = plugin_discovery(BotConfig[:userpluginpath])
+            extras = plugin_discovery(BotConfig[:pluginextraspath])
+            fresh = nil
+            stale = nil
+            users.each_pair{|name, path| stale = path if name == params[:plugin]}
+            extras.each_pair{|name, path| fresh = path if name == params[:plugin]}
+            if(fresh && stale)
+                @pipeline << Messages::Internal::PluginReload.new(fresh, stale)
+                reply message.replyto, "Reloading #{params[:plugin]}"
+            else
+                reply message.replyto, "\2Error:\2 Failed to find new and stale versions of: #{params[:plugin]}"
+            end
+        else
+            @pipeline << Messages::Internal::PluginReload.new
+            @pipeline << Messages::Outgoing::Privmsg.new(message.replyto, 'Full plugin reload requested')
+        end
     end
     
     # message:: ModSpox::Messages::Internal::PluginModuleResponse

data/data/mod_spox/plugins/Triggers.rb

@@ -16,10 +16,11 @@ include Messages::Outgoing
     def active(message, params)
         triggers = Models::Trigger.filter(:active => true)
         if(triggers)
-            @pipeline << Privmsg.new(message.replyto, "\2Currently active triggers:\2")
+            output = ["\2Currently active triggers:\2"]
             triggers.each do |t|
-                @pipeline << Privmsg.new(message.replyto, "#{t.pk}: #{t.trigger}")
+                output << "#{t.pk}: #{t.trigger}"
             end
+            reply message.replyto, output
         else
             @pipeline << Privmsg.new(message.replyto, 'No triggers are currently active')
         end
@@ -28,10 +29,11 @@ include Messages::Outgoing
     def list(message, params)
         triggers = Models::Trigger.all
         if(triggers)
-            @pipeline << Privmsg.new(message.replyto, "\2Trigger listing:\2")
+            output = ["\2Trigger listing:\2"]
             triggers.each do |t|
-                @pipeline << Privmsg.new(message.replyto, "#{t.pk}: #{t.trigger}  ->  \2#{t.active ? "activated" : "not activated"}\2")
+                output << "#{t.pk}: #{t.trigger}  ->  \2#{t.active ? "activated" : "not activated"}\2"
             end
+            reply message.replyto, output
         else
             @pipeline << Privmsg.new(message.replyto, 'No triggers found')
         end

data/lib/mod_spox/Action.rb

@@ -1,3 +1,5 @@
+require 'mod_spox/Logger'
+
 module ModSpox
 
     class Action

data/lib/mod_spox/BaseConfig.rb

@@ -1,3 +1,5 @@
+require 'mod_spox/Exceptions'
+
 module ModSpox
 
     class BaseConfig

data/lib/mod_spox/Bot.rb

@@ -1,3 +1,14 @@
+['mod_spox/Logger',
+ 'mod_spox/Socket',
+ 'mod_spox/Pipeline',
+ 'mod_spox/PluginManager',
+ 'mod_spox/MessageFactory',
+ 'mod_spox/BaseConfig',
+ 'mod_spox/Timer',
+ 'mod_spox/messages/Messages',
+ 'mod_spox/models/Models',
+ 'mod_spox/Monitors',
+ 'mod_spox/Helpers'].each{|f|require f}
 module ModSpox
 
     class Bot
@@ -36,10 +47,10 @@ module ModSpox
         
         # Run the bot
         def run
-            trap('SIGTERM'){ Logger.log("Caught SIGTERM"); @shutdown = true; @waiter.wakeup; sleep(0.1); Thread.current.exit }
-            trap('SIGKILL'){ Logger.log("Caught SIGKILL"); @shutdown = true; @waiter.wakeup; sleep(0.1); Thread.current.exit }
-            trap('SIGINT'){ Logger.log("Caught SIGINT"); @shutdown = true; @waiter.wakeup; sleep(0.1); Thread.current.exit }
-            trap('SIGQUIT'){ Logger.log("Caught SIGQUIT"); @shutdown = true; @waiter.wakeup; sleep(0.1); Thread.current.exit }
+            trap('SIGTERM'){ Logger.log("Caught SIGTERM"); @shutdown = true; @waiter.wakeup; sleep(0.1); Thread.current.exit; Logger.kill; }
+            trap('SIGKILL'){ Logger.log("Caught SIGKILL"); @shutdown = true; @waiter.wakeup; sleep(0.1); Thread.current.exit; Logger.kill; }
+            trap('SIGINT'){ Logger.log("Caught SIGINT"); @shutdown = true; @waiter.wakeup; sleep(0.1); Thread.current.exit; Logger.kill; }
+            trap('SIGQUIT'){ Logger.log("Caught SIGQUIT"); @shutdown = true; @waiter.wakeup; sleep(0.1); Thread.current.exit; Logger.kill; }
             until @shutdown do
                 @timer.start
                 @pipeline << Messages::Internal::BotInitialized.new
@@ -126,7 +137,8 @@ module ModSpox
              :Outgoing_Whois => :whois, :Internal_EstablishConnection => :bot_connect,
              :Internal_StatusRequest => :status, :Internal_ChangeNick => :set_nick,
              :Internal_NickRequest => :get_nick, :Internal_HaltBot => :halt,
-             :Internal_Disconnected => :disconnected, :Internal_TimerClear => :clear_timer
+             :Internal_Disconnected => :disconnected, :Internal_TimerClear => :clear_timer,
+             :Outgoing_Raw => :raw
              }.each_pair{ |type,method| @pipeline.hook(self, method, type) }
         end
         
@@ -273,7 +285,15 @@ module ModSpox
             target = message.target.name if message.target.is_a?(Models::Channel)
             target = message.target.nick if message.target.is_a?(Models::Nick)
             target = message.target unless target
-            @socket << "PRIVMSG #{target} :#{message.is_action? ? "\cAACTION #{message.message}\cA" : message.message}"
+            messages = message.message.is_a?(Array) ? message.message : [message.message]
+            messages.each do |content|
+                while(content.size > 450)
+                    output = content[0..449]
+                    content.slice!(0, 449) #(450, content.size)
+                    @socket << "PRIVMSG #{target} :#{message.is_action? ? "\cAACTION #{output}\cA" : output}"
+                end
+                @socket << "PRIVMSG #{target} :#{message.is_action? ? "\cAACTION #{content}\cA" : content}"
+            end
         end
 
         # message:: Messages::Outgoing::Notice message
@@ -458,6 +478,12 @@ module ModSpox
             @socket << "ISON #{nick}"
         end 
         
+        # message:: Messages::Outoing::Raw message
+        # Send raw message to server
+        def raw(message)
+            @socket << message.message
+        end
+        
         private
         
         # Cleans information from models to avoid

data/lib/mod_spox/BotConfig.rb

@@ -1,3 +1,6 @@
+require 'etc'
+require 'mod_spox/Exceptions'
+
 module ModSpox
 
     class BotConfig

data/lib/mod_spox/Cache.rb

@@ -0,0 +1,57 @@
+module ModSpox
+    class Cache
+        def initialize(size)
+            @size = size
+            @cache = Hash.new
+            @times = Hash.new
+            @store_lock = Mutex.new
+            @read_lock = Mutex.new
+        end
+        
+        def [](key)
+            if(@cache.has_key?(key.to_sym))
+                @times[key.to_sym] = Time.now
+                return @cache[key.to_sym]
+            else
+                return nil
+            end
+        end
+        
+        def has_key?(key)
+            @read_lock.synchronize do
+                return @cache.has_key?(key.to_sym)
+            end
+        end
+        
+        def []=(key, value)
+            @store_lock.synchronize do
+                if(@cache.size > @size)
+                    del_key = oldest_key
+                    unless(key.nil?)
+                        @cache.delete(del_key)
+                        @times.delete(del_key)
+                    end
+                end
+                @cache[key.to_sym] = value
+                @times[key.to_sym] = Time.now
+            end
+        end
+        
+        def delete(key)
+            @read_lock.synchronize do
+                @cache.delete(key.to_sym) if @cache.has_key?(key.to_sym)
+                @times.delete(key.to_sym) if @times.has_key?(key.to_sym)
+            end
+        end
+        
+        private
+        
+        def oldest_key
+            result = nil
+            @read_lock.synchronize do
+                result = @times.sort{|a,b| a[1] <=> b[1]}[0][0]
+            end
+            return result
+        end
+    end
+end

data/lib/mod_spox/ConfigurationWizard.rb

@@ -1,5 +1,9 @@
-['etc', 'mod_spox/Loader',
- 'mod_spox/BotConfig',  'mod_spox/BaseConfig'].each{|f|require f}
+['etc', 
+ 'mod_spox/Database',
+ 'mod_spox/BotConfig',
+ 'mod_spox/BaseConfig'
+ 'mod_spox/models/Models',
+ 'mod_spox/Helpers'].each{|f|require f}
 
 
 module ModSpox

data/lib/mod_spox/Helpers.rb

@@ -1,5 +1,11 @@
-require 'timeout'
-require 'net/http'
+['timeout',
+ 'net/http',
+ 'mod_spox/models/Nick',
+ 'mod_spox/models/Channel',
+ 'mod_spox/models/Server',
+ 'mod_spox/Cache',
+ 'mod_spox/Logger'].each{|f|require f}
+
 module ModSpox
     module Helpers
         # secs:: number of seconds
@@ -60,48 +66,60 @@ module ModSpox
         # or channel name. If the string given does not match the required
         # pattern for a channel or nick, the string is returned.
         def Helpers.find_model(string, create=true)
-            @@channel_cache = {} unless Helpers.class_variable_defined?(:@@channel_cache)
-            @@nick_cache = {} unless Helpers.class_variable_defined?(:@@nick_cache)
+            Helpers.initialize_caches
             if(string =~ /^[A-Za-z\|\\\{\}\[\]\^\`~\_\-]+[A-Za-z0-9\|\\\{\}\[\]\^\`~\_\-]*$/)
-                Logger.log("Model: #{string} -> Nick")
+                Logger.log("Model: #{string} -> Nick", 30)
                 nick = nil
-                if(@@nick_cache.has_key?(string.to_sym))
+                if(@@nick_cache.has_key?(string.downcase.to_sym))
                     begin
-                        nick = Models::Nick[@@nick_cache[string.to_sym]]
+                        nick = Models::Nick[@@nick_cache[string.downcase.to_sym]]
                         Logger.log("Handler cache hit for nick: #{string}", 30)
+                        if(nick.nick.downcase != string.downcase)
+                            Logger.log("Nick returned from cache invalid. Expecting #{string} but got #{nick.nick}", 30)
+                            nick = nil
+                        end
                     rescue Object => boom
-                        Logger.log("Failed to grab cached nick: #{boom}")
+                        Logger.log("Failed to grab cached nick: #{boom}", 30)
                     end
                 end
                 unless(nick)
                     nick = Models::Nick.locate(string, create)
-                    @@nick_cache[string.to_sym] = nick.pk if nick.is_a?(Models::Nick)
-                    Logger.log("Nick was retrieved from database")
+                    @@nick_cache[string.downcase.to_sym] = nick.pk if nick.is_a?(Models::Nick)
+                    Logger.log("Nick was retrieved from database", 30)
                 end
                 return nick
             elsif(string =~ /^[&#+!]/)
-                Logger.log("Model: #{string} -> Channel")
-                if(@@channel_cache.has_key?(string.to_sym))
+                Logger.log("Model: #{string} -> Channel", 30)
+                if(@@channel_cache.has_key?(string.downcase.to_sym))
                     begin
-                        channel = Models::Channel[@@channel_cache[string.to_sym]]
+                        channel = Models::Channel[@@channel_cache[string.downcase.to_sym]]
                         Logger.log("Handler cache hit for channel: #{string}", 30)
+                        if(string.downcase != channel.name.downcase)
+                            Logger.log("Channel returned from cache invalid. Expecting #{string} but got #{channel.name}", 30)
+                            channel = nil
+                        end
                     rescue Object => boom
-                        Logger.log("Failed to grab cached channel: #{boom}")
+                        Logger.log("Failed to grab cached channel: #{boom}", 30)
                     end
                 end
                 unless(channel)
                     channel = Models::Channel.locate(string, create)
-                    @@channel_cache[string.to_sym] = channel.pk if channel.is_a?(Models::Channel)
-                    Logger.log("Channel was retrieved from database")
+                    @@channel_cache[string.downcase.to_sym] = channel.pk if channel.is_a?(Models::Channel)
+                    Logger.log("Channel was retrieved from database", 30)
                 end
                 return channel
             elsif(model = Models::Server.filter(:host => string, :connected => true).first)
-                Logger.log("Model: #{string} -> Server")
+                Logger.log("Model: #{string} -> Server", 30)
                 return model
             else
-                Logger.log("FAIL Model: #{string} -> No match")
+                Logger.log("FAIL Model: #{string} -> No match", 30)
                 return string
             end
         end
+        
+        def Helpers.initialize_caches
+            @@nick_cache = Cache.new(20) unless Helpers.class_variable_defined?(:@@nick_cache)
+            @@channel_cache = Cache.new(5) unless Helpers.class_variable_defined?(:@@channel_cache)
+        end
     end
 end

data/lib/mod_spox/Loader.rb

@@ -1,66 +1,17 @@
-module ModSpox
+['mod_spox/Exceptions',
+ 'mod_spox/BotConfig',
+ 'mod_spox/BaseConfig',
+ 'mod_spox/Database'].each{|f|require f}
 
-    # directory:: path to directory
-    # Requires all .rb files found within the given directory
-    # and all its subdirectories
-    def load_directory(directory='')
-        base = File.dirname(__FILE__)
-        Dir.new("#{base}/#{directory}").each{|item|
-            next if ['.', '..'].include?(item)
-            if(File.directory?("#{base}/#{directory}/#{item}"))
-                load_directory("#{directory}/#{item}")
-            elsif(item =~ /\.rb$/)
-                item = "#{directory}/#{item}" if directory.length > 0
-                begin
-                    require "mod_spox/#{item}"
-                rescue Object => boom
-                    @@failed << item
-                end
-            end
-        }
-        @@failed.each{|f| 
-            begin
-                require "mod_spox/#{f}"
-                @@failed.delete(f)
-            rescue Object => boom
-                # do nothing #
-            end
-        }
-    end
+module ModSpox
     
     # Loads all files needed by the bot
     def initialize_bot
         setup_adapter
-        @@failed = Array.new
-        load_directory
-        tries = 0
-        message = nil
-        until @@failed.empty? || tries > 5 do
-            @@failed.each{|f|
-                begin
-                    require "mod_spox/#{f}"
-                    @@failed.delete(f)
-                rescue Object => boom
-                    message = boom
-                end
-            }
-            tries += 1
-        end
-        if(tries > 5)
-            puts 'Failed'
-            puts "ERROR: Failed to load required libraries"
-            puts "Reason: #{message}"
-            puts "#{message.backtrace.join("\n")}"
-            exit
-        end
     end
     
     # Setup the DataMapper adapter
     def setup_adapter
-        require 'mod_spox/Exceptions'
-        require 'mod_spox/BotConfig'
-        require 'mod_spox/BaseConfig'
-        require 'mod_spox/Database'
         memcache = false
         config = BaseConfig.new(BotConfig[:userconfigpath])
         if(config[:memcache] == 'on')