mod_spox 0.0.1

data/CHANGELOG

@@ -0,0 +1,2 @@
+0.0.1 Release
+    * Initial release. No changes to report.

data/INSTALL

@@ -0,0 +1,9 @@
+Install:
+
+gem install --include-dependencies mod_spox
+
+Requirements include:
+    * sequel
+    * fastthread
+    * termios
+    * Ruby >= 1.8.4

data/README

@@ -0,0 +1,33 @@
+mod_spox
+    http://modspox.rubyforge.org
+    Author: spox
+    
+== Description
+
+A Ruby IRC bot
+
+== Usage
+
+Configuration:
+
+mod_spox --config
+
+Running:
+
+mod_spox
+
+== Requirements
+
+ * fastthread
+ * sequel
+ * termios
+ 
+== Install
+
+gem install --include-dependencies mod_spox
+
+== License
+
+mod_spox is licensed under the GPLv3
+
+Copyright (c) 2008 spox <spox@modspox.com>

data/bin/mod_spox

@@ -0,0 +1,60 @@
+#!/usr/bin/env ruby
+
+## include our needed libraries ##
+
+['rubygems', 'sequel', 'fastthread',
+'thread', 'etc', 'getoptlong'].each{|file| 
+    begin
+        require file
+    rescue Object => boom
+        puts "ERROR: Failed to load required library: #{file}"
+        exit 1
+    end
+}
+
+$BOTVERSION='0.0.1'
+$VERBOSITY = 0
+
+begin
+    require 'mod_spox/Loader'
+rescue
+    p 'ERROR: Failed to load mod_spox'
+    exit 1
+end
+include ModSpox
+
+opts = GetoptLong.new(
+    ['--config', '-c', GetoptLong::NO_ARGUMENT],
+    ['--debug', '-d', GetoptLong::OPTIONAL_ARGUMENT],
+    ['--version', '-v', GetoptLong::NO_ARGUMENT],
+    ['--help', '-h', GetoptLong::NO_ARGUMENT]
+)
+verbose = 0
+opts.each do |opt, arg|
+    case opt
+        when '--help'
+            p 'Usage: mod_spox [opts]'
+            p '--config -c:     starts configuration wizard'
+            p '--debug -d:      turns on debugging (include number >0 for more info)'
+            p '--version -V:    output bot version information'
+            p '--help -h:       print this help message'
+            exit
+        when '--version'
+            p "mod_spox IRC bot version: #{$BOTVERSION}"
+            p 'http://dev.modspox.com'
+            exit
+        when '--debug'
+            if(arg && arg =~ /^[0-9]+/)
+                $VERBOSITY = arg.to_i
+            end
+        when '--config'
+            require 'mod_spox/ConfigurationWizard'
+            wizard = ConfigurationWizard.new
+            wizard.run
+            exit
+    end
+end
+
+initialize_bot
+bot = Bot.new
+bot.run

data/data/mod_spox/extras/Tester.rb

@@ -0,0 +1,14 @@
+class Tester < Plugin
+
+    def initialize(pipeline)
+        super(pipeline)
+        Models::Signature.find_or_create(:signature => 'tester', :plugin => name, :method => 'test',
+            :description => 'List all available plugins')
+        Models::Group.find_or_create(:name => 'testgroup')
+        Models::Group.find_or_create(:name => 'anonymous')
+    end
+    
+    def test(message, params)
+        @pipeline << Messages::Outgoing::Privmsg.new(message.source.nick, 'This is a test')
+    end
+end

data/data/mod_spox/plugins/Authenticator.rb

