Generates struct types with public fields.

Author: c4milo

cli.go

@@ -84,15 +84,11 @@ func main() {
 
 	source, err := format.Source(data.Bytes())
 	if err != nil {
+		fd.Write(data.Bytes())
 		log.Fatalln(err)
 	}
 
 	fd.Write(source)
 
-	// fd.Write(gocode["types"])
-	// fd.Write(gocode["messages"])
-	// fd.Write(gocode["operations"])
-	// fd.Write(gocode["proxy"])
-
 	log.Println("Done 💩")
 }

gowsdl.go

@@ -8,13 +8,16 @@ import (
 	"fmt"
 	"io/ioutil"
 	"log"
+	"net"
 	"net/http"
 	"net/url"
 	"os"
 	"path/filepath"
 	"strings"
 	"sync"
 	"text/template"
+	"time"
+	"unicode"
 )
 
 const maxRecursion uint8 = 5
@@ -35,11 +38,18 @@ func init() {
 	}
 }
 
+var timeout = time.Duration(30 * time.Second)
+
+func dialTimeout(network, addr string) (net.Conn, error) {
+	return net.DialTimeout(network, addr, timeout)
+}
+
 func downloadFile(url string) ([]byte, error) {
 	tr := &http.Transport{
 		TLSClientConfig: &tls.Config{
 			InsecureSkipVerify: true,
 		},
+		Dial: dialTimeout,
 	}
 	client := &http.Client{Transport: tr}
 
@@ -220,42 +230,20 @@ func (g *GoWsdl) resolveXsdExternals(schema *XsdSchema, url *url.URL) error {
 }
 
 func (g *GoWsdl) genTypes() ([]byte, error) {
-	//totalAdts := 0
-	// for _, schema := range g.wsdl.Types.Schemas {
-	// 	for _, el := range schema.Elements {
-	// 		if el.Type == "" {
-	// 			// log.Printf("Complex %s -> %#v\n\n", strings.TrimSuffix(el.ComplexType.Name, "Type"), el.ComplexType.Sequence)
-	// 			totalAdts++
-	// 		} else if el.SimpleType != nil {
-	// 			log.Printf("Simple %s -> %#v\n\n", el.SimpleType.Name, el.SimpleType.Retriction)
-	// 		}
-	// 	}
-
-	// 	for _ /*complexType*/, _ = range schema.ComplexTypes {
-	// 		// log.Printf("Complex %s -> %#v\n\n", strings.TrimSuffix(complexType.Name, "Type"), complexType.Sequence)
-	// 		totalAdts++
-	// 	}
-
-	// 	for _, simpleType := range schema.SimpleType {
-	// 		log.Printf("Simple %s -> %#v\n\n", simpleType.Name, simpleType.Retriction)
-	// 	}
-	// }
-
 	funcMap := template.FuncMap{
-		"toGoType": toGoType,
-		//"TagDelimiter":   TagDelimiter,
+		"toGoType":             toGoType,
+		"stripns":              stripns,
+		"replaceReservedWords": replaceReservedWords,
+		"makeFieldPublic":      makeFieldPublic,
 	}
 
 	data := new(bytes.Buffer)
 	tmpl := template.Must(template.New("types").Funcs(funcMap).Parse(typesTmpl))
 	err := tmpl.Execute(data, g.wsdl.Types)
 	if err != nil {
-		log.Fatalln(err)
+		return nil, err
 	}
 
-	//log.Printf("Abstract data types: %d\n", totalAdts)
-	//log.Printf("Total schemas: %#d\n\n", len(g.wsdl.Types.Schemas))
-
 	return data.Bytes(), nil
 }
 
@@ -270,25 +258,92 @@ func (g *GoWsdl) genOperations() ([]byte, error) {
 	return nil, nil
 }
 
+var reservedWords = map[string]string{
+	"break":       "break_",
+	"default":     "default_",
+	"func":        "func_",
+	"interface":   "interface_",
+	"select":      "select_",
+	"case":        "case_",
+	"defer":       "defer_",
+	"go":          "go_",
+	"map":         "map_",
+	"struct":      "struct_",
+	"chan":        "chan_",
+	"else":        "else_",
+	"goto":        "goto_",
+	"package":     "package_",
+	"switch":      "switch_",
+	"const":       "const_",
+	"fallthrough": "fallthrough_",
+	"if":          "if_",
+	"range":       "range_",
+	"type":        "type_",
+	"continue":    "continue_",
+	"for":         "for_",
+	"import":      "import_",
+	"return":      "return_",
+	"var":         "var_",
+}
+
+func replaceReservedWords(identifier string) string {
+	value := reservedWords[identifier]
+	if value != "" {
+		return value
+	}
+	return identifier
+}
+
 var xsd2GoTypes = map[string]string{
-	"string":  "string",
-	"decimal": "float",
-	"integer": "",
-	"boolean": "bool",
-	"date":    "",
-	"time":    "",
+	"string":   "string",
+	"decimal":  "float64",
+	"integer":  "int64",
+	"int":      "int32",
+	"short":    "int16",
+	"byte":     "int8",
+	"long":     "int64",
+	"boolean":  "bool",
+	"dateTime": "time.Time",
+	"date":     "time.Time",
+	"time":     "time.Time",
+	"anyType":  "interface{}",
 }
 
 func toGoType(xsdType string) string {
 	//Handles name space, ie. xsd:string, xs:string
 	r := strings.Split(xsdType, ":")
+
+	type_ := r[0]
+
+	if len(r) == 2 {
+		type_ = r[1]
+	}
+
+	value := xsd2GoTypes[type_]
+
+	if value != "" {
+		return value
+	}
+
+	return "*" + type_
+}
+
+//TODO: Add namespace support instead of stripping it
+func stripns(xsdType string) string {
+	r := strings.Split(xsdType, ":")
 	type_ := r[0]
 
 	if len(r) == 2 {
 		type_ = r[1]
 	}
 
-	return xsd2GoTypes[type_]
+	return type_
+}
+
+func makeFieldPublic(field_ string) string {
+	field := []rune(field_)
+	field[0] = unicode.ToUpper(field[0])
+	return string(field)
 }
 
 func (g *GoWsdl) genMessages() ([]byte, error) {

types_tmpl.go

@@ -1,24 +1,59 @@
 package main
 
 var typesTmpl = `
+{{define "SimpleType"}}
+	{{$name := .Name}}
+	type {{.Name}} {{toGoType .Restriction.Base}}
+	const (
+		{{with .Restriction}}
+			{{range .Enumeration}}
+				{{replaceReservedWords .Value | makeFieldPublic}} {{$name}} = "{{.Value}}" {{end}}
+		{{end}}
+	)
+{{end}}
+
+{{define "ComplexType"}}
+	{{$name := replaceReservedWords .Name}}
+
+	type {{.Name}} struct {
+		{{if ne .ComplexContent.Extension.Base ""}}
+			{{$baseType := .ComplexContent.Extension.Base}}
+			{{ if $baseType }}
+				*{{stripns $baseType}}
+			{{end}}
+
+			{{template "Elements" .ComplexContent.Extension.Sequence.Elements}}
+		{{ else }}
+			{{template "Elements" .Sequence.Elements}}
+		{{end}}
+	}
+{{end}}
+
+{{define "Elements"}}
+	{{range .}}
+		{{replaceReservedWords .Name | makeFieldPublic}} {{if eq .MaxOccurs "unbounded"}}[]{{end}}{{.Type | toGoType}}{{end}}
+{{end}}
+
 package main
 import (
 	"encoding/xml"
-	"github.com/c4milo/gowsdl"
+	//"time"
+	{{/*range .Imports*/}}
+		{{/*.*/}}
+	{{/*end*/}}
 )
+
 {{range .Schemas}}
 	{{range .SimpleType}}
-		{{$name := .Name}}
-		type {{.Name}} {{toGoType .Restriction.Base}}
-		const (
-			{{with .Restriction}}
-				{{range .Enumeration}}
-				{{.Value}} {{$name}} = "{{.Value}}" {{end}}
-			{{end}}
-		)
+		{{template "SimpleType" .}}
 	{{end}}
 	{{range .Elements}}
+		{{if not .Type}}
+
+		{{end}}
 	{{end}}
 	{{range .ComplexTypes}}
+		{{template "ComplexType" .}}
 	{{end}}
-{{end}}`
+{{end}}
+`

xsd.go

@@ -45,7 +45,7 @@ type XsdComplexType struct {
 	Abstract       bool              `xml:"abstract,attr"`
 	Name           string            `xml:"name,attr"`
 	Mixed          bool              `xml:"mixed,attr"`
-	Sequence       []XsdElement      `xml:"sequence>element"`
+	Sequence       XsdSequence       `xml:"http://www.w3.org/2001/XMLSchema sequence"`
 	Choice         []XsdElement      `xml:"choice>element"`
 	All            []XsdElement      `xml:"all>element"`
 	ComplexContent XsdComplexContent `xml:"http://www.w3.org/2001/XMLSchema complexContent"`
@@ -55,7 +55,7 @@ type XsdComplexType struct {
 type XsdGroup struct {
 	Name     string       `xml:"name, attr"`
 	Ref      string       `xml:"ref,attr"`
-	Sequence []XsdElement `xml:"http://www.w3.org/2001/XMLSchema sequence"`
+	Sequence XsdSequence  `xml:"http://www.w3.org/2001/XMLSchema sequence"`
 	Choice   []XsdElement `xml:"http://www.w3.org/2001/XMLSchema choice"`
 	All      []XsdElement `xml:"http://www.w3.org/2001/XMLSchema all"`
 }
@@ -73,7 +73,7 @@ type XsdSimpleContent struct {
 type XsdExtension struct {
 	XMLName  xml.Name    `xml:"http://www.w3.org/2001/XMLSchema extension"`
 	Base     string      `xml:"base,attr"`
-	Sequence XsdSequence `xml:"http://www.w3.org/2001/XMLSchema extension sequence"`
+	Sequence XsdSequence `xml:"http://www.w3.org/2001/XMLSchema sequence"`
 }
 
 type XsdSimpleType struct {