spox-mod_spox 0.3.1

data/data/mod_spox/extras/FML.rb

@@ -0,0 +1,35 @@
+require 'net/http'
+require 'rexml/document'
+
+class FML < ModSpox::Plugin
+
+    def initialize(pipeline)
+        super
+        add_sig(:sig => 'fml( (love|money|kids|work|health|sex|miscellaneous))?', :method => :random, :desc => 'Fuck my life', :params => [:wspace, :category])
+        @site = 'http://api.betacie.com/view/'
+        @vars = ['key=readonly', 'language=en']
+    end
+    
+    def random(m, params)
+        begin
+            t = params[:category] ? "#{params[:category].strip}/" : ''
+            reply m.replyto, get_text("#{t}random")
+        rescue Object => boom
+            error m.replyto, 'Failed to fetch.' + boom.to_s
+        end
+    end
+    
+    private
+    
+    def get_text(thing)
+        data = Net::HTTP.get_response(URI.parse(@site+thing+'?'+@vars.join('&'))).body
+        doc = REXML::Document.new(data)
+        output = []
+        doc.elements.each('root/items/item/text') do |t|
+            output << Helpers.convert_entities(t.text)
+        end
+        raise 'Failed to fetch item from FML' if output.empty?
+        return output[rand(output.size)]
+    end
+
+end

data/data/mod_spox/extras/FloodKicker.rb

@@ -0,0 +1,129 @@
+class FloodKicker
+    def initialize(pipeline)
+        super
+        flood = Models::Auth.find_or_create(:name => 'flood')
+        @watched = []
+        @channels = Setting.filter(:name => :floodkicker).first
+        @channels = [] if @channels.nil?
+        @channels.each do |c|
+            @watched << c[:channel]
+        end
+        @data = {}
+        @pipeline.hook(self, :listener, :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,
+                :desc => 'Remove channel from flood kicker', :params => [:channel])
+        add_sig(:sig => 'floodkick lines(\s \d+)?', :method => :max_lines, :group => flood,
+                :desc => 'Maximum number of lines in allowed time', :params => [:lines])
+        add_sig(:sig => 'floodkick seconds(\s \d+)?', :method => :max_seconds, :group => flood,
+                :desc => 'Maximum number of seconds for allowed lines', :params => [:seconds])
+        add_sig(:sig => 'floodkick status(\s \S+)?', :method => :status, :desc => 'Show parameters for given channel',
+                :params => [:channel])
+    end
+#    @channels -> {:channel => chan.pk, :lines => \d+, :seconds => \d+}
+    
+    def add_channel(m, params)
+        chan = params[:channel] ? Models::Channel.locate(params[:channel].strip) : m.channel
+        unless(watched_channels_ids.include?(chan.pk))
+            @channels << {:channel => chan.pk, :lines => 5, :seconds => 1}
+            save_channels
+            reply m.replyto, "Flood kicker is now enabled for: #{chan.name}"
+        else
+            reply m.replyto, "\2Error:\2 Flood kicker is already enabled for: #{chan.name}"
+        end
+    end
+    
+    def remove_channel(m, params)
+        chan = params[:channel] ? Models::Channel.locate(params[:channel].strip) : m.channel
+        if(watched_channels_ids.include?(chan.pk))
+            @channels.delete(get_chan(chan.pk))
+            save_channels
+            reply m.replyto, "Flood kicker is now disabled for: #{chan.name}"
+        else
+            reply m.replyto, "Flood kicker is not enabled for: #{chan.name}"
+        end
+    end
+    
+    def max_lines(m, params)
+        lines = params[:lines] ? params[:lines].to_i : nil
+        chan = get_chan(m.channel.pk)
+        unless(chan.nil?)
+            if(lines.nil? || lines == 0)
+                reply m.replyto, "Flood kicker lines for this channel currently set at: #{chan[:lines]} lines"
+            else
+                chan[:lines] = lines
+                save_channels
+                reply m.replyto, "Flood kicker lines updated to: #{lines} lines"
+            end
+        else
+            reply m.replyto, "\2Error:\2 Flood kicker is not enabled in this channel"
+        end
+    end
+    
+    def max_seconds(m, params)
+        seconds = params[:seconds] ? params[:seconds].to_i : nil
+        chan = get_chan(m.channel.pk)
+        unless(chan.nil?)
+            if(seconds.nil? || seconds == 0)
+                reply m.replyto, "Flood kicker seconds for this channel currently set at: #{chan[:seconds]} seconds"
+            else
+                chan[:seconds] = seconds
+                save_channels
+                reply m.replyto, "Flood kicker seconds updated to: #{seconds} seconds"
+            end
+        else
+            reply m.replyto, "\2Error:\2 Flood kicker is not enabled in this channel"
+        end
+    end
+    
+    def listener(m)
+        if(@watched.include?(m.channel.pk))
+            log_message(m)
+            if(kick_nick?(m.nick, m.channel))
+                chan = get_chan(m.channel.pk)
+                @pipeline << Messages::Outgoing::Kick.new(m.nick, m.channel, "Flooding. (exceeded #{chan[:lines]} lines in #{chan[:seconds]} seconds)")
+            end
+        end
+    end
+    
+    private
+    
+    def log_message(m)
+        @data[m.channel.pk] = {} unless @data.has_key?(m.channel.pk)
+        @data[m.channel.pk][m.nick.pk] = [] unless @data[m.channel.pk].has_key?(m.nick.pk)
+        @data[m.channel.pk][m.nick.pk] << {:time => Time.now, :message => m.message}
+        @data[m.channel.pk][m.nick.pk].shift until @data[m.channel.pk][m.nick.pk].size <= get_chan(m.channel.pk)[:lines]
+    end
+    
+    def kick_nick?(nick, channel)
+        chan = get_chan(channel.pk)
+        if(@data[channel.pk].has_key?(nick.pk) && @data[channel.pk][nick.pk].size == chan[:lines])
+            return @data[channel.pk][nick.pk][@data[channel.pk][nick.pk].size - 1][:time].to_i - @data[channel.pk][nick.pk][0].to_i >= chan[:seconds].to_i
+        else
+            return false
+        end
+    end
+    
+    def save_channels
+        s = Models::Setting.find_or_create(:name => 'floodkicker')
+        s.value = @channels
+        s.save
+        @watched.clear
+        @channels.each{|c| @watched << c.pk}
+    end
+    
+    def watched_channels
+        @channels.collect{|c| Models::Channel[c[:channel]]}
+    end
+    
+    def watched_channels_ids
+        @channels.collect{|c| c[:channel]}
+    end
+    
+    def get_chan(pk)
+        @channels.each do |c|
+            return c if c[:channel] == pk
+        end
+    end
+end

