Functions extracted from inline codefile

cmd/kitgen/ast_templates.go

@@ -7,5 +7,5 @@ package main
 import "golang.org/x/tools/godoc/vfs/mapfs"
 
 var ASTTemplates = mapfs.New(map[string]string{
-	`full.go`: "package foo\n\ntype STUBSTRUCT struct{}\n\nfunc (f STUBSTRUCT) Bar(PARAM aType) (string, error) {\n	return \"\", errors.New(\"not implemented\")\n}\n\ntype BarRequest struct {\n	I int\n	S string\n}\n\ntype BarResponse struct {\n	S   string\n	Err error\n}\n\nfunc makeBarEndpoint(s STUBSTRUCT) endpoint.Endpoint {\n	return func(ctx context.Context, request interface{}) (interface{}, error) {\n		req := request.(barrequest)\n		s, err := s.bar(ctx, req.i, req.s)\n		return barresponse{s: s, err: err}, nil\n	}\n}\n\ntype Endpoints struct {\n	Bar endpoint.Endpoint\n}\n\n// Each transport binding should be opt-in with a flag to kitgen.\n// Here's a basic sketch of what HTTP may look like.\n// n.b. comments should encourage users to edit the generated code.\n\nfunc NewHTTPHandler(endpoints Endpoints) http.Handler {\n	m := http.NewServeMux()\n	m.Handle(\"/bar\", httptransport.NewServer(\n		endpoints.Bar,\n		DecodeBarRequest,\n		EncodeBarResponse,\n	))\n	return m\n}\n\nfunc DecodeBarRequest(_ context.Context, r *http.Request) (interface{}, error) {\n	var req BarRequest\n	err := json.NewDecoder(r.Body).Decode(&req)\n	return req, err\n}\n\nfunc EncodeBarResponse(_ context.Context, w http.ResponseWriter, response interface{}) error {\n	w.Header().Set(\"Content-Type\", \"application/json; charset=utf-8\")\n	return json.NewEncoder(w).Encode(response)\n}\n",
+	`full.go`: "package foo\n\ntype stubFooService struct {\n}\n\ntype ExampleRequest struct {\n	I int\n	S string\n}\ntype ExampleResponse struct {\n	S   string\n	Err error\n}\n\ntype Endpoints struct {\n	ExampleEndpoint endpoint.Endpoint\n}\n\nfunc (f stubFooService) ExampleEndpoint(ctx context.Context, i int, s string) (string, error) {\n	return \"\", errors.New(\"not implemented\")\n}\n\nfunc makeExampleEndpoint(f stubFooService) endpoint.Endpoint {\n	return func(ctx context.Context, request interface{}) (interface{}, error) {\n		req := request.(ExampleRequest)\n		s, err := f.ExampleEndpoint(ctx, req.I, req.S)\n		return ExampleResponse{S: s, Err: err}, nil\n	}\n}\n\nfunc inlineHandlerBuilder() {\n	m.Handle(\"/bar\", httptransport.NewServer(endpoints.ExampleEndpoint, DecodeExampleRequest, EncodeExampleResponse))\n}\n\nfunc NewHTTPHandler(endpoints Endpoints) http.Handler {\n	m := http.NewServeMux()\n	inlineHandlerBuilder()\n	return m\n}\n\nfunc DecodeExampleRequest(_ context.Context, r *http.Request) (interface{}, error) {\n	var req ExampleRequest\n	err := json.NewDecoder(r.Body).Decode(&req)\n	return req, err\n}\n\nfunc EncodeExampleResponse(_ context.Context, w http.ResponseWriter, response interface{}) error {\n	w.Header().Set(\"Content-Type\", \"application/json; charset=utf-8\")\n	return json.NewEncoder(w).Encode(response)\n}\n",
 })

cmd/kitgen/sourcecontext.go

@@ -34,6 +34,23 @@ type (
 	}
 )
 
