mod_spox 0.1.0.1 → 0.2.0

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/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

@@ -5,11 +5,30 @@ class Headers < ModSpox::Plugin
 
     def initialize(pipeline)
         super(pipeline)
+        admin = Models::Group.find_or_create(:name => 'headers')
         Models::Signature.find_or_create(:signature => 'headers (https?:\/\/\S+)', :plugin => name, :method => 'fetch_headers',
             :description => 'Fetch HTTP headers').params = [:url]
+        Models::Signature.find_or_create(:signature => 'headers max (\d+)', :plugin => name, :method => 'set_max',
+            :group_id => admin.pk, :description => 'Set maximum number of headers to return').params = [:max]
+        Models::Signature.find_or_create(:signature => 'headers max', :plugin => name, :method => 'show_max',
+            :group_id => admin.pk, :description => 'Show maximum number of headers to return ')
         @lock = Mutex.new
+        @max = Models::Config[:headers_max]
+        @max = @max.nil? ? 0 : @max.to_i
     end
     
+    def set_max(message, params)
+        record = Models::Config.find_or_create(:name => 'headers_max')
+        record.value = params[:max].to_i
+        record.save
+        @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)
         @lock.synchronize do
             secure = false
@@ -28,22 +47,30 @@ class Headers < ModSpox::Plugin
                 location = $1
                 page = $2
             else
-                location = params[:url]
+                location = params[:url].gsub(/\/$/, '')
                 page = '/'
             end
             begin
                 reply message.replyto, "Connecting to: #{location} on port: #{port} retrieving: #{page}"
                 con = Net::HTTP.new(location, port)
                 con.use_ssl = secure
-                response = con.get(page, nil)
+                response = con.get(page)
                 output = ["Response code: #{response.code}"]
+                count = 0
                 response.each{|key,val|
-                    output << "#{key}: #{val}"
+                    output << "#{key.slice(0..50)}: #{val.slice(0..200)}"
+                    count += 1
+                    break if @max != 0 && count >= @max
                 }
-                output << "Header listing complete"
+                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: #{boom}"
+                Logger.warn("#{boom}\n#{boom.backtrace.join("\n")}")
             end
         end
     end

data/data/mod_spox/extras/Karma.rb

@@ -7,20 +7,27 @@ class Karma < ModSpox::Plugin
         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')
