Fixup documentation style to be consistent

Author: sharpner

api.go

@@ -191,20 +191,6 @@ type resource struct {
 	marshalers   map[string]ContentMarshaler
 }
 
-// AddResource registers a data source for the given resource
-// At least the CRUD interface must be implemented, all the other interfaces are optional.
-// `resource` should be either an empty struct instance such as `Post{}` or a pointer to
-// a struct such as `&Post{}`. The same type will be used for constructing new elements.
-func (api *API) AddResource(prototype jsonapi.MarshalIdentifier, source CRUD) {
-	api.addResource(prototype, source, api.marshalers)
-}
-
-// UseMiddleware registers middlewares that implement the api2go.HandlerFunc
-// Middleware is run before any generated routes.
-func (api *API) UseMiddleware(middleware ...HandlerFunc) {
-	api.middlewares = append(api.middlewares, middleware...)
-}
-
 // middlewareChain executes the middleeware chain setup
 func (api *API) middlewareChain(c APIContexter, w http.ResponseWriter, r *http.Request) {
 	for _, middleware := range api.middlewares {

api_interfaces.go

@@ -63,17 +63,17 @@ type URLResolver interface {
 	GetBaseURL() string
 }
 
-//RequestAwareURLResolver allows you to dynamically change
-//generated urls.
+// RequestAwareURLResolver allows you to dynamically change
+// generated urls.
 //
-//This is particulary useful if you have the same
-//API answering to multiple domains, or subdomains
-//e.g customer[1,2,3,4].yourapi.example.com
+// This is particulary useful if you have the same
+// API answering to multiple domains, or subdomains
+// e.g customer[1,2,3,4].yourapi.example.com
 //
-//SetRequest will always be called prior to
-//the GetBaseURL() from `URLResolver` so you
-//have to change the result value based on the last
-//request.
+// SetRequest will always be called prior to
+// the GetBaseURL() from `URLResolver` so you
+// have to change the result value based on the last
+// request.
 type RequestAwareURLResolver interface {
 	URLResolver
 	SetRequest(http.Request)

api_public.go

@@ -5,6 +5,7 @@ import (
 	"strings"
 	"sync"
 
+	"github.com/manyminds/api2go/jsonapi"
 	"github.com/manyminds/api2go/routing"
 )
 
@@ -44,10 +45,24 @@ func (api *API) SetContextAllocator(allocator APIContextAllocatorFunc) {
 	api.contextAllocator = allocator
 }
 
-//SetRedirectTrailingSlash enables 307 redirects on urls ending with /
-//when disabled, an URL ending with / will 404
-//this will and should work only if using the default router
-//DEPRECATED
+// AddResource registers a data source for the given resource
+// At least the CRUD interface must be implemented, all the other interfaces are optional.
+// `resource` should be either an empty struct instance such as `Post{}` or a pointer to
+// a struct such as `&Post{}`. The same type will be used for constructing new elements.
+func (api *API) AddResource(prototype jsonapi.MarshalIdentifier, source CRUD) {
+	api.addResource(prototype, source, api.marshalers)
+}
+
+// UseMiddleware registers middlewares that implement the api2go.HandlerFunc
+// Middleware is run before any generated routes.
+func (api *API) UseMiddleware(middleware ...HandlerFunc) {
+	api.middlewares = append(api.middlewares, middleware...)
+}
+
+// SetRedirectTrailingSlash enables 307 redirects on urls ending with /
+// when disabled, an URL ending with / will 404
+// this will and should work only if using the default router
+// DEPRECATED
 func (api *API) SetRedirectTrailingSlash(enabled bool) {
 	if api.router == nil {
 		panic("router must not be nil")
@@ -86,21 +101,21 @@ func NewAPI(prefix string) *API {
 	return NewAPIWithMarshalers(prefix, "", DefaultContentMarshalers)
 }
 
-//NewAPIWithRouting allows you to use a custom URLResolver, marshalers and custom routing
-//if you want to use the default routing, you should use another constructor.
+// NewAPIWithRouting allows you to use a custom URLResolver, marshalers and custom routing
+// if you want to use the default routing, you should use another constructor.
 //
-//If you don't need any of the parameters you can skip them with the defaults:
-//the default for `prefix` would be `""`, which means there is no namespace for your api.
-//although we suggest using one.
+// If you don't need any of the parameters you can skip them with the defaults:
+// the default for `prefix` would be `""`, which means there is no namespace for your api.
+// although we suggest using one.
 //
-//if your api only answers to one url you can use a NewStaticResolver() as  `resolver`
+// if your api only answers to one url you can use a NewStaticResolver() as  `resolver`
 //
-//if you have no specific marshalling needs, use `DefaultContentMarshalers`
+// if you have no specific marshalling needs, use `DefaultContentMarshalers`
 func NewAPIWithRouting(prefix string, resolver URLResolver, marshalers map[string]ContentMarshaler, router routing.Routeable) *API {
 	return newAPI(prefix, resolver, marshalers, router)
 }
 
-//newAPI is now an internal method that can be changed if params are changing
+// newAPI is now an internal method that can be changed if params are changing
 func newAPI(prefix string, resolver URLResolver, marshalers map[string]ContentMarshaler, router routing.Routeable) *API {
 	if len(marshalers) == 0 {
 		panic("marshaler map must not be empty")
@@ -134,8 +149,8 @@ func newAPI(prefix string, resolver URLResolver, marshalers map[string]ContentMa
 	return api
 }
 
-//NewAPIWithMarshalers is DEPRECATED
-//use NewApiWithMarshalling instead
+// NewAPIWithMarshalers is DEPRECATED
+// use NewApiWithMarshalling instead
 func NewAPIWithMarshalers(prefix string, baseURL string, marshalers map[string]ContentMarshaler) *API {
 	staticResolver := NewStaticResolver(baseURL)
 	return NewAPIWithMarshalling(prefix, staticResolver, marshalers)

error.go

@@ -6,18 +6,18 @@ import (
 	"strconv"
 )
 
-//HTTPError is used for errors
+// HTTPError is used for errors
 type HTTPError struct {
 	err    error
 	msg    string
 	status int
 	Errors []Error `json:"errors,omitempty"`
 }
 
-//Error can be used for all kind of application errors
-//e.g. you would use it to define form errors or any
-//other semantical application problems
-//for more information see http://jsonapi.org/format/#errors
+// Error can be used for all kind of application errors
+// e.g. you would use it to define form errors or any
+// other semantical application problems
+// for more information see http://jsonapi.org/format/#errors
 type Error struct {
 	ID     string       `json:"id,omitempty"`
 	Links  *ErrorLinks  `json:"links,omitempty"`
@@ -34,28 +34,28 @@ func (e Error) GetID() string {
 	return e.ID
 }
 
-//ErrorLinks is used to provide an About URL that leads to
-//further details about the particular occurrence of the problem.
+// ErrorLinks is used to provide an About URL that leads to
+// further details about the particular occurrence of the problem.
 //
-//for more information see http://jsonapi.org/format/#error-objects
+// for more information see http://jsonapi.org/format/#error-objects
 type ErrorLinks struct {
 	About string `json:"about,omitempty"`
 }
 
-//ErrorSource is used to provide references to the source of an error.
+// ErrorSource is used to provide references to the source of an error.
 //
-//The Pointer is a JSON Pointer to the associated entity in the request
-//document.
-//The Paramter is a string indicating which query parameter caused the error.
+// The Pointer is a JSON Pointer to the associated entity in the request
+// document.
+// The Paramter is a string indicating which query parameter caused the error.
 //
-//for more information see http://jsonapi.org/format/#error-objects
+// for more information see http://jsonapi.org/format/#error-objects
 type ErrorSource struct {
 	Pointer   string `json:"pointer,omitempty"`
 	Parameter string `json:"parameter,omitempty"`
 }
 
-//MarshalError marshals errors recursively in json format.
-//it can make use of the jsonapi.HTTPError struct
+// MarshalError marshals errors recursively in json format.
+// it can make use of the jsonapi.HTTPError struct
 func (j JSONContentMarshaler) MarshalError(err error) string {
 	httpErr, ok := err.(HTTPError)
 	if ok {
@@ -67,7 +67,7 @@ func (j JSONContentMarshaler) MarshalError(err error) string {
 	return marshalHTTPError(httpErr, j)
 }
 
-//marshalHTTPError marshals an internal httpError
+// marshalHTTPError marshals an internal httpError
 func marshalHTTPError(input HTTPError, marshaler ContentMarshaler) string {
 	if len(input.Errors) == 0 {
 		input.Errors = []Error{{Title: input.msg, Status: strconv.Itoa(input.status)}}
@@ -90,7 +90,7 @@ func NewHTTPError(err error, msg string, status int) HTTPError {
 	return HTTPError{err: err, msg: msg, status: status}
 }
 
-//Error returns a nice string represenation including the status
+// Error returns a nice string represenation including the status
 func (e HTTPError) Error() string {
 	msg := fmt.Sprintf("http error (%d) %s and %d more errors", e.status, e.msg, len(e.Errors))
 	if e.err != nil {

resolver.go

@@ -7,26 +7,26 @@ type callbackResolver struct {
 	r        http.Request
 }
 
-//NewCallbackResolver handles each resolve via
-//your provided callback func
+// NewCallbackResolver handles each resolve via
+// your provided callback func
 func NewCallbackResolver(callback func(http.Request) string) URLResolver {
 	return &callbackResolver{callback: callback}
 }
 
-//GetBaseURL calls the callback given in the constructor method
-//to implement `URLResolver`
+// GetBaseURL calls the callback given in the constructor method
+// to implement `URLResolver`
 func (c callbackResolver) GetBaseURL() string {
 	return c.callback(c.r)
 }
 
-//SetRequest to implement `RequestAwareURLResolver`
+// SetRequest to implement `RequestAwareURLResolver`
 func (c *callbackResolver) SetRequest(r http.Request) {
 	c.r = r
 }
 
-//staticResolver is only used
-//for backwards compatible reasons
-//and might be removed in the future
+// staticResolver is only used
+// for backwards compatible reasons
+// and might be removed in the future
 type staticResolver struct {
 	baseURL string
 }
@@ -35,8 +35,8 @@ func (s staticResolver) GetBaseURL() string {
 	return s.baseURL
 }
 
-//NewStaticResolver returns a simple resolver that
-//will always answer with the same url
+// NewStaticResolver returns a simple resolver that
+// will always answer with the same url
 func NewStaticResolver(baseURL string) URLResolver {
 	return &staticResolver{baseURL: baseURL}
 }

response.go

@@ -1,9 +1,9 @@
 package api2go
 
-//The Response struct implements api2go.Responder and can be used as a default
-//implementation for your responses
-//you can fill the field `Meta` with all the metadata your application needs
-//like license, tokens, etc
+// The Response struct implements api2go.Responder and can be used as a default
+// implementation for your responses
+// you can fill the field `Meta` with all the metadata your application needs
+// like license, tokens, etc
 type Response struct {
 	Res  interface{}
 	Code int

routing/httprouter.go

@@ -6,12 +6,12 @@ import (
 	"github.com/julienschmidt/httprouter"
 )
 
-//HTTPRouter default router implementation for api2go
+// HTTPRouter default router implementation for api2go
 type HTTPRouter struct {
 	router *httprouter.Router
 }
 
-//Handle each method like before and wrap them into julienschmidt handler func style
+// Handle each method like before and wrap them into julienschmidt handler func style
 func (h HTTPRouter) Handle(protocol, route string, handler HandlerFunc) {
 	wrappedCallback := func(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
 		params := map[string]string{}
@@ -25,26 +25,26 @@ func (h HTTPRouter) Handle(protocol, route string, handler HandlerFunc) {
 	h.router.Handle(protocol, route, wrappedCallback)
 }
 
-//Handler returns the router
+// Handler returns the router
 func (h HTTPRouter) Handler() http.Handler {
 	return h.router
 }
 
-//SetRedirectTrailingSlash wraps this internal functionality of
-//the julienschmidt router.
+// SetRedirectTrailingSlash wraps this internal functionality of
+// the julienschmidt router.
 func (h HTTPRouter) SetRedirectTrailingSlash(enabled bool) {
 	h.router.RedirectTrailingSlash = enabled
 }
 
-//GetRouteParameter implemention will extract the param the julienschmidt way
+// GetRouteParameter implemention will extract the param the julienschmidt way
 func (h HTTPRouter) GetRouteParameter(r http.Request, param string) string {
 	path := httprouter.CleanPath(r.URL.Path)
 	_, params, _ := h.router.Lookup(r.Method, path)
 	return params.ByName(param)
 }
 
-//NewHTTPRouter returns a new instance of julienschmidt/httprouter
-//this is the default router when using api2go
+// NewHTTPRouter returns a new instance of julienschmidt/httprouter
+// this is the default router when using api2go
 func NewHTTPRouter(prefix string, notAllowedHandler http.Handler) Routeable {
 	router := httprouter.New()
 	router.HandleMethodNotAllowed = true

routing/router.go

@@ -2,21 +2,21 @@ package routing
 
 import "net/http"
 
-//HandlerFunc must contain all params from the route
-//in the form key,value
+// HandlerFunc must contain all params from the route
+// in the form key,value
 type HandlerFunc func(w http.ResponseWriter, r *http.Request, params map[string]string)
 
-//Routeable allows drop in replacement for api2go's router
-//by default, we are using julienschmidt/httprouter
-//but you can use any router that has similiar features
-//e.g. gin
+// Routeable allows drop in replacement for api2go's router
+// by default, we are using julienschmidt/httprouter
+// but you can use any router that has similiar features
+// e.g. gin
 type Routeable interface {
-	//Handler should return the routers main handler, often this is the router itself
+	// Handler should return the routers main handler, often this is the router itself
 	Handler() http.Handler
-	//Handle must be implemented to register api2go's default routines
-	//to your used router.
-	//protocol will be PATCH,OPTIONS,GET,POST,PUT
-	//route will be the request route /items/:id where :id means dynamically filled params
-	//handler is the handler that will answer to this specific route
+	// Handle must be implemented to register api2go's default routines
+	// to your used router.
+	// protocol will be PATCH,OPTIONS,GET,POST,PUT
+	// route will be the request route /items/:id where :id means dynamically filled params
+	// handler is the handler that will answer to this specific route
 	Handle(protocol, route string, handler HandlerFunc)
 }