spox-mod_spox 0.3.1

data/data/mod_spox/extras/Roulette.rb

@@ -0,0 +1,267 @@
+require 'mod_spox/messages/internal/PluginRequest'
+
+class Roulette < ModSpox::Plugin
+
+    include Models
+
+    def initialize(pipeline)
+        super(pipeline)
+        add_sig(:sig => 'roulette', :method => :roulette, :req => 'public')
+        add_sig(:sig => 'suicide', :method => :suicide, :req => 'public')
+        add_sig(:sig => 'shoot (\S+)', :method => :shoot, :req => 'public', :params => [:nick])
+        add_sig(:sig => 'roulette topten', :method => :topten, :req => 'public')
+        add_sig(:sig => 'roulette stats ?(\S+)?', :method => :stats, :req => 'public', :params => [:nick])
+        add_sig(:sig => 'roulette chambers', :method => :chambers, :req => 'public')
+        Game.create_table unless Game.table_exists?
+        Info.create_table unless Info.table_exists?
+        @banner = nil
+        @pipeline.hook(self, :get_banner, :Internal_PluginResponse)
+    end
+
+    # message:: ModSpox::Messages::Incoming::Privmsg
+    # Display chamber statistics
+    def chambers(m, p)
+        total = Game.all.size
+        result = Game.group(:chamber).select(:chamber, 'COUNT(chamber) as total'.lit).reverse_order(:total)
+        if(result)
+            output = []
+            result.each do |res|
+                percent = sprintf('%.2d', ((res[:total].to_f / total.to_f) * 100.0))
+                output << "chamber #{res.chamber}: #{percent}% (#{res[:total]})"
+            end
+            reply m.replyto, "\2Chamber stats:\2 #{output.join(', ')}"
+        else
+            reply m.replyto, "\2Error:\2 No games found"
+        end
+    end
+
+    # message:: ModSpox::Messages::Internal::PluginResponse
+    # Get the banner plugin
+    def get_banner(message)
+        @banner = message.plugin if message.found?
+    end
+
+    # message:: ModSpox::Messages::Incoming::Privmsg
+    # params:: empty
+    # Play roulette
+    def roulette(message, params)
+        return unless message.is_public?
+        do_shot(message.source, message.target)
+    end
+
+    # message:: ModSpox::Messages::Incoming::Privmsg
+    # params:: empty
+    # Kill self
+    def suicide(message, params)
+        return unless message.is_public?
+        do_suicide(message.source, message.target)
+    end
+
+    # message:: ModSpox::Messages::Incoming::Privmsg
+    # params:: nick
+    # Shoot other person playing current game
+    def shoot(message, params)
+        return unless message.is_public?
+        cur_game = game(message.target)
+        nick = Helpers.find_model(params[:nick], false)
+        if(cur_game.shots == 1 && nick && Info.filter(:game_id => cur_game.pk, :nick_id => nick.pk))
+            do_shot(nick, message.target)
+        else
+            do_suicide(message.source, message.target)
+        end
+    end
+
+    # message:: ModSpox::Messages::Incoming::Privmsg
+    # params:: empty
+    # List topten players
+    def topten(message, params)
+        return unless message.is_public?
+        ds = Database.db[:infos].left_outer_join(:games, :id => :game_id)
+        res = ds.select(:nick_id, 'COUNT(win) as wins'.lit).where(:channel_id => message.target.pk, :win => true).group(:nick_id).reverse_order(:wins).limit(10)
+        ids = res.map(:nick_id)
+        top = []
+        ids.each do |id|
+            nick = Nick[id]
+            top << "#{nick.nick} (#{win_loss_ratio(nick, message.target)}% survival with #{games_won(nick, message.target)} wins)"
+        end
+        if(top.empty?)
+            reply(message.replyto, "\2Error:\2 No one has survived")
+        else
+            reply(message.replyto, "Roulette topten: #{top.join(', ')}")
+        end
+    end
+
+    # message:: ModSpox::Messages::Incoming::Privmsg
+    # params:: empty | nick
+    # List statistics on self or given nick
+    def stats(message, params)
+        return unless message.is_public?
+        if(params[:nick])
+            nick =  Helpers.find_model(params[:nick], false)
+            unless(nick)
+                reply(message.replyto, "\2Error:\2 Failed to find record of #{params[:nick]}")
+                return
+            end
+        else
+            nick = message.source
+        end
+        reply(message.replyto, "\2Roulette stats #{nick.nick}:\2 #{win_loss_ratio(nick, message.target)}% survival rate. Has won #{games_won(nick, message.target)} games and lost #{games_lost(nick, message.target)} games, taking a total of #{total_shots(nick, message.target)} shots.")
+    end
+
+    private
+
+    # nick:: ModSpox::Models::Nick
+    # channel:: ModSpox::Models::Channel
+    # Report win/loss ratio for nick
+    def win_loss_ratio(nick, channel)
+        if(games_lost(nick, channel) > 0)
+            val = (games_won(nick, channel).to_f / games_total(nick, channel).to_f) * 100
+        elsif(games_lost(nick, channel) == 0 && games_won(nick, channel) == 0)
+            val = 0
+        else
+            val = 100
+        end
+        return sprintf("%.2f", val)
+    end
+
+    # nick:: ModSpox::Models::Nick
+    # channel:: ModSpox::Models::Channel
+    # Return number of games nick has won
+    def games_won(nick, channel)
+        Info.left_outer_join(:games, :id => :game_id).filter('nick_id = ?', nick.pk).filter('channel_id = ?', channel.pk).filter('win = ?', true).count
+    end
+
+    # nick:: ModSpox::Models::Nick
+    # channel:: ModSpox::Models::Channel
+    # Return number of games nick has lost
+    def games_lost(nick, channel)
+        games_total(nick, channel) - games_won(nick, channel)
+    end
+
+    # nick:: ModSpox::Models::Nick
+    # channel:: ModSpox::Models::Channel
+    # Return number of games nick has played
+    def games_total(nick, channel)
+        Info.left_outer_join(:games, :id => :game_id).filter('nick_id = ?', nick.pk).filter('channel_id = ?', channel.pk).exclude(:game_id => game(channel).pk).count
+    end
+
+    # nick:: ModSpox::Models::Nick
+    # channel:: ModSpox::Models::Channel
+    # Return number of shots nick has taken
+    def total_shots(nick, channel)
+        v = Info.left_outer_join(:games, :id => :game_id).filter('nick_id = ?', nick.pk).filter('channel_id = ?', channel.pk).exclude(:game_id => game(channel).pk).sum(:infos__shots)
+        v = 0 unless v
+        return v
+    end
+
+    # nick:: ModSpox::Models::Nick
+    # channel:: ModSpox::Models::Channel
+    # Fire shot
+    def do_shot(nick, channel)
+        begin
+            shot(nick, channel)
+            reply(channel, "#{nick.nick}: *click*")
+        rescue Bullet => bang
+            game_over(nick, bang.game)
+            kill_nick(nick, channel)
+        end
+    end
+
+    # nick:: ModSpox::Models::Nick
+    # channel:: ModSpox::Models::Channel
+    # Commit suicide
+    def do_suicide(nick, channel)
+        begin
+            6.times do
+                shot(nick, channel)
+            end
+        rescue Bullet => bang
+            game_over(nick, bang.game)
+            kill_nick(nick, channel)
+        end
+    end
+
+    def kill_nick(nick, channel)
+        unless(@banner.nil?)
+            begin
+                @banner.plugin.ban(nick, channel, 30, '*BANG*', true, false)
+            rescue Banner::NotOperator => boom
+                reply(channel, "#{nick.nick}: *BANG*")
+            rescue Object => boom
+                reply(channel, "#{nick.nick}: *BANG*")
+                Logger.warn("Error: Roulette ban generated an unexpected error: #{boom}")
+            end
+        else
+            reply(channel, "#{nick.nick}: *BANG*")
+        end
+    end
+
+    # channel:: ModSpox::Models::Channel
+    # Return current game
+    def game(channel)
+        @pipeline << Messages::Internal::PluginRequest.new(self, 'Banner') if @banner.nil?
+        game = Game.filter('shots > ?', 0).filter('channel_id = ?', channel.pk).first
+        unless(game)
+            chamber = rand(6) + 1
+            game = Game.new(:chamber => chamber, :shots => chamber, :channel_id => channel.pk)
+            game.save
+        end
+        return game
+    end
+
+    # nick:: ModSpox::Models::Nick
+    # channel:: ModSpox::Models::Channel
+    # Process shot
+    def shot(nick, channel)
+        cur_game = game(channel)
+        info = Info.find_or_create(:game_id => cur_game.pk, :nick_id => nick.pk)
+        info.update(:shots => info.shots + 1)
+        cur_game.update(:shots => cur_game.shots - 1)
+        raise Bullet.new(cur_game) if cur_game.shots < 1
+    end
+
+    # nick:: ModSpox::Models::Nick
+    # game:: Game
+    # Return number of games nick has won
+    def game_over(nick, game)
+        Info.filter(:game_id => game.pk).each do |info|
+            info.update(:win => true) unless info.nick_id == nick.pk
+        end
+    end
+
+    class Game < Sequel::Model
+        set_schema do
+            primary_key :id
+            timestamp :stamp, :null => false
+            integer :shots, :null => false, :default => 6
+            integer :chamber, :null => false, :default => 1
+            foreign_key :channel_id, :null => false, :table => :channels
+        end
+
+        many_to_one :channel, :class => ModSpox::Models::Channel
+
+        def before_create
+            self.stamp = Time.now
+        end
+    end
+
+    class Info < Sequel::Model
+        set_schema do
+            primary_key :id
+            integer :shots, :null => false, :default => 0
+            boolean :win, :null => false, :default => false
+            foreign_key :nick_id, :null => false, :table => :nicks
+            foreign_key :game_id, :null => false, :table => :games
+        end
+        
+        many_to_one :nick, :class => ModSpox::Models::Nick
+        many_to_one :game, :class => Game
+    end
+
+    class Bullet < Exception
+        attr_reader :game
+        def initialize(game)
+            @game = game
+        end
+    end
+end

