// pathParamNames return the names of the parameters of the path factory function for the given route.
func pathParamNames(r *design.RouteDefinition) string {
params := r.Params()
goified := make([]string, len(params))
for i, p := range params {
goified[i] = codegen.Goify(p, false)
}
return strings.Join(goified, ", ")
}
// pathParams return the function signature of the path factory function for the given route.
func pathParams(r *design.RouteDefinition) string {
pnames := r.Params()
params := make(design.Object, len(pnames))
for _, p := range pnames {
params[p] = r.Parent.Params.Type.ToObject()[p]
}
return join(&design.AttributeDefinition{Type: params}, pnames)
}
// toSchemaHref produces a href that replaces the path wildcards with JSON schema references when
// appropriate.
func toSchemaHref(api *design.APIDefinition, r *design.RouteDefinition) string {
params := r.Params()
args := make([]interface{}, len(params))
for i, p := range params {
args[i] = fmt.Sprintf("/{%s}", p)
}
tmpl := design.WildcardRegex.ReplaceAllLiteralString(r.FullPath(), "%s")
return fmt.Sprintf(tmpl, args...)
}
func createTestMethod(resource *design.ResourceDefinition, action *design.ActionDefinition, response *design.ResponseDefinition, route *design.RouteDefinition, routeIndex int, mediaType *design.MediaTypeDefinition, view *design.ViewDefinition) TestMethod {
routeNameQualifier := suffixRoute(action.Routes, routeIndex)
viewNameQualifier := func() string {
if view != nil && view.Name != "default" {
return view.Name
}
return ""
}()
method := TestMethod{}
method.Name = fmt.Sprintf("%s%s%s%s%s", codegen.Goify(action.Name, true), codegen.Goify(resource.Name, true), codegen.Goify(response.Name, true), routeNameQualifier, codegen.Goify(viewNameQualifier, true))
method.ActionName = codegen.Goify(action.Name, true)
method.ResourceName = codegen.Goify(resource.Name, true)
method.Comment = fmt.Sprintf("test setup")
method.ControllerName = fmt.Sprintf("%s.%sController", TargetPackage, codegen.Goify(resource.Name, true))
method.ContextVarName = fmt.Sprintf("%sCtx", codegen.Goify(action.Name, false))
method.ContextType = fmt.Sprintf("%s.New%s%sContext", TargetPackage, codegen.Goify(action.Name, true), codegen.Goify(resource.Name, true))
method.RouteVerb = route.Verb
method.Status = response.Status
method.FullPath = goPathFormat(route.FullPath())
if view != nil && mediaType != nil {
p, _, err := mediaType.Project(view.Name)
if err != nil {
panic(err)
}
tmp := codegen.GoTypeName(p, nil, 0, false)
if !p.IsBuiltIn() {
tmp = fmt.Sprintf("%s.%s", TargetPackage, tmp)
}
validate := codegen.RecursiveChecker(p.AttributeDefinition, false, false, false, "payload", "raw", 1, true)
returnType := ObjectType{}
returnType.Type = tmp
returnType.Pointer = "*"
returnType.Validatable = validate != ""
method.ReturnType = &returnType
}
if len(route.Params()) > 0 {
var params = []ObjectType{}
for _, paramName := range route.Params() {
for name, att := range action.Params.Type.ToObject() {
if name == paramName {
param := ObjectType{}
param.Name = codegen.Goify(name, false)
param.Type = codegen.GoTypeRef(att.Type, nil, 0, false)
if att.Type.IsPrimitive() && action.Params.IsPrimitivePointer(name) {
param.Pointer = "*"
}
params = append(params, param)
}
}
}
method.Params = params
}
if action.Payload != nil {
payload := ObjectType{}
payload.Name = "payload"
payload.Type = fmt.Sprintf("%s.%s", TargetPackage, codegen.Goify(action.Payload.TypeName, true))
if !action.Payload.IsPrimitive() && !action.Payload.IsArray() && !action.Payload.IsHash() {
payload.Pointer = "*"
}
validate := codegen.RecursiveChecker(action.Payload.AttributeDefinition, false, false, false, "payload", "raw", 1, true)
if validate != "" {
payload.Validatable = true
}
method.Payload = &payload
}
return method
}
// pathParams returns the path params for the given action and route.
func pathParams(action *design.ActionDefinition, route *design.RouteDefinition) []*ObjectType {
return paramFromNames(action, route.Params())
}