@@ -0,0 +1,245 @@
+class Authenticator < ModSpox::Plugin
+    def initialize(pipeline)
+        super(pipeline)
+        group = Models::Group.filter(:name => 'admin').first
+        Models::Signature.find_or_create(:signature => 'auth (\S+)', :plugin => name, :method => 'authenticate', 
+            :description => 'Authenticate with bot using a password').params = [:password]
+        Models::Signature.find_or_create(:signature => 'ident', :plugin => name, :method => 'send_whois',
+            :description => 'Instructs the bot to check your NickServ status')
+        Models::Signature.find_or_create(:signature => 'auth mask add (\S+) (\S+)', :plugin => name, :method => 'add_mask',
+            :group_id => group.pk, :description => 'Add authentication mask and set initial group').params = [:mask, :group]
+        Models::Signature.find_or_create(:signature => 'auth mask set (\d+) (.+)', :plugin => name, :method => 'set_mask_groups',
+            :group_id => group.pk, :description => 'Set groups for the given mask').params = [:id, :group_ids]
+        Models::Signature.find_or_create(:signature => 'auth mask unset (\d+) (.+)', :plugin => name, :method => 'del_mask_groups',
+            :group_id => group.pk, :description => 'Remove groups for the given mask').params = [:id, :groups]
+        Models::Signature.find_or_create(:signature => 'auth mask remove (\d+)', :plugin => name, :method => 'remove_mask',
+            :group_id => group.pk, :description => 'Remove authentication mask').params = [:id]
+        Models::Signature.find_or_create(:signature => 'auth mask list', :plugin => name, :method => 'list_mask',
+            :group_id => group.pk, :description => 'List all available authentication masks')
+        Models::Signature.find_or_create(:signature => 'auth nick ident (\S+) (true|false)', :plugin => name, :method => 'nick_ident',
+            :group_id => group.pk, :description => 'Allow authentication to nicks identified to NickServ').params = [:nick, :ident]
+        Models::Signature.find_or_create(:signature => 'auth nick password (\S+) (\S+)', :plugin => name, :method => 'nick_pass', 
+            :group_id => group.pk, :description => 'Set authentication password for nick').params = [:nick, :password]
+        Models::Signature.find_or_create(:signature => 'auth nick clear password (\S+)', :plugin => name, :method => 'clear_pass',
+            :group_id => group.pk, :description => 'Clear nicks authentication password').params = [:nick]
+        Models::Signature.find_or_create(:signature => 'auth nick info (\S+)', :plugin => name, :method => 'nick_info', 
+            :group_id => group.pk, :description => 'Return authentication information about given nick').params = [:nick]
+        Models::Signature.find_or_create(:signature => 'auth nick set (\S+) (\S+)', :plugin => name, :method => 'set_nick', 
+            :group_id => group.pk, :description => 'Set the group for a given nick').params = [:nick, :group]
+        Models::Signature.find_or_create(:signature => 'auth nick unset (\S+) (\S+)', :plugin => name, :method => 'unset_nick',
+            :group_id => group.pk, :description => 'Unset the group for a given nick').params = [:nick, :group]
+        Models::Signature.find_or_create(:signature => 'auth group list', :plugin => name, :method => 'list_groups',
+            :group_id => group.pk, :description => 'List available authentication groups')
+        Models::Signature.find_or_create(:signature => 'auth group info (\S+)', :plugin => name, :method => 'group_info',
+            :group_id => group.pk, :description => 'List members of given group').params = [:group]
+    end
+    
+    # message:: ModSpox::Messages::Incoming::Privmsg
+    # params:: Signature parameters
+    # Authenticate a user by password
+    def authenticate(message, params)
+        if(message.is_private? && message.source.auth.check_password(params[:password]))
+            @pipeline << Messages::Outgoing::Privmsg.new(message.source.nick, 'Authentication was successful')
+        else
+            @pipeline << Messages::Outgoing::Privmsg.new(message.source.nick, 'Authentication failed')
+        end            
+    end
+    
+    # message:: ModSpox::Messages::Incoming::Privmsg
+    # params:: Signature parameters
+    # Add an authentication mask
+    def add_mask(message, params)
+        begin
+            group = Models::Group.filter(:name => params[:group]).first
+            raise Exception.new("Failed to find group") unless group
+            a = Models::Auth.find_or_create(:mask => Regexp.new(params[:mask]).source)
+            a.group = group
+            a.save
+            @pipeline << Messages::Outgoing::Privmsg.new(message.source.nick, 'Mask has been successfully added to authentication table')
+        rescue Object => boom
+            @pipeline << Messages::Outgoing::Privmsg.new(message.source.nick, "Authentication failed to add mask. Reason: #{boom}")
+        end
+    end
+    
+    # message:: ModSpox::Messages::Incoming::Privmsg
+    # params:: Signature parameters
+    # Add an authentication group to a given mask
+    def set_mask_groups(message, params)
+        auth = Models::Auth[params[:id]]
+        if(auth)
+            params[:groups].split(/\s/).each do |g|
+                group = Models::Group.filter(:name => g).first
+                auth.group = group if group
+            end
+            @pipeline << Messages::Outgoing::Privmsg.new(message.source.nick, "Mask groups have been updated")
+        else
+            @pipeline << Messages::Outgoing::Privmsg.new(message.source.nick, "Failed to find mask with ID: #{params[:id]}")
+        end
+    end
+    
+    # message:: ModSpox::Messages::Incoming::Privmsg
+    # params:: Signature parameters
+    # Remove an authentication group from a given mask
+    def del_mask_groups(message, params)
+        auth = Models::Auth[params[:id]]
+        if(auth)
+            params[:groups].split(/\s/).each do |g|
+                group = Models::Group.filter(:name => g).first
+                auth.remove_group(group) if group
+            end
+            @pipeline << Messages::Outgoing::Privmsg.new(message.source.nick, "Mask groups have been updated")
+        else
+            @pipeline << Messages::Outgoing::Privmsg.new(message.source.nick, "Failed to find mask with ID: #{params[:id]}")
+        end
+    end
+    
+    # message:: ModSpox::Messages::Incoming::Privmsg
+    # params:: Signature parameters
+    # List all authentication masks
+    def list_mask(message, params)
+        @pipeline << Messages::Outgoing::Privmsg.new(message.source.nick, 'Authentication Mask Listing:')
+        auths = []
+        Models::Auth.where('mask is not null').each{|a| auths << a}
+        auths.each do |a|
+            groups = []
+            a.groups.each{|g| groups << g.name}
+            @pipeline << Messages::Outgoing::Privmsg.new(message.source.nick, "\2ID:\2 #{a.pk}: \2mask:\2 #{a.mask} \2groups:\2 #{groups.join(', ')}")
+        end
+    end
+    
+    # message:: ModSpox::Messages::Incoming::Privmsg
+    # params:: Signature parameters
+    # Remove given authentication mask
+    def remove_mask(message, params)
+        auth = Models::Auth[params[:id].to_i]
+        if(auth)
+            auth.destroy
+            @pipeline << Messages::Outgoing::Privmsg.new(message.source.nick, "Authentication mask with ID #{params[:id]} was deleted")
+        else
+            @pipeline << Messages::Outgoing::Privmsg.new(message.source.nick, "\2Failed\2: Could not find an authentication mask with ID: #{params[:id]}")
+        end
+    end
+    
+    # message:: ModSpox::Messages::Incoming::Privmsg
+    # params:: Signature parameters
+    # Set nick authentication by NickServ
+    def nick_ident(message, params)
+        nick = Models::Nick.find_or_create(:nick => params[:nick])
+        if(params[:ident] == 'true')
+            nick.auth.set(:services => true)
+        else
+            nick.auth.set(:services => false)
+        end
+        @pipeline << Messages::Outgoing::Privmsg.new(message.source.nick, "Nick #{params[:nick]} has been updated. Services for authentication has been set to #{params[:ident]}")
+    end
+    
+    
+    # message:: ModSpox::Messages::Incoming::Privmsg
+    # params:: Signature parameters
+    # Set password for given nick
+    def nick_pass(message, params)
+        nick = Models::Nick.find_or_create(:nick => params[:nick])
+        nick.auth.password = params[:password]
+        @pipeline << Messages::Outgoing::Privmsg.new(message.source.nick, "Nick #{params[:nick]} has been updated. Password has been set.")
+    end
+    
+    # message:: ModSpox::Messages::Incoming::Privmsg
+    # params:: Signature parameters
+    # Clear password field for given nick
+    def nick_clear(message, params)
+        nick = Models::Nick.find_or_create(:nick => params[:nick])
+        nick.auth.password = nil
+        @pipeline << Messages::Outgoing::Privmsg.new(message.source.nick, "Nick #{params[:nick]} has been updated. Password has been set.")
+    end
+    
+    # message:: ModSpox::Messages::Incoming::Privmsg
+    # params:: Signature parameters
+    # Display info for given nick
+    def nick_info(message, params)
+        nick = Models::Nick.filter(:nick => params[:nick]).first
+        if(nick)
+            info = []
+            info << "\2INFO [#{nick.nick}]:\2"
+            groups = []
+            nick.auth_groups.each{|g| groups << g.name}
+            info << "Groups: #{groups.join(', ')}."
+            nick.auth.password.nil? ? info << 'Password has not been set.' : info << 'Password has been set.'
+            nick.auth.services ? info << 'Nickserv ident is enabled.' : info << 'Nickserv ident is disabled.'
+            @pipeline << Messages::Outgoing::Privmsg.new(message.source.nick, "#{info.join(' ')}")
+        else
+            @pipeline << Messages::Outgoing::Privmsg.new(message.source.nick, "I have no record of nick: #{params[:nick]}")
+        end
+    end
+    
+    # message:: ModSpox::Messages::Incoming::Privmsg
+    # params:: Signature parameters
+    # Add given nick to authentication group
+    def set_nick(message, params)
+        group = Models::Group.filter(:name => params[:group]).first
+        nick = Models::Nick.find_or_create(:nick => params[:nick])
+        if(group)
+            nick.group = group
+            @pipeline << Messages::Outgoing::Privmsg.new(message.source.nick, "Nick #{params[:nick]} has been added to the group: #{params[:group]}")
+        else
+            @pipeline << Messages::Outgoing::Privmsg.new(message.source.nick, "Failed to find authentication group: #{params[:group]}")
+
+        end
+    end
+    
+    # message:: ModSpox::Messages::Incoming::Privmsg
+    # params:: Signature parameters
+    # Remove given nick from authenticationg group
+    def unset_nick(message, params)
+        group = Models::Group.filter(:name => params[:group]).first
+        nick = Models::Nick.filter(:nick => params[:nick]).first
+        if(group && nick)
+            nick.remove_group(group)
+            @pipeline << Messages::Outgoing::Privmsg.new(message.source.nick, "Removed #{params[:nick]} from the #{params[:group]} authentication group.")
+        else
+            @pipeline << Messages::Outgoing::Privmsg.new(message.source.nick, "Failed to find nick: #{params[:nick]}") unless nick
+            @pipeline << Messages::Outgoing::Privmsg.new(message.source.nick, "Failed to find group: #{params[:group]}") unless group
+        end
+    end
+    
+    # message:: ModSpox::Messages::Incoming::Privmsg
+    # params:: Signature parameters
+    # Send WHOIS for nick
+    def send_whois(message, params)
+        @pipeline << Messages::Outgoing::Whois.new(message.source.nick)
+    end
+    
+    # message:: ModSpox::Messages::Incoming::Privmsg
+    # params:: Signature parameters
+    # Display all available authentication groups
+    def list_groups(message, params)
+        groups = []
+        Models::Group.all.each{|g| groups << g.name}
+        @pipeline << Messages::Outgoing::Privmsg.new(message.source.nick, "\2Groups:\2 #{groups.join(', ')}")
+    end
+    
+    # message:: ModSpox::Messages::Incoming::Privmsg
+    # params:: Signature parameters
+    # Display info about given group
+    def group_info(message, params)
+        group = Models::Group.filter(:name => params[:group]).first
+        if(group)
+            nicks = []
+            masks = []
+            Models::AuthGroup.filter(:group_id => group.pk).each do |ag|
+                if(ag.auth.nick)
+                    nicks << ag.auth.nick.nick
+                end
+                if(ag.auth.mask)
+                    masks << ag.auth.mask
+                end
+            end
+            output = []
+            output << "\2Nicks:\2 #{nicks.join(', ')}" if nicks.size > 0
+            output << "\2Masks:\2 #{masks.join(' | ')}" if masks.size > 0
+            @pipeline << Messages::Outgoing::Privmsg.new(message.source.nick, "\2Group #{params[:group]}:\2 #{output.join('. ')}")
+        else
+            @pipeline << Messages::Outgoing::Privmsg.new(message.source.nick, "Failed to find group named: #{params[:group]}")
+        end
+    end
+
+end

