Removed Slack prefix from some structs

Author: nlopes

TODO.txt

@@ -1,5 +1,3 @@
 - Add more tests!!!
-- Add timeouts
-- Fix the Websocket mess
 - Add support to have markdown hints
   - See section Message Formatting at https://api.slack.com/docs/formatting

examples/websocket/websocket.go

@@ -36,7 +36,7 @@ func main() {
 			case *slack.LatencyReport:
 				fmt.Printf("Current latency: %v\n", ev.Value)
 
-			case *slack.SlackWSError:
+			case *slack.RTMError:
 				fmt.Printf("Error: %s\n", ev.Error())
 
 			default:

info.go

@@ -157,7 +157,7 @@ type Info struct {
 
 type infoResponseFull struct {
 	Info
-	SlackWebResponse
+	WebResponse
 }
 
 // GetBotByID returns a bot given a bot id

misc.go

@@ -16,6 +16,17 @@ import (
 	"time"
 )
 
+type WebResponse struct {
+	Ok    bool      `json:"ok"`
+	Error *WebError `json:"error"`
+}
+
+type WebError string
+
+func (s WebError) Error() string {
+	return string(s)
+}
+
 func fileUploadReq(path, fpath string, values url.Values) (*http.Request, error) {
 	fullpath, err := filepath.Abs(fpath)
 	if err != nil {

websocket.go

@@ -25,7 +25,7 @@ type RTM struct {
 
 	// Connection life-cycle
 	conn             *websocket.Conn
-	IncomingEvents   chan SlackEvent
+	IncomingEvents   chan RTMEvent
 	outgoingMessages chan OutgoingMessage
 	killChannel      chan bool
 	forcePing        chan bool
@@ -46,7 +46,7 @@ type RTM struct {
 func newRTM(api *Client) *RTM {
 	return &RTM{
 		Client:           *api,
-		IncomingEvents:   make(chan SlackEvent, 50),
+		IncomingEvents:   make(chan RTMEvent, 50),
 		outgoingMessages: make(chan OutgoingMessage, 20),
 		pings:            make(map[int]time.Time),
 		isConnected:      false,

websocket_managed_conn.go

@@ -36,7 +36,7 @@ func (rtm *RTM) ManageConnection() {
 			return
 		}
 		rtm.info = info
-		rtm.IncomingEvents <- SlackEvent{"connected", &ConnectedEvent{
+		rtm.IncomingEvents <- RTMEvent{"connected", &ConnectedEvent{
 			ConnectionCount: connectionCount,
 			Info:            info,
 		}}
@@ -76,7 +76,7 @@ func (rtm *RTM) connect(connectionCount int) (*Info, *websocket.Conn, error) {
 
 	for {
 		// send connecting event
-		rtm.IncomingEvents <- SlackEvent{"connecting", &ConnectingEvent{
+		rtm.IncomingEvents <- RTMEvent{"connecting", &ConnectingEvent{
 			Attempt:         boff.attempts + 1,
 			ConnectionCount: connectionCount,
 		}}
@@ -86,13 +86,13 @@ func (rtm *RTM) connect(connectionCount int) (*Info, *websocket.Conn, error) {
 			return info, conn, nil
 		}
 		// check for fatal errors - currently only invalid_auth
-		if sErr, ok := err.(*SlackWebError); ok && sErr.Error() == "invalid_auth" {
-			rtm.IncomingEvents <- SlackEvent{"invalid_auth", &InvalidAuthEvent{}}
+		if sErr, ok := err.(*WebError); ok && sErr.Error() == "invalid_auth" {
+			rtm.IncomingEvents <- RTMEvent{"invalid_auth", &InvalidAuthEvent{}}
 			return nil, nil, sErr
 		}
 		// any other errors are treated as recoverable and we try again after
 		// sending the event along the IncomingEvents channel
-		rtm.IncomingEvents <- SlackEvent{"connection_error", &ConnectionErrorEvent{
+		rtm.IncomingEvents <- RTMEvent{"connection_error", &ConnectionErrorEvent{
 			Attempt:  boff.attempts,
 			ErrorObj: err,
 		}}
@@ -132,7 +132,7 @@ func (rtm *RTM) killConnection(keepRunning chan bool, intentional bool) error {
 	rtm.isConnected = false
 	rtm.wasIntentional = intentional
 	err := rtm.conn.Close()
-	rtm.IncomingEvents <- SlackEvent{"disconnected", &DisconnectedEvent{intentional}}
+	rtm.IncomingEvents <- RTMEvent{"disconnected", &DisconnectedEvent{intentional}}
 	return err
 }
 
@@ -198,15 +198,15 @@ func (rtm *RTM) handleIncomingEvents(keepRunning <-chan bool) {
 func (rtm *RTM) sendOutgoingMessage(msg OutgoingMessage) {
 	rtm.Debugln("Sending message:", msg)
 	if len(msg.Text) > MaxMessageTextLength {
-		rtm.IncomingEvents <- SlackEvent{"outgoing_error", &MessageTooLongEvent{
+		rtm.IncomingEvents <- RTMEvent{"outgoing_error", &MessageTooLongEvent{
 			Message:   msg,
 			MaxLength: MaxMessageTextLength,
 		}}
 		return
 	}
 	err := websocket.JSON.Send(rtm.conn, msg)
 	if err != nil {
-		rtm.IncomingEvents <- SlackEvent{"outgoing_error", &OutgoingErrorEvent{
+		rtm.IncomingEvents <- RTMEvent{"outgoing_error", &OutgoingErrorEvent{
 			Message:  msg,
 			ErrorObj: err,
 		}}
@@ -249,7 +249,7 @@ func (rtm *RTM) receiveIncomingEvent() {
 		rtm.forcePing <- true
 		return
 	} else if err != nil {
-		rtm.IncomingEvents <- SlackEvent{"incoming_error", &IncomingEventError{
+		rtm.IncomingEvents <- RTMEvent{"incoming_error", &IncomingEventError{
 			ErrorObj: err,
 		}}
 		// force a ping here too?
@@ -268,14 +268,14 @@ func (rtm *RTM) handleRawEvent(rawEvent json.RawMessage) {
 	event := &Event{}
 	err := json.Unmarshal(rawEvent, event)
 	if err != nil {
-		rtm.IncomingEvents <- SlackEvent{"unmarshalling_error", &UnmarshallingErrorEvent{err}}
+		rtm.IncomingEvents <- RTMEvent{"unmarshalling_error", &UnmarshallingErrorEvent{err}}
 		return
 	}
 	switch event.Type {
 	case "":
 		rtm.handleAck(rawEvent)
 	case "hello":
-		rtm.IncomingEvents <- SlackEvent{"hello", &HelloEvent{}}
+		rtm.IncomingEvents <- RTMEvent{"hello", &HelloEvent{}}
 	case "pong":
 		rtm.handlePong(rawEvent)
 	default:
@@ -292,9 +292,9 @@ func (rtm *RTM) handleAck(event json.RawMessage) {
 		return
 	}
 	if ack.Ok {
-		rtm.IncomingEvents <- SlackEvent{"ack", ack}
+		rtm.IncomingEvents <- RTMEvent{"ack", ack}
 	} else {
-		rtm.IncomingEvents <- SlackEvent{"ack_error", &AckErrorEvent{ack.Error}}
+		rtm.IncomingEvents <- RTMEvent{"ack_error", &AckErrorEvent{ack.Error}}
 	}
 }
 
@@ -310,7 +310,7 @@ func (rtm *RTM) handlePong(event json.RawMessage) {
 	}
 	if pingTime, exists := rtm.pings[pong.ReplyTo]; exists {
 		latency := time.Since(pingTime)
-		rtm.IncomingEvents <- SlackEvent{"latency_report", &LatencyReport{Value: latency}}
+		rtm.IncomingEvents <- RTMEvent{"latency_report", &LatencyReport{Value: latency}}
 		delete(rtm.pings, pong.ReplyTo)
 	} else {
 		rtm.Debugln("RTM Error - unmatched 'pong' event:", string(event))
@@ -328,7 +328,7 @@ func (rtm *RTM) handleEvent(typeStr string, event json.RawMessage) {
 	if !exists {
 		rtm.Debugf("RTM Error, received unmapped event %q: %s\n", typeStr, string(event))
 		err := fmt.Errorf("RTM Error: Received unmapped event %q: %s\n", typeStr, string(event))
-		rtm.IncomingEvents <- SlackEvent{"unmarshalling_error", &UnmarshallingErrorEvent{err}}
+		rtm.IncomingEvents <- RTMEvent{"unmarshalling_error", &UnmarshallingErrorEvent{err}}
 		return
 	}
 	t := reflect.TypeOf(v)
@@ -337,10 +337,10 @@ func (rtm *RTM) handleEvent(typeStr string, event json.RawMessage) {
 	if err != nil {
 		rtm.Debugf("RTM Error, could not unmarshall event %q: %s\n", typeStr, string(event))
 		err := fmt.Errorf("RTM Error: Could not unmarshall event %q: %s\n", typeStr, string(event))
-		rtm.IncomingEvents <- SlackEvent{"unmarshalling_error", &UnmarshallingErrorEvent{err}}
+		rtm.IncomingEvents <- RTMEvent{"unmarshalling_error", &UnmarshallingErrorEvent{err}}
 		return
 	}
-	rtm.IncomingEvents <- SlackEvent{typeStr, recvEvent}
+	rtm.IncomingEvents <- RTMEvent{typeStr, recvEvent}
 }
 
 // eventMapping holds a mapping of event names to their corresponding struct

websocket_misc.go

@@ -10,38 +10,27 @@ type AckMessage struct {
 	ReplyTo   int    `json:"reply_to"`
 	Timestamp string `json:"ts"`
 	Text      string `json:"text"`
-	SlackWSResponse
+	RTMResponse
 }
 
-type SlackWebResponse struct {
-	Ok    bool           `json:"ok"`
-	Error *SlackWebError `json:"error"`
+type RTMResponse struct {
+	Ok    bool      `json:"ok"`
+	Error *RTMError `json:"error"`
 }
 
-type SlackWebError string
-
-func (s SlackWebError) Error() string {
-	return string(s)
-}
-
-type SlackWSResponse struct {
-	Ok    bool          `json:"ok"`
-	Error *SlackWSError `json:"error"`
-}
-
-type SlackWSError struct {
+type RTMError struct {
 	Code int
 	Msg  string
 }
 
-func (s SlackWSError) Error() string {
+func (s RTMError) Error() string {
 	return fmt.Sprintf("Code %d - %s", s.Code, s.Msg)
 }
 
 type MessageEvent Message
 
-// SlackEvent is the main wrapper. You will find all the other messages attached
-type SlackEvent struct {
+// RTMEvent is the main wrapper. You will find all the other messages attached
+type RTMEvent struct {
 	Type string
 	Data interface{}
 }