Change framework to support output handlers

[belak]

Currently handlers are only used to sort input. It would be nice to be able to handle output as well for preprocessing and hooks. It would make the lib act more like a middleware lib.

Perhaps a way of registering middleware and depending on what it implements, running it at different times?

[Xe]

👍

[belak]

On a side note, I'm open to ideas for this. I didn't make this a high priority because I didn't have a huge use for it and couldn't think of anything that was very clean.

I've seen a couple good uses for this lately, but I still don't have any good ideas for the design. :(

[belak]

So far the most elegant solution I've come up with is more complicated than I want it to be:

• The write function would send the message to the output handler
• The output handler would have muxes, similar to how input works - it could eventually be split out into message types
• The output handler would receive raw lines, but could parse them and change them before finally rendering them again

This has a number of issues. If designed similar to negroni's middleware framework, it would be impossible to send more than one message from an output handler, unless yet another parameter was passed in which would be a function for sending messages.

This is already getting more complicated than I wanted it, so I'm open to any better solutions.

[belak]

I've been toying with a few ideas and I've come up with one that MAY be workable... there would just be some sort of filter function that can be registered which will take an irc.Message and return an irc.Message or nil if it should be dropped.

That wouldn't allow for sending multiple messages though, so any improvements would be welcome.

[Xe]

Have things return []irc.Message instead of just one.

[belak]

I had an idea... not sure how realistic it is

// OutputHandler is meant as a filter function which takes a
// message and returns whether or not it should be written
// to the stream.
//
// The conn is passed as a first parameter so things like message
// splitting can be implemented by simply splitting the messages,
// calling c.WriteMessage multiple times, and returning false.
type OutputHandler func(c *irc.Conn, m *irc.Message) bool

[Xe]

OutputHandler is a misleading term for a a -> b -> Bool function type name IMO.

[belak]

OutputFilter, perhaps?