data/data/mod_spox/plugins/BotNick.rb

@@ -0,0 +1,18 @@
+class BotNick < ModSpox::Plugin
+
+    def initialize(pipeline)
+        super(pipeline)
+        @pipeline.hook(self, :shutdown, :Internal_Shutdown)
+    end
+    
+    def shutdown(message)
+        clear_nicks
+    end
+    
+    private
+    
+    def clear_nicks
+        Models::Nick.filter(:botnick => true).each{|nick| nick.botnick = false; nick.save}
+    end
+
+end

data/data/mod_spox/plugins/Initializer.rb

@@ -0,0 +1,41 @@
+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)
+        @servers = Array.new
+    end
+    
+    # message:: ModSpox::Messages::Internal::BotInitialized
+    # Instructs bot to connect to server
+    def connect(message)
+        populate_servers if @servers.empty?
+        s = @servers.pop
+        @pipeline << Messages::Internal::EstablishConnection.new(s.host, s.port)
+    end
+    
+    # message:: ModSpox::Messages::Internal::Connected
+    # Send bot information to server when connection is established
+    def send_info(message)
+        @pipeline << Messages::Outgoing::Nick.new(Models::Config[:bot_nick])
+        @pipeline << Messages::Outgoing::User.new(Models::Config[:bot_username], Models::Config[:bot_realname], 8)    
+    end
+    
+    # message:: ModSpox::Messages::Internal::ConnectionFailed or ModSpox::Messages::Internal::Disconnected
+    # Reconnect to server on disconnection or connection failure
+    def reconnect(message)
+        @pipeline << Messages::Internal::TimerAdd.new(self, Models::Config[:reconnect_wait].to_i, nil, true){ connect(nil) }
+    end
+    
+    private
+    
+    def populate_servers
+        Models::Server.order(:priority.DESC).each{|s|
+            @servers << s
+        }
+    end
+
+end