data/data/mod_spox/extras/Fortune.rb

@@ -0,0 +1,76 @@
+class Fortune < ModSpox::Plugin
+
+    def initialize(pipeline)
+        super
+        add_sig(:sig => 'fortune( \S+)?', :method => :fortune, :desc => 'Get a fortune', :params => [:type])
+        add_sig(:sig => 'fortunes', :method => :show_groups, :desc => 'Show available fortune types')
+        add_sig(:sig => 'fortunes count( \S+)?', :method => :count, :desc => 'Count fortunes', :params => [:type])
+        @fetching = false
+        @db = nil
+        @ids = {}
+        unless(File.exists?(BotConfig[:userpath] + '/fortunes.db.sql3'))
+            @fetching = true
+            do_fetch
+        else
+            @db = Sequel.sqlite(BotConfig[:userpath] + '/fortunes.db.sql3')
+        end
+    end
+
+    def count(m, params)
+        unless(@fetching)
+            output = nil
+            if(params[:type])
+                params[:type].strip!
+                output = "Number of fortunes (type #{params[:type]}): #{@db[:fortunes].filter(:type => params[:type]).count}"
+            else
+                output = "Number of fortunes: #{@db[:fortunes].count}"
+            end
+            information m.replyto, output
+        else
+            error m.replyto, "Waiting for fortunes to complete download"
+        end
+    end
+    
+    def show_groups(m, params)
+        unless(@fetching)
+            information m.replyto, "Fortune types available: #{@db['select distinct(type) from fortunes order by type'].map(:type).join(', ')}"
+        else
+            error m.replyto, "Waiting for fortunes to complete download"
+        end
+    end
+    
+    def fortune(m, params)
+        unless(@fortune)
+            f = nil
+            if(params[:type])
+                t = params[:type].downcase.strip
+                unless(@ids[t])
+                    c = @db[:fortunes].filter(:type => t).map(:id)
+                    @ids[t] = c unless c.empty?
+                end
+                f = @db[:fortunes].filter(:id => @ids[t][rand(@ids[t].size)]).first if @ids[t]
+            else
+                @ids[:all] = @db[:fortunes].count
+                f = @db[:fortunes].filter(:id => rand(@ids[:all])).first
+            end
+            if(f)
+                reply m.replyto, f[:fortune]
+            else
+                error m.replyto, "Failed to locate fortune"
+            end
+        else
+            error m.replyto, "Waiting for fortunes to complete download"
+        end
+    end
+
+    private
+
+    def do_fetch
+        Thread.new do
+            `wget --output-document=#{BotConfig[:userpath]}/fortunes.tar.gz http://rubyforge.org/frs/download.php/59569/fortunes.tar.gz`
+            `tar -C #{BotConfig[:userpath]} -xzf #{BotConfig[:userpath]}/fortunes.tar.gz`
+            @fetching = false
+            @db = Sequel.sqlite(BotConfig[:userpath] + '/fortunes.db.sql3')
+        end
+    end
+end

