Initial work on factoring out client code

client/genclients.go

@@ -8,6 +8,7 @@ import (
 	"github.com/go-openapi/spec"
 
 	"github.com/Clever/wag/swagger"
+	"github.com/Clever/wag/templates"
 )
 
 // Generate generates a client
@@ -21,10 +22,16 @@ func Generate(packageName string, s spec.Swagger) error {
 	return nil
 }
 
-func generateClient(packageName string, s spec.Swagger) error {
-	g := swagger.Generator{PackageName: packageName}
+type clientCodeTemplate struct {
+	PackageName           string
+	ServiceName           string
+	FormattedServiceName  string
+	BaseParamToStringCode string
+	Methods               []string
+}
 
-	g.Printf(`package client
+var clientCodeTemplateStr = `
+package client
 
 import (
 		"context"
@@ -36,8 +43,7 @@ import (
 		"encoding/json"
 		"strconv"
 		"time"
-
-		"%[1]s/models"
+		"{{.PackageName}}/models"
 
 		discovery "github.com/Clever/discovery-go"
 )
@@ -47,7 +53,7 @@ var _ = strings.Replace
 var _ = strconv.FormatInt
 var _ = bytes.Compare
 
-// WagClient is used to make requests to the %[2]s service.
+// WagClient is used to make requests to the {{.ServiceName}} service.
 type WagClient struct {
 	basePath    string
 	requestDoer doer
@@ -71,11 +77,11 @@ func New(basePath string) *WagClient {
 }
 
 // NewFromDiscovery creates a client from the discovery environment variables. This method requires
-// the three env vars: SERVICE_%[3]s_HTTP_(HOST/PORT/PROTO) to be set. Otherwise it returns an error.
+// the three env vars: SERVICE_{{.FormattedServiceName}}_HTTP_(HOST/PORT/PROTO) to be set. Otherwise it returns an error.
 func NewFromDiscovery() (*WagClient, error) {
-	url, err := discovery.URL("%[2]s", "default")
+	url, err := discovery.URL("{{.ServiceName}}", "default")
 	if err != nil {
-		url, err = discovery.URL("%[2]s", "http") // Added fallback to maintain reverse compatibility
+		url, err = discovery.URL("{{.ServiceName}}", "http") // Added fallback to maintain reverse compatibility
 		if err != nil {
 			return nil, err
 		}
@@ -97,21 +103,39 @@ func (c *WagClient) WithTimeout(timeout time.Duration) *WagClient {
 	return c
 }
 
-`, packageName,
-		s.Info.InfoProps.Title,
-		strings.ToUpper(strings.Replace(s.Info.InfoProps.Title, "-", "_", -1)))
+{{.BaseParamToStringCode}}
+
+{{range $methodCode := .Methods}}
+	{{$methodCode}}
+{{end}}
 
-	g.Printf(swagger.BaseParamToStringCode())
+`
+
+func generateClient(packageName string, s spec.Swagger) error {
+
+	codeTemplate := clientCodeTemplate{
+		PackageName:           packageName,
+		ServiceName:           s.Info.InfoProps.Title,
+		FormattedServiceName:  strings.ToUpper(strings.Replace(s.Info.InfoProps.Title, "-", "_", -1)),
+		BaseParamToStringCode: swagger.BaseParamToStringCode(),
+	}
 
 	for _, path := range swagger.SortedPathItemKeys(s.Paths.Paths) {
 		pathItem := s.Paths.Paths[path]
 		pathItemOps := swagger.PathItemOperations(pathItem)
 		for _, method := range swagger.SortedOperationsKeys(pathItemOps) {
 			op := pathItemOps[method]
-			g.Printf(methodCode(op, s.BasePath, method, path))
+			codeTemplate.Methods = append(codeTemplate.Methods, methodCode(op, s.BasePath, method, path))
 		}
 	}
 
+	clientCode, err := templates.WriteTemplate(clientCodeTemplateStr, codeTemplate)
+	if err != nil {
+		return err
+	}
+
+	g := swagger.Generator{PackageName: packageName}
+	g.Printf(clientCode)
 	return g.WriteFile("client/client.go")
 }
 

server/genserver.go

@@ -8,8 +8,7 @@ import (
 	"github.com/go-openapi/spec"
 
 	"github.com/Clever/wag/swagger"
-
-	"text/template"
+	"github.com/Clever/wag/templates"
 )
 
 // Generate server package for a swagger spec.
@@ -126,7 +125,7 @@ func generateRouter(packageName string, s spec.Swagger, paths *spec.Paths) error
 		}
 	}
 
-	routerCode, err := writeTemplate(routerTemplateStr, template)
+	routerCode, err := templates.WriteTemplate(routerTemplateStr, template)
 	if err != nil {
 		return err
 	}
@@ -181,7 +180,7 @@ func generateInterface(packageName string, serviceName string, paths *spec.Paths
 		}
 	}
 
-	interfaceCode, err := writeTemplate(interfaceTemplateStr, tmpl)
+	interfaceCode, err := templates.WriteTemplate(interfaceTemplateStr, tmpl)
 	if err != nil {
 		return err
 	}
@@ -255,7 +254,7 @@ func generateHandlers(packageName string, paths *spec.Paths) error {
 		}
 	}
 
-	handlerCode, err := writeTemplate(handlerFileTemplateStr, tmpl)
+	handlerCode, err := templates.WriteTemplate(handlerFileTemplateStr, tmpl)
 	if err != nil {
 		return err
 	}
@@ -289,7 +288,7 @@ func generateOperationHandler(op *spec.Operation) (string, error) {
 		EmptyStatusCode:    emptyResponseCode,
 		TypesToStatusCodes: typeToCode,
 	}
-	handlerCode, err := writeTemplate(handlerTemplate, handlerOp)
+	handlerCode, err := templates.WriteTemplate(handlerTemplate, handlerOp)
 	if err != nil {
 		return "", err
 	}
@@ -306,23 +305,6 @@ func generateOperationHandler(op *spec.Operation) (string, error) {
 	return buf.String(), nil
 }
 
-// writeTemplate takes in the template and the definition of its variables
-// and returns a filled-out template.
-func writeTemplate(templateStr string, templateStruct interface{}) (string, error) {
-
-	tmpl, err := template.New("test").Parse(templateStr)
-	if err != nil {
-		return "", err
-	}
-
-	var tmpBuf bytes.Buffer
-	err = tmpl.Execute(&tmpBuf, templateStruct)
-	if err != nil {
-		return "", err
-	}
-	return tmpBuf.String(), nil
-}
-
 // handlerOp contains the template variables for the handlerTemplate
 type handlerOp struct {
 	Op                 string

templates/templates.go

@@ -0,0 +1,23 @@
+package templates
+
+import (
+	"bytes"
+	"text/template"
+)
+
+// WriteTemplate takes in the template and the definition of its variables
+// and returns a filled-out template.
+func WriteTemplate(templateStr string, templateStruct interface{}) (string, error) {
+
+	tmpl, err := template.New("test").Parse(templateStr)
+	if err != nil {
+		return "", err
+	}
+
+	var tmpBuf bytes.Buffer
+	err = tmpl.Execute(&tmpBuf, templateStruct)
+	if err != nil {
+		return "", err
+	}
+	return tmpBuf.String(), nil
+}