spox-mod_spox 0.3.1 → 0.3.2

data/data/mod_spox/extras/FloodKicker.rb

@@ -9,7 +9,8 @@ class FloodKicker
             @watched << c[:channel]
         end
         @data = {}
-        @pipeline.hook(self, :listener, :Incoming_Privmsg)
+        Helpers.load_message(:incoming, :Privmsg)
+        @pipeline.hook(self, :listener, ModSpox::Messages::Incoming::Privmsg)
         add_sig(:sig => 'floodkick enable(\s \S+)?', :method => :add_channel, :group => flood,
                 :desc => 'Add channel to flood kicker', :params => [:channel])
         add_sig(:sig => 'floodkick disable(\s \S+)?', :method => :remove_channel, :group => flood,

data/data/mod_spox/extras/Fortune.rb

@@ -54,7 +54,11 @@ class Fortune < ModSpox::Plugin
                 f = @db[:fortunes].filter(:id => rand(@ids[:all])).first
             end
             if(f)
-                reply m.replyto, f[:fortune]
+                if(f[:fortune].size > 350)
+                    fortune(m, params)
+                else
+                    reply m.replyto, f[:fortune]
+                end
             else
                 error m.replyto, "Failed to locate fortune"
             end

data/data/mod_spox/extras/Karma.rb

@@ -20,7 +20,8 @@ class Karma < ModSpox::Plugin
         add_sig(:sig => 'antikarma fight (\S+|\(.+?\)) (\S+|\(.+?\))', :method => :antifight, :desc => 'Make two antikarma objects fight', :params => [:thing, :thang])
         add_sig(:sig => 'karma topten', :method => :topten, :desc => 'Show top ten highest karma objects')
         add_sig(:sig => 'karma bottomten', :method => :bottomten, :desc => 'Show bottom ten lowest karma objects')
-        @pipeline.hook(self, :check, :Incoming_Privmsg)
+        Helpers.load_message(:incoming, :Privmsg)
+        @pipeline.hook(self, :check, ModSpox::Messages::Incoming::Privmsg)
         @thing_maxlen = 32
         @karma_regex = /(\(.{1,#@thing_maxlen}?\)|\S{1,#@thing_maxlen})([+-]{2})(?:\s|$)/
         @eggs = {}

data/data/mod_spox/extras/Logger.rb

@@ -13,15 +13,17 @@ class ChatLogger < ModSpox::Plugin
         super
         PublicLog.create_table unless PublicLog.table_exists?
         PrivateLog.create_table unless PrivateLog.table_exists?
-        @pipeline.hook(self, :log_privmsg, :Incoming_Privmsg)
-        @pipeline.hook(self, :log_join, :Incoming_Join)
-        @pipeline.hook(self, :log_part, :Incoming_Part)
-        @pipeline.hook(self, :log_quit, :Incoming_Quit)
-        @pipeline.hook(self, :log_kick, :Incoming_Kick)
-        @pipeline.hook(self, :log_mode, :Incoming_Mode)
-        @pipeline.hook(self, :log_privmsg, :Incoming_Notice)
-        @pipeline.hook(self, :log_outpriv, :Outgoing_Privmsg)
-        @pipeline.hook(self, :log_outpriv, :Outgoing_Notice)
+        [:Privmsg, :Join, :Part, :Quit, :Kick, :Mode].each{|t|Helpers.load_message(:incoming, t)}
+        [:Privmsg, :Notice].each{|t|Helpers.load_message(:outgoing, t)}
+        @pipeline.hook(self, :log_privmsg, ModSpox::Messages::Incoming::Privmsg)
+        @pipeline.hook(self, :log_join, ModSpox::Messages::Incoming::Join)
+        @pipeline.hook(self, :log_part, ModSpox::Messages::Incoming::Part)
+        @pipeline.hook(self, :log_quit, ModSpox::Messages::Incoming::Quit)
+        @pipeline.hook(self, :log_kick, ModSpox::Messages::Incoming::Kick)
+        @pipeline.hook(self, :log_mode, ModSpox::Messages::Incoming::Mode)
+        @pipeline.hook(self, :log_privmsg, ModSpox::Messages::Incoming::Notice)
+        @pipeline.hook(self, :log_outpriv, ModSpox::Messages::Outgoing::Privmsg)
+        @pipeline.hook(self, :log_outpriv, ModSpox::Messages::Outgoing::Notice)
         add_sig(:sig => 'seen (\S+)', :method => :seen, :desc => 'Report last sighting of nick', :params => [:nick])
         add_sig(:sig => 'lastspoke (\S+)', :method => :spoke, :desc => 'Report last time nick spoke', :params => [:nick])
     end

data/data/mod_spox/extras/NickServ.rb

@@ -18,7 +18,8 @@ class NickServ < ModSpox::Plugin
         unless(@nickserv.is_a?(Hash) && @nickserv.has_key?(:address) && @nickserv.has_key?(:combos))
             @nickserv = {:address => nil, :combos => {}}
         end
-        @pipeline.hook(self, :send_nickserv, :Incoming_Welcome)
+        Helpers.load_message(:incoming, :Welcome)
+        @pipeline.hook(self, :send_nickserv, ModSpox::Messages::Incoming::Welcome)
     end
     
     # @nickserv = {:address => 'nickserv@blah', :combos => {'nick' => 'pass'}}

data/data/mod_spox/extras/PhpCli.rb

@@ -232,7 +232,7 @@ class PhpCli < ModSpox::Plugin
             foreign_key :nick_id, :null => false
             primary_key :id
         end
-        
+        Sequel::Model.plugin :lazy_attributes, :php_function
         Sequel::Model.plugin :serialization, :marshal, :php_function
 #         serialize(:php_function, :format => :marshal)
         

data/data/mod_spox/extras/PhpFuncLookup.rb

@@ -71,7 +71,8 @@ class PhpFuncLookup < ModSpox::Plugin
         add_sig(:sig => 'pfunc show trigger', :method => :show_trigger, :desc => 'Show current trigger')
         add_sig(:sig => 'pfunc (add|remove) (\S+)', :method => :set_channels, :group => admin, :desc => 'Add or remove channels from auto-lookups', :params => [:action, :channel])
         add_sig(:sig => 'pfunc show channels', :method => :list_channels, :desc => 'Show channels with auto lookup enabled')
-        @pipeline.hook(self, :listen, :Incoming_Privmsg)
+        Helpers.load_message(:incoming, :Privmsg)
+        @pipeline.hook(self, :listen, ModSpox::Messages::Incoming::Privmsg)
         populate_classes
     end
         

data/data/mod_spox/extras/RegexTracker.rb

@@ -13,7 +13,8 @@ class RegexTracker < ModSpox::Plugin
                 :params => [:id], :group => track)
         add_sig(:sig => 'track modify (\d+) (.+)', :method => :modify, :desc => 'Modify regex',
                 :params => [:id, :regex], :group => track)
-        @pipeline.hook(self, :check, :Incoming_Privmsg)
+        Helpers.load_message(:incoming, :Privmsg)
+        @pipeline.hook(self, :check, ModSpox::Messages::Incoming::Privmsg)
         TrackInfo.create_table unless TrackInfo.table_exists?
         @cache = {}
         build_cache

data/data/mod_spox/extras/Roulette.rb

@@ -1,4 +1,5 @@
 require 'mod_spox/messages/internal/PluginRequest'
+require 'mod_spox/messages/internal/PluginResponse'
 
 class Roulette < ModSpox::Plugin
 
@@ -15,7 +16,7 @@ class Roulette < ModSpox::Plugin
         Game.create_table unless Game.table_exists?
         Info.create_table unless Info.table_exists?
         @banner = nil
-        @pipeline.hook(self, :get_banner, :Internal_PluginResponse)
+        @pipeline.hook(self, :get_banner, ModSpox::Messages::Internal::PluginResponse)
     end
 
     # message:: ModSpox::Messages::Incoming::Privmsg

data/data/mod_spox/extras/Seen.rb

@@ -2,14 +2,16 @@ class Seen < ModSpox::Plugin
     def initialize(pipe)
         super
         SeenLog.create_table unless SeenLog.table_exists?
-        @pipeline.hook(self, :log_privmsg, :Incoming_Privmsg)
-        @pipeline.hook(self, :log_join, :Incoming_Join)
-        @pipeline.hook(self, :log_part, :Incoming_Part)
-        @pipeline.hook(self, :log_quit, :Incoming_Quit)
-        @pipeline.hook(self, :log_kick, :Incoming_Kick)
-        @pipeline.hook(self, :log_privmsg, :Incoming_Notice)
-        @pipeline.hook(self, :log_outpriv, :Outgoing_Privmsg)
-        @pipeline.hook(self, :log_outpriv, :Outgoing_Notice)
+        [:Privmsg, :Join, :Part, :Quit, :Kick, :Notice].each{|t| Helpers.load_message(:incoming, t)}
+        [:Privmsg, :Notice].each{|t|Helpers.load_message(:outgoing, t)}
+        @pipeline.hook(self, :log_privmsg, ModSpox::Messages::Incoming::Privmsg)
+        @pipeline.hook(self, :log_join, ModSpox::Messages::Incoming::Join)
+        @pipeline.hook(self, :log_part, ModSpox::Messages::Incoming::Part)
+        @pipeline.hook(self, :log_quit, ModSpox::Messages::Incoming::Quit)
+        @pipeline.hook(self, :log_kick, ModSpox::Messages::Incoming::Kick)
+        @pipeline.hook(self, :log_privmsg, ModSpox::Messages::Incoming::Notice)
+        @pipeline.hook(self, :log_outpriv, ModSpox::Messages::Outgoing::Privmsg)
+        @pipeline.hook(self, :log_outpriv, ModSpox::Messages::Outgoing::Notice)
         add_sig(:sig => 'seen (\S+)', :method => :seen, :desc => 'Report last sighting of nick', :params => [:nick])
     end
 

data/data/mod_spox/extras/Topten.rb

@@ -9,7 +9,8 @@ class Topten < ModSpox::Plugin
         add_sig(:sig => 'topten ([0-9]{4}\/[0-9]{2}\/[0-9]{2})', :method => :archive, :desc => 'Show topten from given date', :req => 'public', :params => [:date])
         add_sig(:sig => 'stats ?(\S+)?', :method => :stats, :desc => 'Show stats on nick', :req => 'public', :params => [:nick])
         add_sig(:sig => 'stats lifetime (\S+)?', :method => :life_stats, :desc => 'Show stat totals for given nick', :req => 'public', :params => [:nick])
-        @pipeline.hook(self, :log_stats, :Incoming_Privmsg)
+        Helpers.load_message(:incoming, :Privmsg)
+        @pipeline.hook(self, :log_stats, ModSpox::Messages::Incoming::Privmsg)
     end
     
     def topten(m, p)

data/data/mod_spox/extras/Translate.rb

@@ -8,7 +8,8 @@ class Translate < ModSpox::Plugin
         add_sig(:sig => 'autotranslate add ([a-z]{2}) (\S+)', :method => :auto_add, :desc => 'Add a nick to the autotranslate service', :params => [:lang, :nick])
         add_sig(:sig => 'autotranslate remove (\S+)', :method => :auto_remove, :desc => 'Remove a nick from the autotranslate service', :params => [:nick])
         add_sig(:sig => 'translate languages', :method => :langs, :desc => 'Show available languages')
-        @pipeline.hook(self, :listener, :Incoming_Privmsg)
+        Helpers.load_message(:incoming, :Privmsg)
+        @pipeline.hook(self, :listener, ModSpox::Messages::Incoming::Privmsg)
         @watchers = {}
         @cache = {}
         @allowed = {'zh'=>'Chinese-simplified','zt'=>'Chinese-traditional','en'=>'English','nl'=>'Dutch',

data/data/mod_spox/extras/Twitter.rb

@@ -70,7 +70,7 @@ class Twitter < ModSpox::Plugin
         add_sig(:sig => 'twitter alias (\S+) (\S+)', :method => :alias_user, :desc => 'Set alias for twitter account', :group => twitter, :params => [:twit, :irc])
         add_sig(:sig => 'twitter aliases (\S+)', :method => :show_aliases, :desc => 'Show alias for twit', :params => [:twit])
         add_sig(:sig => 'twitter dealias (\S+)', :method => :remove_alias, :desc => 'Remove alias for twit', :params => [:twit], :group => twitter)
-        @pipeline.hook(self, :get_timer, :Internal_TimerResponse)
+        @pipeline.hook(self, :get_timer, ModSpox::Messages::Internal::TimerResponse)
         @auth_info = Models::Setting.find_or_create(:name => 'twitter').value
         @twitter = ModClient.new
         @search_url = 'http://search.twitter.com/search.json'

data/data/mod_spox/plugins/Authenticator.rb

@@ -1,6 +1,3 @@
-require 'mod_spox/messages/outgoing/Raw'
-require 'mod_spox/messages/internal/TimerAdd'
-
 class Authenticator < ModSpox::Plugin
     def initialize(pipeline)
         super(pipeline)
@@ -24,10 +21,13 @@ class Authenticator < ModSpox::Plugin
         @nickserv_nicks = []
         @nickserv_cache = []
         populate_nickserv
-        @pipeline.hook(self, :check_join, :Incoming_Join)
-        @pipeline.hook(self, :check_nicks, :Incoming_Who)
-        @pipeline.hook(self, :check_nicks, :Incoming_Names)
-        @pipeline.hook(self, :check_notice, :Incoming_Notice)
+        [:Join, :Who, :Names, :Notice].each{|t| Helpers.load_message(:incoming, t)}
+        Helpers.load_message(:outgoing, :Raw)
+        Helpers.load_message(:internal, :TimerAdd)
+        @pipeline.hook(self, :check_join, ModSpox::Messages::Incoming::Join)
+        @pipeline.hook(self, :check_nicks, ModSpox::Messages::Incoming::Who)
+        @pipeline.hook(self, :check_nicks, ModSpox::Messages::Incoming::Names)
+        @pipeline.hook(self, :check_notice, ModSpox::Messages::Incoming::Notice)
     end
 
     # message:: ModSpox::Messages::Incoming::Privmsg

data/data/mod_spox/plugins/Banner.rb

@@ -24,10 +24,10 @@ class Banner < ModSpox::Plugin
         add_sig(:sig => 'exempt source (\S+)', :method => :exempt_source, :group => admin, :desc => 'Exempt a source from kicks globally or per channel', :params => [:source, :channel])
         add_sig(:sig => 'exempt list (nick|mode|source)', :method => :exempt_list, :group => admin, :desc => 'List current exemptions of given type', :params => [:type])
         add_sig(:sig => 'exempt remove (nick|mode|source) (\d+)', :method => :exempt_remove, :group => admin, :desc => '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, :process_ban, :Banner_Ban)
+        @pipeline.hook(self, :mode_check, ModSpox::Messages::Incoming::Mode)
+        @pipeline.hook(self, :join_check, ModSpox::Messages::Incoming::Join)
+        @pipeline.hook(self, :who_check, ModSpox::Messages::Incoming::Who)
+        @pipeline.hook(self, :process_ban, 'Banner::Ban')
         BanRecord.create_table unless BanRecord.table_exists?
         BanMask.create_table unless BanMask.table_exists?
         BanNickExempt.create_table unless BanNickExempt.table_exists?
@@ -110,7 +110,7 @@ class Banner < ModSpox::Plugin
                 record.remaining = record.remaining + time.to_i
                 record.save
             else
-                record = BanRecord.new(:nick_id => nick.pk, :bantime => time.to_i, :remaining => time.to_i,
+                record = BanRecord.new(:nick_id => nick.pk, :bantime => time.to_i, :remaining => time.to_i, :stamp => ::Time.now,
                     :invite => invite, :channel_id => channel.pk, :mask => mask)
                 record.save
             end
@@ -472,7 +472,7 @@ class Banner < ModSpox::Plugin
         many_to_one :nick, :class => ModSpox::Models::Nick
 
         def before_create
-            update(:stamp => Object::Time.now)
+            stamp = Object::Time.now
         end
     end
 

data/data/mod_spox/plugins/BotNick.rb

@@ -2,7 +2,8 @@ class BotNick < ModSpox::Plugin
 
     def initialize(pipeline)
         super(pipeline)
-        @pipeline.hook(self, :shutdown, :Internal_Shutdown)
+        Helpers.load_message(:internal, :Shutdown)
+        @pipeline.hook(self, :shutdown, ModSpox::Messages::Internal::Shutdown)
     end
     
     def shutdown(message)

data/data/mod_spox/plugins/Initializer.rb

@@ -6,10 +6,10 @@ class Initializer < ModSpox::Plugin
 
     def initialize(pipeline)
         super(pipeline)
-        @pipeline.hook(self, :connect, :Internal_BotInitialized)
-        @pipeline.hook(self, :send_info, :Internal_Connected)
-        @pipeline.hook(self, :reconnect, :Internal_ConnectionFailed)
-        @pipeline.hook(self, :reconnect, :Internal_Disconnected)
+        @pipeline.hook(self, :connect, ModSpox::Messages::Internal::BotInitialized)
+        @pipeline.hook(self, :send_info, ModSpox::Messages::Internal::Connected)
+        @pipeline.hook(self, :reconnect, ModSpox::Messages::Internal::ConnectionFailed)
+        @pipeline.hook(self, :reconnect, ModSpox::Messages::Internal::Disconnected)
         @servers = Array.new
     end
     

data/data/mod_spox/plugins/Joiner.rb

@@ -6,7 +6,7 @@ class Joiner < ModSpox::Plugin
         super(pipeline)
         admin = Models::Group.filter(:name => 'admin').first
         add_sig(:sig => 'join (\S+)', :method => :join, :group => admin, :params => [:channel])
-        @pipeline.hook(self, :send_who, :Incoming_Join)
+        @pipeline.hook(self, :send_who, ModSpox::Messages::Incoming::Join)
     end
     
     # message:: ModSpox::Messages::Incoming::Privmsg

data/data/mod_spox/plugins/PluginLoader.rb

@@ -13,7 +13,7 @@ class PluginLoader < ModSpox::Plugin
         add_sig(:sig => 'plugins load (\S+)', :method => :load_plugin, :group => admin, :desc => 'Load the given plugin', :params => [:plugin])
         add_sig(:sig => 'plugins unload (\S+)', :method => :unload_plugin, :group => admin, :desc => 'Unload given plugin', :params => [:plugin])
         add_sig(:sig => 'plugins reload ?(\S+)?', :method => :reload_plugin, :group => admin, :desc => 'Reload single plugin or all plugins if names not provided', :params => [:plugin])
-        @pipeline.hook(self, :get_module, :Internal_PluginModuleResponse)
+        @pipeline.hook(self, :get_module, ModSpox::Messages::Internal::PluginModuleResponse)
         @plugins_mod = nil
     end
 

data/data/mod_spox/plugins/Ponger.rb

@@ -1,8 +1,3 @@
-require 'mod_spox/messages/outgoing/Pong'
-require 'mod_spox/messages/outgoing/Ping'
-require 'mod_spox/messages/internal/Reconnect'
-require 'mod_spox/messages/internal/TimerAdd'
-
 class Ponger < ModSpox::Plugin
 
     def initialize(pipeline)
@@ -11,10 +6,15 @@ class Ponger < ModSpox::Plugin
         @last = nil
         @attempts = 0
         add_sig(:sig => 'lag', :method => :print_lag, :desc => 'Shows bot\'s current lag to server')
-        @pipeline.hook(self, :ping, :Incoming_Ping)
-        @pipeline.hook(self, :get_lag_pong, :Incoming_Pong)
+        Helpers.load_message(:incoming, :Ping)
+        Helpers.load_message(:incoming, :Pong)
+        Helpers.load_message(:internal, :PluginsReady)
+        Helpers.load_message(:internal, :Reconnect)
+        Helpers.load_message(:internal, :TimerAdd)
+        @pipeline.hook(self, :ping, ModSpox::Messages::Incoming::Ping)
+        @pipeline.hook(self, :get_lag_pong, ModSpox::Messages::Incoming::Pong)
         @lock = Mutex.new
-        @pipeline.hook(self, :check_start_ponger, :Internal_PluginsReady)
+        @pipeline.hook(self, :check_start_ponger, ModSpox::Messages::Internal::PluginsReady)
         @running = false
         send_lag_ping
     end

data/data/mod_spox/plugins/Status.rb

@@ -7,7 +7,7 @@ class Status < ModSpox::Plugin
         add_sig(:sig => 'status', :method => :status, :desc => 'Show current status')
         add_sig(:sig => 'version', :method => :version, :desc => 'Show version information')
         add_sig(:sig => 'VERSION', :method => :version, :desc => 'Show version information')
-        @pipeline.hook(self, :get_status, :Internal_StatusResponse)
+        @pipeline.hook(self, :get_status, ModSpox::Messages::Internal::StatusResponse)
         @resp = []
     end
     

data/lib/mod_spox/Bot.rb

@@ -161,33 +161,33 @@ module ModSpox
 
         # Adds hooks to pipeline for processing messages
         def hook_pipeline
-            {:Outgoing_Admin => :admin, :Outgoing_Away => :away,
-             :Outgoing_ChannelMode => :channel_mode, :Outgoing_Connect => :connect,
-             :Outgoing_Die => :die, :Outgoing_Info => :info,
-             :Outgoing_Invite => :invite, :Outgoing_Ison => :ison,
-             :Outgoing_Join => :join, :Outgoing_Kick => :kick,
-             :Outgoing_Kill => :kill, :Outgoing_Links => :links,
-             :Outgoing_List => :list, :Outgoing_Lusers => :lusers,
-             :Outgoing_Motd => :motd, :Outgoing_Names => :names,
-             :Outgoing_Nick => :nick, :Outgoing_Notice => :notice,
-             :Outgoing_Oper => :oper, :Outgoing_Part => :part,
-             :Outgoing_Pass => :pass, :Outgoing_Ping => :ping,
-             :Outgoing_Pong => :pong, :Outgoing_Privmsg => :privmsg,
-             :Outgoing_Quit => :quit, :Outgoing_Rehash => :rehash,
-             :Outgoing_ServList => :servlist, :Outgoing_Squery => :squery,
-             :Outgoing_Squit => :squit, :Outgoing_Stats => :stats,
-             :Outgoing_Summon => :summon, :Outgoing_Time => :time,
-             :Outgoing_Topic => :topic, :Outgoing_Trace => :trace,
-             :Outgoing_Unaway => :unaway, :Outgoing_User => :user,
-             :Outgoing_UserHost => :userhost, :Outgoing_UserMode => :user_mode,
-             :Outgoing_Users => :users, :Outgoing_Version => :version,
-             :Outgoing_Who => :who, :Outgoing_WhoWas => :whowas,
-             :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,
-             :Outgoing_Raw => :raw, :Internal_Reconnect => :reconnect,
-             :Incoming_Join => :check_join, :Incoming_Part => :check_part
+            {'ModSpox::Messages::Outgoing::Admin' => :admin, 'ModSpox::Messages::Outgoing::Away' => :away,
+             'ModSpox::Messages::Outgoing::ChannelMode' => :channel_mode, 'ModSpox::Messages::Outgoing::Connect' => :connect,
+             'ModSpox::Messages::Outgoing::Die' => :die, 'ModSpox::Messages::Outgoing::Info' => :info,
+             'ModSpox::Messages::Outgoing::Invite' => :invite, 'ModSpox::Messages::Outgoing::Ison' => :ison,
+             'ModSpox::Messages::Outgoing::Join' => :join, 'ModSpox::Messages::Outgoing::Kick' => :kick,
+             'ModSpox::Messages::Outgoing::Kill' => :kill, 'ModSpox::Messages::Outgoing::Links' => :links,
+             'ModSpox::Messages::Outgoing::List' => :list, 'ModSpox::Messages::Outgoing::Lusers' => :lusers,
+             'ModSpox::Messages::Outgoing::Motd' => :motd, 'ModSpox::Messages::Outgoing::Names' => :names,
+             'ModSpox::Messages::Outgoing::Nick' => :nick, 'ModSpox::Messages::Outgoing::Notice' => :notice,
+             'ModSpox::Messages::Outgoing::Oper' => :oper, 'ModSpox::Messages::Outgoing::Part' => :part,
+             'ModSpox::Messages::Outgoing::Pass' => :pass, 'ModSpox::Messages::Outgoing::Ping' => :ping,
+             'ModSpox::Messages::Outgoing::Pong' => :pong, 'ModSpox::Messages::Outgoing::Privmsg' => :privmsg,
+             'ModSpox::Messages::Outgoing::Quit' => :quit, 'ModSpox::Messages::Outgoing::Rehash' => :rehash,
+             'ModSpox::Messages::Outgoing::ServList' => :servlist, 'ModSpox::Messages::Outgoing::Squery' => :squery,
+             'ModSpox::Messages::Outgoing::Squit' => :squit, 'ModSpox::Messages::Outgoing::Stats' => :stats,
+             'ModSpox::Messages::Outgoing::Summon' => :summon, 'ModSpox::Messages::Outgoing::Time' => :time,
+             'ModSpox::Messages::Outgoing::Topic' => :topic, 'ModSpox::Messages::Outgoing::Trace' => :trace,
+             'ModSpox::Messages::Outgoing::Unaway' => :unaway, 'ModSpox::Messages::Outgoing::User' => :user,
+             'ModSpox::Messages::Outgoing::UserHost' => :userhost, 'ModSpox::Messages::Outgoing::UserMode' => :user_mode,
+             'ModSpox::Messages::Outgoing::Users' => :users, 'ModSpox::Messages::Outgoing::Version' => :version,
+             'ModSpox::Messages::Outgoing::Who' => :who, 'ModSpox::Messages::Outgoing::WhoWas' => :whowas,
+             'ModSpox::Messages::Outgoing::Whois' => :whois, 'ModSpox::Messages::Internal::EstablishConnection' => :bot_connect,
+             'ModSpox::Messages::Internal::StatusRequest' => :status, 'ModSpox::Messages::Internal::ChangeNick' => :set_nick,
+             'ModSpox::Messages::Internal::NickRequest' => :get_nick, 'ModSpox::Messages::Internal::HaltBot' => :halt,
+             'ModSpox::Messages::Internal::Disconnected' => :disconnected, 'ModSpox::Messages::Internal::TimerClear' => :clear_timer,
+             'ModSpox::Messages::Outgoing::Raw' => :raw, 'ModSpox::Messages::Internal::Reconnect' => :reconnect,
+             'ModSpox::Messages::Incoming::Join' => :check_join, 'ModSpox::Messages::Incoming::Part' => :check_part
              }.each_pair{ |type,method| @pipeline.hook(self, method, type) }
         end
 

data/lib/mod_spox/BotConfig.rb

@@ -19,27 +19,22 @@ module ModSpox
         # :userpluginpath => path to user's plugin directory
         # :userconfigpath => path to the user configuration file        
         def BotConfig.populate(createdir=true)
-            gemname, gem = Gem.source_index.find{|name, spec|
-                spec.name == 'mod_spox' && spec.version.version = ModSpox.botversion
-            }
-            if(gem)
-                p = gem.full_gem_path
-                up = ModSpox.mod_spox_path.nil? ? Etc.getpwnam(Etc.getlogin).dir : ModSpox.mod_spox.path
-                @@config = {:basepath => p,
-                           :libpath => "#{p}/lib/mod_spox",
-                           :datapath => "#{p}/data/mod_spox",
-                           :pluginpath => "#{p}/data/mod_spox/plugins",
-                           :pluginextraspath => "#{p}/data/mod_spox/extras",
-                           :userpath => "#{up}/.mod_spox",
-                           :userpluginpath => "#{up}/.mod_spox/plugins",
-                           :userconfigpath => "#{up}/.mod_spox/config"}
-                if(createdir)
-                    [@@config[:userpath], @@config[:userpluginpath]].each do |path|
-                        Dir.mkdir(path) unless File.exists?(path)
-                    end
+            path = __FILE__.split(File::Separator)
+            3.times{ path.pop }
+            path = path.join(File::Separator)
+            upath = ModSpox.mod_spox_path.nil? ? Etc.getpwnam(Etc.getlogin).dir : ModSpox.mod_spox_path
+            @@config = {:basepath => path,
+                        :libpath => "#{path}/lib/mod_spox",
+                        :datapath => "#{path}/data/mod_spox",
+                        :pluginpath => "#{path}/data/mod_spox/plugins",
+                        :pluginextraspath => "#{path}/data/mod_spox/extras",
+                        :userpath => "#{upath}/.mod_spox",
+                        :userpluginpath => "#{upath}/.mod_spox/plugins",
+                        :userconfigpath => "#{upath}/.mod_spox/config"}
+            if(createdir)
+                [@@config[:userpath], @@config[:userpluginpath]].each do |mpath|
+                    Dir.mkdir(mpath) unless File.exists?(mpath)
                 end
-            else
-                raise Exceptions::InstallationError.new('Failed to find mod_spox gem')
             end
         end
         
@@ -47,7 +42,8 @@ module ModSpox
         # Provides access to important path values
         def BotConfig.[](name)
             BotConfig.populate unless @@config
-            name = name.to_sym unless name.is_a?(Symbol)
+            raise ArgumentError.new('Parameter must have a to_s method') unless name.respond_to?(:to_s)
+            name = name.to_s.to_sym unless name.is_a?(Symbol)
             raise Exceptions::UnknownKey.new("Failed to find given key: #{name}") unless @@config.has_key?(name)
             return @@config[name]
         end

data/lib/mod_spox/Filter.rb

@@ -0,0 +1,29 @@
+module ModSpox
+    class Filter
+        # message type filter is applied to
+        attr_reader :type
+        def initialize(t)
+            @type = t
+        end
+
+        # message:: Message from pipeline
+        # Applies filters to message
+        def filter(message)
+            raise ArgumentError.new("Wrong type supplied (Expected: #{@type})") unless Helpers.type_of?(message, @type)
+            do_filter(message)
+        end
+        
+        protected
+        
+        # message:: Message to be filtered
+        # This is where the actual filtering takes place. This
+        # is the method to overload!
+        # NOTE: Messages can be filtered in any way. For a filter to
+        # basically "throw away" a message, simply set the message to
+        # nil and it will not be processed or added to the pipeline:
+        #   *message = nil
+        def do_filter(message)
+            raise Exceptions::NotImplemented.new
+        end
+    end
+end