data/data/mod_spox/plugins/Joiner.rb

@@ -0,0 +1,13 @@
+class Joiner < ModSpox::Plugin
+    def initialize(pipeline)
+        super(pipeline)
+        admin = Models::Group.filter(:name => 'admin').first
+        Models::Signature.find_or_create(:signature => 'join (\S+)', :plugin => name, :method => 'join', :group_id => admin.pk).params = [:channel]
+    end
+    
+    # message:: ModSpox::Messages::Incoming::Privmsg
+    # Join the given channel
+    def join(message, params)
+        @pipeline << Messages::Outgoing::Join.new(params[:channel])
+    end
+end

data/data/mod_spox/plugins/Parter.rb

@@ -0,0 +1,22 @@
+class Parter < ModSpox::Plugin
+
+    def initialize(pipeline)
+        super(pipeline)
+        admin = Models::Group.filter(:name => 'admin').first
+        Models::Signature.find_or_create(:signature => 'part (\S+)', :plugin => name, :method => 'part', :group_id => admin.pk).params = [:channel]
+        Models::Signature.find_or_create(:signature => 'part', :plugin => name, :method => 'direct_part', :group_id => admin.pk)
+    end
+    
+    # message:: ModSpox::Messages::Incoming::Privmsg
+    # Bot will part from given channel
+    def part(message, params)
+        @pipeline << Messages::Outgoing::Part.new(params[:channel])
+    end
+    
+    # message:: ModSpox::Messages::Incoming::Privmsg
+    # Bot will part from channel command is issued within
+    def direct_part(message, params)
+        @pipeline << Messages::Outgoing::Part.new(message.target)
+    end
+
+end