data/data/mod_spox/extras/RubyCli.rb

@@ -0,0 +1,93 @@
+
+require 'timeout'
+class RubyCli < ModSpox::Plugin
+
+    include Models
+    include Messages::Outgoing
+
+    def initialize(pipeline)
+        super(pipeline)
+        ruby = Group.find_or_create(:name => 'ruby')
+        admin = Group.filter(:name => 'admin').first
+        add_sig(:sig => 'ruby (on|off)', :method => :set_channel, :group => admin, :desc => 'Add or remove channel from allowing ruby command', :params => [:action])
+        add_sig(:sig => 'ruby (?!on|off)(.+)', :method => :execute_ruby, :group => ruby, :desc => 'Execute ruby code', :params => [:code])
+        add_sig(:sig => 'rubyq (?!on|off)(.+)', :method => :quiet_ruby, :group => ruby, :params => [:code], :desc => 'Execute ruby quietly')
+        @channels = Setting.filter(:name => 'rubycli').first
+        @channels = @channels.nil? ? [] : @channels.value
+    end
+
+    def set_channel(message, params)
+        return unless message.is_public?
+        if(params[:action] == 'on')
+            unless(@channels.include?(message.target.pk))
+                @channels << message.target.pk
+                tmp = Setting.find_or_create(:name => 'rubycli')
+                tmp.value = @channels
+                tmp.save
+            end
+            information message.replyto, 'Ruby command now active'
+        else
+            unless(@channels.include?(message.target.pk))
+                warning message.replyto, 'Ruby command is not currently active in this channel'
+            else
+                @channels.delete(message.target.pk)
+                tmp = Setting.find_or_create(:name => 'rubycli')
+                tmp.value = @channels
+                tmp.save
+                information message.replyto, 'Ruby command is now disabled'
+            end
+        end
+    end
+
+    def quiet_ruby(message, params)
+        execute_ruby(message, params, true)
+    end
+    
+    # we fork into a separate process for more control
+    # over untrusted code
+    def execute_ruby(message, params, shh=false)
+        return unless @channels.include?(message.target.pk)
+        rd, wr = IO.pipe
+        cid = Kernel.fork do
+            rd.close
+            result = nil
+            begin
+                result = lambda{$SAFE=4; eval(params[:code])}.call
+            rescue Object => boom
+                result = boom
+            ensure
+                wr.write [Marshal.dump(result)].pack('m')
+            end
+        end
+        if(cid)
+            Database.reset_connections
+            begin
+                result = nil
+                Timeout::timeout(5) do
+                    wr.close
+                    result = rd.read
+                    rd.close
+                end
+                result = result.size > 0 ? Marshal.load(result.unpack('m')[0]) : ''
+                if(result.is_a?(Exception))
+                    error message.replyto, "Exception generated: #{result.to_s.index(' for ').nil? ? result.to_s : result.to_s.slice(0..result.to_s.index(' for '))}"
+                else
+                    result = result.to_s
+                    reply message.replyto, "#{message.source.nick}: Your result has been truncated. Don't print so much." if result.size > 300
+                    reply message.replyto, "#{shh ? '' : 'Result: '}#{result.slice(0..300)}"
+                end
+            rescue Timeout::Error
+                error message.replyto, 'Execution timeout reached.'
+                Logger.warn("Child process #{cid} to be killed")
+                Process.kill('KILL', cid)
+                Logger.warn("Child process #{cid} has been killed")
+            rescue Object => boom
+                error message.replyto, "Unknown error encountered: #{boom}"
+            ensure
+                Process.wait(cid, Process::WNOHANG)
+                Logger.info("RubyCli process has exited.")
+            end
+        end
+    end
+
+end

