Fix formatting

.drone.yml

@@ -1,4 +1,19 @@
 kind: pipeline
+name: tests-fmt
+steps:
+  - name: go
+    image: golang:1.13
+    commands:
+      - make test_fmt
+trigger:
+  branch:
+    - master
+    - develop
+  event:
+    - push
+    - pull_request
+---
+kind: pipeline
 name: tests-integration
 steps:
   - name: wait
@@ -36,7 +51,7 @@ kind: pipeline
 name: tests-unit
 steps:
   - name: go
-    image: golang:1.12
+    image: golang:1.13
     commands:
       - make test_unit
 trigger:

Makefile

@@ -3,6 +3,7 @@ GORUN=$(GOCMD) run
 GOBUILD=$(GOCMD) build
 GOCLEAN=$(GOCMD) clean
 GOTEST=$(GOCMD) test
+GOFMT_PROG=gofmt
 DOCKERCOMPOSE=docker-compose
 
 
@@ -18,6 +19,9 @@ build:
 
 test: test_unit test_integration
 
+test_fmt:
+	$(GOFMT_PROG) -l .
+
 test_unit:
 	$(GOTEST) -tags=unit -v -cover
 

contact.go

@@ -54,24 +54,24 @@ func (h *Handler) CreateContact(w http.ResponseWriter, r *http.Request, p httpro
 		return
 	}
 
-  // Publish NATs
-  if h.nc != nil {
-    contact := Contact {
-      UserA: userID,
-      UserB: contact.ID,
-    }
-    contactString, err := json.Marshal(&contact)
-    if err == nil {
-      updateMsg := UpdateMsg {
-        Type: "add",
-        Data: string(contactString),
-      }
-      updateMsgString, err := json.Marshal(&updateMsg)
-      if err == nil {
-        h.nc.Publish("contact", updateMsgString)
-      }
-    }
-  }
+	// Publish NATs
+	if h.nc != nil {
+		contact := Contact{
+			UserA: userID,
+			UserB: contact.ID,
+		}
+		contactString, err := json.Marshal(&contact)
+		if err == nil {
+			updateMsg := UpdateMsg{
+				Type: "add",
+				Data: string(contactString),
+			}
+			updateMsgString, err := json.Marshal(&updateMsg)
+			if err == nil {
+				h.nc.Publish("contact", updateMsgString)
+			}
+		}
+	}
 
 	// Respond
 	w.WriteHeader(200)

conversation.go

@@ -57,20 +57,20 @@ func (h *Handler) CreateConversation(w http.ResponseWriter, r *http.Request, p h
 		return
 	}
 
-  // Publish NATs
-  if h.nc != nil {
-    conversationString, err := json.Marshal(&conversation)
-    if err == nil {
-      updateMsg := UpdateMsg {
-        Type: "add",
-        Data: string(conversationString),
-      }
-      updateMsgString, err := json.Marshal(&updateMsg)
-      if err == nil {
-        h.nc.Publish("conversation", updateMsgString)
-      }
-    }
-  }
+	// Publish NATs
+	if h.nc != nil {
+		conversationString, err := json.Marshal(&conversation)
+		if err == nil {
+			updateMsg := UpdateMsg{
+				Type: "add",
+				Data: string(conversationString),
+			}
+			updateMsgString, err := json.Marshal(&updateMsg)
+			if err == nil {
+				h.nc.Publish("conversation", updateMsgString)
+			}
+		}
+	}
 
 	// Respond
 	w.Header().Set("Content-Type", "application/json")
@@ -196,20 +196,20 @@ func (h *Handler) UpdateConversation(w http.ResponseWriter, r *http.Request, p h
 		}
 	}
 
