mod_spox 0.0.1 → 0.0.2

data/data/mod_spox/plugins/Banner.rb

@@ -0,0 +1,392 @@
+class Banner < ModSpox::Plugin
+
+    include Models
+    include Messages::Outgoing
+    
+    def initialize(pipeline)
+        super(pipeline)
+        admin = Group.find_or_create(:name => 'banner')
+        Signature.find_or_create(:signature => 'ban (\S+)', :plugin => name, :method => 'default_ban', :group_id => admin.pk,
+            :description => 'Kickban given nick from current channel').params = [:nick]
+        Signature.find_or_create(:signature => 'ban (\S+) (\S+)', :plugin => name, :method => 'channel_ban', :group_id => admin.pk,
+            :description => 'Kickban given nick from given channel').params = [:nick, :channel]
+        Signature.find_or_create(:signature => 'ban (\S+) (\S+) (\d+) ?(.+)?', :plugin => name, :method => 'full_ban', :group_id => admin.pk,
+            :description => 'Kickban given nick from given channel for given number of seconds').params = [:nick, :channel, :time, :message]
+        Signature.find_or_create(:signature => 'banmask (\S+) (\S+) (\d+) ?(.+)?', :plugin => name, :method => 'message_mask_ban', :group_id => admin.pk,
+            :description => 'Kickban given mask from given channel for given number of seconds providing an optional message'
+            ).params = [:mask, :message, :time, :channel]
+        Signature.find_or_create(:signature => 'banmask list', :plugin => name, :method => 'mask_list', :group_id => admin.pk,
+            :description => 'List all currently active banmasks')
+        Signature.find_or_create(:signature => 'banmask remove (\d+)', :plugin => name, :method => 'mask_remove', :group_id => admin.pk,
+            :description => 'Remove a currently enabled ban mask').params = [:id]
+        Signature.find_or_create(:signature => 'banlist', :plugin => name, :method => 'ban_list', :group_id => admin.pk,
+            :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]
+        @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?
+        @actions = []
+        @up_sync = Mutex.new
+        @timer_sync = Mutex.new
+        updater
+    end
+    
+    def destroy
+        do_update
+    end
+    
+    # message:: ModSpox::Messages::Incoming::Privmsg
+    # params:: parameters
+    # Perform a simple ban with default values
+    def default_ban(message, params)
+        params[:time] = 86400
+        params[:channel] = message.target.name
+        full_ban(message, params)
+    end
+    
+    # message:: ModSpox::Messages::Incoming::Privmsg
+    # params:: parameters
+    # Ban given nick in given channel
+    def channel_ban(message, params)
+        params[:time] = 86400
+        full_ban(message, params)
+    end
+    
+    # message:: ModSpox::Messages::Incoming::Privmsg
+    # 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
+        channel = Channel.filter(:name => params[:channel]).first
+        if(!me.is_op?(message.target))
+            reply(message.replyto, "Error: I'm not a channel operator")
+        elsif(!nick)
+            reply(message.replyto, "#{message.source.nick}: Failed to find nick #{params[:nick]}")
+        elsif(!channel)
+            reply(message.replyto, "#{message.source.nick}: Failed to find channel #{params[:channel]}")
+        else
+            ban(nick, channel, params[:time], params[:message])
+        end
+    end
+    
+    # nick:: ModSpox::Models::Nick to ban
+    # channel:: ModSpox::Models::Channel to ban nick from
+    # time:: number of seconds ban should last
+    # reason:: reason for the ban
+    # invite:: invite nick back to channel when ban expires
+    # show_time:: show ban time in kick message
+    def ban(nick, channel, time, reason, invite=false, show_time=true)
+        raise Exceptions::InvalidType.new("Nick given is not a nick model") unless nick.is_a?(Models::Nick)
+        raise Exceptions::InvalidType.new("Channel given is not a channel model") unless channel.is_a?(Models::Channel)
+        if(!me.is_op?(channel))
+            raise Exceptions::NotOperator.new("I am not an operator in #{channel.name}")
+        elsif(!nick.channels.include?(channel))
+            raise Exceptions::NotInChannel.new("#{nick.nick} is not in channel: #{channel.name}")
+        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,
+                :invite => invite, :channel_id => channel.pk, :mask => mask).save
+            message = reason ? reason : 'no soup for you!'
+            message = "#{message} (Duration: #{Helpers.format_seconds(time.to_i)})" if show_time
+            @pipeline << ChannelMode.new(channel, '+b', mask)
+            @pipeline << Kick.new(nick, channel, message)
+            updater
+        end
+    end
+    
+    # mask:: mask to match against source (Regexp)
+    # channel:: ModSpox::Models::Channel to ban from
+    # message:: kick message
+    # time:: time ban on mask should stay in place
+    # Bans all users who's source matches the given mask
+    def mask_ban(mask, channel, message, time)
+        raise NotInChannel.new("I am not in channel: #{channel.name}") unless me.channels.include?(channel)
+        BanMask.new(:mask => mask, :channel_id => channel.pk, :message => message, :bantime => time.to_i, :stamp => Object::Time.now).save
+        check_masks
+        updater
+    end
+    
+    # message:: ModSpox::Messages::Incoming::Privmsg
+    # params:: parameters
+    # Set a ban on any nick with a source match given regex
+    def message_mask_ban(message, params)
+        channel = params[:channel] ? Channel.filter(:name => params[:channel]).first : message.target
+        if(channel)
+            begin
+                mask_ban(params[:mask], channel, params[:message], params[:time])
+                reply(message.replyto, "Okay")
+            rescue Object => boom
+                reply(message.replyto, "Error: Failed to ban mask. Reason: #{boom}")
+                Logger.log("ERROR: #{boom} #{boom.backtrace.join("\n")}")
+            end
+        else
+            reply(message.replyto, "Error: No record of channel: #{params[:channel]}")
+        end 
+    end
+    
+    # message:: ModSpox::Messages::Incoming::Privmsg
+    # params:: parameters
+    # List all ban masks
+    def mask_list(message, params)
+        updater
+        if(BanMask.all.size > 0)
+            reply(message.replyto, "Masks currently banned:")
+            BanMask.all.each do |mask|
+                reply(message.replyto, "\2ID:\2 #{mask.pk} \2Mask:\2 #{mask.mask} \2Time:\2 #{Helpers.format_seconds(mask.bantime.to_i)} \2Channel:\2 #{mask.channel.name}")
+            end
+        else
+            reply(message.replyto, "No ban masks currently enabled")
+        end
+    end
+
+    # message:: ModSpox::Messages::Incoming::Privmsg
+    # params:: parameters
+    # Remove ban mask with given ID
+    def mask_remove(message, params)
+        mask = BanMask[params[:id].to_i]
+        if(mask)
+            mask.destroy
+            updater
+            reply(message.replyto, 'Okay')
+        else
+            reply(message.replyto, "\2Error:\2 Failed to find ban mask with ID: #{params[:id]}")
+        end
+    end
+    
+    # message:: ModSpox::Messages::Incoming::Privmsg
+    # params:: parameters
+    # List all currently active bans originating from the bot    
+    def ban_list(message, params)
+        updater
+        set = BanRecord.filter(:removed => false)
+        if(set.size > 0)
+            reply(message.replyto, "Currently active bans:")
+            set.each do |record|
+                reply(message.replyto, "\2ID:\2 #{record.pk} \2Nick:\2 #{record.nick.nick} \2Channel:\2 #{record.channel.name} \2Initial time:\2 #{Helpers.format_seconds(record.bantime.to_i)} \2Time remaining:\2 #{Helpers.format_seconds(record.remaining.to_i)}")
+            end
+        else
+            reply(message.replyto, "No bans currently active")
+        end
+    end
+    
+    # message:: ModSpox::Messages::Incoming::Privmsg
+    # params:: parameters
+    # Remove given ban
+    def ban_remove(message, params)
+        record = BanRecord[params[:id].to_i]
+        if(record)
+            record.set(:remaining => 0)
+            updater
+            reply(message.replyto, 'Okay')
+        else
+            reply(message.replyto, "\2Error:\2 Failed to find ban record with ID: #{params[:id]}")
+        end 
+    end
+    
+    # Check all enabled ban masks and ban any matches found
+    def check_masks
+        masks = BanMask.map_masks
+        masks.keys.each do |channel_name|
+            channel = Channel.filter(:name => channel_name).first
+            if(me.is_op?(channel))
+                channel.nicks.each do |nick|
+                    match = nil
+                    masks[channel.name].each do |mask|
+                        if(nick.source =~ /#{mask[:mask]}/)
+                            match = mask if match.nil? || mask[:bantime].to_i > match[:bantime].to_i
+                        end
+                    end
+                    unless match.nil?
+                        begin
+                            ban(nick, channel, match[:bantime], match[:message]) 
+                        rescue Object => boom
+                            Logger.log("Mask based ban failed. Reason: #{boom}")
+                        end
+                    end
+                end
+            else
+                Logger.log("Ban masks will not be processed due to lack of operator status")
+            end
+        end
+    end
+    
+    # nick:: ModSpox::Models::Nick
+    # channel:: ModSpox::Models::Channel
+    # Check if the nick in the channel matches any ban masks
+    def mask_check(nick, channel)
+        return unless me.is_op?(channel)
+        updater
+        match = nil
+        BanMask.filter(:channel_id => channel.pk).each do |bm|
+            if(nick.source =~ /#{bm.mask}/)
+                match = bm if match.nil? ||  match.bantime < bm.bantime
+            end
+        end
+        unless(match.nil?)
+            begin
+                ban(nick, channel, match.bantime, match.message)
+            rescue Object => boom
+                Logger.log("Mask based ban failed. Reason: #{boom}")
+            end
+        end
+    end
+    
+    # message:: ModSpox::Messages::Incoming::Mode
+    # Check for mode changes. Remove pending ban removals if
+    # done manually
+    def mode_check(message)
+        if(message.target.is_a?(String) && message.source != me)
+            if(message.mode == '-b')
+                update = false
+                BanRecord.filter(:mask => message.target, :channel_id => message.channel.pk).each do |match|
+                    match.set(:remaining => 0)
+                    match.set(:removed => true)
+                    update = true
+                end
+                updater if update
+            end
+        end
+        if(message.target == me && message.mode == '+o')
+            check_masks
+            updater
+        end
+    end
+    
+    # message:: ModSpox::Messages::Incoming::Join
+    # Check is nick is banned
+    def join_check(message)
+        mask_check(message.nick, message.channel)
+    end
+    
+    # message:: ModSpox::Messages::Incoming::Who
+    # Check if we updated any addresses
+    def who_check(message)
+        check_masks
+    end
+    
+    # message:: ModSpox::Messages::Internal::TimerResponse
+    # Store any timer actions we have registered
+    def get_action(message)
+        if(message.action_added? && message.origin == self)
+            @actions << message.action
+        elsif(message.action_removed? && @actions.include?(message.action))
+            @actions.delete(message.action)
+        end
+    end
+    
+    # Update all BanMask and BanRecords
+    def updater
+        @up_sync.synchronize do
+            unless(@actions.empty?)
+                @actions.each{|a|@pipeline << Messages::Internal::TimerRemove.new(a)}
+                Logger.log("Waiting for actions to become empty")
+                sleep(0.01) until @actions.empty?
+                Logger.log("Actions has now become empty")
+            end
+            do_update
+        end
+    end
+    
+    # Completes update
+    def do_update
+        @timer_sync.synchronize do
+            begin
+                time = @sleep.nil? ? 0 : (Object::Time.now - @sleep).to_i
+                if(time > 0)
+                    BanRecord.filter{:remaining > 0}.update("remaining = remaining - #{time}")
+                    BanMask.filter{:bantime > 0}.update("bantime = bantime - #{time}")
+                end
+                BanRecord.filter{:remaining <= 0 && :removed == false}.each do |record|
+                    if(me.is_op?(record.channel))
+                        @pipeline << ChannelMode.new(record.channel, '-b', record.mask)
+                        record.set(:removed => true)
+                        @pipeline << Invite.new(record.nick, record.channel) if record.invite
+                    end
+                end
+                BanMask.filter{:bantime < 1}.destroy
+                next_ban_record = BanRecord.filter{:remaining > 0}.order(:remaining.ASC).first
+                next_mask_record = BanMask.filter{:bantime > 0}.order(:bantime.ASC).first
+                if(next_ban_record && next_mask_record)
+                    time = next_ban_record.bantime < next_mask_record.bantime ? next_ban_record.bantime : next_mask_record.bantime
+                elsif(next_ban_record)
+                    time = next_ban_record.bantime
+                elsif(next_mask_record)
+                    time = next_mask_record.bantime
+                else
+                    time = nil
+                end
+                Logger.log("Time left to sleep is now: #{time}")
+                unless(time.nil?)
+                    @sleep = Object::Time.now
+                    @pipeline << Messages::Internal::TimerAdd.new(self, time, nil, true){ do_update }
+                else
+                    @sleep = nil
+                end
+            rescue Object => boom
+                Logger.log("Updating encountered an unexpected error: #{boom}")
+            end
+        end
+    end
+    
+    class BanRecord < Sequel::Model
+        set_schema do
+            primary_key :id
+            timestamp :stamp, :null => false
+            integer :bantime, :null => false, :default => 1
+            integer :remaining, :null => false, :default => 1
+            text :mask, :null => false
+            boolean :invite, :null => false, :default => false
+            boolean :removed, :null => false, :default => false
+            foreign_key :channel_id, :null => false, :table => :channels
+            foreign_key :nick_id, :null => false, :table => :nicks
+        end
+        
+        before_create do
+            set :stamp => Time.now
+        end
+        
+        def channel
+            ModSpox::Models::Channel[channel_id]
+        end
+        
+        def nick
+            ModSpox::Models::Nick[nick_id]
+        end
+    end
+    
+    class BanMask < Sequel::Model
+        set_schema do
+            primary_key :id
+            text :mask, :unique => true, :null => false
+            timestamp :stamp, :null => false
+            integer :bantime, :null => false, :default => 1
+            text :message
+            foreign_key :channel_id, :null => false, :table => :channels
+        end
+        
+        def channel
+            ModSpox::Models::Channel[channel_id]
+        end
+        
+        def self.map_masks
+            masks = {}
+            BanMask.all.each do |mask|
+                Logger.log("Processing mask for channel: #{mask.channel.name}")
+                masks[mask.channel.name] = [] unless masks.has_key?(mask.channel.name)
+                masks[mask.channel.name] << {:mask => mask.mask, :message => mask.message, :bantime => mask.bantime, :channel => mask.channel}
+            end
+            return masks
+        end
+    end
+    
+    class NotOperator < Exceptions::BotException
+    end
+    
+    class NotInChannel < Exceptions::BotException
+    end
+
+end

data/data/mod_spox/plugins/Joiner.rb

@@ -3,6 +3,7 @@ class Joiner < ModSpox::Plugin
         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]
+        @pipeline.hook(self, :send_who, :Incoming_Join)
     end
     
     # message:: ModSpox::Messages::Incoming::Privmsg
@@ -10,4 +11,10 @@ class Joiner < ModSpox::Plugin
     def join(message, params)
         @pipeline << Messages::Outgoing::Join.new(params[:channel])
     end
+    
+    # message:: ModSpox::Messages::Incoming::Join
+    # Send a WHO request for channel on join
+    def send_who(message)
+        @pipeline << ModSpox::Messages::Outgoing::Who.new(message.channel.name) if message.nick == me
+    end
 end

data/data/mod_spox/plugins/PluginLoader.rb

@@ -21,9 +21,9 @@ 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.source.nick, "\2Currently available plugins:\2")
+        @pipeline << Messages::Outgoing::Privmsg.new(message.replyto, "\2Currently available plugins:\2")
         find_plugins.each_pair do | plugin, path |
