From 354da79bb2edaa1af7d909d2774e7d67eb4e198c Mon Sep 17 00:00:00 2001 From: Dimitri Sokolyuk Date: Tue, 23 Jan 2018 18:17:51 +0100 Subject: Add vendor --- vendor/github.com/fluffle/goirc/client/commands.go | 304 +++++++++++++++++++++ 1 file changed, 304 insertions(+) create mode 100644 vendor/github.com/fluffle/goirc/client/commands.go (limited to 'vendor/github.com/fluffle/goirc/client/commands.go') 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, " ")) + } +} -- cgit v1.2.3