root/lang/ruby/chokan/branches/citrus/plugins/http.rb @ 6404

#!/usr/bin/env ruby


require "pathname"
require "uri"

class HTTP < Citrus::Plugin

        attr_reader :handlers

        def initialize(*args)
                super

                @handlers_dir = Pathname.new(@core.config.general["plugin_dir"]) + "http"
                Pathname.glob(@handlers_dir + "*.rb") do |f|
                        eval(f.read)
                end

                plugin = self
                Handler.__send__(:define_method, :log) do |*args|
                        plugin.log(*args)
                end

                @handlers = Handler.handlers.map do |h|
                        name = h.name.sub(/^.+::/, "")
                        h.new(self)
                end

                @handlers << "Default"
        end

        def on_privmsg(prefix, channel, message)
                message.scan(URI.regexp(["http"])).each do
                        uri = Regexp.last_match.to_s
                        Thread.start(channel, URI(uri)) do |chan, u|
                                begin
                                        response(chan, u)
                                rescue Exception => e
                                        post NOTICE, chan, e.inspect
                                        log e.inspect
                                        e.backtrace.each do |l|
                                                log l
                                        end
                                end
                        end
                end
        end

        def response(chan, uri)
                ret = nil
                @handlers.each do |handler|
                        ret = handler.process(uri)
                        break if ret
                end
                if ret
                        post NOTICE, chan, ret
                end
        end

        class Handler
                @@handlers = []

                def self.handlers
                        @@handlers
                end

                def self.inherited(subclass)
                        @@handlers << subclass
                end

                def initialize(config)
                        @config = config
                end

                def process(uri)
                end
        end
end

tests do

        describe HTTP do
                before :all do
                        @core   = DummyCore.new({})
                        @socket = @core.socket
                        @prefix = Net::IRC::Prefix.new("foo!foo@localhsot")
                        @handlers_dir = Pathname.tempname + "http"
                        @handlers_dir.mkpath

                        (@handlers_dir + "foo.rb").open("w") do |f|
                                f.puts <<-EOF
                                        class Foo < Handler

                                                def process(uri)
                                                        return unless uri.host == "foo"

                                                        "foo foo"
                                                end
                                        end
                                EOF
                        end

                        (@handlers_dir + "bar.rb").open("w") do |f|
                                f.puts <<-EOF
                                        class Bar < Handler

                                                def process(uri)
                                                        return unless uri.host == "bar"

                                                        "bar bar"
                                                end
                                        end
                                EOF
                        end

                        (@handlers_dir + "default.rb").open("w") do |f|
                                f.puts File.read("./plugins/http/default.rb")
                        end

                        @core.config.general["plugin_dir"] = @handlers_dir.parent.to_s

                        @plugin = HTTP.new(@core, { "HTTP" => {
                                "handlers" => [
                                        { "class" => "Foo"  },
                                        { "class" => "Bar" },
                                ]
                        } })
                end

                it "should reply correctly" do
                        Thread.abort_on_exception = true
                        Thread.critical = true
                        @socket.string = ""
                        @plugin.on_privmsg(@prefix, "#test", "http://foo/")
                        Thread.pass
                        @socket.string.should == "NOTICE #test :foo foo\r\n"


                        @socket.string = ""
                        @plugin.on_privmsg(@prefix, "#test", "http://bar/")
                        Thread.pass
                        @socket.string.should == "NOTICE #test :bar bar\r\n"
                        Thread.critical = false

                        @socket.string = ""
                        @plugin.on_privmsg(@prefix, "#test", "http://example.com/")
                        true while @socket.string.empty?
                        @socket.string.should == "NOTICE #test :Example Web Page [text/html; charset=UTF-8]\r\n"

                        @socket.string = ""
                        @plugin.on_privmsg(@prefix, "#test", "http://localhost/")
                        true while @socket.string.empty?
                        @socket.string.should == "NOTICE #test :#<Net::HTTP::Paranoid::NotAllowedHostError: localhost is blocked by Paranoid because it is LAN.>\r\n"
                end
        end

end