Exemplo n.º 1
0
// processResource recursively process resources and their nested children
// and returns the path so far for the children. The function takes a routerFunc
// as an argument that is invoked with the verb, resource path and handler as
// the resources are processed, so the calling code can use pat, mux, httprouter
// or whatever router they desire and we don't need to know about it.
func processResource(parent, name string, resource *raml.Resource, params []*Parameter, routerFunc func(s *Endpoint)) error {
	var path = parent + name
	var err error
	for name, param := range resource.UriParameters {
		params = append(params, newParam(name, &param))
	}

	s := make([]*Endpoint, 0, 6)
	for _, m := range resource.Methods() {
		s, err = appendEndpoint(s, m, params)
		if err != nil {
			return err
		}
	}

	for _, ep := range s {
		ep.Path = path
		routerFunc(ep)
	}

	// Get all children.
	for nestname, nested := range resource.Nested {
		return processResource(path, nestname, nested, params, routerFunc)
	}

	return nil
}
Exemplo n.º 2
0
// generateRoute builds app/Http/routes.php
func generateRoute(parent, uri string, resource *raml.Resource, e *template.Template, f *os.File) {
	path := parent + uri
	err := e.Execute(f, Route{path, resource.UriParameters, resource.Methods(), resource.Description, resource.DisplayName})
	if err != nil {
		log.Println("executing template:", err)
	}

	// Get all children.
	for nestname, nested := range resource.Nested {
		generateRoute(path, nestname, nested, e, f)
	}
}
Exemplo n.º 3
0
// generateResource creates a handler struct from an API resource
// and executes the associated template.
func generateResource(parent, name string, resource *raml.Resource, t *template.Template, f *os.File) string {
	path := parent + name

	for _, method := range resource.Methods() {
		err := t.Execute(f, HandlerInfo{ramlapi.Variableize(method.DisplayName), method.Name, path, method.Description})
		if err != nil {
			log.Println("executing template:", err)
		}
	}

	// Get all children.
	for nestname, nested := range resource.Nested {
		return generateResource(path, nestname, nested, t, f)
	}
	return path
}
Exemplo n.º 4
0
// generateMap builds a map of string labels to handler funcs - this is
// used by the calling code to link the display name strings that come
// from the RAML file to handler funcs in the client code.
func generateMap(parent, name string, resource *raml.Resource, e *template.Template, f *os.File) {
	path := parent + name

	for _, method := range resource.Methods() {
		name := ramlapi.Variableize(method.DisplayName)
		err := e.Execute(f, RouteMapEntry{name, name})
		if err != nil {
			log.Println("executing template:", err)
		}
	}

	// Get all children.
	for nestname, nested := range resource.Nested {
		generateMap(path, nestname, nested, e, f)
	}
}