-  // Publish NATs
-  if h.nc != nil {
-    conversationString, err := json.Marshal(&conversation)
-    if err == nil {
-      updateMsg := UpdateMsg {
-        Type: "update",
-        Data: string(conversationString),
-      }
-      updateMsgString, err := json.Marshal(&updateMsg)
-      if err == nil {
-        h.nc.Publish("conversation", updateMsgString)
-      }
-    }
-  }
+	// Publish NATs
+	if h.nc != nil {
+		conversationString, err := json.Marshal(&conversation)
+		if err == nil {
+			updateMsg := UpdateMsg{
+				Type: "update",
+				Data: string(conversationString),
+			}
+			updateMsgString, err := json.Marshal(&updateMsg)
+			if err == nil {
+				h.nc.Publish("conversation", updateMsgString)
+			}
+		}
+	}
 
 	w.WriteHeader(200)
 }
@@ -266,23 +266,23 @@ func (h *Handler) DeleteConversation(w http.ResponseWriter, r *http.Request, p h
 		return
 	}
 
-  // Publish NATs
-  if h.nc != nil {
-    conversation := Conversation {
-      ID: conversationID,
-    }
-    conversationString, err := json.Marshal(&conversation)
-    if err == nil {
-      updateMsg := UpdateMsg {
-        Type: "delete",
-        Data: string(conversationString),
-      }
-      updateMsgString, err := json.Marshal(&updateMsg)
-      if err == nil {
-        h.nc.Publish("conversation", updateMsgString)
-      }
-    }
-  }
+	// Publish NATs
+	if h.nc != nil {
+		conversation := Conversation{
+			ID: conversationID,
+		}
+		conversationString, err := json.Marshal(&conversation)
+		if err == nil {
+			updateMsg := UpdateMsg{
+				Type: "delete",
+				Data: string(conversationString),
+			}
+			updateMsgString, err := json.Marshal(&updateMsg)
+			if err == nil {
+				h.nc.Publish("conversation", updateMsgString)
+			}
+		}
+	}
 
 	w.WriteHeader(200)
 }
@@ -378,25 +378,25 @@ func (h *Handler) CreateConversationMember(w http.ResponseWriter, r *http.Reques
 		return
 	}
 
-  // Publish NATs
-  if h.nc != nil {
-    member := Member {
-      User: member.ID,
-      Conversation: conversationID,
-      Pinned: false, // default
-    }
-    memberString, err := json.Marshal(&member)
-    if err == nil {
-      updateMsg := UpdateMsg {
-        Type: "add",
-        Data: string(memberString),
-      }
-      updateMsgString, err := json.Marshal(&updateMsg)
-      if err == nil {
-        h.nc.Publish("member", updateMsgString)
-      }
-    }
-  }
+	// Publish NATs
+	if h.nc != nil {
+		member := Member{
+			User:         member.ID,
+			Conversation: conversationID,
+			Pinned:       false, // default
+		}
+		memberString, err := json.Marshal(&member)
+		if err == nil {
+			updateMsg := UpdateMsg{
+				Type: "add",
+				Data: string(memberString),
+			}
+			updateMsgString, err := json.Marshal(&updateMsg)
+			if err == nil {
+				h.nc.Publish("member", updateMsgString)
+			}
+		}
+	}
 
 	// Respond
 	//w.Header().Set("Content-Type", "application/json")
@@ -465,25 +465,25 @@ func (h *Handler) PinConversation(w http.ResponseWriter, r *http.Request, p http
 		return
 	}
 
-  // Publish NATs
-  if h.nc != nil {
-    member := Member {
-      User: userID,
-      Conversation: conversationID,
-      Pinned: true,
-    }
-    memberString, err := json.Marshal(&member)
-    if err == nil {
-      updateMsg := UpdateMsg {
-        Type: "update",
-        Data: string(memberString),
-      }
-      updateMsgString, err := json.Marshal(&updateMsg)
-      if err == nil {
-        h.nc.Publish("member", updateMsgString)
-      }
-    }
-  }
+	// Publish NATs
+	if h.nc != nil {
+		member := Member{
+			User:         userID,
+			Conversation: conversationID,
+			Pinned:       true,
+		}
+		memberString, err := json.Marshal(&member)
+		if err == nil {
+			updateMsg := UpdateMsg{
+				Type: "update",
+				Data: string(memberString),
+			}
+			updateMsgString, err := json.Marshal(&updateMsg)
+			if err == nil {
+				h.nc.Publish("member", updateMsgString)
+			}
+		}
+	}
 
 	w.WriteHeader(200)
 }