data/data/mod_spox/extras/GoogleIt.rb

@@ -0,0 +1,13 @@
+class GoogleIt < ModSpox::Plugin
+    def initialize(pipeline)
+        super
+        add_sig(:sig => 'googleit (.+)', :method => :git, :description => 'Let me google that for you', :params => [:term])
+    end
+    
+    def git(m, params)
+        link = "http://www.letmegooglethatforyou.com/?q=#{URI.escape(params[:term])}"
+        output = ["Oh please, let me google: \2#{params[:term]}\2 for you."]
+        output << "\2Result:\2 #{Helpers.tinyurl(link)}"
+        reply m.replyto, output
+    end
+end

data/data/mod_spox/extras/Headers.rb

@@ -0,0 +1,59 @@
+require 'net/http'
+require 'net/https'
+require 'uri'
+
+class Headers < ModSpox::Plugin
+
+    def initialize(pipeline)
+        super(pipeline)
+        admin = Models::Group.find_or_create(:name => 'headers')
+        add_sig(:sig => 'headers ((https?:\/\/)?\S+)', :method => :fetch_headers, :desc => 'Fetch HTTP headers', :params => [:url])
+        add_sig(:sig => 'headers max (\d+)', :method => :set_max, :group => admin, :desc => 'Set maximum number of headers to return', :params => [:max])
+        add_sig(:sig => 'headers max', :method => :show_max, :group => admin, :desc => 'Show maximum number of headers to return ')
+        @lock = Mutex.new
+        @max = Models::Config.val(:headers_max)
+        @max = @max.nil? ? 0 : @max.to_i
+    end
+    
+    def set_max(message, params)
+        record = Models::Config.set(:headers_max, params[:max].to_i)
+        @max = params[:max].to_i
+        reply message.replyto, "Max headers returned set to: #{params[:max].to_i}"
+    end
+    
+    def show_max(message, params)
+        reply message.replyto, "Maximum headers returned: #{@max == 0 ? 'no limit' : @max}"
+    end
+
+    def fetch_headers(message, params)
+        params[:url] = "http://#{params[:url]}" unless params[:url].slice(0..3).downcase == 'http'
+        uri = URI.parse(params[:url])
+        begin
+            path = uri.path.nil? || uri.path.empty? ? '/' : uri.path
+            path += "?#{uri.query}" unless uri.query.nil?
+            reply message.replyto, "Connecting to: #{uri.host} on port: #{uri.port} retrieving: #{path}"
+            con = Net::HTTP.new(uri.host, uri.port)
+            #con.secure = uri.scheme == 'https'
+            con.open_timeout = 5
+            con.read_timeout = 5
+            response = con.head(path)
+            output = ["Response code: #{response.code}"]
+            count = 0
+            response.each_capitalized{|key,val|
+                output << "#{key.slice(0..50)}: #{val.slice(0..200)}"
+                count += 1
+                break if @max != 0 && count >= @max
+            }
+            if(count >= @max && @max != 0)
+                output << 'Maximum header limit reached.'
+            else
+                output << 'Header listing complete'
+            end
+            reply message.replyto, output
+        rescue Object => boom
+            reply message.replyto, "Error retrieving headers (#{uri.host}): #{boom}"
+            Logger.warn("Headers plugin error: #{boom}")
+        end
+    end
+
+end