data/data/mod_spox/plugins/PluginLoader.rb

@@ -0,0 +1,136 @@
+class PluginLoader < ModSpox::Plugin
+
+    def initialize(pipeline)
+        super(pipeline)
+        admin = Models::Group.filter(:name => 'admin').first
+        Models::Signature.find_or_create(:signature => 'plugins available', :plugin => name, :method => 'available_plugins',
+            :group_id => admin.pk, :description => 'List all available plugins')
+        Models::Signature.find_or_create(:signature => 'plugins loaded', :plugin => name, :method => 'loaded_plugins',
+            :group_id => admin.pk, :description => 'List all plugins currently loaded')
+        Models::Signature.find_or_create(:signature => 'plugins load (\S+)', :plugin => name, :method => 'load_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')
+        @pipeline.hook(self, :get_module, :Internal_PluginModuleResponse)
+        @plugins_mod = nil
+    end
+    
+    # message:: ModSpox::Messages::Incoming::Privmsg
+    # params:: matching signature params
+    # Output currently available plugins for loading
+    def available_plugins(message, params)
+        @pipeline << Messages::Outgoing::Privmsg.new(message.source.nick, "\2Currently available plugins:\2")
+        find_plugins.each_pair do | plugin, path |
+            @pipeline << Messages::Outgoing::Privmsg.new(message.source.nick, "\2#{plugin}:\2 #{path}")
+        end
+    end
+    
+    # message:: ModSpox::Messages::Incoming::Privmsg
+    # params:: matching signature params
+    # Output currently loaded plugins
+    def loaded_plugins(message, params)
+        @pipeline << Messages::Outgoing::Privmsg.new(message.source.nick, "\2Currently loaded plugins:\2 #{plugin_list.join(', ')}")
+    end
+    # message:: ModSpox::Messages::Incoming::Privmsg
+    # params:: matching signature params
+    # Load the given plugin
+    def load_plugin(message, params)
+        plugins = find_plugins
+        if(plugins.has_key?(params[:plugin]))
+            name = plugin_discovery(BotConfig[:pluginextraspath]).keys.include?(params[:plugin]) ? nil : "#{params[:plugin]}.rb"
+            @pipeline << Messages::Internal::PluginLoadRequest.new(self, plugins[params[:plugin]], name)
+            @pipeline << Messages::Outgoing::Privmsg.new(message.source.nick, "Okay")
+        else
+            @pipeline << Messages::Outgoing::Privmsg.new(message.source.nick, "Failed to find plugin: #{params[:plugin]}")
+        end
+    end
+    
+    # message:: ModSpox::Messages::Incoming::Privmsg
+    # params:: matching signature params
+    # Unload the given plugin
+    def unload_plugin(message, params)
+        path = loaded_path(params[:plugin])
+        unless(path.nil?)
+            name = plugin_discovery(BotConfig[:pluginextraspath]).keys.include?(params[:plugin]) ? nil : ".#{params[:plugin]}.rb"
+            @pipeline << Messages::Internal::PluginUnloadRequest.new(self, path, name)
+            @pipeline << Messages::Outgoing::Privmsg.new(message.source.nick, "Okay")
+        else
+            @pipeline << Messages::Outgoing::Privmsg.new(message.source.nick, "Failed to find loaded plugin named: #{params[:plugin]}")
+        end
+    end
+    
+    # message:: ModSpox::Messages::Incoming::Privmsg
+    # params:: matching signature params
+    # Reloads plugins    
+    def reload_plugin(message, params)
+        @pipeline << Messages::Internal::PluginReload.new
+        @pipeline << Messages::Outgoing::Privmsg.new(message.source.nick, 'Okay')
+    end
+    
+    # message:: ModSpox::Messages::Internal::PluginModuleResponse
+    # Receives the plugins module
+    def get_module(message)
+        @plugins_mod = message.module
+    end
+
+    private
+    
+    # Returns the list of currently loaded plugins
+    def plugin_list
+        plug = []
+        @pipeline << Messages::Internal::PluginModuleRequest.new(self)
+        sleep(0.01) while @plugins_mod.nil?
+        @plugins_mod.constants.sort.each do |const|
+            klass = @plugins_mod.const_get(const)
+            if(klass < Plugin)
+                plug << const
+            end
+        end
+        @plugins_mod = nil
+        return plug
+    end
+    
+    # Finds available plugins for loading
+    def find_plugins
+        users = plugin_discovery(BotConfig[:userpluginpath])
+        extras = plugin_discovery(BotConfig[:pluginextraspath])
+        plugins = users.merge(extras)
+        plugin_list.each do |name|
+            plugins.delete(name) if plugins.has_key?(name)
+        end
+        return plugins
+    end
+    
+    # path:: path to directory
+    # Discovers any plugins within the files in the given path
+    def plugin_discovery(path)
+        plugins = Hash.new
+        Dir.new(path).each do |file|
+            next unless file =~ /\.rb$/
+            sandbox = Module.new
+            sandbox.module_eval(IO.readlines("#{path}/#{file}").join("\n"))
+            sandbox.constants.each do |const|
+                klass = sandbox.const_get(const)
+                plugins[const] = "#{path}/#{file}" if klass < Plugin
+            end
+        end
+        return plugins
+    end
+    
+    # name:: plugin name
+    # Returns the file path the given plugin originated from
+    def loaded_path(name)
+        Dir.new(BotConfig[:userpluginpath]).each do |file|
+            next unless file =~ /\.rb$/
+            sandbox = Module.new
+            sandbox.module_eval(IO.readlines("#{BotConfig[:userpluginpath]}/#{file}").join("\n"))
+            sandbox.constants.each do |const|
+                return "#{BotConfig[:userpluginpath]}/#{file}" if const == name
+            end
+        end
+        return nil
+    end
+
+end

data/data/mod_spox/plugins/Ponger.rb

@@ -0,0 +1,14 @@
+class Ponger < ModSpox::Plugin
+
+    def initialize(pipeline)
+        super(pipeline)
+        @pipeline.hook(self, :ping, :Incoming_Ping)
+    end
+    
+    # message:: ModSpox::Messages::Incoming::Ping
+    # Sends responding pongs to server pings
+    def ping(message)
+        @pipeline << Messages::Outgoing::Pong.new(message.server, message.string)
+    end
+
+end

data/data/mod_spox/plugins/Quitter.rb

@@ -0,0 +1,14 @@
+class Quitter < ModSpox::Plugin
+
+    def initialize(pipeline)
+        super(pipeline)
+        Models::Signature.find_or_create(:signature => 'quit\s(.*)', :plugin => name, :method => 'quit',
+            :group_id => Models::Group.filter(:name => 'admin').first.pk).params = [:channel, :message]
+    end
+
+    # message:: ModSpox::Messages::Incoming::Privmsg
+    # Instructs the bot to shutdown    
+    def quit(message, params)
+        @pipeline << Messages::Internal::HaltBot.new
+    end
+end