Example #1
0
func NewMethod(r *raml.Resource, rd *Resource, m *raml.Method, methodName string, sbn SetBodyName) Method {
	method := Method{
		Method:       m,
		Endpoint:     r.FullURI(),
		verb:         strings.ToUpper(methodName),
		RAMLResource: r,
	}

	// set request body
	method.ReqBody = sbn(m.Bodies, method.Endpoint+methodName, commons.ReqBodySuffix)

	//set response body
	for k, v := range m.Responses {
		code := commons.AtoiOrPanic(string(k))
		if code >= 200 && code < 300 {
			method.RespBody = sbn(v.Bodies, method.Endpoint+methodName, commons.RespBodySuffix)
		}
	}

	// set func comment
	if len(m.Description) > 0 {
		method.FuncComments = commons.ParseDescription(m.Description)
	}

	return method
}
Example #2
0
// create a python class representations
func newClass(name, description string, properties map[string]interface{}) class {
	pc := class{
		Name:        name,
		Description: commons.ParseDescription(description),
		Fields:      map[string]field{},
	}

	// generate fields
	for k, v := range properties {
		p := raml.ToProperty(k, v)
		field := field{
			Name:     p.Name,
			Required: p.Required,
		}
		field.setType(p.Type)

		if field.Type == "" { // type is not supported, no need to generate the field
			continue
		}

		field.buildValidators(p)
		pc.Fields[p.Name] = field

	}
	return pc
}
Example #3
0
// create new struct def
func newStructDef(name, packageName, description string, properties map[string]interface{}) structDef {
	// generate struct's fields from type properties
	fields := make(map[string]fieldDef)
	for k, v := range properties {
		prop := raml.ToProperty(k, v)
		fd := fieldDef{
			Name:      strings.Title(prop.Name),
			Type:      convertToGoType(prop.Type),
			IsOmitted: !prop.Required,
		}

		fd.buildValidators(prop)
		fields[prop.Name] = fd
	}
	return structDef{
		Name:        name,
		PackageName: packageName,
		Fields:      fields,
		Description: commons.ParseDescription(description),
	}
}
Example #4
0
func newObject(name, description string, properties map[string]interface{}) (object, error) {
	// generate fields from type properties
	fields := make(map[string]field)

	for k, v := range properties {
		prop := raml.ToProperty(k, v)
		fd := field{
			Name: prop.Name,
			Type: toNimType(prop.Type),
		}
		if fd.Type == "" {
			return object{}, fmt.Errorf("unsupported type in nim:%v", prop.Type)
		}
		fields[prop.Name] = fd
	}

	return object{
		Name:        name,
		Fields:      fields,
		Description: commons.ParseDescription(description),
	}, nil
}
Example #5
0
func NewStruct(t raml.Type, name, lang, pkg string) (Struct, error) {
	// generate fields from type properties
	fields := make(map[string]field)

	for k, v := range t.Properties {
		fd := newField(name, raml.ToProperty(k, v), lang, pkg)
		fields[fd.Name] = fd
	}

	s := Struct{
		ID:          getID(),
		Name:        name,
		Fields:      fields,
		Description: commons.ParseDescription(t.Description),
		T:           t,
		pkg:         pkg,
		lang:        lang,
	}
	if err := s.checkValidCapnp(); err != nil {
		return s, err
	}
	return s, s.orderFields()
}