data/data/mod_spox/extras/Search.rb

@@ -0,0 +1,49 @@
+require 'net/http'
+require 'open-uri'
+require 'cgi'
+class Search < ModSpox::Plugin
+
+    include Messages::Outgoing
+
+    def initialize(pipeline)
+        super(pipeline)
+        add_sig(:sig => 'search count (.+)', :method => 'search_count', :params => [:terms], :desc => 'Show number of results for given search')
+        add_sig(:sig => 'search (?!count)(\d+)? ?(.+)', :method => 'search', :desc => 'Search the internet', :params => [:number, :terms])
+    end
+
+    def search(message, params)
+        limit = params[:number] ? params[:number].to_i : 1
+        limit = limit > 5 || limit < 1 ? 1 : limit
+        begin
+            resp = Net::HTTP.new('www.scroogle.org', 80).request_get("/cgi-bin/nbbw.cgi?Gw=#{CGI::escape(params[:terms])}")
+            resp.value
+            page = resp.body
+            results = []
+            page.scan(/<A Href="(.+?)">(.+?)<\/a>/) do |url,title|
+                title.gsub!(/<.*?>/, '')
+                title = CGI::unescapeHTML(title)
+                results.push [title, url]
+            end
+            output = []
+            results.slice(0, limit).each do |title, url|
+                output << "#{Helpers.convert_entities(title)} -> #{Helpers.tinyurl(url)} [#{url.scan(/^http:\/\/.+?\//)[0]}]"
+            end
+            output = output.empty? ? "No results for: \2#{params[:terms]}\2" :  ["Search results for \2#{params[:terms]}:\2"] + output
+            reply message.replyto, output
+        rescue Object => boom
+            reply message.replyto, "Failed to find any results for: #{params[:terms]} Reason: #{boom}"
+            Logger.warn("Error: #{boom}\n#{boom.backtrace.join("\n")}")
+        end
+    end
+    
+    def search_count(m, params)
+        buf = open("http://www.google.com/search?hl=en&q=#{CGI::escape(params[:terms])}", 'UserAgent' => 'mod_spox IRC bot').read
+        output = ''
+        if(buf =~ /of\s+about.+?([\d,]+)/)
+            output = "There are about \2#{$1}\2 results for the term \2#{params[:terms]}\2"
+        else
+            output = "There are no results found for the term \2#{params[:terms]}\2"
+        end
+        reply m.replyto, output
+    end
+end