handlers.go

@@ -3,40 +3,40 @@ package main
 import (
 	"database/sql"
 
-  "github.com/nats-io/go-nats"
+	"github.com/nats-io/go-nats"
 )
 
 type Handler struct {
 	db *sql.DB
-  nc *nats.Conn
+	nc *nats.Conn
 
-  contactConnections        map[string]chan []byte
-  conversationConnections   map[string]chan []byte
-  userConnections           map[string]chan []byte
-  memberConnections         map[string]map[string]chan []byte
+	contactConnections      map[string]chan []byte
+	conversationConnections map[string]chan []byte
+	userConnections         map[string]chan []byte
+	memberConnections       map[string]map[string]chan []byte
 }
 
 func NewHandler(db *sql.DB, nc *nats.Conn) *Handler {
-  contactConnections := make(map[string]chan []byte)
-  conversationConnections := make(map[string]chan []byte)
-  userConnections := make(map[string]chan []byte)
-  memberConnections := make(map[string]map[string]chan []byte)
+	contactConnections := make(map[string]chan []byte)
+	conversationConnections := make(map[string]chan []byte)
+	userConnections := make(map[string]chan []byte)
+	memberConnections := make(map[string]map[string]chan []byte)
 
-  h := &Handler{
-    db,
-    nc,
-    contactConnections,
-    conversationConnections,
-    userConnections,
-    memberConnections,
-  }
+	h := &Handler{
+		db,
+		nc,
+		contactConnections,
+		conversationConnections,
+		userConnections,
+		memberConnections,
+	}
 
-  if nc != nil {
-    nc.Subscribe("contacts", h.ContactHandler)
-    nc.Subscribe("conversations", h.ConversationHandler)
-    nc.Subscribe("users", h.UserHandler)
-    nc.Subscribe("members", h.MemberHandler)
-  }
+	if nc != nil {
+		nc.Subscribe("contacts", h.ContactHandler)
+		nc.Subscribe("conversations", h.ConversationHandler)
+		nc.Subscribe("users", h.UserHandler)
+		nc.Subscribe("members", h.MemberHandler)
+	}
 
-  return h
+	return h
 }

main.go

@@ -7,8 +7,8 @@ import (
 	"os"
 
 	"github.com/joho/godotenv"
-  "github.com/nats-io/go-nats"
 	_ "github.com/lib/pq"
+	"github.com/nats-io/go-nats"
 )
 
 var listen string
