all request and response info is now recorded to apib doc file; still need to group resources together

Author: s-mang

Diff for: doc/action.go

@@ -1,10 +1,14 @@
 package doc
 
-import "text/template"
+import (
+	"net/http"
+	"net/http/httptest"
+	"text/template"
+)
 
 var (
 	actionTmpl *template.Template
-	actionFmt  = `### {{.Title}} [{{.HTTPMethod}}]
+	actionFmt  = `### {{.Title}} [{{.Method}}]
 {{.Description}}
 {{with .Request}}
 {{.Render}}{{end}}
@@ -19,13 +23,31 @@ func init() {
 type Action struct {
 	Title       string
 	Description string
-	HTTPMethod  string
-	Request     *Request // status OK
-	Response    *Response
+	Method      httpMethod
+	Request     Request // status OK
+	Response    Response
 
 	// TODO: document non-OK requests ??
 }
 
 func (a *Action) Render() string {
 	return render(actionTmpl, a)
 }
+
+func NewAction(req *http.Request, resp *httptest.ResponseRecorder) (*Action, error) {
+	docReq, err := NewRequest(req)
+	if err != nil {
+		return nil, err
+	}
+
+	docResp := NewResponse(resp)
+
+	return &Action{
+		Title:       "Some Action",
+		Description: "Some description.",
+		Method:      httpMethod(req.Method),
+		Request:     *docReq,
+		Response:    *docResp,
+	}, nil
+
+}

Diff for: doc/body.go

@@ -4,11 +4,9 @@ import "text/template"
 
 var (
 	bodyTmpl *template.Template
-	bodyFmt  = `
-	+ Body
+	bodyFmt  = `	+ Body
 
-        {{.BodyStr}}
-        
+            {{.FormattedJSON}}        
 `
 )
 
@@ -21,3 +19,13 @@ type Body []byte
 func (b *Body) Render() string {
 	return render(bodyTmpl, b)
 }
+
+// TODO: support other content-types
+func (b *Body) FormattedJSON() string {
+	fbody, err := indentJSONBody(string(*b))
+	if err != nil {
+		panic(err.Error())
+	}
+
+	return fbody
+}

Diff for: doc/doc.go

@@ -16,8 +16,8 @@ const (
 
 var (
 	docTmpl *template.Template
-	docFmt  = `FORMAT: {{.Metadata.Format}}
-HOST: {{.Metadata.Host}}
+	docFmt  = `FORMAT: {{with .Metadata}}{{.Format}}
+HOST: {{.Host}}{{end}}
 
 # {{.Title}}
 {{.Description}}
@@ -32,7 +32,7 @@ func init() {
 type Doc struct {
 	Title          string
 	Description    string
-	Metadata       *Metadata
+	Metadata       Metadata
 	ResourceGroups []*ResourceGroup
 	file           *os.File
 
@@ -57,14 +57,20 @@ func NewDoc(outDir string) (doc *Doc, err error) {
 	doc = tmpDoc
 	doc.file = fi
 
-	err = docTmpl.Execute(fi, doc)
-	if err != nil {
-		return
-	}
-
 	return
 }
 
+// TODO: add Resource to appropriate ResourceGroup,
+//  not just to ResourceGroups[0]
+func (d *Doc) AddResource(resource *Resource) {
+	group := d.ResourceGroups[0]
+	group.Resources = append(group.Resources, *resource)
+}
+
+func (d *Doc) Write() error {
+	return docTmpl.Execute(d.file, d)
+}
+
 func getPayload(req *http.Request) (body []byte, err error) {
 	body, err = ioutil.ReadAll(req.Body)
 	if err != nil {

Diff for: doc/request.go

@@ -1,18 +1,16 @@
 package doc
 
 import (
-	"fmt"
 	"net/http"
 	"text/template"
 )
 
 var (
 	requestTmpl *template.Template
 	requestFmt  = `{{if or .Header .Body}}
-+ Request {{with .Header}}({{.ContentType}}){{end}}{{end}}
-{{.Header.Render}}
-{{.Body.Render}}
-`
++ Request {{with .Header}}({{.ContentType}}){{end}}
+{{with .Header}}{{.Render}}{{end}}
+{{with .Body}}{{.Render}}{{end}}{{end}}`
 )
 
 func init() {
@@ -58,26 +56,3 @@ func (r *Request) BodyStr() string {
 
 	return fbody
 }
-
-func RecordRequest(doc *Doc, req *http.Request) error {
-	body, err := getPayload(req)
-	if err != nil {
-		return err
-	}
-
-	fmt.Println(body)
-
-	// err = doc.WriteRequestTitle("")
-	// if err != nil {
-	// 	return err
-	// }
-
-	// err = doc.WriteHeaders(req.Header)
-	// if err != nil {
-	// 	return err
-	// }
-
-	// return doc.WriteBody(string(body))
-
-	return nil
-}

Diff for: doc/resource.go

@@ -6,27 +6,44 @@ var (
 	resourceTmpl *template.Template
 	resourceFmt  = `## {{.Title}} [{{with .URL}}{{.ParameterizedPath}}{{end}}]
 {{.Description}}
-{{with .URL}}{{with .Parameters}}+ Parameters
-{{range .}}
-{{.Render}}{{end}}{{end}}{{end}}{{range .Actions}}
+{{with .URL}}{{if .Parameters}}+ Parameters
+{{range .Parameters}}
+{{.Render}}{{end}}{{end}}{{end}}
+{{range .Actions}}
 {{.Render}}{{end}}`
 )
 
 func init() {
 	resourceTmpl = template.Must(template.New("resource").Parse(resourceFmt))
 }
 
+type httpMethod string
+
 type Resource struct {
 	Title       string
 	Description string
 	//Model       *Model
 	URL     *URL
-	Actions []*Action
+	Actions map[httpMethod]*Action
 
 	// TODO:
 	// Attributes
 }
 
+func NewResource(urlPath string) *Resource {
+	resource := &Resource{}
+	resource.Actions = map[httpMethod]*Action{}
+	return resource
+}
+
+func (r *Resource) AddAction(action *Action) {
+	if r.Actions == nil {
+		r.Actions = map[httpMethod]*Action{}
+	}
+
+	r.Actions[action.Method] = action
+}
+
 func (r *Resource) Render() string {
 	return render(resourceTmpl, r)
 }

Diff for: doc/resourcegroup.go

@@ -18,7 +18,7 @@ func init() {
 type ResourceGroup struct {
 	Title       string
 	Description string
-	Resources   []*Resource
+	Resources   []Resource
 }
 
 func (rg *ResourceGroup) Render() string {

Diff for: doc/response.go

@@ -1,7 +1,6 @@
 package doc
 
 import (
-	"net/http"
 	"net/http/httptest"
 	"text/template"
 )
@@ -10,8 +9,8 @@ var (
 	responseTmpl *template.Template
 	responseFmt  = `
 + Response {{.StatusCode}} {{with .ContentType}}({{.}}){{end}}
-{{.Header.Render}}
-{{.Body.Render}}`
+{{with .Header}}{{.Render}}{{end}}
+{{with .Body}}{{.Render}}{{end}}`
 )
 
 func init() {
@@ -22,28 +21,19 @@ type Response struct {
 	StatusCode  int
 	Description string
 	Header      Header
-	Body        []byte
+	Body        Body
 
 	// TODO:
 	// Attributes
 	// Schema
 }
 
-func NewResponse(description string, w *httptest.ResponseRecorder) (*Response, error) {
-
-	body1, body2, err := cloneBody(w.Body)
-	if err != nil {
-		return nil, err
-	}
-
-	w.Body = body1
-
+func NewResponse(resp *httptest.ResponseRecorder) *Response {
 	return &Response{
-		StatusCode:  w.Code,
-		Description: description,
-		Header:      Header(w.Header()),
-		Body:        body2.Bytes(),
-	}, nil
+		StatusCode: resp.Code,
+		Header:     Header(resp.Header()),
+		Body:       resp.Body.Bytes(),
+	}
 }
 
 func (r *Response) Render() string {
@@ -62,21 +52,3 @@ func (r *Response) BodyStr() string {
 
 	return fbody
 }
-
-func RecordResponse(doc *Doc, handler http.Handler, req *http.Request) (resp *httptest.ResponseRecorder, err error) {
-	resp = httptest.NewRecorder()
-	handler.ServeHTTP(resp, req)
-
-	// err = doc.WriteResponseTitle(resp.Code, resp.Header().Get("Content-Type"))
-	// if err != nil {
-	// 	return
-	// }
-
-	// err = doc.WriteHeaders(resp.Header())
-	// if err != nil {
-	// 	return
-	// }
-
-	// err = doc.WriteBody(string(resp.Body.String()))
-	return
-}

Diff for: doc/response_test.go

@@ -17,8 +17,7 @@ func (t *suite) TestNewResponse_ResponseBodyIsCorrectlyCopied() {
 	w := httptest.NewRecorder()
 	testResponseHandler(w, req)
 
-	apiResp, err := NewResponse("example", w)
-	t.Must(t.Nil(err))
+	apiResp := NewResponse(w)
 
 	t.Equal(string(apiResp.Body), testResponseBody)
 }
@@ -31,8 +30,7 @@ func (t *suite) TestNewResponse_OriginalResponseBodyDoesNotChange() {
 	w := httptest.NewRecorder()
 	testResponseHandler(w, req)
 
-	_, err = NewResponse("example", w)
-	t.Must(t.Nil(err))
+	_ = NewResponse(w)
 
 	t.Equal(w.Body.String(), testRequestBody)
 }

Diff for: doc/tmp.go

@@ -1,65 +1,18 @@
 package doc
 
-import (
-	"fmt"
-	"net/url"
-	"strings"
-)
-
 var (
-	tmpResourceCount = 0
-	tmpResourceNames = []string{"Thing", "Foozle", "Bardy", "Wallet"}
-	tmpDoc           = &Doc{
+	tmpDoc = &Doc{
 		Title:       "JSON Placeholder API",
 		Description: "Fake Online REST API for Testing and Prototyping",
-		Metadata: &Metadata{
+		Metadata: Metadata{
 			Format: FORMAT,
 			Host:   "http://jsonplaceholder.typicode.com",
 		},
 		ResourceGroups: []*ResourceGroup{
 			&ResourceGroup{
 				Title:       "A Lovely Resource Group",
 				Description: "All CRUD endpoints for A Lovely Resource Group",
-				Resources:   newTmpResources(1),
-			},
-			&ResourceGroup{
-				Title:       "An Awesome Resource Group",
-				Description: "All non-CRUD endpoints",
-				Resources:   newTmpResources(2),
 			},
 		},
 	}
 )
-
-func newTmpResources(n int) []*Resource {
-	resources := make([]*Resource, n)
-
-	for i := 0; i < n; i++ {
-		resources[i] = newTmpResource()
-	}
-	return resources
-}
-
-func newTmpResource() *Resource {
-	tmpResourceCount += 1
-	index := tmpResourceCount % len(tmpResourceNames)
-	name := tmpResourceNames[index]
-
-	var query string
-	if index == 0 {
-		query = fmt.Sprintf("?a=0")
-	} else if index == 1 {
-		query = fmt.Sprintf("?b=hello+world")
-	}
-
-	u, err := url.Parse(fmt.Sprintf("/%s/id/%d"+query, strings.ToLower(name), tmpResourceCount))
-	if err != nil {
-		panic(err.Error())
-	}
-
-	return &Resource{
-		Title:       fmt.Sprintf("Resource #%d", tmpResourceCount),
-		Description: "This resource is just like all the others.",
-		URL:         &URL{u, nil},
-	}
-}