func (cfg *Config) genTypeSpec(t xsd.Type) (result []spec, err error) {
var s []spec
cfg.debugf("generating type spec for %q", xsd.XMLName(t).Local)
switch t := t.(type) {
case *xsd.SimpleType:
s, err = cfg.genSimpleType(t)
case *xsd.ComplexType:
s, err = cfg.genComplexType(t)
case xsd.Builtin:
// Some built-ins, though built-in, require marshal/unmarshal methods
// to be able to use them with the encoding/xml package.
switch t {
case xsd.Date, xsd.Time, xsd.DateTime, xsd.GDay, xsd.GMonth, xsd.GMonthDay, xsd.GYear, xsd.GYearMonth:
s, err = cfg.genTimeSpec(t)
case xsd.HexBinary, xsd.Base64Binary:
s, err = cfg.genBinarySpec(t)
case xsd.ENTITIES, xsd.IDREFS, xsd.NMTOKENS:
s, err = cfg.genTokenListSpec(t)
}
default:
cfg.logf("unexpected %T %s", t, xsd.XMLName(t).Local)
}
if err != nil || s == nil {
return result, err
}
return append(result, s...), nil
}
// Generate a type declaration for the bult-in list values, along with
// marshal/unmarshal methods
func (cfg *Config) genTokenListSpec(t xsd.Builtin) ([]spec, error) {
cfg.debugf("generating Go source for token list %q", xsd.XMLName(t).Local)
s := spec{
name: strings.ToLower(t.String()),
expr: builtinExpr(t),
xsdType: t,
}
marshal, err := gen.Func("MarshalText").
Receiver("x "+s.name).
Returns("[]byte", "error").
Body(`
return []byte(strings.Join(x, " ")), nil
`).Decl()
if err != nil {
return nil, fmt.Errorf("MarshalText %s: %v", s.name, err)
}
unmarshal, err := gen.Func("UnmarshalText").
Receiver("x " + s.name).
Args("text []byte").
Returns("error").
Body(`
*x = bytes.Fields(text)
return nil
`).Decl()
if err != nil {
return nil, fmt.Errorf("UnmarshalText %s: %v", s.name, err)
}
s.methods = append(s.methods, marshal, unmarshal)
return []spec{s}, nil
}
func (cfg *Config) genSimpleType(t *xsd.SimpleType) ([]spec, error) {
var result []spec
if t.List {
return cfg.genSimpleListSpec(t)
}
if len(t.Union) > 0 {
// We don't support unions because the code that needs
// to be generated to check which of the member types
// the value would be is too complex.
result = append(result, spec{
name: cfg.typeName(t.Name),
expr: builtinExpr(xsd.String),
xsdType: t,
})
return result, nil
}
base, err := cfg.expr(t.Base)
if err != nil {
return nil, fmt.Errorf("simpleType %s: base type %s: %v",
t.Name.Local, xsd.XMLName(t.Base).Local, err)
}
result = append(result, spec{
name: cfg.typeName(t.Name),
expr: base,
xsdType: t,
})
return result, nil
}
// Flatten out our tree of dependent types. If a type is marked as
// private by a user filter and not used as a struct field or embedded
// struct, it is ommitted from the output.
func (cfg *Config) flatten(types map[xml.Name]xsd.Type) []xsd.Type {
var result []xsd.Type
push := func(t xsd.Type) {
result = append(result, t)
}
for _, t := range types {
if cfg.filterTypes != nil && cfg.filterTypes(t) {
continue
}
if t := cfg.flatten1(t, push); t != nil {
result = append(result, t)
}
}
// Remove duplicates
seen := make(map[xml.Name]bool)
var a []xsd.Type
for _, v := range result {
name := xsd.XMLName(v)
if _, ok := seen[name]; !ok {
seen[name] = true
a = append(a, v)
}
}
cfg.debugf("discovered %d types", len(a))
return a
}
// Generate a type declaration for the built-in binary values, along with
// marshal/unmarshal methods for them.
func (cfg *Config) genBinarySpec(t xsd.Builtin) ([]spec, error) {
cfg.debugf("generating Go source for binary type %q", xsd.XMLName(t).Local)
s := spec{
expr: builtinExpr(t),
name: xsd.XMLName(t).Local,
xsdType: t,
}
marshal := gen.Func("MarshalText").Receiver("b "+s.name).Returns("[]byte", "error")
unmarshal := gen.Func("UnmarshalText").Receiver("b " + s.name).Args("text []byte").
Returns("err error")
switch t {
case xsd.HexBinary:
unmarshal.Body(`
*b, err = hex.DecodeString(string(text))
return err
`)
marshal.Body(`
n := hex.EncodedLen([]byte(b))
buf := make([]byte, n)
hex.Encode(buf, []byte(b))
return buf, nil
`)
case xsd.Base64Binary:
unmarshal.Body(`
*b, err = base64.StdEncoding.DecodeString(string(text))
return err
`)
marshal.Body(`
var buf bytes.Buffer
enc := base64.NewEncoder(base64.StdEncoding, &buf)
enc.Write([]byte(b))
enc.Close()
return buf.Bytes()
`)
}
marshalFn, err := marshal.Decl()
if err != nil {
return nil, fmt.Errorf("MarshalText %s: %v", s.name, err)
}
unmarshalFn, err := unmarshal.Decl()
if err != nil {
return nil, fmt.Errorf("UnmarshalText %s: %v", s.name, err)
}
s.methods = append(s.methods, unmarshalFn, marshalFn)
return []spec{s}, nil
}
// Return the identifier for non-builtin types, and the Go expression
// mapped to the built-in type.
func (cfg *Config) expr(t xsd.Type) (ast.Expr, error) {
if t, ok := t.(xsd.Builtin); ok {
ex := builtinExpr(t)
if ex == nil {
return nil, fmt.Errorf("Unknown built-in type %q", t.Name().Local)
}
return ex, nil
}
return ast.NewIdent(cfg.typeName(xsd.XMLName(t))), nil
}
// Generate a type declaration for the built-in time values, along with
// marshal/unmarshal methods for them.
func (cfg *Config) genTimeSpec(t xsd.Builtin) ([]spec, error) {
var timespec string
cfg.debugf("generating Go source for time type %q", xsd.XMLName(t).Local)
s := spec{
expr: ast.NewIdent("time.Time"),
name: builtinExpr(t).(*ast.Ident).Name,
xsdType: t,
}
switch t {
case xsd.GDay:
timespec = "---02"
case xsd.GMonth:
timespec = "--01"
case xsd.GMonthDay:
timespec = "--01-02"
case xsd.GYear:
timespec = "2006"
case xsd.GYearMonth:
timespec = "2006-01"
case xsd.Time:
timespec = "15:04:05.999999999"
case xsd.Date:
timespec = "2006-01-02"
case xsd.DateTime:
timespec = "2006-01-02T15:04:05.999999999"
}
unmarshal, err := gen.Func("UnmarshalText").
Receiver("t *"+s.name).
Args("text []byte").
Returns("error").
Body(`
return _unmarshalTime(text, (*time.Time)(t), %q)
`, timespec).Decl()
if err != nil {
return nil, fmt.Errorf("could not generate unmarshal function for %s: %v", s.name, err)
}
marshal, err := gen.Func("MarshalText").
Receiver("t *"+s.name).
Returns("[]byte", "error").
Body(`
return []byte((*time.Time)(t).Format(%q)), nil
`, timespec).Decl()
if err != nil {
return nil, fmt.Errorf("could not generate marshal function for %s: %v", s.name, err)
}
s.methods = append(s.methods, unmarshal, marshal)
if helper := cfg.helper("_unmarshalTime"); helper != nil {
//panic(fmt.Sprint("adding ", helper.Name.Name, " to functions for ", s.name))
s.methods = append(s.methods, helper)
}
return []spec{s}, nil
}
// SOAP arrays are declared as follows (unimportant fields ellided):
//
// <xs:complexType name="Array">
// <xs:attribute name="arrayType" type="xs:string" />
// <xs:any namespace="##any" minOccurs="0" maxOccurs="unbounded" />
// </xs:complexType>
//
// Then schemas that want to declare a fixed-type soap array do so like this:
//
// <xs:complexType name="IntArray">
// <xs:complexContent>
// <xs:restriction base="soapenc:Array>
// <xs:attribute ref="soapenc:arrayType" wsdl:arrayType="xs:int[]" />
// </xs:restriction>
// </xs:complexContent>
// </xs:complexType>
//
// XML Schema is wonderful, aint it?
func (cfg *Config) parseSOAPArrayType(s xsd.Schema, t xsd.Type) xsd.Type {
const soapenc = "http://schemas.xmlsoap.org/soap/encoding/"
const wsdl = "http://schemas.xmlsoap.org/wsdl/"
var itemType xml.Name
c, ok := t.(*xsd.ComplexType)
if !ok {
return t
}
var attr []xsd.Attribute
for _, v := range c.Attributes {
if v.Name.Local != "arrayType" {
attr = append(attr, v)
continue
}
for _, a := range v.Attr {
if (a.Name != xml.Name{wsdl, "arrayType"}) {
continue
}
itemType = v.Resolve(a.Value)
break
}
break
}
if itemType.Local == "" {
return c
}
itemType.Local = strings.TrimSpace(itemType.Local)
itemType.Local = strings.TrimSuffix(itemType.Local, "[]")
if b := s.FindType(itemType); b != nil {
c = cfg.overrideWildcardType(c, b)
} else {
cfg.logf("could not lookup item type %q in namespace %q",
itemType.Local, itemType.Space)
}
// Have to remove arrayType from the "base" type, without affecting
// others inheriting from this type.
basep, ok := c.Base.(*xsd.ComplexType)
if !ok {
cfg.logf("type %s derives from non-complexType %s", c.Name.Local, xsd.XMLName(c.Base).Local)
return c
}
base := *basep
base.Attributes = make([]xsd.Attribute, 0, len(basep.Attributes)-1)
for _, v := range basep.Attributes {
if v.Name.Local != "arrayType" {
base.Attributes = append(base.Attributes, v)
}
}
c.Base = &base
c.Attributes = attr
return c
}
func (cfg *Config) overrideWildcardType(t *xsd.ComplexType, base xsd.Type) *xsd.ComplexType {
var elem xsd.Element
var found bool
var replaced bool
Loop:
for x := xsd.Type(t); xsd.Base(x) != nil; x = xsd.Base(x) {
c, ok := x.(*xsd.ComplexType)
if !ok {
cfg.logf("warning: soap-encoded array %s extends %T %s",
xsd.XMLName(x).Local, base, xsd.XMLName(base).Local)
return t
}
for _, v := range c.Elements {
if v.Wildcard {
elem = v
found = true
break Loop
}
}
}
if !found {
cfg.logf("could not override wildcard type for %s; not found in type hierarchy", t.Name.Local)
return t
}
cfg.debugf("overriding wildcard element of %s type from %s to %s",
t.Name.Local, xsd.XMLName(elem.Type).Local, xsd.XMLName(base).Local)
elem.Type = base
for i, v := range t.Elements {
if v.Wildcard {
t.Elements[i] = elem
replaced = true
}
}
if !replaced {
t.Elements = append(t.Elements, elem)
}
return t
}
// OnlyTypes defines a whitelist of fully-qualified type name patterns
// to include in the generated Go source. Only types in the whitelist,
// and types that they depend on, will be included in the Go source.
func OnlyTypes(patterns ...string) Option {
pat := strings.Join(patterns, "|")
reg, err := regexp.Compile(pat)
return func(cfg *Config) Option {
return replacePropertyFilter(&cfg.filterTypes, func(v interface{}) bool {
t, ok := v.(xsd.Type)
if !ok {
panic(fmt.Sprintf("non-type %[1]T %[1]v passed to cfg.filterTypes", v))
}
if err != nil {
cfg.logf("invalid regex %q passed to OnlyTypes: %v", pat, err)
return false
}
return !reg.MatchString(xsd.XMLName(t).Local)
})(cfg)
}
}
// Generate a type declaration for a <list> type, along with marshal/unmarshal
// methods.
func (cfg *Config) genSimpleListSpec(t *xsd.SimpleType) ([]spec, error) {
cfg.debugf("generating Go source for simple list %q", xsd.XMLName(t).Local)
expr, err := cfg.expr(t.Base)
if err != nil {
return nil, err
}
s := spec{
name: cfg.typeName(t.Name),
expr: expr,
xsdType: t,
}
marshal, err := gen.Func("MarshalText").
Receiver("x *"+s.name).
Returns("[]byte", "error").
Body(`
return nil, nil
`).Decl()
if err != nil {
return nil, fmt.Errorf("MarshalText %s: %v", s.name, err)
}
unmarshal, err := gen.Func("UnmarshalText").
Receiver("x *" + s.name).
Args("text []byte").
Returns("error").
Body(`
return nil
`).Decl()
if err != nil {
return nil, fmt.Errorf("UnmarshalText %s: %v", s.name, err)
}
s.methods = append(s.methods, marshal, unmarshal)
return []spec{s}, nil
}
func (cfg *Config) genComplexType(t *xsd.ComplexType) ([]spec, error) {
var result []spec
var fields []ast.Expr
if t.Extends {
base, err := cfg.expr(t.Base)
if err != nil {
return nil, fmt.Errorf("%s base type %s: %v",
t.Name.Local, xsd.XMLName(t.Base).Local, err)
}
switch b := t.Base.(type) {
case *xsd.SimpleType:
cfg.debugf("complexType %[1]s extends simpleType %[2]s. Naming"+
" the chardata struct field after %[2]s", t.Name.Local, b.Name.Local)
fields = append(fields, base, base, gen.String(`xml:",chardata"`))
case xsd.Builtin:
if b == xsd.AnyType {
// extending anyType doesn't really make sense, but
// we can just ignore it.
cfg.debugf("complexType %s: don't know how to extend anyType, ignoring",
t.Name.Local)
break
}
// Name the field after the xsd type name.
cfg.debugf("complexType %[1]s extends %[2]s, naming chardata struct field %[2]s",
t.Name.Local, b)
fields = append(fields, ast.NewIdent(b.String()), base, gen.String(`xml:",chardata"`))
case *xsd.ComplexType:
// Use struct embedding when extending a complex type
cfg.debugf("complexType %s extends %s, embedding struct",
t.Name.Local, b.Name.Local)
fields = append(fields, nil, base, nil)
}
} else {
// When restricting a complex type, all attributes are "inherited" from
// the base type (but not elements!). In addition, any <xs:any> elements,
// while not explicitly inherited, do not disappear.
switch b := t.Base.(type) {
case *xsd.ComplexType:
t.Attributes = mergeAttributes(t, b)
hasWildcard := false
for _, el := range t.Elements {
if el.Wildcard {
hasWildcard = true
break
}
}
if hasWildcard {
break
}
for _, el := range b.Elements {
if el.Wildcard {
t.Elements = append(t.Elements, el)
break
}
}
}
}
attributes, elements := cfg.filterFields(t)
cfg.debugf("complexType %s: generating struct fields for %d elements and %d attributes",
xsd.XMLName(t).Local, len(elements), len(attributes))
hasDefault := false
for _, attr := range attributes {
hasDefault = hasDefault || (attr.Default != "")
tag := fmt.Sprintf(`xml:"%s,attr"`, attr.Name.Local)
base, err := cfg.expr(attr.Type)
if err != nil {
return nil, fmt.Errorf("%s attribute %s: %v", t.Name.Local, attr.Name.Local, err)
}
fields = append(fields, ast.NewIdent(cfg.public(attr.Name)), base, gen.String(tag))
}
for _, el := range elements {
hasDefault = hasDefault || (el.Default != "")
tag := fmt.Sprintf(`xml:"%s %s"`, el.Name.Space, el.Name.Local)
base, err := cfg.expr(el.Type)
if err != nil {
return nil, fmt.Errorf("%s element %s: %v", t.Name.Local, el.Name.Local, err)
}
name := ast.NewIdent(cfg.public(el.Name))
if el.Wildcard {
tag = `xml:",any"`
if el.Plural {
name = ast.NewIdent("Items")
} else {
name = ast.NewIdent("Item")
}
if b, ok := el.Type.(xsd.Builtin); ok && b == xsd.AnyType {
cfg.debugf("complexType %s: defaulting wildcard element to []string", t.Name.Local)
base = builtinExpr(xsd.String)
}
}
if el.Plural {
base = &ast.ArrayType{Elt: base}
}
fields = append(fields, name, base, gen.String(tag))
}
expr := gen.Struct(fields...)
s := spec{
name: cfg.typeName(t.Name),
expr: expr,
xsdType: t,
}
if hasDefault {
unmarshal, marshal, err := cfg.genMarshalComplexType(t)
if err != nil {
//NOTE(droyo) may want to log this instead of stopping the generator
return result, err
} else {
if unmarshal != nil {
s.methods = append(s.methods, unmarshal)
}
if marshal != nil {
s.methods = append(s.methods, marshal)
}
}
}
result = append(result, s)
return result, nil
}
// To reduce the size of the Go source generated, all intermediate types
// are "squashed"; every type should be based on a Builtin or another
// type that the user wants included in the Go source.
func (cfg *Config) flatten1(t xsd.Type, push func(xsd.Type)) xsd.Type {
switch t := t.(type) {
case *xsd.SimpleType:
var (
chain []xsd.Type
base, builtin xsd.Type
ok bool
)
// TODO: handle list/union types
for base = xsd.Base(t); base != nil; base = xsd.Base(base) {
if builtin, ok = base.(xsd.Builtin); ok {
break
}
chain = append(chain, base)
}
for _, v := range chain {
if v, ok := v.(*xsd.SimpleType); ok {
v.Base = builtin
push(v)
}
}
t.Base = builtin
return t
case *xsd.ComplexType:
// We can "unpack" a struct if it is extending a simple
// or built-in type and we are ignoring all of its attributes.
switch t.Base.(type) {
case xsd.Builtin, *xsd.SimpleType:
if b, ok := t.Base.(xsd.Builtin); ok && b == xsd.AnyType {
break
}
attributes, _ := cfg.filterFields(t)
if len(attributes) == 0 {
cfg.debugf("complexType %s extends simpleType %s, but all attributes are filtered. unpacking.",
t.Name.Local, xsd.XMLName(t.Base))
switch b := t.Base.(type) {
case xsd.Builtin:
return b
case *xsd.SimpleType:
return cfg.flatten1(t.Base, push)
}
}
}
// We can flatten a struct field if its type does not
// need additional methods for unmarshalling.
for i, el := range t.Elements {
el.Type = cfg.flatten1(el.Type, push)
if b, ok := el.Type.(*xsd.SimpleType); ok {
if !b.List && len(b.Union) == 0 {
el.Type = xsd.Base(el.Type)
}
}
t.Elements[i] = el
}
for i, attr := range t.Attributes {
attr.Type = cfg.flatten1(attr.Type, push)
if b, ok := attr.Type.(*xsd.SimpleType); ok {
if !b.List && len(b.Union) == 0 {
attr.Type = xsd.Base(attr.Type)
}
}
t.Attributes[i] = attr
}
return t
case xsd.Builtin:
// There are a few built-ins that do not map directly to Go types.
// for these, we will declare them in the Go source.
switch t {
case xsd.ENTITIES, xsd.IDREFS, xsd.NMTOKENS:
push(t)
case xsd.Base64Binary, xsd.HexBinary:
push(t)
case xsd.Date, xsd.Time, xsd.DateTime:
push(t)
case xsd.GDay, xsd.GMonth, xsd.GMonthDay, xsd.GYear, xsd.GYearMonth:
push(t)
}
return t
}
panic(fmt.Sprintf("unexpected %T", t))
}
func (cfg *Config) genAST(schema xsd.Schema, extra ...xsd.Schema) (*ast.File, error) {
var errList errorList
decls := make(map[string]spec)
cfg.addStandardHelpers()
collect := make(map[xml.Name]xsd.Type)
for k, v := range schema.Types {
collect[k] = v
}
for _, schema := range extra {
for k, v := range schema.Types {
collect[k] = v
}
}
prev := schema.Types
schema.Types = collect
if cfg.preprocessType != nil {
cfg.debugf("running user-defined pre-processing functions")
for name, t := range prev {
if t := cfg.preprocessType(schema, t); t != nil {
prev[name] = t
}
}
}
schema.Types = prev
cfg.debugf("generating Go source for schema %q", schema.TargetNS)
typeList := cfg.flatten(schema.Types)
for _, t := range typeList {
specs, err := cfg.genTypeSpec(t)
if err != nil {
errList = append(errList, fmt.Errorf("generate type %q: %v", xsd.XMLName(t).Local, err))
} else {
for _, s := range specs {
decls[s.name] = s
}
}
}
if cfg.postprocessType != nil {
cfg.debugf("running user-defined post-processing functions")
for name, s := range decls {
decls[name] = cfg.postprocessType(s)
}
}
if len(errList) > 0 {
return nil, errList
}
var result []ast.Decl
keys := make([]string, 0, len(decls))
for name := range decls {
keys = append(keys, name)
}
sort.Strings(keys)
for _, name := range keys {
info := decls[name]
typeDecl := &ast.GenDecl{
Tok: token.TYPE,
Specs: []ast.Spec{
&ast.TypeSpec{
Name: ast.NewIdent(name),
Type: info.expr,
},
},
}
result = append(result, typeDecl)
for _, f := range info.methods {
result = append(result, f)
}
}
if cfg.pkgname == "" {
cfg.pkgname = "ws"
}
file := &ast.File{
Decls: result,
Name: ast.NewIdent(cfg.pkgname),
Doc: nil,
}
return file, nil
}