summaryrefslogtreecommitdiff
path: root/vendor/github.com/fluffle/goirc/client/commands.go
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/github.com/fluffle/goirc/client/commands.go')
-rw-r--r--vendor/github.com/fluffle/goirc/client/commands.go304
1 files changed, 304 insertions, 0 deletions
diff --git a/vendor/github.com/fluffle/goirc/client/commands.go b/vendor/github.com/fluffle/goirc/client/commands.go
new file mode 100644
index 0000000..101c7d3
--- /dev/null
+++ b/vendor/github.com/fluffle/goirc/client/commands.go
@@ -0,0 +1,304 @@
+package client
+
+import (
+ "fmt"
+ "strings"
+)
+
+const (
+ REGISTER = "REGISTER"
+ CONNECTED = "CONNECTED"
+ DISCONNECTED = "DISCONNECTED"
+ ACTION = "ACTION"
+ AWAY = "AWAY"
+ CAP = "CAP"
+ CTCP = "CTCP"
+ CTCPREPLY = "CTCPREPLY"
+ ERROR = "ERROR"
+ INVITE = "INVITE"
+ JOIN = "JOIN"
+ KICK = "KICK"
+ MODE = "MODE"
+ NICK = "NICK"
+ NOTICE = "NOTICE"
+ OPER = "OPER"
+ PART = "PART"
+ PASS = "PASS"
+ PING = "PING"
+ PONG = "PONG"
+ PRIVMSG = "PRIVMSG"
+ QUIT = "QUIT"
+ TOPIC = "TOPIC"
+ USER = "USER"
+ VERSION = "VERSION"
+ VHOST = "VHOST"
+ WHO = "WHO"
+ WHOIS = "WHOIS"
+ defaultSplit = 450
+)
+
+// cutNewLines() pares down a string to the part before the first "\r" or "\n".
+func cutNewLines(s string) string {
+ r := strings.SplitN(s, "\r", 2)
+ r = strings.SplitN(r[0], "\n", 2)
+ return r[0]
+}
+
+// indexFragment looks for the last sentence split-point (defined as one of
+// the punctuation characters .:;,!?"' followed by a space) in the string s
+// and returns the index in the string after that split-point. If no split-
+// point is found it returns the index after the last space in s, or -1.
+func indexFragment(s string) int {
+ max := -1
+ for _, sep := range []string{". ", ": ", "; ", ", ", "! ", "? ", "\" ", "' "} {
+ if idx := strings.LastIndex(s, sep); idx > max {
+ max = idx
+ }
+ }
+ if max > 0 {
+ return max + 2
+ }
+ if idx := strings.LastIndex(s, " "); idx > 0 {
+ return idx + 1
+ }
+ return -1
+}
+
+// splitMessage splits a message > splitLen chars at:
+// 1. the end of the last sentence fragment before splitLen
+// 2. the end of the last word before splitLen
+// 3. splitLen itself
+func splitMessage(msg string, splitLen int) (msgs []string) {
+ // This is quite short ;-)
+ if splitLen < 13 {
+ splitLen = defaultSplit
+ }
+ for len(msg) > splitLen {
+ idx := indexFragment(msg[:splitLen-3])
+ if idx < 0 {
+ idx = splitLen - 3
+ }
+ msgs = append(msgs, msg[:idx]+"...")
+ msg = msg[idx:]
+ }
+ return append(msgs, msg)
+}
+
+// Raw sends a raw line to the server, should really only be used for
+// debugging purposes but may well come in handy.
+func (conn *Conn) Raw(rawline string) {
+ // Avoid command injection by enforcing one command per line.
+ conn.out <- cutNewLines(rawline)
+}
+
+// Pass sends a PASS command to the server.
+// PASS password
+func (conn *Conn) Pass(password string) { conn.Raw(PASS + " " + password) }
+
+// Nick sends a NICK command to the server.
+// NICK nick
+func (conn *Conn) Nick(nick string) { conn.Raw(NICK + " " + nick) }
+
+// User sends a USER command to the server.
+// USER ident 12 * :name
+func (conn *Conn) User(ident, name string) {
+ conn.Raw(USER + " " + ident + " 12 * :" + name)
+}
+
+// Join sends a JOIN command to the server with an optional key.
+// JOIN channel [key]
+func (conn *Conn) Join(channel string, key ...string) {
+ k := ""
+ if len(key) > 0 {
+ k = " " + key[0]
+ }
+ conn.Raw(JOIN + " " + channel + k)
+}
+
+// Part sends a PART command to the server with an optional part message.
+// PART channel [:message]
+func (conn *Conn) Part(channel string, message ...string) {
+ msg := strings.Join(message, " ")
+ if msg != "" {
+ msg = " :" + msg
+ }
+ conn.Raw(PART + " " + channel + msg)
+}
+
+// Kick sends a KICK command to remove a nick from a channel.
+// KICK channel nick [:message]
+func (conn *Conn) Kick(channel, nick string, message ...string) {
+ msg := strings.Join(message, " ")
+ if msg != "" {
+ msg = " :" + msg
+ }
+ conn.Raw(KICK + " " + channel + " " + nick + msg)
+}
+
+// Quit sends a QUIT command to the server with an optional quit message.
+// QUIT [:message]
+func (conn *Conn) Quit(message ...string) {
+ msg := strings.Join(message, " ")
+ if msg == "" {
+ msg = conn.cfg.QuitMessage
+ }
+ conn.Raw(QUIT + " :" + msg)
+}
+
+// Whois sends a WHOIS command to the server.
+// WHOIS nick
+func (conn *Conn) Whois(nick string) { conn.Raw(WHOIS + " " + nick) }
+
+// Who sends a WHO command to the server.
+// WHO nick
+func (conn *Conn) Who(nick string) { conn.Raw(WHO + " " + nick) }
+
+// Privmsg sends a PRIVMSG to the target nick or channel t.
+// If msg is longer than Config.SplitLen characters, multiple PRIVMSGs
+// will be sent to the target containing sequential parts of msg.
+// PRIVMSG t :msg
+func (conn *Conn) Privmsg(t, msg string) {
+ prefix := PRIVMSG + " " + t + " :"
+ for _, s := range splitMessage(msg, conn.cfg.SplitLen) {
+ conn.Raw(prefix + s)
+ }
+}
+
+// Privmsgln is the variadic version of Privmsg that formats the message
+// that is sent to the target nick or channel t using the
+// fmt.Sprintln function.
+// Note: Privmsgln doesn't add the '\n' character at the end of the message.
+func (conn *Conn) Privmsgln(t string, a ...interface{}) {
+ msg := fmt.Sprintln(a...)
+ // trimming the new-line character added by the fmt.Sprintln function,
+ // since it's irrelevant.
+ msg = msg[:len(msg)-1]
+ conn.Privmsg(t, msg)
+}
+
+// Privmsgf is the variadic version of Privmsg that formats the message
+// that is sent to the target nick or channel t using the
+// fmt.Sprintf function.
+func (conn *Conn) Privmsgf(t, format string, a ...interface{}) {
+ msg := fmt.Sprintf(format, a...)
+ conn.Privmsg(t, msg)
+}
+
+// Notice sends a NOTICE to the target nick or channel t.
+// If msg is longer than Config.SplitLen characters, multiple NOTICEs
+// will be sent to the target containing sequential parts of msg.
+// NOTICE t :msg
+func (conn *Conn) Notice(t, msg string) {
+ for _, s := range splitMessage(msg, conn.cfg.SplitLen) {
+ conn.Raw(NOTICE + " " + t + " :" + s)
+ }
+}
+
+// Ctcp sends a (generic) CTCP message to the target nick
+// or channel t, with an optional argument.
+// PRIVMSG t :\001CTCP arg\001
+func (conn *Conn) Ctcp(t, ctcp string, arg ...string) {
+ // We need to split again here to ensure
+ for _, s := range splitMessage(strings.Join(arg, " "), conn.cfg.SplitLen) {
+ if s != "" {
+ s = " " + s
+ }
+ // Using Raw rather than PRIVMSG here to avoid double-split problems.
+ conn.Raw(PRIVMSG + " " + t + " :\001" + strings.ToUpper(ctcp) + s + "\001")
+ }
+}
+
+// CtcpReply sends a (generic) CTCP reply to the target nick
+// or channel t, with an optional argument.
+// NOTICE t :\001CTCP arg\001
+func (conn *Conn) CtcpReply(t, ctcp string, arg ...string) {
+ for _, s := range splitMessage(strings.Join(arg, " "), conn.cfg.SplitLen) {
+ if s != "" {
+ s = " " + s
+ }
+ // Using Raw rather than NOTICE here to avoid double-split problems.
+ conn.Raw(NOTICE + " " + t + " :\001" + strings.ToUpper(ctcp) + s + "\001")
+ }
+}
+
+// Version sends a CTCP "VERSION" to the target nick or channel t.
+func (conn *Conn) Version(t string) { conn.Ctcp(t, VERSION) }
+
+// Action sends a CTCP "ACTION" to the target nick or channel t.
+func (conn *Conn) Action(t, msg string) { conn.Ctcp(t, ACTION, msg) }
+
+// Topic() sends a TOPIC command for a channel.
+// If no topic is provided this requests that a 332 response is sent by the
+// server for that channel, which can then be handled to retrieve the current
+// channel topic. If a topic is provided the channel's topic will be set.
+// TOPIC channel
+// TOPIC channel :topic
+func (conn *Conn) Topic(channel string, topic ...string) {
+ t := strings.Join(topic, " ")
+ if t != "" {
+ t = " :" + t
+ }
+ conn.Raw(TOPIC + " " + channel + t)
+}
+
+// Mode sends a MODE command for a target nick or channel t.
+// If no mode strings are provided this requests that a 324 response is sent
+// by the server for the target. Otherwise the mode strings are concatenated
+// with spaces and sent to the server. This allows e.g.
+// conn.Mode("#channel", "+nsk", "mykey")
+//
+// MODE t
+// MODE t modestring
+func (conn *Conn) Mode(t string, modestring ...string) {
+ mode := strings.Join(modestring, " ")
+ if mode != "" {
+ mode = " " + mode
+ }
+ conn.Raw(MODE + " " + t + mode)
+}
+
+// Away sends an AWAY command to the server.
+// If a message is provided it sets the client's away status with that message,
+// otherwise it resets the client's away status.
+// AWAY
+// AWAY :message
+func (conn *Conn) Away(message ...string) {
+ msg := strings.Join(message, " ")
+ if msg != "" {
+ msg = " :" + msg
+ }
+ conn.Raw(AWAY + msg)
+}
+
+// Invite sends an INVITE command to the server.
+// INVITE nick channel
+func (conn *Conn) Invite(nick, channel string) {
+ conn.Raw(INVITE + " " + nick + " " + channel)
+}
+
+// Oper sends an OPER command to the server.
+// OPER user pass
+func (conn *Conn) Oper(user, pass string) { conn.Raw(OPER + " " + user + " " + pass) }
+
+// VHost sends a VHOST command to the server.
+// VHOST user pass
+func (conn *Conn) VHost(user, pass string) { conn.Raw(VHOST + " " + user + " " + pass) }
+
+// Ping sends a PING command to the server, which should PONG.
+// PING :message
+func (conn *Conn) Ping(message string) { conn.Raw(PING + " :" + message) }
+
+// Pong sends a PONG command to the server.
+// PONG :message
+func (conn *Conn) Pong(message string) { conn.Raw(PONG + " :" + message) }
+
+// Cap sends a CAP command to the server.
+// CAP subcommand
+// CAP subcommand :message
+func (conn *Conn) Cap(subcommmand string, capabilities ...string) {
+ if len(capabilities) == 0 {
+ conn.Raw(CAP + " " + subcommmand)
+ } else {
+ conn.Raw(CAP + " " + subcommmand + " :" + strings.Join(capabilities, " "))
+ }
+}