data/data/mod_spox/extras/Seen.rb

@@ -0,0 +1,150 @@
+class Seen < ModSpox::Plugin
+    def initialize(pipe)
+        super
+        SeenLog.create_table unless SeenLog.table_exists?
+        @pipeline.hook(self, :log_privmsg, :Incoming_Privmsg)
+        @pipeline.hook(self, :log_join, :Incoming_Join)
+        @pipeline.hook(self, :log_part, :Incoming_Part)
+        @pipeline.hook(self, :log_quit, :Incoming_Quit)
+        @pipeline.hook(self, :log_kick, :Incoming_Kick)
+        @pipeline.hook(self, :log_privmsg, :Incoming_Notice)
+        @pipeline.hook(self, :log_outpriv, :Outgoing_Privmsg)
+        @pipeline.hook(self, :log_outpriv, :Outgoing_Notice)
+        add_sig(:sig => 'seen (\S+)', :method => :seen, :desc => 'Report last sighting of nick', :params => [:nick])
+    end
+
+    def seen(m, params)
+        nick = Models::Nick.filter(:nick => params[:nick]).first
+        log = SeenLog.filter(:nick_id => nick.pk).first if nick
+        if(nick && log)
+            message = "I last saw #{params[:nick]} on #{log.received} "
+            case log.type
+                when 'join'
+                    message << "joining #{log.channel.name}"
+                when 'part'
+                    message << "parting #{log.channel.name} "
+                    message << "reason: #{log.message}" unless log.message.nil? || log.message.empty?
+                when 'privmsg'
+                    message << "in #{log.channel.name} " unless log.channel.nil?
+                    message << "saying #{log.message}" unless log.action
+                    message << "doing: #{log.message}" if log.action
+                when 'notice'
+                    message << "in #{log.channel.name} " unless log.channel.nil?
+                    message << "sending notice: #{log.message}"
+                when 'kicking'
+                    mes = log.message.dup
+                    k = mes.slice!(0..mes.index('|')-1)
+                    mes.slice!(0)
+                    k = Models::Nick[k.to_i]
+                    message << "kicking #{k.nick} from #{log.channel.name} (Reason: #{mes})"
+                when 'kicked'
+                    mes = log.message.dup
+                    k = mes.slice!(0..mes.index('|')-1)
+                    mes.slice!(0)
+                    k = Models::Nick[k.to_i]
+                    message << "kicked from #{log.channel.name} by #{k.nick} (Reason: #{mes})"
+            end
+            information m.replyto, message
+        else
+            error m.replyto, "Failed to find record of given nick: #{params[:nick]}"
+        end
+    end
+
+    def log_outpriv(message)
+        type = message.instance_of?(Messages::Outgoing::Privmsg) ? 'privmsg' : 'notice'
+        target = message.target.is_a?(Sequel::Model) ? message.target : Helpers.find_model(message.target)
+        target = nil unless target.is_a?(Models::Channel)
+        log = get_log(me.pk)
+        log.action = message.is_action?
+        log.message = message.message
+        log.type = type
+        log.channel = target unless target.nil?
+        log.received = Time.now
+        log.save
+    end
+    
+    def log_privmsg(message)
+        return unless message.source.is_a?(Models::Nick)
+        type = message.instance_of?(Messages::Incoming::Privmsg) ? 'privmsg' : 'notice'
+        target = message.target.is_a?(Sequel::Model) ? message.target : Helpers.find_model(message.target)
+        target = nil unless target.is_a?(Models::Channel)
+        log = get_log(message.source.pk)
+        log.action = message.is_action?
+        log.message = message.message
+        log.type = type
+        log.channel = target unless target.nil?
+        log.received = message.time
+        log.save
+    end
+    
+    def log_join(message)
+        log = get_log(message.nick.pk)
+        log.action = false
+        log.message = nil
+        log.type = 'join'
+        log.channel = message.channel
+        log.received = message.time
+        log.save
+    end
+    
+    def log_part(message)
+        log = get_log(message.nick.pk)
+        log.action = false
+        log.type = 'part'
+        log.message = message.reason
+        log.channel = message.channel
+        log.received = message.time
+        log.save
+    end
+    
+    def log_quit(message)
+        log = get_log(message.nick.pk)
+        log.action = false
+        log.type = 'quit'
+        log.message = message.message
+        log.channel = nil
+        log.received = message.time
+        log.save
+    end
+    
+    def log_kick(message)
+        # log kicker
+        log = get_log(message.kicker.pk)
+        log.action = false
+        log.type = 'kicking'
+        log.channel = message.channel
+        log.received = message.time
+        log.message = "#{message.kickee.pk}|#{message.reason}"
+        log.save
+        # log kickee
+        log = get_log(message.kickee.pk)
+        log.action = false
+        log.type = 'kicked'
+        log.channel = message.channel
+        log.received = message.time
+        log.message = "#{message.kicker.pk}|#{message.reason}"
+        log.save
+    end
+
+    private
+    
+    def get_log(pk)
+        log = SeenLog.filter(:nick_id => pk).first
+        log = SeenLog.new(:nick_id => pk) unless log
+        return log
+    end
+
+    class SeenLog < Sequel::Model
+        set_schema do
+            foreign_key :nick_id, :table => :nicks, :null => false
+            foreign_key :channel_id, :table => :channels
+            varchar :type, :default => 'privmsg'
+            timestamp :received, :null => false
+            boolean :action, :null => false, :default => true
+            text :message
+            primary_key :nick_id
+        end
+        many_to_one :nick, :class => ModSpox::Models::Nick
+        many_to_one :channel, :class => ModSpox::Models::Channel
+    end
+end