data/data/mod_spox/extras/Karma.rb

@@ -0,0 +1,302 @@
+require 'mod_spox/messages/internal/TimerAdd'
+require 'mod_spox/messages/outgoing/Privmsg'
+
+class Karma < ModSpox::Plugin
+
+    include Messages::Outgoing
+
+    def initialize(pipeline)
+        super(pipeline)
+        Datatype::Karma.create_table unless Datatype::Karma.table_exists?
+        Datatype::Alias.create_table unless Datatype::Alias.table_exists?
+        alias_group = Models::Group.find_or_create(:name => 'alias')
+        add_sig(:sig => 'karma (?!topten|bottomten$)(?!(fight|alias|dealias|aliases|reset) (\S+|\(.+?\)) ?(\S+|\(.+?\))?$)(\S+|\(.+?\))', :method => :score, :desc => 'Returns karma for given thing', :params => [:crap, :crap2, :crap3, :thing])
+        add_sig(:sig => 'karma reset (\S+|\(.+?\))', :method => :reset, :group => Models::Group.filter(:name => 'admin').first, :desc => 'Reset a karma score', :params => [:thing])
+        add_sig(:sig => 'karma alias (\S+|\(.+?\)) (\S+|\(.+?\))', :method => :aka, :group => alias_group, :desc => 'Alias a karma object to another karma object', :params => [:thing, :thang])
+        add_sig(:sig => 'karma dealias (\S+|\(.+?\)) (\S+|\(.+?\))', :method => :dealias, :group => alias_group, :desc => 'Remove a karma alias', :params => [:thing, :otherthing])
+        add_sig(:sig => 'karma aliases (\S+|\(.+?\))', :method => :show_aliases, :desc => 'Show all aliases for given thing', :params => [:thing])
+        add_sig(:sig => 'karma fight (\S+|\(.+?\)) (\S+|\(.+?\))', :method => :fight, :desc => 'Make two karma objects fight', :params => [:thing, :thang])
+        add_sig(:sig => 'antikarma (\S+|\(.+?\))', :method => :antikarma, :desc => 'Show things antikarma', :params => [:thing])
+        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)
+        @thing_maxlen = 32
+        @karma_regex = /(\(.{1,#@thing_maxlen}?\)|\S{1,#@thing_maxlen})([+-]{2})(?:\s|$)/
+        @eggs = {}
+        @eggs[:chameleon] = []
+        @eggs[:chameleon] << 'Karma karma karma karma karma chameleon You come and go You come and go Loving would be easy if your colors were like my dream Red, gold and green Red, gold and green'
+        @eggs[:chameleon] << 'Didn\'t hear your wicked words every day And you used to be so sweet I heard you say That my love was an addiction When we cling our love is strong When you go youre gone forever You string along You string along'
+        @eggs[:chameleon] << 'Every day is like a survival You\'re my lover not my rival Every day is like a survival You\'re my lover not my rival'
+        @eggs[:chameleon] << 'I\'m a man without conviction I\'m a man who doesnt know How to sell a contradication You come and go You come and go'
+    end
+
+    def check(message)
+        if(message.is_public?)
+            @dupes = {}
+            message.message.scan(@karma_regex) do |match|
+                thing, adj = match
+                thing.downcase!
+                thing = thing[1..-2] if thing[0..0] == '(' && thing[-1..-1] == ')'
+                next if @dupes.has_key?(thing) && @dupes[thing].include?(adj)
+                @dupes[thing] = [] unless @dupes[thing]
+                @dupes[thing] << adj
+                adj = adj == '++' ? +1 : -1
+                things = [thing]
+                karma = Datatype::Karma.find_or_create(:thing => thing, :channel_id => message.target.pk)
+                Datatype::Alias.get_aliases(karma.pk).each do |id|
+                    things << Datatype::Karma[id].thing.downcase
+                end
+                if(things.include?(message.source.nick.downcase))
+                    adj = -1
+                end
+                karma = Datatype::Karma.find_or_create(:thing => thing, :channel_id => message.target.pk)
+                karma.score = karma.score + adj
+                karma.save
+            end
+        end
+    end
+
+    def score(message, params)
+        return unless message.is_public?
+        thing = params[:thing]
+        orig = thing[1..-2] if thing[0..0] == '(' && thing[-1..-1] == ')'
+        orig = thing if orig.nil?
+        thing = orig.downcase
+        karma = Datatype::Karma.filter(:thing => thing, :channel_id => message.target.pk).first
+        if(karma)
+            @pipeline << Privmsg.new(message.replyto, "Karma for \2#{orig}\2 is #{Datatype::Alias.score_object(karma.pk)}")
+        else
+            @pipeline << Privmsg.new(message.replyto, "\2Error:\2 #{orig} has no karma")
+        end
+        if(@eggs.has_key?(params[:thing].downcase.to_sym))
+            @pipeline << Messages::Internal::TimerAdd.new(self, rand(5) + 1, nil, true){ egg(params[:thing].downcase, message) }
+        end
+    end
+    
+    def bottomten(m, params)
+        set = Datatype::Karma.filter(:channel_id => m.target.pk).order(:thing.asc).order(:score.asc).limit(10)
+        if(set.count > 0)
+            output = []
+            set.each do |thing|
+                output << "#{thing.thing} (#{thing.score.to_s.slice(0) == '-' ? '' : '+'}#{thing.score})"
+            end
+            reply m.replyto, "\2Karma bottom ten:\2 #{output.join(', ')}"
+        else
+            error m.replyto, 'No karma objects stored'
+        end
+    end
+    
+    def topten(m, params)
+        set = Datatype::Karma.filter(:channel_id => m.target.pk).order(:thing.asc).order(:score.desc).limit(10)
+        if(set.count > 0)
+            output = []
+            set.each do |thing|
+                output << "#{thing.thing} (#{thing.score.to_s.slice(0) == '-' ? '' : '+'}#{thing.score})"
+            end
+            reply m.replyto, "\2Karma topten:\2 #{output.join(', ')}"
+        else
+            error m.replyto, 'No karma objects stored'
+        end
+    end
+
+    def antikarma(message, params)
+        return unless message.is_public?
+        thing = params[:thing]
+        orig = thing[1..-2] if thing[0..0] == '(' && thing[-1..-1] == ')'
+        orig = thing if orig.nil?
+        thing = orig.downcase
+        karma = Datatype::Karma.filter(:thing => thing, :channel_id => message.target.pk).first
+        if(karma)
+            @pipeline << Privmsg.new(message.replyto, "Anti-Karma for \2#{orig}\2 is #{0 - Datatype::Alias.score_object(karma.pk).to_i}")
+        else
+            @pipeline << Privmsg.new(message.replyto, "\2Error:\2 #{orig} has no anti-karma")
+        end
+    end
+
+    def reset(message, params)
+        sthing = params[:thing].downcase
+        sthing = thing[1..-2] if thing[0..0] == '(' && thing[-1..-1] == ')'
+        return unless message.is_public?
+        karma = Datatype::Karma.filter(:thing => sthing, :channel_id => message.target.pk).first
+        if(karma)
+            karma.update(:score => 0)
+            @pipeline << Privmsg.new(message.replyto, "Karma for \2#{karma.thing}\2 has been reset")
+        else
+            @pipeline << Privmsg.new(message.replyto, "\2Error:\2 #{sthing} has no karma")
+        end
+    end
+
+    def fight(message, params)
+        thing = params[:thing]
+        thang = params[:thang]
+        thing = thing[1..-2] if thing[0..0] == '(' && thing[-1..-1] == ')'
+        thang = thang[1..-2] if thang[0..0] == '(' && thang[-1..-1] == ')'
+        rthing = Datatype::Karma.find_or_create(:thing => thing.downcase, :channel_id => message.target.pk)
+        rthang = Datatype::Karma.find_or_create(:thing => thang.downcase, :channel_id => message.target.pk)
+        thing_score = Datatype::Alias.score_object(rthing.pk)
+        thang_score = Datatype::Alias.score_object(rthang.pk)
+        winner = thing_score > thang_score ? thing : thang
+        loser = thing_score > thang_score ? thang : thing
+        distance = (thing_score - thang_score).abs
+        output = ["\2KARMA FIGHT RESULTS:\2 "]
+        if(distance > 0)
+            output << "\2#{winner}\2 #{winner[-1] == 's' || winner[-1] == 115 ? 'have' : 'has'} beaten \2#{loser}\2 #{distance > 50 ? 'like a redheaded step child' : ''} (+#{distance} points)"
+        else
+            output << "\2#{winner}\2 #{winner[-1] == 's' || winner[-1] == 115 ? 'have' : 'has'} tied \2#{loser}\2"
+        end
+        reply message.replyto, output
+    end
+
+    def antifight(message, params)
+        thing = params[:thing]
+        thang = params[:thang]
+        thing = thing[1..-2] if thing[0..0] == '(' && thing[-1..-1] == ')'
+        thang = thang[1..-2] if thang[0..0] == '(' && thang[-1..-1] == ')'
+        rthing = Datatype::Karma.find_or_create(:thing => thing.downcase, :channel_id => message.target.pk)
+        rthang = Datatype::Karma.find_or_create(:thing => thang.downcase, :channel_id => message.target.pk)
+        thing_score = Datatype::Alias.score_object(rthing.pk) * -1
+        thang_score = Datatype::Alias.score_object(rthang.pk) * -1
+        winner = thing_score > thang_score ? thing : thang
+        loser = thing_score > thang_score ? thang : thing
+        distance = (thing_score - thang_score).abs
+        output = ["\2ANTI-KARMA FIGHT RESULTS:\2 "]
+        if(distance > 0)
+            output << "\2#{winner}\2 #{winner[-1] == 's' || winner[-1] == 115 ? 'have' : 'has'} beaten \2#{loser}\2 #{distance > 50 ? 'like a redheaded step child' : ''} (+#{distance} points)"
+        else
+            output << "\2#{winner}\2 #{winner[-1] == 's' || winner[-1] == 115 ? 'have' : 'has'} tied \2#{loser}\2"
+        end
+        reply message.replyto, output
+    end
+
+    def aka(message, params)
+        thing = params[:thing].downcase
+        thang = params[:thang].downcase
+        thing = thing[1..-2] if thing[0..0] == '(' && thing[-1..-1] == ')'
+        thang = thang[1..-2] if thang[0..0] == '(' && thang[-1..-1] == ')'
+        thing = Datatype::Karma.find_or_create(:thing => thing, :channel_id => message.target.pk)
+        thang = Datatype::Karma.find_or_create(:thing => thang, :channel_id => message.target.pk)
+        if(Datatype::Alias.filter('(thing_id = ? AND aka_id = ?) OR (thing_id = ? AND aka_id = ?)', thing.pk, thang.pk, thang.pk, thing.pk).first)
+            reply message.replyto, "\2Error:\2 #{thing.thing} is already aliased to #{thang.thing}"
+        else
+            Datatype::Alias.find_or_create(:thing_id => thing.pk, :aka_id => thang.pk)
+            reply message.replyto, "\2Karma Alias:\2 #{thing.thing} is now aliased to #{thang.thing}"
+        end
+    end
+
+    def dealias(message, params)
+        sthing = params[:thing].downcase
+        sotherthing = params[:otherthing].downcase
+        sthing = sthing[1..-2] if sthing[0..0] == '(' && sthing[-1..-1] == ')'
+        sotherthing = sotherthing[1..-2] if sotherthing[0..0] == '(' && sotherthing[-1..-1] == ')'
+        thing = Datatype::Karma.filter(:thing => sthing, :channel_id => message.target.pk).first
+        otherthing = Datatype::Karma.filter(:thing => sotherthing, :channel_id => message.target.pk).first
+        if(thing && otherthing)
+            set = Datatype::Alias.filter('(thing_id = ? AND aka_id = ?) OR (thing_id = ? AND aka_id = ?)', thing.pk, otherthing.pk, otherthing.pk, thing.pk)
+            if(set.count < 1)
+                reply message.replyto, "\2Error:\2 No alias found between #{thing.thing} and #{otherthing.thing}"
+            else
+                set.destroy
+                reply message.replyto, "#{thing.thing} has been successfully dealiased from #{otherthing.thing}"
+            end
+        else
+            reply message.replyto, "\2Error:\2 No alias found between #{sthing} and #{sotherthing}"
+        end
+    end
+
+    def show_aliases(message, params)
+        thing = params[:thing].downcase
+        thing = thing[1..-2] if thing[0..0] == '(' && thing[-1..-1] == ')'
+        thing = Datatype::Karma.filter(:thing => thing, :channel_id => message.target.pk).first
+        begin
+            if(thing)
+                things = []
+                Datatype::Alias.get_aliases(thing.pk).each do |id|
+                    things << Datatype::Karma[id].thing
+                end
+                if(things.empty?)
+                    reply message.replyto, "#{thing.thing} is not currently aliased"
+                else
+                    reply message.replyto, "#{thing.thing} is currently aliased to: #{things.sort.join(', ')}"
+                end
+            else
+                reply message.replyto, "\2Error:\2 #{params[:thing]} has never been used and has no aliases"
+            end
+        rescue Object
+            error message.replyto, "No aliases found"
+        end
+    end
+    
+    def egg(karma, message)
+        if(karma.downcase == 'chameleon')
+            reply message.replyto, @eggs[:chameleon][rand(@eggs[:chameleon].size - 1)]
+        end
+    end
+
+    module Datatype
+        class Karma < Sequel::Model
+            set_schema do
+                primary_key :id
+                text :thing, :null => false
+                integer :score, :null => false, :default => 0
+                foreign_key :channel_id, :table => :channels
+                index [:thing, :channel_id], :unique => true
+            end
+
+            many_to_one :channel, :class => ModSpox::Models::Channel
+        end
+        class Alias < Sequel::Model
+            set_schema do
+                primary_key :id
+                foreign_key :thing_id, :null => false
+                foreign_key :aka_id, :null => false
+            end
+
+            def thing
+                Karma[thing_id]
+            end
+
+            def aka
+                Karma[aka_id]
+            end
+
+            def Alias.score_object(object_id)
+                Alias.create_lock unless class_variable_defined?(:@@lock)
+                @@objects = []
+                score = 0
+                @@lock.synchronize do
+                    score += Alias.sum_objects(object_id)
+                end
+                return score
+            end
+
+            def Alias.get_aliases(object_id)
+                Alias.score_object(object_id)
+                objs = @@objects.dup
+                objs.delete(object_id)
+                return objs
+            end
+
+            private
+
+            def Alias.sum_objects(object_id)
+                return 0 if @@objects.include?(object_id)
+                @@objects << object_id
+                object = Karma[object_id]
+                score = object ? object.score : 0
+                Alias.filter(:thing_id => object_id).each do |ali|
+                    score += Alias.sum_objects(ali.aka.pk)
+                end
+                Alias.filter(:aka_id => object_id).each do |ali|
+                    score += Alias.sum_objects(ali.thing.pk)
+                end
+                return score
+            end
+
+            def Alias.create_lock
+                @@lock = Mutex.new
+            end
+
+        end
+    end
+end

data/data/mod_spox/extras/Locator.rb

@@ -0,0 +1,44 @@
+class Locator < ModSpox::Plugin
+
+    def initialize(pipeline)
+        super
+        add_sig(:sig => 'locate (\S+)', :method => :locate, :desc => 'Locate the given nick', :params => [:nick])
+    end
+
+    def locate(m, params)
+        nick = Models::Nick.filter(:nick => params[:nick]).first
+        if(nick)
+            if(!nick.address.nil? && !nick.address.empty?)
+                con = Net::HTTP.new('www.ip-adress.com', 80)
+                res = con.request_get("/ip_tracer/#{nick.address}", nil)
+                begin
+                    info = []
+                    res.value
+                    page = res.body
+                    page = page.split("\n")
+                    page.size.times do |line|
+                        unless(page[line].index('IP address country:').nil?)
+                            info << "\2Country:\2 #{page[line+2].gsub(/<.+?>/, '').strip}"
+                        end
+                        unless(page[line].index('IP address state:').nil?)
+                            info << "\2State:\2 #{page[line+2].gsub(/<.+?>/, '').strip}"
+                        end
+                        unless(page[line].index('IP address city:').nil?)
+                            info << "\2City:\2 #{page[line+2].gsub(/<.+?>/, '').strip}"
+                        end
+                        unless(page[line].index('ISP of this IP').nil?)
+                            info << "\2ISP:\2 #{page[line+2].gsub(/<.+?>/, '').strip}"
+                        end
+                    end
+                    reply m.replyto, "\2Locator:\2 #{params[:nick]} - #{info.join(', ')}"
+                rescue Object => boom
+                    Logger.error("Locator plugin generated an exception: #{boom}")
+                end
+            else
+                error m.replyto, "Current address unavailable for nick: #{params[:nick]}"
+            end
+        else
+            error m.replyto, "Failed to find record of nick: #{params[:nick]}"
+        end
+    end
+end