// NameSystems returns the name system used by the generators in this package. func NameSystems() namer.NameSystems { return namer.NameSystems{ "public": conversionNamer(), "raw": namer.NewRawNamer("", nil), "defaultfn": defaultFnNamer(), } }
// NameSystems returns the name system used by the generators in this package. func NameSystems() namer.NameSystems { return namer.NameSystems{ "public": namer.NewPublicNamer(0), "private": namer.NewPrivateNamer(0), "raw": namer.NewRawNamer("", nil), } }
func (g *genConversion) Namers(c *generator.Context) namer.NameSystems { // Have the raw namer for this file track what it imports. return namer.NameSystems{ "raw": namer.NewRawNamer(g.targetPackage, g.imports), "publicIT": &namerPlusImportTracking{ delegate: conversionNamer(), tracker: g.imports, }, } }
func testOpenAPITypeWritter(t *testing.T, code string) (error, *assert.Assertions, *bytes.Buffer) { assert := assert.New(t) var testFiles = map[string]string{ "base/foo/bar.go": code, } rawNamer := namer.NewRawNamer("o", nil) namers := namer.NameSystems{ "raw": namer.NewRawNamer("", nil), } builder, universe, _ := construct(t, testFiles, rawNamer) context, err := generator.NewContext(builder, namers, "raw") if err != nil { t.Fatal(err) } buffer := &bytes.Buffer{} sw := generator.NewSnippetWriter(buffer, context, "$", "$") blahT := universe.Type(types.Name{Package: "base/foo", Name: "Blah"}) return newOpenAPITypeWriter(sw).generate(blahT), assert, buffer }
func (g *genDeepCopy) Namers(c *generator.Context) namer.NameSystems { // Have the raw namer for this file track what it imports. return namer.NameSystems{ "raw": namer.NewRawNamer(g.targetPackage, g.imports), "dcFnName": &dcFnNamer{ public: deepCopyNamer(), tracker: g.imports, myPackage: g.targetPackage, }, } }
// NameSystems returns the name system used by the generators in this package. func NameSystems() namer.NameSystems { pluralExceptions := map[string]string{ "Endpoints": "Endpoints", "ComponentStatus": "ComponentStatus", } return namer.NameSystems{ "public": namer.NewPublicNamer(0), "private": namer.NewPrivateNamer(0), "raw": namer.NewRawNamer("", nil), "publicPlural": namer.NewPublicPluralNamer(pluralExceptions), "privatePlural": namer.NewPrivatePluralNamer(pluralExceptions), } }
// NameSystems returns the name system used by the generators in this package. func NameSystems() namer.NameSystems { pluralExceptions := map[string]string{ "Endpoints": "Endpoints", "SecurityContextConstraints": "SecurityContextConstraints", } return namer.NameSystems{ "public": namer.NewPublicNamer(0), "private": namer.NewPrivateNamer(0), "raw": namer.NewRawNamer("", nil), "publicPlural": namer.NewPublicPluralNamer(pluralExceptions), "privatePlural": namer.NewPrivatePluralNamer(pluralExceptions), "allLowercasePlural": namer.NewAllLowercasePluralNamer(pluralExceptions), } }
func (g *genClientset) Namers(c *generator.Context) namer.NameSystems { return namer.NameSystems{ "raw": namer.NewRawNamer(g.outputPackage, g.imports), } }
// NameSystems returns the name system used by the generators in this package. func NameSystems() namer.NameSystems { return namer.NameSystems{ "raw": namer.NewRawNamer("", nil), } }
func (g *genConversion) Namers(c *generator.Context) namer.NameSystems { // Have the raw namer for this file track what it imports. return namer.NameSystems{"raw": namer.NewRawNamer(g.targetPackage, g.imports)} }
func TestBuilder(t *testing.T) { var testFiles = map[string]string{ "base/foo/proto/foo.go": ` package foo import ( "base/common/proto" ) type Blah struct { common.Object Count int64 Frobbers map[string]*Frobber Baz []Object Nickname *string NumberIsAFavorite map[int]bool } type Frobber struct { Name string Amount int64 } type Object struct { common.Object } func AFunc(obj1 common.Object, obj2 Object) Frobber { } `, "base/common/proto/common.go": ` package common type Object struct { ID int64 } `, } var tmplText = ` package o {{define "Struct"}}type {{Name .}} interface { {{range $m := .Members}}{{$n := Name $m.Type}} {{if $m.Embedded}}{{$n}}{{else}}{{$m.Name}}() {{$n}}{{if $m.Type.Elem}}{{else}} Set{{$m.Name}}({{$n}}){{end}}{{end}}{{end}} } {{end}} {{define "Func"}}{{$s := .Signature}}func {{Raw .}}( {{range $s.Parameters}}{{Raw .}} {{end}}) {{range $s.Results}}{{Raw .}} {{end}}{} {{end}} {{range $t := .}}{{if eq $t.Kind "Struct"}}{{template "Struct" $t}}{{end}}{{end}} {{range $t := .}}{{if eq $t.Kind "Func"}}{{template "Func" $t}}{{end}}{{end}}` var expect = ` package o type CommonObject interface { ID() Int64 SetID(Int64) } type FooBlah interface { CommonObject Count() Int64 SetCount(Int64) Frobbers() MapStringToPointerFooFrobber Baz() SliceFooObject Nickname() PointerString NumberIsAFavorite() MapIntToBool } type FooFrobber interface { Name() String SetName(String) Amount() Int64 SetAmount(Int64) } type FooObject interface { CommonObject } func proto.AFunc( proto.Object proto.Object ) proto.Frobber {} ` testNamer := namer.NewPublicNamer(1, "proto") rawNamer := namer.NewRawNamer("o", nil) _, u, o := construct(t, testFiles, testNamer) t.Logf("\n%v\n\n", o) tmpl := template.Must( template.New(""). Funcs( map[string]interface{}{ "Name": testNamer.Name, "Raw": rawNamer.Name, }). Parse(tmplText), ) buf := &bytes.Buffer{} tmpl.Execute(buf, o) if e, a := expect, buf.String(); e != a { t.Errorf("Wanted, got:\n%v\n-----\n%v\n", e, a) } if p := u.Package("base/foo/proto"); !p.HasImport("base/common/proto") { t.Errorf("Unexpected lack of import line: %#s", p.Imports) } }
func TestTypeKindParse(t *testing.T) { var testFiles = map[string]string{ "a/foo.go": "package a\ntype Test string\n", "b/foo.go": "package b\ntype Test map[int]string\n", "c/foo.go": "package c\ntype Test []string\n", "d/foo.go": "package d\ntype Test struct{a int; b struct{a int}; c map[int]string; d *string}\n", "e/foo.go": "package e\ntype Test *string\n", "f/foo.go": ` package f import ( "a" "b" ) type Test []a.Test type Test2 *a.Test type Test3 map[a.Test]b.Test type Test4 struct { a struct {a a.Test; b b.Test} b map[a.Test]b.Test c *a.Test d []a.Test e []string } `, "g/foo.go": ` package g type Test func(a, b string) (c, d string) func (t Test) Method(a, b string) (c, d string) { return t(a, b) } type Interface interface{Method(a, b string) (c, d string)} `, } // Check that the right types are found, and the namers give the expected names. assertions := []struct { Package, Name string k types.Kind names []string }{ { Package: "a", Name: "Test", k: types.Alias, names: []string{"Test", "ATest", "test", "aTest", "a.Test"}, }, { Package: "b", Name: "Test", k: types.Map, names: []string{"Test", "BTest", "test", "bTest", "b.Test"}, }, { Package: "c", Name: "Test", k: types.Slice, names: []string{"Test", "CTest", "test", "cTest", "c.Test"}, }, { Package: "d", Name: "Test", k: types.Struct, names: []string{"Test", "DTest", "test", "dTest", "d.Test"}, }, { Package: "e", Name: "Test", k: types.Pointer, names: []string{"Test", "ETest", "test", "eTest", "e.Test"}, }, { Package: "f", Name: "Test", k: types.Slice, names: []string{"Test", "FTest", "test", "fTest", "f.Test"}, }, { Package: "g", Name: "Test", k: types.Func, names: []string{"Test", "GTest", "test", "gTest", "g.Test"}, }, { Package: "g", Name: "Interface", k: types.Interface, names: []string{"Interface", "GInterface", "interface", "gInterface", "g.Interface"}, }, { Package: "", Name: "string", k: types.Builtin, names: []string{"String", "String", "string", "string", "string"}, }, { Package: "", Name: "int", k: types.Builtin, names: []string{"Int", "Int", "int", "int", "int"}, }, { Package: "", Name: "struct{a int}", k: types.Struct, names: []string{"StructInt", "StructInt", "structInt", "structInt", "struct{a int}"}, }, { Package: "", Name: "struct{a a.Test; b b.Test}", k: types.Struct, names: []string{"StructTestTest", "StructATestBTest", "structTestTest", "structATestBTest", "struct{a a.Test; b b.Test}"}, }, { Package: "", Name: "map[int]string", k: types.Map, names: []string{"MapIntToString", "MapIntToString", "mapIntToString", "mapIntToString", "map[int]string"}, }, { Package: "", Name: "map[a.Test]b.Test", k: types.Map, names: []string{"MapTestToTest", "MapATestToBTest", "mapTestToTest", "mapATestToBTest", "map[a.Test]b.Test"}, }, { Package: "", Name: "[]string", k: types.Slice, names: []string{"SliceString", "SliceString", "sliceString", "sliceString", "[]string"}, }, { Package: "", Name: "[]a.Test", k: types.Slice, names: []string{"SliceTest", "SliceATest", "sliceTest", "sliceATest", "[]a.Test"}, }, { Package: "", Name: "*string", k: types.Pointer, names: []string{"PointerString", "PointerString", "pointerString", "pointerString", "*string"}, }, { Package: "", Name: "*a.Test", k: types.Pointer, names: []string{"PointerTest", "PointerATest", "pointerTest", "pointerATest", "*a.Test"}, }, } namers := []namer.Namer{ namer.NewPublicNamer(0), namer.NewPublicNamer(1), namer.NewPrivateNamer(0), namer.NewPrivateNamer(1), namer.NewRawNamer("", nil), } for nameIndex, namer := range namers { _, u, _ := construct(t, testFiles, namer) t.Logf("Found types:\n") for pkgName, pkg := range u { for typeName, cur := range pkg.Types { t.Logf("%q-%q: %s %s", pkgName, typeName, cur.Name, cur.Kind) } } t.Logf("\n\n") for _, item := range assertions { n := types.Name{Package: item.Package, Name: item.Name} thisType := u.Get(n) if thisType == nil { t.Errorf("type %s not found", n) continue } if e, a := item.k, thisType.Kind; e != a { t.Errorf("%v-%s: type kind wrong, wanted %v, got %v (%#v)", nameIndex, n, e, a, thisType) } if e, a := item.names[nameIndex], namer.Name(thisType); e != a { t.Errorf("%v-%s: Expected %q, got %q", nameIndex, n, e, a) } } // Also do some one-off checks gtest := u.Get(types.Name{Package: "g", Name: "Test"}) if e, a := 1, len(gtest.Methods); e != a { t.Errorf("expected %v but found %v methods: %#v", e, a, gtest) } iface := u.Get(types.Name{Package: "g", Name: "Interface"}) if e, a := 1, len(iface.Methods); e != a { t.Errorf("expected %v but found %v methods: %#v", e, a, iface) } } }
// NameSystems returns the name system used by the generators in this package. func NameSystems() namer.NameSystems { return namer.NameSystems{ "public": deepCopyNamer(), "raw": namer.NewRawNamer("", nil), } }
func (g *genFakeForGroup) Namers(c *generator.Context) namer.NameSystems { return namer.NameSystems{ "raw": namer.NewRawNamer(g.outputPackage, g.imports), } }
func (g *genSet) Namers(c *generator.Context) namer.NameSystems { return namer.NameSystems{ "raw": namer.NewRawNamer(g.imports), } }
func (g *openAPIGen) Namers(c *generator.Context) namer.NameSystems { // Have the raw namer for this file track what it imports. return namer.NameSystems{ "raw": namer.NewRawNamer(g.targetType.Name.Package, g.imports), } }