-            @pipeline << Messages::Outgoing::Privmsg.new(message.source.nick, "\2#{plugin}:\2 #{path}")
+            @pipeline << Messages::Outgoing::Privmsg.new(message.replyto, "\2#{plugin}:\2 #{path}")
         end
     end
     
@@ -31,7 +31,7 @@ class PluginLoader < ModSpox::Plugin
     # 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(', ')}")
+        @pipeline << Messages::Outgoing::Privmsg.new(message.replyto, "\2Currently loaded plugins:\2 #{plugin_list.join(', ')}")
     end
     # message:: ModSpox::Messages::Incoming::Privmsg
     # params:: matching signature params
@@ -41,9 +41,9 @@ class PluginLoader < ModSpox::Plugin
         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")
+            @pipeline << Messages::Outgoing::Privmsg.new(message.replyto, "Okay")
         else
-            @pipeline << Messages::Outgoing::Privmsg.new(message.source.nick, "Failed to find plugin: #{params[:plugin]}")
+            @pipeline << Messages::Outgoing::Privmsg.new(message.replyto, "Failed to find plugin: #{params[:plugin]}")
         end
     end
     
@@ -55,9 +55,9 @@ class PluginLoader < ModSpox::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")
+            @pipeline << Messages::Outgoing::Privmsg.new(message.replyto, "Okay")
         else