@@ -27,8 +27,8 @@ func main() {
 
 	// Database
 	db := connect()
-  // NATs
-  nc := connectNats()
+	// NATs
+	nc := connectNats()
 	// Handler
 	h := NewHandler(db, nc)
 	// Routes
@@ -56,15 +56,15 @@ func connect() *sql.DB {
 }
 
 func connectNats() *nats.Conn {
-  natsHost := os.Getenv("NATS")
-  var nc *nats.Conn
-  var err error
-  if natsHost != "" {
-    log.Printf("connecting to nats %s", natsHost)
-    nc, err = nats.Connect(natsHost)
-    if err != nil {
-      log.Fatal(err)
-    }
-  }
-  return nc
+	natsHost := os.Getenv("NATS")
+	var nc *nats.Conn
+	var err error
+	if natsHost != "" {
+		log.Printf("connecting to nats %s", natsHost)
+		nc, err = nats.Connect(natsHost)
+		if err != nil {
+			log.Fatal(err)
+		}
+	}
+	return nc
 }

nats_handlers.go

@@ -1,101 +1,101 @@
 package main
 
 import (
-  "encoding/json"
-  "log"
+	"encoding/json"
+	"log"
 
-  "github.com/nats-io/go-nats"
+	"github.com/nats-io/go-nats"
 )
 
 func (h *Handler) ContactHandler(msg *nats.Msg) {
-  // Validate JSON
-  updateMsg := UpdateMsg{}
-  err := json.Unmarshal(msg.Data, &updateMsg)
-  if err != nil {
-    log.Println(err)
-    return
-  }
+	// Validate JSON
+	updateMsg := UpdateMsg{}
+	err := json.Unmarshal(msg.Data, &updateMsg)
+	if err != nil {
+		log.Println(err)
+		return
+	}
 
-  contact := Contact{}
-  err = json.Unmarshal([]byte(updateMsg.Data), &contact)
-  if err != nil {
-    log.Println(err)
-    return
-  }
+	contact := Contact{}
+	err = json.Unmarshal([]byte(updateMsg.Data), &contact)
+	if err != nil {
+		log.Println(err)
+		return
+	}
 
-  // Transmit
-  for _, conn := range h.contactConnections {
-    conn <- msg.Data
-  }
+	// Transmit
+	for _, conn := range h.contactConnections {
+		conn <- msg.Data
+	}
 }
 
 func (h *Handler) ConversationHandler(msg *nats.Msg) {
-  // Validate JSON
-  updateMsg := UpdateMsg{}
-  err := json.Unmarshal(msg.Data, &updateMsg)
-  if err != nil {
-    log.Println(err)
-    return
-  }
+	// Validate JSON
+	updateMsg := UpdateMsg{}
+	err := json.Unmarshal(msg.Data, &updateMsg)
+	if err != nil {
+		log.Println(err)
+		return
+	}
 
-  conversation := Conversation{}
-  err = json.Unmarshal([]byte(updateMsg.Data), &conversation)
-  if err != nil {
-    log.Println(err)
-    return
-  }
+	conversation := Conversation{}
+	err = json.Unmarshal([]byte(updateMsg.Data), &conversation)
+	if err != nil {
+		log.Println(err)
+		return
+	}
 
-  // Transmit
-  for _, conn := range h.conversationConnections {
-    conn <- msg.Data
-  }
+	// Transmit
+	for _, conn := range h.conversationConnections {
+		conn <- msg.Data
+	}
 }
 
 func (h *Handler) UserHandler(msg *nats.Msg) {
-  // Validate JSON
-  updateMsg := UpdateMsg{}
-  err := json.Unmarshal(msg.Data, &updateMsg)
-  if err != nil {
-    log.Println(err)
-    return
-  }
+	// Validate JSON
+	updateMsg := UpdateMsg{}
+	err := json.Unmarshal(msg.Data, &updateMsg)
+	if err != nil {
+		log.Println(err)
+		return
+	}
 
-  user := User{}
-  err = json.Unmarshal([]byte(updateMsg.Data), &user)
-  if err != nil {
-    log.Println(err)
-    return
-  }
+	user := User{}
+	err = json.Unmarshal([]byte(updateMsg.Data), &user)
+	if err != nil {
+		log.Println(err)
+		return
+	}
 
-  // Transmit
-  for _, conn := range h.userConnections {
-    conn <- msg.Data
-  }
+	// Transmit
+	for _, conn := range h.userConnections {
+		conn <- msg.Data
+	}
 }
 
 func (h *Handler) MemberHandler(msg *nats.Msg) {
-  // Validate JSON
-  updateMsg := UpdateMsg{}
-  err := json.Unmarshal(msg.Data, &updateMsg)
-  if err != nil {
-    log.Println(err)
-    return
-  }
+	// Validate JSON
+	updateMsg := UpdateMsg{}
+	err := json.Unmarshal(msg.Data, &updateMsg)
+	if err != nil {
+		log.Println(err)
+		return
+	}
 
-  member := Member{}
-  err = json.Unmarshal([]byte(updateMsg.Data), &member)
-  if err != nil {
-    log.Println(err)
-    return
-  }
+	member := Member{}
+	err = json.Unmarshal([]byte(updateMsg.Data), &member)
+	if err != nil {
+		log.Println(err)
+		return
+	}
 
-  // Get transmit channel
-  if channels, ok := h.memberConnections[member.Conversation]; ok {
-    // Transmit
-    for _, conn := range channels {
-      conn <- msg.Data
-    }
-  } else {
-    log.Printf("member conversation %s not found\n", member.Conversation)
-  }
+	// Get transmit channel
+	if channels, ok := h.memberConnections[member.Conversation]; ok {
+		// Transmit
+		for _, conn := range channels {
+			conn <- msg.Data
+		}
+	} else {
+		log.Printf("member conversation %s not found\n", member.Conversation)
+	}
 }

router.go

@@ -38,11 +38,11 @@ func NewRouter(h *Handler) *httprouter.Router {
 	//router.DELETE("/user/:user/contact/:contact", h.DeleteContact)
 	//router.GET("/user/:user/contact/:contact/conversation/", h.GetContactConversations)
 
-  // Subscribe
-  router.GET("/user/subscribe/contact", AuthMiddleware(h.SubscribeContact))
-  router.GET("/user/subscribe/conversation", AuthMiddleware(h.SubscribeConversation))
-  router.GET("/user/subscribe", AuthMiddleware(h.SubscribeUser))
-  router.GET("/user/subscribe/conversation/:conversation/member", AuthMiddleware(h.SubscribeMember))
+	// Subscribe
+	router.GET("/user/subscribe/contact", AuthMiddleware(h.SubscribeContact))
+	router.GET("/user/subscribe/conversation", AuthMiddleware(h.SubscribeConversation))
+	router.GET("/user/subscribe", AuthMiddleware(h.SubscribeUser))
+	router.GET("/user/subscribe/conversation/:conversation/member", AuthMiddleware(h.SubscribeMember))
 
 	return router
 }

subscribe.go

@@ -1,64 +1,64 @@
 package main
 
 import (
-  "fmt"
-  "net/http"
-  "time"
+	"fmt"
+	"net/http"
+	"time"
 
 	"github.com/julienschmidt/httprouter"
 )
 
 func (h *Handler) SubscribeContact(w http.ResponseWriter, r *http.Request, p httprouter.Params) {
-  Subscribe(h.contactConnections, w, r, p)
+	Subscribe(h.contactConnections, w, r, p)
 }
 
 func (h *Handler) SubscribeConversation(w http.ResponseWriter, r *http.Request, p httprouter.Params) {
-  Subscribe(h.conversationConnections, w, r, p)
+	Subscribe(h.conversationConnections, w, r, p)
 }
 
 func (h *Handler) SubscribeUser(w http.ResponseWriter, r *http.Request, p httprouter.Params) {
-  Subscribe(h.userConnections, w, r, p)
+	Subscribe(h.userConnections, w, r, p)
 }
 
 func (h *Handler) SubscribeMember(w http.ResponseWriter, r *http.Request, p httprouter.Params) {
-  conversation := p.ByName("conversation")
-  if _, ok := h.memberConnections[conversation]; !ok {
-    h.memberConnections[conversation] = make(map[string]chan []byte)
-  }
+	conversation := p.ByName("conversation")
+	if _, ok := h.memberConnections[conversation]; !ok {
+		h.memberConnections[conversation] = make(map[string]chan []byte)
+	}
 
-  Subscribe(h.memberConnections[conversation], w, r, p)
+	Subscribe(h.memberConnections[conversation], w, r, p)
 }
 
 func Subscribe(channels map[string]chan []byte, w http.ResponseWriter, r *http.Request, p httprouter.Params) {
-  flusher, ok := w.(http.Flusher)
-  if !ok {
-    http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
-    return
-  }
+	flusher, ok := w.(http.Flusher)
+	if !ok {
+		http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
+		return
+	}
 
-  w.Header().Set("Content-Type", "text/event-stream")
-  w.Header().Set("Cache-Control", "no-cache")
-  w.Header().Set("Connection", "keep-alive")
+	w.Header().Set("Content-Type", "text/event-stream")
+	w.Header().Set("Cache-Control", "no-cache")
+	w.Header().Set("Connection", "keep-alive")
 
-  id := RandomHex()
-  recv := make(chan []byte)
-  channels[id] = recv
+	id := RandomHex()
+	recv := make(chan []byte)
+	channels[id] = recv
 
-  // Refresh connection periodically
-  resClosed := w.(http.CloseNotifier).CloseNotify()
-  ticker := time.NewTicker(25 * time.Second)
+	// Refresh connection periodically
+	resClosed := w.(http.CloseNotifier).CloseNotify()
+	ticker := time.NewTicker(25 * time.Second)
 
-  for {
-    select {
-      case msg := <-recv:
-        fmt.Fprintf(w, "data: %s\n\n", msg)
-        flusher.Flush()
-      case <- ticker.C:
-        w.Write([]byte(":\n\n"))
-      case <- resClosed:
-        ticker.Stop()
-        delete(channels, id)
-        return
-    }
-  }
+	for {
+		select {
+		case msg := <-recv:
+			fmt.Fprintf(w, "data: %s\n\n", msg)
+			flusher.Flush()
+		case <-ticker.C:
+			w.Write([]byte(":\n\n"))
+		case <-resClosed:
+			ticker.Stop()
+			delete(channels, id)
+			return
+		}
+	}
 }

types.go

@@ -3,19 +3,19 @@ package main
 // String pointer means nullable
 
 type UpdateMsg struct {
-  Type    string `json:"type"`
-  Data    string `json:"data"`
+	Type string `json:"type"`
+	Data string `json:"data"`
 }
 
 type Contact struct {
-  UserA   string `json:"usera"`   // First user ID
-  UserB   string `json:"userb"`   // Second user ID
+	UserA string `json:"usera"` // First user ID
+	UserB string `json:"userb"` // Second user ID
 }
 
 type Member struct {
-  User          string  `json:"user"`
-  Conversation  string  `json:"conversation"`
-  Pinned        bool    `json:"pinned"`
+	User         string `json:"user"`
+	Conversation string `json:"conversation"`
+	Pinned       bool   `json:"pinned"`
 }
 
 type Conversation struct {

user.go

@@ -50,20 +50,20 @@ func (h *Handler) CreateUser(w http.ResponseWriter, r *http.Request, _ httproute
 	}
 	user.ID = finalId
 
-  // Publish NATs
-  if h.nc != nil {
-    userString, err := json.Marshal(&user)
-    if err == nil {
-      updateMsg := UpdateMsg {
-        Type: "add",
-        Data: string(userString),
-      }
-      updateMsgString, err := json.Marshal(&updateMsg)
-      if err == nil {
-        h.nc.Publish("user", updateMsgString)
-      }
-    }
-  }
+	// Publish NATs
+	if h.nc != nil {
+		userString, err := json.Marshal(&user)
+		if err == nil {
+			updateMsg := UpdateMsg{
+				Type: "add",
+				Data: string(userString),
+			}
+			updateMsgString, err := json.Marshal(&updateMsg)
+			if err == nil {
+				h.nc.Publish("user", updateMsgString)
+			}
+		}
+	}
 
 	// Respond
 	w.Header().Set("Content-Type", "application/json")
@@ -181,20 +181,20 @@ func (h *Handler) UpdateUser(w http.ResponseWriter, r *http.Request, p httproute
 		return
 	}
 
-  // Publish NATs
-  if h.nc != nil {
-    userString, err := json.Marshal(&user)
-    if err == nil {
-      updateMsg := UpdateMsg {
-        Type: "update",
-        Data: string(userString),
-      }
-      updateMsgString, err := json.Marshal(&updateMsg)
-      if err == nil {
-        h.nc.Publish("user", updateMsgString)
-      }
-    }
-  }
+	// Publish NATs
+	if h.nc != nil {
+		userString, err := json.Marshal(&user)
+		if err == nil {
+			updateMsg := UpdateMsg{
+				Type: "update",
+				Data: string(userString),
+			}
+			updateMsgString, err := json.Marshal(&updateMsg)
+			if err == nil {
+				h.nc.Publish("user", updateMsgString)
+			}
+		}
+	}
 
 	w.WriteHeader(200)
 }