data/data/mod_spox/extras/Slashdot.rb

@@ -0,0 +1,35 @@
+require 'rexml/document'
+require 'open-uri'
+
+class Slashdot < ModSpox::Plugin
+
+    def initialize(pipeline)
+        begin
+            require 'htmlentities'
+        rescue Object => boom
+            Logger.warn('Error: This plugin requires the HTMLEntities gem. Please install and reload plugin.')
+            raise Exceptions::BotException.new("Missing required HTMLEntities library")
+        end
+        super
+        add_sig(:sig => '(slashdot|\/\.) ?(\d+)?', :method => 'show_slashdot', :desc => 'Slashdot headlines', :params => [:trig, :num])
+        @coder = HTMLEntities.new
+    end
+
+    def show_slashdot(message, params)
+        src = open('http://rss.slashdot.org/Slashdot/slashdot')
+        doc = REXML::Document.new(src.read)
+        num = params[:num].nil? || params[:num].to_i < 1 ? 1 : params[:num].to_i
+        num = 5 if num > 5
+        output = []
+        doc.elements.each('rdf:RDF/item') do |item|
+            num -= 1
+            title = CGI::unescapeHTML(item.elements['title'].text)
+            title = title.gsub(/<.+?>/, ' ').gsub(/[\r\n]/, '').gsub(/\s+/, ' ')
+            title = @coder.decode(title)
+            output << "\2/.\2 #{title.strip} \2->\2 #{Helpers.tinyurl(item.elements['link'].text)}"
+            break if num < 1
+        end
+        reply message.replyto, output
+    end
+
+end