-            @pipeline << Messages::Outgoing::Privmsg.new(message.source.nick, "Failed to find loaded plugin named: #{params[:plugin]}")
+            @pipeline << Messages::Outgoing::Privmsg.new(message.replyto, "Failed to find loaded plugin named: #{params[:plugin]}")
         end
     end
     
@@ -66,7 +66,7 @@ class PluginLoader < ModSpox::Plugin
     # Reloads plugins    
     def reload_plugin(message, params)
         @pipeline << Messages::Internal::PluginReload.new
-        @pipeline << Messages::Outgoing::Privmsg.new(message.source.nick, 'Okay')
+        @pipeline << Messages::Outgoing::Privmsg.new(message.replyto, 'Okay')
     end
     
     # message:: ModSpox::Messages::Internal::PluginModuleResponse
@@ -108,12 +108,16 @@ class PluginLoader < ModSpox::Plugin
     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
+            begin
+                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
+            rescue Object => boom
+                Logger.log("Failed to parse file: #{path}/#{file}. Reason: #{boom}")
             end
         end
         return plugins

data/data/mod_spox/plugins/Triggers.rb

@@ -0,0 +1,80 @@
+class Triggers < ModSpox::Plugin
+
+include Messages::Outgoing
+
+    def initialize(pipeline)
+        super(pipeline)
+        admin = Models::Group.filter(:name => 'admin').first
+        Models::Signature.find_or_create(:signature => 'triggers active', :plugin => name, :method => 'active', :group_id => admin.pk, :description => 'List all currently active triggers')
+        Models::Signature.find_or_create(:signature => 'triggers list', :plugin => name, :method => 'list', :group_id => admin.pk, :description => 'List all triggers and their current status')
+        Models::Signature.find_or_create(:signature => 'triggers add (\S+)', :plugin => name, :method => 'add', :group_id => admin.pk, :description => 'Add a new trigger and activate it').params = [:trigger]
+        Models::Signature.find_or_create(:signature => 'triggers remove (\d+)', :plugin => name, :method => 'remove', :group_id => admin.pk, :description => 'Remove trigger').params = [:id]
+        Models::Signature.find_or_create(:signature => 'triggers activate (\d+)', :plugin => name, :method => 'activate', :group_id => admin.pk, :description => 'Activate the trigger').params = [:id]
+        Models::Signature.find_or_create(:signature => 'triggers deactivate (\d+)', :plugin => name, :method => 'deactivate', :group_id => admin.pk, :description => 'Deactivate the trigger').params = [:id]
+    end
+
+    def active(message, params)
+        triggers = Models::Trigger.filter(:active => true)
+        if(triggers)
+            @pipeline << Privmsg.new(message.replyto, "\2Currently active triggers:\2")
+            triggers.each do |t|
+                @pipeline << Privmsg.new(message.replyto, "#{t.pk}: #{t.trigger}")
+            end
+        else
+            @pipeline << Privmsg.new(message.replyto, 'No triggers are currently active')
+        end
+    end
+    
+    def list(message, params)
+        triggers = Models::Trigger.all
+        if(triggers)
+            @pipeline << Privmsg.new(message.replyto, "\2Trigger listing:\2")
+            triggers.each do |t|
+                @pipeline << Privmsg.new(message.replyto, "#{t.pk}: #{t.trigger}  ->  \2#{t.active ? "activated" : "not activated"}\2")
+            end
+        else
+            @pipeline << Privmsg.new(message.replyto, 'No triggers found')
+        end
+    end
+    
+    def add(message, params)
+        Models::Trigger.find_or_create(:trigger => params[:trigger]).set(:active => true)
+        @pipeline << Privmsg.new(message.replyto, "Trigger #{params[:trigger]} is now active")
+        @pipeline << Messages::Internal::TriggersUpdate.new
+    end
+    
+    def remove(message, params)
+        trigger = Models::Trigger[params[:id]]
+        if(trigger)
+            trig = trigger.trigger
+            trigger.destroy
+            @pipeline << Privmsg.new(message.replyto, "Trigger #{trig} has been removed")
+            @pipeline << Messages::Internal::TriggersUpdate.new
+        else
+            @pipeline << Privmsg.new(message.replyto, "Failed to find trigger with ID: #{params[:id]}")
+        end
+    end
+    
+    def activate(message, params)
+        trigger = Models::Trigger[params[:id]]
+        if(trigger)
+            trigger.set(:active => true)
+            @pipeline << Privmsg.new(message.replyto, "Trigger #{trigger.trigger} has been activated")
+            @pipeline << Messages::Internal::TriggersUpdate.new
+        else
+            @pipeline << Privmsg.new(message.replyto, "Failed to find trigger with ID: #{params[:id]}")
+        end
+    end
+    
+    def deactivate(message, params)
+        trigger = Models::Trigger[params[:id]]
+        if(trigger)
+            trigger.set(:active => false)
+            @pipeline << Privmsg.new(message.replyto, "Trigger #{trigger.trigger} has been deactivated")
+            @pipeline << Messages::Internal::TriggersUpdate.new
+        else
+            @pipeline << Privmsg.new(message.replyto, "Failed to find trigger with ID: #{params[:id]}")
+        end
+    end
+
+end

