spox-mod_spox 0.3.1

data/data/mod_spox/extras/PhpFuncLookup.rb

@@ -0,0 +1,297 @@
+require 'cgi'
+require 'open-uri'
+
+# Inspired from an old plugin for the original mod_spox
+# Original development: spox & Ryan "pizza_milkshake" Flynn
+# Ported: 2008
+
+class PhpFuncLookup < ModSpox::Plugin
+
+    include Models
+
+    def initialize(pipeline)
+        super(pipeline)
+        setup_setting
+        @path = Setting.val(:phpfunc)[:directory]
+        @trigger = Setting.val(:phpfunc)[:trigger]
+        @manual = "#{@path}/html"
+        @classlist = []
+        fetch_manual unless File.exists?("#{@path}/manual.tar.gz")
+        @ops = {
+            "-"     => [ "arithmetic",  "Subtraction or Negation",      "3 - 2 == 1" ],
+            "+"     => [ "arithmetic",  "Addition",                     "3 + 2 == 5" ],
+            "*"     => [ "arithmetic",  "Multiplication",               "3 * 2 == 6" ],
+            "/"     => [ "arithmetic",  "Division",                     "3 / 2 == 1.5" ],
+            "%"     => [ "arithmetic",  "Modulus",                      "3 % 2 == 1" ],
+            "="     => [ "assignment",  "Assignment",                   "$foo = 1; -> $foo == 1" ],
+            "&"     => [
+                        [ "bitwise", "references" ],
+                        [ "Bitwise And", "Reference" ],
+                        [ "0x3 & 0x1 -> 1",  "$foo=1; $bar=&$foo; $bar++; -> $foo == 2" ]
+                       ],
+            "|"     => [ "bitwise",     "Bitwise Or",                   "" ],
+            "^"     => [ "bitwise",     "Bitwise Xor",                  "" ],
+            "~"     => [ "bitwise",     "Bitwise Not",                  "" ],
+            "<<"    => [ "bitwise",     "Bitwise Shift left",           "" ],
+            ">>"    => [ "bitwise",     "Bitwise Shift right",          "" ],
+            "=="    => [ "comparison",  "Equal",                        "" ],
+            "==="   => [ "comparison",  "Identical",                    "" ],
+            "!="    => [ "comparison",  "Not Equal",                    "" ],
+            "<>"    => [ "comparison",  "Not Equal",                    "" ],
+            "!=="   => [ "comparison",  "Not Identical",                "" ],
+            "<"     => [ "comparison",  "Less Than",                    "" ],
+            ">"     => [ "comparison",  "Greater Than",                 "" ],
+            "<="    => [ "comparison",  "Less Than Or Equal To",        "" ],
+            ">="    => [ "comparison",  "Greater Than Or Equal To",     "" ],
+            "@"     => [ "errorcontrol","Error Control",                "" ],
+            "`"     => [ "execution",   "Execution",                    "" ],
+            "++"    => [ "increment",   "Pre- or Post-Increment",       "" ],
+            "--"    => [ "increment",   "Pre- or Post-Decrement",       "" ],
+            "and"   => [ "logical",     "And",                          "" ],
+            "or"    => [ "logical",     "Or",                           "" ],
+            "xor"   => [ "logical",     "Xor",                          "" ],
+            "!"     => [ "logical",     "Not",                          "" ],
+            "&&"    => [ "logical",     "And",                          "" ],
+            "||"    => [ "logical",     "Or",                           "" ],
+            "."     => [ "string",      "Concatenation",                "" ],
+            ".="    => [ "string",      "Concatenation Assignment",     "" ],
+            "instanceof" => [ "type",   "Instance Of",                  "" ],
+            "new"   => [ "",            "New Object",                   "" ],
+            "+="    => [ "assignment",  "Addition Assignment",          "" ],
+            "-="    => [ "assignment",  "Subtraction Assignment",       "" ],
+            "/="    => [ "assignment",  "Division Assignment",          "" ],
+            "*="    => [ "assignment",  "Multiplication Assignment",    "" ],
+            "%="    => [ "assignment",  "Modulus Assignment",           "" ],
+            "->"    => [ "?",           "Object member accessor thingy","" ],
+        }
+        admin = Group.filter(:name => 'admin').first
+        add_sig(:sig => 'pfunc (\S+)', :method => :phpfunc, :desc => 'Lookup PHP function', :params => [:name])
+        add_sig(:sig => 'fetch php manual', :method => :fetch, :group => admin, :desc => 'Download and extract PHP manual')
+        add_sig(:sig => 'pfunc trigger (\S+)', :method => :set_trigger, :group => admin, :desc => 'Set the trigger for auto-lookups', :params => [:trigger])
+        add_sig(:sig => 'pfunc show trigger', :method => :show_trigger, :desc => 'Show current trigger')
+        add_sig(:sig => 'pfunc (add|remove) (\S+)', :method => :set_channels, :group => admin, :desc => 'Add or remove channels from auto-lookups', :params => [:action, :channel])
+        add_sig(:sig => 'pfunc show channels', :method => :list_channels, :desc => 'Show channels with auto lookup enabled')
+        @pipeline.hook(self, :listen, :Incoming_Privmsg)
+        populate_classes
+    end
+        
+    def phpfunc(m, params)
+        name = params[:name].downcase
+        Logger.info "phpfunc name=#{name}"
+        if name =~ /^\S+$/ && name =~ /\*/
+            parse_wildcard(m, name) 
+        elsif name =~ /^\$/
+            parse_predefined(m, name)
+        elsif name =~ /^\S+$/ && filename = find_control_file(name)
+            parse_control(m, name, filename)
+        elsif name =~ /^\S+$/ && filename = find_function_file(name)
+            parse_function(m, name, filename) 
+        elsif @ops.has_key?(name)
+            parse_operator(m, name) 
+        end
+    end
+    
+    def fetch(m, params)
+        reply m.replyto, "Fetching PHP manual (This could take a few minutes)"
+        fetch_manual(m)
+    end
+    
+    def listen(m)
+        if(m.target.is_a?(Channel) && Setting.val(:phpfunc)[:channels].include?(m.target.pk))
+            if m.message =~ /^#{Regexp.escape(@trigger)}(\S+)$/
+                phpfunc(m, {:name => $1})
+            end
+        end
+    end
+    
+    def set_trigger(message, params)
+        vals = Setting.val(:phpfunc)
+        vals[:trigger] = params[:trigger]
+        Setting.filter(:name => 'phpfunc').first.value = vals
+        @trigger = params[:trigger]
+        reply message.replyto, "PHP function lookup trigger set to: #{params[:trigger]}"
+    end
+    
+    def set_channels(message, params)
+        channel = Channel.filter(:name => params[:channel]).first
+        if(channel)
+            vals = Setting.val(:phpfunc)
+            if(params[:action] == 'add')
+                vals[:channels] << channel.pk unless Setting.val(:phpfunc)[:channels].include?(channel.pk)
+                reply message.replyto, "Channel \2#{params[:channel]}\2 added to PHP auto lookup"
+            else
+                vals[:channels].delete(channel.pk) if Setting.val(:phpfunc)[:channels].include?(channel.pk)
+                reply message.replyto, "Channel \2#{params[:channel]}\2 has been removed from PHP auto lookup"
+            end
+            Setting.filter(:name => 'phpfunc').first.value = vals
+        else
+            reply message.replyto, "Error: No record of channel #{params[:channel]}"
+        end
+    end
+    
+    def list_channels(message, params)
+        if(Setting.val(:phpfunc)[:channels].size > 0)
+            chans = []
+            Setting.val(:phpfunc)[:channels].each do |id|
+                chans << Channel[id].name
+            end
+            reply message.replyto, "PHP auto lookup enabled channels: #{chans.join(', ')}"
+        else
+            reply message.replyto, 'No channels currently enabled for PHP auto lookup'
+        end
+    end
+    
+    def show_trigger(message, p)
+        reply message.replyto, "PHP auto lookup trigger: \2#{Setting.val(:phpfunc)[:trigger]}\2"
+    end
+    
+    private
+
+    def find_function_file(name)
+        Dir.new(@manual).each do |filename|
+            return filename if filename.downcase == "function.#{name.gsub(/(_|->)/, '-').downcase}.html"
+        end
+        return nil
+    end
+    
+    def find_control_file(name)
+        Dir.new(@manual).each do |filename|
+            return filename if filename.downcase == "control-structures.#{name}.html"
+        end
+        return nil
+    end
+
+    def fetch_manual(message=nil, params=nil)
+        Thread.new do
+            Logger.info 'Fetching PHP manual from http://us.php.net'
+            open("#{@path}/manual.tar.gz", 'w').write(open('http://us.php.net/distributions/manual/php_manual_en.tar.gz').read)
+            Dir.chdir(@path)
+            Helpers.safe_exec("tar -xzf #{@path}/manual.tar.gz", 60)
+            Logger.info "PHP manual fetching complete."
+            reply message.replyto, "PHP manual fetch is now complete" unless message.nil?
+        end
+    end
+
+    def setup_setting
+        s = Setting.filter(:name => 'phpfunc').first
+        unless(s)
+            s = Setting.find_or_create(:name => 'phpfunc')
+            s.value = {:directory => Config.val(:plugin_directory) + '/php', :trigger => '@', :channels => []}
+        end
+        unless(File.directory?(Setting.val(:phpfunc)[:directory]))
+            FileUtils.mkdir_p(Setting.val(:phpfunc)[:directory])
+        end
+    end
+    
+    def parse_predefined(m, name)
+        name.upcase!
+        page = File.open("#{@manual}/language.variables.predefined.html").readlines.join(' ').gsub(/[\n\r]/, '')
+        if page =~ /<dt>\s*<span class="term"><a href="reserved\.variables\.html.+? class="link">#{name.gsub(/\$/, '\$')}<\/a><\/span>\s*<dd>\s*<span class="simpara">(.+?)<\/span>/
+            desc = $1
+            desc.gsub!(/[\r\n]/, ' ')
+            desc.gsub!(/<.+?>/, ' ')
+            desc = CGI::unescapeHTML(desc.gsub(/\s+/, ' '))
+            output = ["\2PHP Superglobal\2"]
+            output << "\2#{name}:\2 #{desc}"
+        else
+            output = "No superglobal found matching: #{name}"
+        end
+        reply m.replyto, output
+    end
+    
+    def parse_wildcard(m, name)
+        matches = []
+        pattern = name.gsub(/\*/, '.*?').gsub(/_/, '-')
+        Dir.open(@manual).each do |file|
+            if(file =~ /^(function\.#{pattern})\.html/)
+                match = $1
+                if(match =~ /^function\.(.+?)\-/)
+                    if(@classlist.include?($1.downcase))
+                        match.gsub!(/[-]/, '_')
+                        match.sub!(/_/, '->')
+                    else
+                        match.gsub!(/[-]/, '_')
+                    end
+                end
+                match.gsub!(/^function\./, '')
+                matches << match unless match.empty?
+            end
+        end
+        matches.sort!
+        output = matches.size > 20 ? ["Lots of matching functions. Truncating list to 20 results."] : []
+        if(matches.empty?)
+            output = "\2Error:\2 No matches found"
+        else
+            output << "Matches against term: \2#{name}:\2"
+            output << matches.values_at(0..19).join(', ')
+        end
+        reply m.replyto, output
+    end
+    
+    def parse_function(m, name, filename)
+        page = File.open("#{@manual}/#{filename}", 'r').readlines.join('')
+        page.gsub!(/[\r\n]/, '')
+        versions = page =~ /<p class="verinfo">(.+?)<\/p>/i ? $1 : '(UNKNOWN)'
+        proto = page =~ /<div class="methodsynopsis dc-description">(.+?)<\/div>/i ? $1 : name
+        desc = page =~ /<p class="(para rdfs-comment|simpara)">(.+?)<\/p>/i ? $2.strip : '(UNKNOWN)'
+        versions = CGI::unescapeHTML(versions)
+        proto = CGI::unescapeHTML(proto.gsub(/<.+?>/, ' ').gsub(/[\s]+/, ' '))
+        desc = CGI::unescapeHTML(desc.gsub(/<.+?>/, ' ').gsub(/[\s]+/, ' '))
+        output = [versions]
+        output << "\2#{proto}\2"
+        output << Helpers.convert_entities(desc)
+        output << "http://www.php.net/manual/en/#{filename.gsub(/\.html$/, '.php')}"
+        reply m.replyto, output
+    end
+
+    def parse_operator(m, name)
+        Logger.info "parse_operator name=#{name}"
+        name.downcase!
+        type, title, ejemplo = @ops[name]
+        if(title.is_a?(Array))
+            output = ["\2#{name}\2 is the \2#{title.join("\2 or \2")}\2 operator"]
+            if(ejemplo.is_a?(Array))
+                (0..(ejemplo.size - 1)).each do |i|
+                    output << "\2Example (#{type[i]}):\2 #{ejemplo[i]}"
+                end
+            elsif(!ejemplo.nil?)
+                output << "\2Example (#{type}):\2 #{ejemplo}"
+            end
+            type.each do |t|
+                output << "http://php.net/manual/en/language.operators.#{t}.php"
+            end
+        else
+            output = ["\2#{name}\2 is the \2#{title}\2 operator"]
+            output << "\2Example usage:\2 #{ejemplo}" unless ejemplo.nil? || ejemplo.empty?
+            output << "http://php.net/manual/en/language.operators.#{type}.php"
+        end
+        reply m.replyto, output
+    end
+    
+    def parse_control(m, name, filename)
+        page = File.open("#{@manual}/#{filename}", 'r').readlines.join('')
+        page.gsub!(/[\r\n]/, '')
+        con = page =~ /<h2 class="title"><i>([^<]+)</ ? $1 : '(UNKNOWN)'
+        par = page =~ /^.+?<p class="para">(.+?)<div/ ? $1.strip : '(UNKNOWN)'
+        Logger.info("Match: #{par}")
+        par = par.gsub(/<.+?>/, ' ').gsub(/\s{2,}/, ' ')
+        par.gsub!(/\.[^\.]+:$/, '.')
+        #par.slice!(0..199) if par.size > 200
+        output = ["\2Control structure: #{con}\2"]
+        output << par
+        output << "http://www.php.net/manual/en/#{filename.gsub(/\.html$/, '.php')}"
+        reply m.replyto, output
+    end
+    
+    def populate_classes
+        if(@classlist.empty?)
+            Dir.open(@manual).each do |file|
+                if(file =~ /^class\.(.+?)\.html/)
+                    @classlist << $1
+                end
+            end
+            @classlist.uniq!
+        end
+    end
+    
+end

data/data/mod_spox/extras/Pinger.rb

@@ -0,0 +1,11 @@
+class Pinger < ModSpox::Plugin
+
+    def initialize(pipeline)
+        super(pipeline)
+        add_sig(:sig => 'ping', :method => :ping)
+    end
+    
+    def ping(message, params)
+        reply message.replyto, "#{message.source.nick}: pong"
+    end
+end

data/data/mod_spox/extras/Quotes.rb

@@ -0,0 +1,79 @@
+class Quotes < ModSpox::Plugin
+
+    include Models
+    
+    def initialize(pipeline)
+        super
+        Quote.create_table unless Quote.table_exists?
+        group = Group.find_or_create(:name => 'quote')
+        add_sig(:sig => 'quote ?(.+)?', :method => :quote, :desc => 'Display random quote, random quote containing search term, or quote with given ID', :params => [:term])
+        add_sig(:sig => 'addquote (.+)', :method => :addquote, :desc => 'Add a new quote', :params => [:quote])
+        add_sig(:sig => 'searchquote (.+)', :method => :searchquote, :desc => 'Return IDs of quotes matching term', :params => [:term])
+        add_sig(:sig => 'delquote (\d+)', :method => :delquote, :group => group, :desc => 'Delete quote with given ID', :params => [:id])
+    end
+    
+    def quote(message, params)
+        quote = nil
+        reg = false
+        if(params[:term])
+            if(params[:term] =~ /^\d+$/)
+                quote = Quote[params[:term].to_i]
+            else
+                ids = Quote.filter(:quote => Regexp.new(params[:term], Regexp::IGNORECASE)).map(:id) 
+                quote = Quote[ids[rand(ids.size)].to_i]
+                reg = true
+            end
+        else
+            ids = Quote.select(:id).map(:id)
+            quote = Quote[ids[rand(ids.size)].to_i]
+        end
+        if(quote)
+            reply message.replyto, "\2[\2#{quote.pk}\2|\2#{quote.added.year}/#{sprintf('%02d', quote.added.month)}/#{sprintf('%02d', quote.added.day)}\2]:\2 #{reg ? quote.quote.gsub(/(#{params[:term]})/i, "\2\\1\2") : quote.quote}"
+        else
+            reply message.replyto, "\2Error:\2 Failed to find quote"
+        end
+    end
+    
+    def addquote(message, params)
+        quote = Quote.new(:nick_id => message.source.pk, :channel_id => message.target.pk)
+        quote.quote = params[:quote]
+        quote.added = Time.now
+        quote.save
+        reply message.replyto, "\2Quote added:\2 ##{quote.pk}"
+    end
+    
+    def searchquote(message, params)
+        result = Quote.filter(:quote => Regexp.new(params[:term], Regexp::IGNORECASE))
+        if(result.count > 0)
+            ids = result.map(:id)
+            ids.sort!
+            ids = ids.slice(0, 20)
+            reply message.replyto, "Quotes matching term (#{params[:term]}): #{ids.join(', ')}"
+        else
+            reply message.replyto, "\2Error:\2 No quotes match search term: #{params[:term]}"
+        end
+    end
+    
+    def delquote(message, params)
+        result = Quote.filter(:id => params[:id].to_i)
+        if(result.count < 1)
+            reply message.replyto, "\2Error:\2 Failed to find quote with ID: #{params[:id]}"
+        else
+            result.destroy
+            reply message.replyto, "\2Quote deleted:\2 ##{params[:id]}"
+        end
+    end
+    
+    class Quote < Sequel::Model
+        set_schema do
+            primary_key :id
+            text :quote, :null => false
+            timestamp :added, :null => false
+            foreign_key :nick_id, :table => :nicks
+            foreign_key :channel_id, :table => :channels
+        end
+        many_to_one :nick, :class => ModSpox::Models::Nick
+        many_to_one :channel, :class => ModSpox::Models::Channel
+    end
+    
+end

data/data/mod_spox/extras/RegexTracker.rb

@@ -0,0 +1,158 @@
+class RegexTracker < ModSpox::Plugin
+
+    include Models
+    def initialize(pipeline)
+        super
+        track = Group.find_or_create(:name => 'track')
+        add_sig(:sig => 'track info (\d+)', :method => :score, :desc => 'Show info on regex tracking',
+                :params => [:id])
+        add_sig(:sig => 'track list(\s\S+)?', :method => :list, :desc => 'List currently tracked regex', :params => [:channel])
+        add_sig(:sig => 'track add (.+)', :method => :add, :desc => 'Add new regex for tracking',
+                :params => [:regex], :group => track)
+        add_sig(:sig => 'track remove (\d+)', :method => :remove, :desc => 'Remove regex from tracking',
+                :params => [:id], :group => track)
+        add_sig(:sig => 'track modify (\d+) (.+)', :method => :modify, :desc => 'Modify regex',
+                :params => [:id, :regex], :group => track)
+        @pipeline.hook(self, :check, :Incoming_Privmsg)
+        TrackInfo.create_table unless TrackInfo.table_exists?
+        @cache = {}
+        build_cache
+    end
+    
+    def check(message)
+        return unless @cache.has_key?(message.target.pk.to_i)
+        time = Time.now
+        @cache[message.target.pk.to_i].each do |t|
+            if(message.message =~ /#{t[:regex]}/)
+                ti = TrackInfo[t[:id]]
+                if(ti.last_score.year != time.year || ti.last_score.yday != time.yday)
+                    ti.score_today = 0
+                end
+                ti.last_score = Time.now
+                ti.score_today += 1
+                ti.score_total += 1
+                ti.save
+            end
+        end
+    end
+    
+    def list(message, params)
+        output = ''
+        begin
+            raise 'No channel given for list' if message.is_private? && !params[:channel]
+            channel = params[:channel] ? Helpers.find_model(params[:channel].strip, false) : message.target
+            if(TrackInfo.filter(:channel_id => channel.pk).count > 0)
+                output = []
+                output << "\2Currently tracked regexs in #{channel.name}"
+                TrackInfo.filter(:channel_id => channel.pk).each do |t|
+                    output << "\2ID:\2 #{t.pk} --- \2REGEX:\2 #{t.regex}"
+                end
+            else
+                output = 'Error: Nothing is currently being tracked'
+            end
+        rescue Object => boom
+            output = "Error: #{boom}"
+        ensure
+            reply message.replyto, output
+        end
+    end
+    
+    def add(message, params)
+        output = ''
+        begin
+            r = Regexp.new(params[:regex])
+            t = TrackInfo.new
+            t.regex = params[:regex]
+            t.channel = message.target
+            t.last_score = Time.now
+            t.save
+            build_cache
+            output = "New regex has been added for tracking (ID: #{t.pk})"
+        rescue Object => boom
+            output = "Failed to save regex: #{boom}"
+        ensure
+            reply message.replyto, output
+        end
+    end
+    
+    def remove(message, params)
+        id = params[:id].to_i
+        tis = TrackInfo.filter(:id => id)
+        if(tis.count > 0)
+            tis.destroy
+            build_cache
+            reply message.replyto, "Regex has been removed (ID: #{id})"
+        else
+            reply message.replyto, "Failed to find regex being tracked with ID: #{id}"
+        end
+    end
+    
+    def modify(message, params)
+        id = params[:id].to_i
+        tis = TrackInfo.filter(:id => id)
+        output = ''
+        begin
+            r = Regexp.new(params[:regex])
+            if(tis.count > 0)
+                t = tis.first
+                t.regex = params[:regex]
+                t.save
+                build_cache
+                output = "Regex has been update (ID: #{t.pk})"
+            else
+                output = "Failed to locate tracking regex (ID: #{id})"
+            end
+        rescue Object => boom
+            output = "Failed to save regex. #{boom}"
+        ensure
+            reply message.replyto, output
+        end
+    end
+    
+    def score(message, params)
+        id = params[:id].to_i
+        t = TrackInfo.filter(:id => id).first
+        if(t)
+            reply message.replyto, "\2(#{id})\2: Regex: #{t.regex}, Today: #{t.score_today}, Total: #{t.score_total}, Last occurance: #{t.last_score}"
+        else
+            reply message.replyto, "Failed to find tracking regex with ID: #{id}"
+        end
+    end
+    
+    def build_cache
+        @cache = {}
+        TrackInfo.all.each do |t|
+            @cache[t.channel_id.to_i] = [] unless @cache.has_key?(t.channel_id.to_i)
+            @cache[t.channel_id.to_i] << {:id => t.pk, :regex => t.regex}
+        end
+    end
+    
+    class TrackInfo < Sequel::Model
+        set_schema do
+            primary_key :id, :null => false
+            varchar :regex, :null => false
+            integer :score_total, :null => false, :default => 0
+            integer :score_today, :null => false, :default => 0
+            timestamp :last_score, :null => false
+            foreign_key :channel_id, :table => :channels, :null => false
+            index [:regex, :channel_id], :unique => true
+        end
+
+        many_to_one :channel, :class => ModSpox::Models::Channel
+        
+        def channel=(chan)
+            raise Exceptions::InvalidType.new('Channel model was expected') unless chan.is_a?(Models::Channel)
+            values[:channel_id] = chan.pk
+        end
+        
+        def regex=(r)
+            r = [Marshal.dump(r)].pack('m')
+            super(r)
+        end
+        
+        def regex
+            values[:regex] ? Marshal.load(values[:regex].unpack('m')[0]) : nil
+        end
+    end
+
+end