+func fetchFuncDecl(name string) *ast.FuncDecl {
+	full, err := ASTTemplates.Open("full.go")
+	if err != nil {
+		panic(err)
+	}
+	f, err := parser.ParseFile(token.NewFileSet(), "templates/full.go", full, parser.DeclarationErrors)
+	if err != nil {
+		panic(err)
+	}
+	for _, decl := range f.Decls {
+		if f, ok := decl.(*ast.FuncDecl); ok && f.Name.Name == name {
+			return f
+		}
+	}
+	panic(fmt.Errorf("No function called %q in 'templates/full.go'", name))
+}
+
 func id(name string) *ast.Ident {
 	return ast.NewIdent(name)
 }
@@ -80,14 +97,6 @@ func structDecl(name *ast.Ident, fields *ast.FieldList) ast.Decl {
 	}
 }
 
-func mustParseExpr(s string) ast.Node {
-	n, err := parser.ParseExpr(s)
-	if err != nil {
-		panic(err)
-	}
-	return n
-}
-
 func pasteStmts(body *ast.BlockStmt, idx int, stmts []ast.Stmt) {
 	list := body.List
 	prefix := list[:idx]
@@ -138,16 +147,13 @@ func NewHTTPHandler(endpoints Endpoints) http.Handler {
 	return m
 }
 */
+
 func (i iface) httpHandler() ast.Decl {
-	handlerFn := mustParseExpr(`func (endpoints Endpoints) http.Handler {
-		m := http.NewServeMux()
-		replaceWithHandleCalls()
-		return m
-	}`).(*ast.FuncLit)
+	handlerFn := fetchFuncDecl("NewHTTPHandler")
 
 	handleCalls := []ast.Stmt{}
 	for _, m := range i.methods {
-		handleCall := mustParseExpr(`m.Handle("", httptransport.NewServer())`).(*ast.CallExpr)
+		handleCall := fetchFuncDecl("inlineHandlerBuilder").Body.List[0].(*ast.ExprStmt).X.(*ast.CallExpr)
 
 		handleCall.Args[0].(*ast.BasicLit).Value = `"` + m.pathName() + `"`
 
@@ -159,11 +165,7 @@ func (i iface) httpHandler() ast.Decl {
 
 	pasteStmts(handlerFn.Body, 1, handleCalls)
 
-	return &ast.FuncDecl{
-		Name: id("NewHTTPHandler"),
-		Type: handlerFn.Type,
-		Body: handlerFn.Body,
-	}
+	return handlerFn
 }
 
 func (i iface) reciever() *ast.Field {
@@ -195,27 +197,22 @@ func (i iface) receiverName() *ast.Ident {
 }
 
 func (m method) definition(ifc iface) ast.Decl {
-	notImpl := mustParseExpr(`func() {return "", errors.New("not implemented")}`).(*ast.FuncLit)
+	notImpl := fetchFuncDecl("ExampleEndpoint")
 
-	parms := m.funcParams()
-	if m.hasContext() {
-		parms = &ast.FieldList{
-			List: append([]*ast.Field{{
-				Names: []*ast.Ident{ast.NewIdent("ctx")},
-				Type:  sel(id("context"), id("Context")),
-			}}, parms.List...),
-		}
-	}
+	notImpl.Name = m.name
+	notImpl.Recv = &ast.FieldList{List: []*ast.Field{ifc.reciever()}}
+	notImpl.Type.Params = m.funcParams()
+	notImpl.Type.Results = m.funcResults()
 
-	return &ast.FuncDecl{
-		Recv: &ast.FieldList{List: []*ast.Field{ifc.reciever()}},
-		Name: m.name,
-		Type: &ast.FuncType{
-			Params:  parms,
-			Results: m.funcResults(),
-		},
-		Body: notImpl.Body,
+	return notImpl
+}
+
+func scopeWith(names ...string) *ast.Scope {
+	scope := ast.NewScope(nil)
+	for _, name := range names {
+		scope.Insert(ast.NewObj(ast.Var, name))
 	}
+	return scope
 }
 
 /*
@@ -228,42 +225,23 @@ func (m method) definition(ifc iface) ast.Decl {
 	}
 */
 func (m method) endpointMaker(ifc iface) ast.Decl {
-	endpointFn := mustParseExpr(`func() {return func(ctx context.Context, request interface{}) (interface{}, error) { }}`).(*ast.FuncLit)
-	scope := ast.NewScope(nil)
-	scope.Insert(ast.NewObj(ast.Var, ifc.receiverName().Name))
-	scope.Insert(ast.NewObj(ast.Var, "ctx"))
-	scope.Insert(ast.NewObj(ast.Var, "req"))
+	endpointFn := fetchFuncDecl("makeExampleEndpoint")
+	scope := scopeWith("ctx", "req", ifc.receiverName().Name)
 
 	anonFunc := endpointFn.Body.List[0].(*ast.ReturnStmt).Results[0].(*ast.FuncLit)
 	if !m.hasContext() { // is this the right thing?
 		anonFunc.Type.Params.List = anonFunc.Type.Params.List[1:]
 	}
 
-	castReq := mustParseExpr(`func() {req := request.(NOTTHIS)}`).(*ast.FuncLit).Body.List[0].(*ast.AssignStmt)
-	castReq.Rhs[0].(*ast.TypeAssertExpr).Type = m.requestStructName()
-
+	anonFunc.Body.List[0].(*ast.AssignStmt).Rhs[0].(*ast.TypeAssertExpr).Type = m.requestStructName()
 	callMethod := m.called(ifc, scope, "ctx", "req")
+	anonFunc.Body.List[1] = callMethod
+	anonFunc.Body.List[2].(*ast.ReturnStmt).Results[0] = m.wrapResult(callMethod.Lhs)
 
-	returnResponse := &ast.ReturnStmt{
-		Results: []ast.Expr{m.wrapResult(callMethod.Lhs), id("nil")},
-	}
-
-	anonFunc.Body = blockStmt(
-		castReq,
-		callMethod,
-		returnResponse,
-	)
-
-	return &ast.FuncDecl{
-		Name: m.endpointMakerName(),
-		Type: &ast.FuncType{
-			Params: &ast.FieldList{List: []*ast.Field{ifc.reciever()}},
-			Results: &ast.FieldList{List: []*ast.Field{
-				&ast.Field{Type: sel(id("endpoint"), id("Endpoint"))},
-			}},
-		},
-		Body: endpointFn.Body,
-	}
+	endpointFn.Name = m.endpointMakerName()
+	endpointFn.Type.Params = &ast.FieldList{List: []*ast.Field{ifc.reciever()}}
+	endpointFn.Type.Results = &ast.FieldList{List: []*ast.Field{&ast.Field{Type: sel(id("endpoint"), id("Endpoint"))}}}
+	return endpointFn
 }
 
 func (m method) pathName() string {
@@ -390,36 +368,16 @@ func (m method) resolveStructNames() {
 }
 
 func (m method) decoderFunc() ast.Decl {
-	fn := mustParseExpr(`
-		func (_ context.Context, r *http.Request) (interface{}, error) {
-			var req ReqStructName
-			err := json.NewDecoder(r.Body).Decode(&req)
-			return req, err
-		}
-	`).(*ast.FuncLit)
-
+	fn := fetchFuncDecl("DecodeExampleRequest")
+	fn.Name = m.decodeFuncName()
 	fn.Body.List[0].(*ast.DeclStmt).Decl.(*ast.GenDecl).Specs[0].(*ast.ValueSpec).Type = m.requestStructName()
-
-	return &ast.FuncDecl{
-		Name: m.decodeFuncName(),
-		Type: fn.Type,
-		Body: fn.Body,
-	}
+	return fn
 }
 
 func (m method) encoderFunc() ast.Decl {
-	fn := mustParseExpr(`
-		func (_ context.Context, w http.ResponseWriter, response interface{}) error {
-			w.Header().Set("Content-Type", "application/json; charset=utf-8")
-			return json.NewEncoder(w).Encode(response)
-		}
-	`).(*ast.FuncLit)
-
-	return &ast.FuncDecl{
-		Name: m.encodeFuncName(),
-		Type: fn.Type,
-		Body: fn.Body,
-	}
+	fn := fetchFuncDecl("EncodeExampleResponse")
+	fn.Name = m.encodeFuncName()
+	return fn
 }
 
 func (m method) endpointMakerName() *ast.Ident {
@@ -459,9 +417,17 @@ func (m method) nonContextParams() []arg {
 }
 
 func (m method) funcParams() *ast.FieldList {
-	return fieldList(func(a arg) *ast.Field {
+	parms := &ast.FieldList{}
+	if m.hasContext() {
+		parms.List = []*ast.Field{{
+			Names: []*ast.Ident{ast.NewIdent("ctx")},
+			Type:  sel(id("context"), id("Context")),
+		}}
+	}
+	parms.List = append(parms.List, fieldList(func(a arg) *ast.Field {
 		return a.field()
-	}, m.nonContextParams()...)
+	}, m.nonContextParams()...).List...)
+	return parms
 }
 
 func (m method) funcResults() *ast.FieldList {

cmd/kitgen/templates/full.go

@@ -1,54 +1,50 @@
 package foo
 
-type STUBSTRUCT struct{}
-
-func (f STUBSTRUCT) METHOD(PARAM aType) (string, error) {
-	return "", errors.New("not implemented")
+type stubFooService struct {
 }
 
-type BarRequest struct {
+type ExampleRequest struct {
 	I int
 	S string
 }
-
-type BarResponse struct {
+type ExampleResponse struct {
 	S   string
 	Err error
 }
 
-func MAKEENDPOINT(s STUBSTRUCT) endpoint.Endpoint {
+type Endpoints struct {
+	ExampleEndpoint endpoint.Endpoint
+}
+
+func (f stubFooService) ExampleEndpoint(ctx context.Context, i int, s string) (string, error) {
+	return "", errors.New("not implemented")
+}
+
+func makeExampleEndpoint(f stubFooService) endpoint.Endpoint {
 	return func(ctx context.Context, request interface{}) (interface{}, error) {
-		req := request.(REQUESTSTRUCT)
-		s, err := s.bar(ctx, req.i, req.s)
-		return RESPONSESTRUCT{s: s, err: err}, nil
+		req := request.(ExampleRequest)
+		s, err := f.ExampleEndpoint(ctx, req.I, req.S)
+		return ExampleResponse{S: s, Err: err}, nil
 	}
 }
 
-type Endpoints struct {
-	Bar endpoint.Endpoint
+func inlineHandlerBuilder() {
+	m.Handle("/bar", httptransport.NewServer(endpoints.ExampleEndpoint, DecodeExampleRequest, EncodeExampleResponse))
 }
 
-// Each transport binding should be opt-in with a flag to kitgen.
-// Here's a basic sketch of what HTTP may look like.
-// n.b. comments should encourage users to edit the generated code.
-
 func NewHTTPHandler(endpoints Endpoints) http.Handler {
 	m := http.NewServeMux()
-	m.Handle("/bar", httptransport.NewServer(
-		endpoints.Bar,
-		DecodeBarRequest,
-		EncodeBarResponse,
-	))
+	inlineHandlerBuilder()
 	return m
 }
 
-func DecodeBarRequest(_ context.Context, r *http.Request) (interface{}, error) {
-	var req BarRequest
+func DecodeExampleRequest(_ context.Context, r *http.Request) (interface{}, error) {
+	var req ExampleRequest
 	err := json.NewDecoder(r.Body).Decode(&req)
 	return req, err
 }
 
-func EncodeBarResponse(_ context.Context, w http.ResponseWriter, response interface{}) error {
+func EncodeExampleResponse(_ context.Context, w http.ResponseWriter, response interface{}) error {
 	w.Header().Set("Content-Type", "application/json; charset=utf-8")
 	return json.NewEncoder(w).Encode(response)
 }

cmd/kitgen/transform.go

@@ -2,8 +2,6 @@ package main
 
 import (
 	"go/ast"
-
-	"github.com/davecgh/go-spew/spew"
 )
 
 func transformAST(ctx *sourceContext) (ast.Node, error) {
@@ -40,7 +38,6 @@ func addStubStruct(root *ast.File, iface iface) {
 
 func addMethod(root *ast.File, iface iface, meth method) {
 	def := meth.definition(iface)
-	spew.Dump(def)
 	root.Decls = append(root.Decls, def)
 }