-        Models::Signature.find_or_create(:signature => 'karma (\S+)', :plugin => name, :method => 'score', :description => 'Returns karma for given thing').params = [:thing]
-        Models::Signature.find_or_create(:signature => 'karma reset (\S+)', :plugin => name, :method => 'reset',
+        Models::Signature.find_or_create(:signature => 'karma (?!(fight|alias|dealias|aliases|reset) (\S+|\(.+?\)) ?(\S+|\(.+?\))?$)(\S+|\(.+?\))', :plugin => name, :method => 'score', :description => 'Returns karma for given thing').params = [:crap, :crap2, :crap3, :thing]
+        Models::Signature.find_or_create(:signature => 'karma reset (\S+|\(.+?\))', :plugin => name, :method => 'reset',
             :group_id => Models::Group.filter(:name => 'admin').first.pk, :description => 'Reset a karma score').params = [:thing]
-        Models::Signature.find_or_create(:signature => 'karma alias (\S+) (\S+)', :plugin => name, :method => 'aka',
+        Models::Signature.find_or_create(:signature => 'karma alias (\S+|\(.+?\)) (\S+|\(.+?\))', :plugin => name, :method => 'aka',
             :group_id => alias_group.pk, :description => 'Alias a karma object to another karma object').params = [:thing, :thang]
-        Models::Signature.find_or_create(:signature => 'karma dealias (\S+) (\S+)', :plugin => name, :method => 'dealias',
+        Models::Signature.find_or_create(:signature => 'karma dealias (\S+|\(.+?\)) (\S+|\(.+?\))', :plugin => name, :method => 'dealias',
             :group_id => alias_group.pk, :description => 'Remove a karma alias').params = [:thing, :otherthing]
-        Models::Signature.find_or_create(:signature => 'karma aliases (\S+)', :plugin => name, :method => 'show_aliases',
+        Models::Signature.find_or_create(:signature => 'karma aliases (\S+|\(.+?\))', :plugin => name, :method => 'show_aliases',
             :description => 'Show all aliases for given thing').params = [:thing]
-        Models::Signature.find_or_create(:signature => 'karma fight (\S+) (\S+)', :plugin => name, :method => 'fight',
+        Models::Signature.find_or_create(:signature => 'karma fight (\S+|\(.+?\)) (\S+|\(.+?\))', :plugin => name, :method => 'fight',
             :description => 'Make two karma objects fight').params = [:thing, :thang]
+        add_sig(:sig => 'antikarma (\S+|\(.+?\))', :method => :antikarma, :desc => 'Show things antikarma', :params => [:thing])
         @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)
@@ -28,7 +35,7 @@ class Karma < ModSpox::Plugin
             message.message.scan(@karma_regex) do |match|
                 thing, adj = match
                 thing.downcase!
-                thing = thing[1..-2] if thing[0..0] == '(' && thing[-1..1] == ')'
+                thing = thing[1..-2] if thing[0..0] == '(' && thing[-1..-1] == ')'
                 adj = adj == '++' ? +1 : -1
                 things = [thing]
                 karma = Datatype::Karma.find_or_create(:thing => thing, :channel_id => message.target.pk)
@@ -44,81 +51,128 @@ class Karma < ModSpox::Plugin
             end
         end
     end
-    
+
     def score(message, params)
         return unless message.is_public?
-        karma = Datatype::Karma.filter(:thing => params[:thing].downcase, :channel_id => message.target.pk).first
+        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#{params[:thing]}\2 is #{Datatype::Alias.score_object(karma.pk)}")
+            @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 #{params[:thing]} has no karma")
+            @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 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)
-        params[:thing].downcase!
+        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 => params[:thing], :channel_id => message.target.pk).first
+        karma = Datatype::Karma.filter(:thing => sthing, :channel_id => message.target.pk).first
         if(karma)
             karma.update_with_params(:score => 0)
             @pipeline << Privmsg.new(message.replyto, "Karma for \2#{karma.thing}\2 has been reset")
         else
-            @pipeline << Privmsg.new(message.replyto, "\2Error:\2 #{params[:thing]} has no karma")
-        end        
+            @pipeline << Privmsg.new(message.replyto, "\2Error:\2 #{sthing} has no karma")
+        end
     end
-    
+
     def fight(message, params)
-        thing = Datatype::Karma.find_or_create(:thing => params[:thing].downcase)
-        thang = Datatype::Karma.find_or_create(:thing => params[:thang].downcase)
-        thing_score = Datatype::Alias.score_object(thing.pk)
-        thang_score = Datatype::Alias.score_object(thang.pk)
-        winner = thing_score > thang_score ? params[:thing] : params[:thang]
-        loser = thing_score > thang_score ? params[:thang] : params[:thing]
+        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
-        reply message.replyto, "\2KARMA FIGHT RESULTS:\2 \2#{winner}\2 has beaten \2#{loser}\2 by a #{distance} point lead"
+        output = "\2KARMA FIGHT RESULTS:\2 "
+        if(distance > 0)
+            reply message.replyto, "\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
+            reply message.replyto, "\2#{winner}\2 #{winner[-1] == 's' || winner[-1] == 115 ? 'have' : 'has'} tied \2#{loser}\2"
+        end
     end
-    
+
     def aka(message, params)
-        thing = Datatype::Karma.find_or_create(:thing => params[:thing].downcase, :channel_id => message.target.pk)
-        thang = Datatype::Karma.find_or_create(:thing => params[:thang].downcase, :channel_id => message.target.pk)
+        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 #{params[:thing]} is already aliased to #{params[:thang]}"
+            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 #{params[:thing]} is now aliased to #{params[:thang]}"
+            reply message.replyto, "\2Karma Alias:\2 #{thing.thing} is now aliased to #{thang.thing}"
         end
     end
-     
+
     def dealias(message, params)
-        thing = Datatype::Karma.filter(:thing => params[:thing].downcase, :channel_id => message.target.pk).first
-        otherthing = Datatype::Karma.filter(:thing => params[:otherthing].downcase, :channel_id => message.target.pk).first
+        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.size < 1)
-                reply message.replyto, "\2Error:\2 No alias found between #{params[:thing]} and #{params[:otherthing]}"
+                reply message.replyto, "\2Error:\2 No alias found between #{thing.thing} and #{otherthing.thing}"
             else
                 set.destroy
-                reply message.replyto, "#{params[:thing]} has been successfully dealiased from #{params[:otherthing]}"
+                reply message.replyto, "#{thing.thing} has been successfully dealiased from #{otherthing.thing}"
             end
         else
-            reply message.replyto, "\2Error:\2 No alias found between #{params[:thing]} and #{params[:otherthing]}"
+            reply message.replyto, "\2Error:\2 No alias found between #{sthing} and #{sotherthing}"
         end
     end
-    
+
     def show_aliases(message, params)
-        thing = Datatype::Karma.filter(:thing => params[:thing].downcase, :channel_id => message.target.pk).first
+        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
         if(thing)
             things = []
             Datatype::Alias.get_aliases(thing.pk).each do |id|
                 things << Datatype::Karma[id].thing
             end
             if(things.empty?)
-                reply message.replyto, "#{params[:thing]} is not currently aliased"
+                reply message.replyto, "#{thing.thing} is not currently aliased"
             else
-                reply message.replyto, "#{params[:thing]} is currently aliased to: #{things.join(', ')}"
+                reply message.replyto, "#{thing.thing} is currently aliased to: #{things.join(', ')}"
             end
         else
-            reply message.replyto, "\2Error:\2 #{params[:thing]} has never been used and has no aliases"
+            reply message.replyto, "\2Error:\2 #{thing.thing} has never been used and has no aliases"
+        end
+    end
+    
+    def egg(karma, message)
+        if(karma.downcase == 'chameleon')
+            reply message.replyto, @eggs[:chameleon][rand(@eggs[:chameleon].size - 1)]
         end
     end
 
@@ -131,7 +185,7 @@ class Karma < ModSpox::Plugin
                 foreign_key :channel_id, :table => :channels
                 index [:thing, :channel_id], :unique => true
             end
-            
+
             def channel
                 ModSpox::Models::Channel[channel_id]
             end
@@ -142,15 +196,15 @@ class Karma < ModSpox::Plugin
                 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 = []
@@ -160,16 +214,16 @@ class Karma < ModSpox::Plugin
                 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
@@ -183,11 +237,11 @@ class Karma < ModSpox::Plugin
                 end
                 return score
             end
-            
+
             def Alias.create_lock
                 @@lock = Mutex.new
             end
-            
+
         end
     end
 end

data/data/mod_spox/extras/Logger.rb

@@ -31,11 +31,11 @@ class ChatLogger < ModSpox::Plugin
         type = 'action' if message.is_action?
         target = message.target.is_a?(Sequel::Model) ? message.target : Helpers.find_model(message.target)
         if(target.is_a?(Models::Channel))
-            PublicLog.new(:message => message.message, :type => type, :sender => me.pk,
-                :channel => target.pk, :received => Time.now).save
+            PublicLog.new(:message => message.message, :type => type, :sender_id => me.pk,
+                :channel_id => target.pk, :received => Time.now).save
         else
-            PrivateLog.new(:message => message.message, :type => type, :sender => me.pk,
-                :receiver => target.pk, :received => Time.now).save
+            PrivateLog.new(:message => message.message, :type => type, :sender_id => me.pk,
+                :receiver_id => target.pk, :received => Time.now).save
         end        
     end
     
@@ -43,30 +43,30 @@ class ChatLogger < ModSpox::Plugin
         type = message.is_a?(Messages::Incoming::Privmsg) ? 'privmsg' : 'notice'
         type = 'action' if message.is_action?
         if(message.is_public?)
-            PublicLog.new(:message => message.message, :type => type, :sender => message.source.pk,
-                :channel => message.target.pk, :received => message.time).save
+            PublicLog.new(:message => message.message, :type => type, :sender_id => message.source.pk,
+                :channel_id => message.target.pk, :received => message.time).save
         else
-            PrivateLog.new(:message => message.message, :type => type, :sender => message.source.pk,
-                :receiver => message.target.pk, :received => message.time).save
+            PrivateLog.new(:message => message.message, :type => type, :sender_id => message.source.pk,
+                :receiver_id => message.target.pk, :received => message.time).save
         end
     end
     
     def log_join(message)
-        PublicLog.new(:type => 'join', :sender => message.nick.pk, :channel => message.channel.pk, :received => message.time).save
+        PublicLog.new(:type => 'join', :sender_id => message.nick.pk, :channel_id => message.channel.pk, :received => message.time).save
     end
     
     def log_part(message)
-        PublicLog.new(:message => message.reason, :type => 'part', :sender => message.nick.pk,
-            :channel => message.channel.pk, :received => message.time).save
+        PublicLog.new(:message => message.reason, :type => 'part', :sender_id => message.nick.pk,
+            :channel_id => message.channel.pk, :received => message.time).save
     end
     
     def log_quit(message)
-        PublicLog.new(:message => message.message, :type => 'quit', :sender => message.nick.pk, :received => message.time).save
+        PublicLog.new(:message => message.message, :type => 'quit', :sender_id => message.nick.pk, :received => message.time).save
     end
     
     def log_kick(message)
-        PublicLog.new(:message => "#{message.kickee.pk}|#{message.reason}", :type => 'kick', :sender => message.kicker.pk,
-            :channel => message.channel.pk, :received => message.time).save
+        PublicLog.new(:message => "#{message.kickee.pk}|#{message.reason}", :type => 'kick', :sender_id => message.kicker.pk,
+            :channel_id => message.channel.pk, :received => message.time).save
     end
     
     # TODO: Fix this
@@ -83,27 +83,27 @@ class ChatLogger < ModSpox::Plugin
     def seen(m, p)
         nick = Helpers.find_model(p[:nick], false)
         if(nick.is_a?(Models::Nick))
-            record = PublicLog.filter(:sender => nick.pk).order(:received).last
-            record_p = PrivateLog.filter(:sender => nick.pk).order(:received).last
+            record = PublicLog.filter(:sender_id => nick.pk).order(:received).last
+            record_p = PrivateLog.filter(:sender_id => nick.pk).order(:received).last
             record = record_p if !record || (record_p && record && record_p.received > record.received)
             if(record)
                 if(record.is_a?(PublicLog))
                     case record.values[:type]
                         when 'join'
-                            message = "joining #{Channel[record.channel].name}"
+                            message = "joining #{record.channel.name}"
                         when 'part'
-                            message = "parting #{Channel[record.channel].name} with the message: #{record.message}"
+                            message = "parting #{record.channel.name} with the message: #{record.message}"
                         when 'privmsg'
-                            message = "in #{Channel[record.channel].name} saying: #{record.message}"
+                            message = "in #{record.channel.name} saying: #{record.message}"
                         when 'action'
-                            message = "in #{Channel[record.channel].name} saying: * #{p[:nick]} #{record.message}"
+                            message = "in #{record.channel.name} saying: * #{p[:nick]} #{record.message}"
                         when 'notice'
-                            message = "in #{Channel[record.channel].name} saying: #{record.message}"
+                            message = "in #{record.channel.name} saying: #{record.message}"
                         when 'kick'
                             if(record.message =~ /^([0-9]+)\|/)
                                 kickee = Nick[$1.to_i]
                                 reason = $2
-                                message = "kicking #{kickee.nick} from #{Channel[record.channel].name} (#{record.message})"
+                                message = "kicking #{kickee.nick} from #{record.channel.name} (#{record.message})"
                             end
                         end
                 else
@@ -121,8 +121,8 @@ class ChatLogger < ModSpox::Plugin
     def spoke(m, p)
         nick = Helpers.find_model(p[:nick], false)
         if(nick.is_a?(Models::Nick))
-            record = PublicLog.filter(:sender => nick.pk).filter("type in ('privmsg', 'action')").order(:received).last
-            record_p = PrivateLog.filter(:sender => nick.pk).order(:received).last
+            record = PublicLog.filter(:sender_id => nick.pk).filter("type in ('privmsg', 'action')").order(:received).last
+            record_p = PrivateLog.filter(:sender_id => nick.pk).order(:received).last
             record = record_p if !record || (record_p && record && record_p.received > record.received)
             if(record)
                 if(record.is_a?(PublicLog))
@@ -145,9 +145,16 @@ class ChatLogger < ModSpox::Plugin
             text :type, :null => false, :default => 'privmsg'
             boolean :action, :null => false, :default => false
             timestamp :received, :null => false
-            foreign_key :sender, :table => :nicks
-            foreign_key :receiver, :table => :nicks
-            index :message, :type => :full_text
+            foreign_key :sender_id, :table => :nicks
+            foreign_key :receiver_id, :table => :nicks
+        end
+        
+        def sender
+            Models::Nick[sender_id]
+        end
+        
+        def receiver
+            Models::Nick[receiver_id]
         end
     end
     
@@ -158,10 +165,18 @@ class ChatLogger < ModSpox::Plugin
             text :type, :null => false, :default => 'privmsg'
             boolean :action, :null => false, :default => false
             timestamp :received, :null => false
-            foreign_key :sender, :table => :nicks
-            foreign_key :channel, :table => :channels
-            index :message, :type => :full_text
+            foreign_key :sender_id, :table => :nicks
+            foreign_key :channel_id, :table => :channels
+        end
+        
+        def sender
+            Models::Nick[sender_id]
+        end
+        
+        def channel
+            Models::Channel[channel_id]
         end
+        
     end
 
 end

data/data/mod_spox/extras/LolSpeak.rb

@@ -8,7 +8,7 @@ class LolSpeak < ModSpox::Plugin
         begin
             require 'lolspeak'
         rescue Object => boom
-            Logger.log('Error: This plugins requires the lolspeak gem. Please install gem and reload plugin.')
+            Logger.warn('Error: This plugins requires the lolspeak gem. Please install gem and reload plugin.')
             raise BotException.new("Failed to initialize plugin. Missing lolspeak gem.")
         end
         Signature.find_or_create(:signature => 'lolspeak (.+)', :plugin => name, :method => 'translate',