コード例 #1
0
ファイル: generator.go プロジェクト: ajoulie/goa
// gotTypeRefExt computes the type reference for a type in a different package.
func goTypeRefExt(t design.DataType, tabs int, pkg string) string {
	ref := codegen.GoTypeRef(t, nil, tabs, false)
	if strings.HasPrefix(ref, "*") {
		return fmt.Sprintf("%s.%s", pkg, ref[1:])
	}
	return fmt.Sprintf("%s.%s", pkg, ref)
}
コード例 #2
0
ファイル: generator.go プロジェクト: jim-slattery-rs/goa
func okResp(a *design.ActionDefinition) map[string]interface{} {
	var ok *design.ResponseDefinition
	for _, resp := range a.Responses {
		if resp.Status == 200 {
			ok = resp
			break
		}
	}
	if ok == nil {
		return nil
	}
	var mt *design.MediaTypeDefinition
	var ok2 bool
	if mt, ok2 = design.Design.MediaTypes[design.CanonicalIdentifier(ok.MediaType)]; !ok2 {
		return nil
	}
	name := codegen.GoTypeRef(mt, mt.AllRequired(), 1, false)
	var pointer string
	if strings.HasPrefix(name, "*") {
		name = name[1:]
		pointer = "*"
	}
	typeref := fmt.Sprintf("%s%s.%s", pointer, TargetPackage, name)
	if strings.HasPrefix(typeref, "*") {
		typeref = "&" + typeref[1:]
	}
	return map[string]interface{}{
		"Name":    ok.Name,
		"GoType":  codegen.GoNativeType(mt),
		"TypeRef": typeref,
	}
}
コード例 #3
0
ファイル: generator.go プロジェクト: konstantin-dzreev/goa
// decodeGoTypeRef handles the case where the type being decoded is a error response media type.
func decodeGoTypeRef(t design.DataType, required []string, tabs int, private bool) string {
	mt, ok := t.(*design.MediaTypeDefinition)
	if ok && mt.IsError() {
		return "*goa.ErrorResponse"
	}
	return codegen.GoTypeRef(t, required, tabs, private)
}
コード例 #4
0
ファイル: test_generator.go プロジェクト: smessier/goa
func attToObject(name string, parent, att *design.AttributeDefinition) *ObjectType {
	obj := &ObjectType{}
	obj.Label = name
	obj.Name = codegen.Goify(name, false)
	obj.Type = codegen.GoTypeRef(att.Type, nil, 0, false)
	if att.Type.IsPrimitive() && parent.IsPrimitivePointer(name) {
		obj.Pointer = "*"
	}
	return obj
}
コード例 #5
0
ファイル: generator.go プロジェクト: smessier/goa
func (g *Generator) okResp(a *design.ActionDefinition) map[string]interface{} {
	var ok *design.ResponseDefinition
	for _, resp := range a.Responses {
		if resp.Status == 200 {
			ok = resp
			break
		}
	}
	if ok == nil {
		return nil
	}
	var mt *design.MediaTypeDefinition
	var ok2 bool
	if mt, ok2 = design.Design.MediaTypes[design.CanonicalIdentifier(ok.MediaType)]; !ok2 {
		return nil
	}
	view := ok.ViewName
	if view == "" {
		view = design.DefaultView
	}
	pmt, _, err := mt.Project(view)
	if err != nil {
		return nil
	}
	var typeref string
	if pmt.IsError() {
		typeref = `goa.ErrInternal("not implemented")`
	} else {
		name := codegen.GoTypeRef(pmt, pmt.AllRequired(), 1, false)
		var pointer string
		if strings.HasPrefix(name, "*") {
			name = name[1:]
			pointer = "*"
		}
		typeref = fmt.Sprintf("%s%s.%s", pointer, g.Target, name)
		if strings.HasPrefix(typeref, "*") {
			typeref = "&" + typeref[1:]
		}
		typeref += "{}"
	}
	var nameSuffix string
	if view != "default" {
		nameSuffix = codegen.Goify(view, true)
	}
	return map[string]interface{}{
		"Name":    ok.Name + nameSuffix,
		"GoType":  codegen.GoNativeType(pmt),
		"TypeRef": typeref,
	}
}
コード例 #6
0
ファイル: generator.go プロジェクト: ajoulie/goa
func okResp(a *design.ActionDefinition) map[string]interface{} {
	var ok *design.ResponseDefinition
	for _, resp := range a.Responses {
		if resp.Status == 200 {
			ok = resp
			break
		}
	}
	if ok == nil {
		return nil
	}
	var mt *design.MediaTypeDefinition
	var ok2 bool
	if mt, ok2 = design.Design.MediaTypes[design.CanonicalIdentifier(ok.MediaType)]; !ok2 {
		return nil
	}
	view := "default"
	if _, ok := mt.Views["default"]; !ok {
		for v := range mt.Views {
			view = v
			break
		}
	}
	pmt, _, err := mt.Project(view)
	if err != nil {
		return nil
	}
	name := codegen.GoTypeRef(pmt, pmt.AllRequired(), 1, false)
	var pointer string
	if strings.HasPrefix(name, "*") {
		name = name[1:]
		pointer = "*"
	}
	typeref := fmt.Sprintf("%s%s.%s", pointer, TargetPackage, name)
	if strings.HasPrefix(typeref, "*") {
		typeref = "&" + typeref[1:]
	}
	var nameSuffix string
	if view != "default" {
		nameSuffix = codegen.Goify(view, true)
	}
	return map[string]interface{}{
		"Name":    ok.Name + nameSuffix,
		"GoType":  codegen.GoNativeType(pmt),
		"TypeRef": typeref,
	}
}
コード例 #7
0
func paramFromNames(action *design.ActionDefinition, names []string) (params []*ObjectType) {
	for _, paramName := range names {
		for name, att := range action.Params.Type.ToObject() {
			if name == paramName {
				param := &ObjectType{}
				param.Label = name
				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)
			}
		}
	}
	return
}
コード例 #8
0
ファイル: test_generator.go プロジェクト: jim-slattery-rs/goa
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
}
コード例 #9
0
ファイル: types_test.go プロジェクト: jianjunliu/goa
				})

				Context("unmarshaler code", func() {
					BeforeEach(func() {
						unmarshaler = codegen.TypeUnmarshaler(o, false, "", context, source, target)
						data := map[string]interface{}{
							"raw": `interface{}(map[string]interface{}{
								"baz": map[string]interface{}{
									"foo": 345.0,
									"bar":[]interface{}{[]interface{}{1.0,2.0,3.0}},
								},
								"faz": 2.0,
							})`,
							"source":     unmarshaler,
							"target":     target,
							"targetType": codegen.GoTypeRef(o, nil, 1),
						}
						err := tmpl.Execute(tmpFile, data)
						Ω(err).ShouldNot(HaveOccurred())
					})
					It("compiles", func() {
						Ω(string(out)).Should(BeEmpty())

						bin := "codegen"
						if runtime.GOOS == "windows" {
							bin += ".exe"
						}
						cmd := exec.Command(filepath.FromSlash(fmt.Sprintf("./%s", bin)))
						cmd.Env = []string{fmt.Sprintf("PATH=%s", filepath.Join(gopath, "bin"))}
						cmd.Dir = srcDir
						code, err := cmd.CombinedOutput()
コード例 #10
0
ファイル: generator.go プロジェクト: konstantin-dzreev/goa
func (g *Generator) generateActionClient(action *design.ActionDefinition, file *codegen.SourceFile, funcs template.FuncMap) error {
	var (
		params        []string
		names         []string
		queryParams   []*paramData
		headers       []*paramData
		signer        string
		clientsTmpl   = template.Must(template.New("clients").Funcs(funcs).Parse(clientsTmpl))
		requestsTmpl  = template.Must(template.New("requests").Funcs(funcs).Parse(requestsTmpl))
		clientsWSTmpl = template.Must(template.New("clientsws").Funcs(funcs).Parse(clientsWSTmpl))
	)
	if action.Payload != nil {
		params = append(params, "payload "+codegen.GoTypeRef(action.Payload, action.Payload.AllRequired(), 1, false))
		names = append(names, "payload")
	}
	initParams := func(att *design.AttributeDefinition) []*paramData {
		if att == nil {
			return nil
		}
		obj := att.Type.ToObject()
		var pdata []*paramData
		var optData []*paramData
		for n, q := range obj {
			varName := codegen.Goify(n, false)
			param := &paramData{
				Name:      n,
				VarName:   varName,
				Attribute: q,
			}
			if q.Type.IsPrimitive() {
				param.MustToString = q.Type.Kind() != design.StringKind
				if att.IsRequired(n) {
					param.ValueName = varName
					pdata = append(pdata, param)
				} else {
					param.ValueName = "*" + varName
					param.CheckNil = true
					optData = append(optData, param)
				}
			} else {
				if q.Type.IsArray() {
					param.IsArray = true
					param.ElemAttribute = q.Type.ToArray().ElemType
				}
				param.MustToString = true
				param.ValueName = varName
				param.CheckNil = true
				if att.IsRequired(n) {
					pdata = append(pdata, param)
				} else {
					optData = append(optData, param)
				}
			}
		}

		sort.Sort(byParamName(pdata))
		sort.Sort(byParamName(optData))

		// Update closure
		for _, p := range pdata {
			names = append(names, p.VarName)
			params = append(params, p.VarName+" "+cmdFieldType(p.Attribute.Type, false))
		}
		for _, p := range optData {
			names = append(names, p.VarName)
			params = append(params, p.VarName+" "+cmdFieldType(p.Attribute.Type, p.Attribute.Type.IsPrimitive()))
		}

		return append(pdata, optData...)
	}
	queryParams = initParams(action.QueryParams)
	headers = initParams(action.Headers)
	if action.Security != nil {
		signer = codegen.Goify(action.Security.Scheme.SchemeName, true)
	}
	data := struct {
		Name            string
		ResourceName    string
		Description     string
		Routes          []*design.RouteDefinition
		HasPayload      bool
		Params          string
		ParamNames      string
		CanonicalScheme string
		Signer          string
		QueryParams     []*paramData
		Headers         []*paramData
	}{
		Name:            action.Name,
		ResourceName:    action.Parent.Name,
		Description:     action.Description,
		Routes:          action.Routes,
		HasPayload:      action.Payload != nil,
		Params:          strings.Join(params, ", "),
		ParamNames:      strings.Join(names, ", "),
		CanonicalScheme: action.CanonicalScheme(),
		Signer:          signer,
		QueryParams:     queryParams,
		Headers:         headers,
	}
	if action.WebSocket() {
		return clientsWSTmpl.Execute(file, data)
	}
	if err := clientsTmpl.Execute(file, data); err != nil {
		return err
	}
	return requestsTmpl.Execute(file, data)
}