data/lib/mod_spox/Bot.rb

@@ -102,7 +102,7 @@ module ModSpox
         # Adds hooks to pipeline for processing messages
         def hook_pipeline
             {:Outgoing_Admin => :admin, :Outgoing_Away => :away,
-             :Outgoing_ChannelMode => :chanmode, :Outgoing_Connect => :connect,
+             :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,
@@ -119,7 +119,7 @@ module ModSpox
              :Outgoing_Summon => :summon, :Outgoing_Time => :time,
              :Outgoing_Topic => :topic, :Outgoing_Trace => :trace,
              :Outgoing_Unaway => :unaway, :Outgoing_User => :user,
-             :Outgoing_UserHost => :userhost, :Outgoing_UserMode => :usermode,
+             :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,
@@ -359,7 +359,7 @@ module ModSpox
         # message:: Messages::Outgoing::Who message
         # Sends WHO message to server
         def who(message)
-            o = message.only_ops ? 'o' : ''
+            o = message.only_ops? ? 'o' : ''
             @socket << "WHO #{message.mask} #{o}"
         end
 

data/lib/mod_spox/ConfigurationWizard.rb

@@ -164,7 +164,8 @@ module ModSpox
                     Database.db << "CREATE TABLE if not exists nick_channels (channel_id integer NOT NULL REFERENCES channels, nick_id integer NOT NULL REFERENCES nicks, primary key (channel_id, nick_id))"
                     Database.db << "CREATE TABLE if not exists nick_modes (id integer PRIMARY KEY AUTOINCREMENT, mode string NOT NULL, nick_id integer NOT NULL REFERENCES nicks, channel_id integer REFERENCES channels)"
                     Database.db << "CREATE UNIQUE INDEX if not exists nick_modes_nick_id_channel_id_index ON nick_modes (nick_id, channel_id)"
-                    Database.db << "CREATE TABLE if not exists servers (id integer primary key autoincrement, host string NOT NULL, port integer NOT NULL DEFAULT 6667, priority integer NOT NULL DEFAULT 0, connected boolean NOT NULL DEFAULT 'f', unique index servers_server_port_index (server, port))"
+                    Database.db << "CREATE TABLE if not exists servers (id integer primary key autoincrement, host string NOT NULL, port integer NOT NULL DEFAULT 6667, priority integer NOT NULL DEFAULT 0, connected boolean NOT NULL DEFAULT 'f')"
+                    Database.db << "CREATE UNIQUE INDEX if not exists servers_host_port_index on servers (host, port)"
                     Database.db << "CREATE TABLE if not exists settings (id integer PRIMARY KEY AUTOINCREMENT, name string UNIQUE NOT NULL, value text)"
                     Database.db << "CREATE TABLE if not exists signatures (id integer PRIMARY KEY AUTOINCREMENT, signature string NOT NULL UNIQUE, params string, group_id integer DEFAULT NULL REFERENCES groups, method string NOT NULL, plugin string NOT NULL, description text)"
                     Database.db << "CREATE TABLE if not exists triggers (id integer PRIMARY KEY AUTOINCREMENT, trigger string UNIQUE NOT NULL, active boolean NOT NULL DEFAULT 'f')"            

data/lib/mod_spox/Helpers.rb

@@ -1,17 +1,22 @@
 require 'timeout'
+require 'net/http'
 module ModSpox
     module Helpers
         # secs:: number of seconds
         # Converts seconds into a human readable string
         def Helpers.format_seconds(secs)
+            str = []
             d = (secs / 86400).to_i
             secs = secs % 86400
-            m = (secs / 3600).to_i
+            h = (secs / 3600).to_i
             secs = secs % 3600
-            str = Array.new
-            str << d == 1 ? "#{d} day" : "#{d} days" if d > 0
-            str << m == 1 ? "#{m} minute" : "#{m} minutes" if m > 0
-            str << secs == 1 ? "#{secs} second" : "#{secs} seconds" if secs > 0
+            m = (secs / 60).to_i
+            secs = secs % 60
+            {:day => d, :hour => h, :minute => m, :second => secs}.each_pair do |type, value|
+                if(value > 0)
+                    str << "#{value} #{type}#{value == 1 ? '':'s'}"
+                end
+            end
             return str.join(' ')
         end
         
@@ -29,7 +34,25 @@ module ModSpox
                 Logger.log("Command generated an exception (command: #{command} | error: #{boom})")
             end
         end
-                
-    
+        
+        # url:: URL to shorten
+        # Gets a tinyurl for given URL
+        def Helpers.tinyurl(url)
+            begin
+                connection = Net::HTTP.new('tinyurl.com', 80)
+                resp, data = connection.get("/create.php?url=#{url}", nil)
+                if(resp.code !~ /^200$/)
+                    raise "Failed to make the URL small."
+                end
+                data.gsub!(/[\n\r]/, '')
+                if(data =~ /<input type=hidden name=tinyurl value="(.+?)">/)
+                    return $1
+                else
+                    raise "Failed to locate the small URL."
+                end
+            rescue Object => boom
+                raise "Failed to process URL. #{boom}"
+            end
+        end
     end
 end