1package pgs 2 3import ( 4 "fmt" 5 "testing" 6 7 "strings" 8 9 "github.com/stretchr/testify/assert" 10) 11 12func TestName_Split(t *testing.T) { 13 t.Parallel() 14 15 tests := []struct { 16 in string 17 parts []string 18 }{ 19 // camel case 20 {"fooBar", []string{"foo", "Bar"}}, 21 {"FooBar", []string{"Foo", "Bar"}}, 22 {"myJSON", []string{"my", "JSON"}}, 23 {"JSONStringFooBar", []string{"JSON", "String", "Foo", "Bar"}}, 24 {"myJSONString", []string{"my", "JSON", "String"}}, 25 26 // snake case 27 {"FOO_BAR", []string{"FOO", "BAR"}}, 28 {"foo_bar_baz", []string{"foo", "bar", "baz"}}, 29 {"Foo_Bar", []string{"Foo", "Bar"}}, 30 {"JSONString_Foo_Bar", []string{"JSONString", "Foo", "Bar"}}, 31 32 // dot notation 33 {"foo.bar", []string{"foo", "bar"}}, 34 {".foo.bar", []string{"", "foo", "bar"}}, 35 {".JSONString.Foo.Bar", []string{"", "JSONString", "Foo", "Bar"}}, 36 37 // leading underscore 38 {"_Privatish", []string{"_Privatish"}}, 39 {"_privatish", []string{"_privatish"}}, 40 {"_foo_bar", []string{"_foo", "bar"}}, 41 {"_Foo_Bar", []string{"_Foo", "Bar"}}, 42 {"_JSON_String", []string{"_JSON", "String"}}, 43 {"_JString", []string{"_J", "String"}}, 44 {"__Double", []string{"_", "Double"}}, 45 46 // numbers 47 {"abc123", []string{"abc", "123"}}, 48 {"123def", []string{"123", "def"}}, 49 {"abc1def", []string{"abc", "1", "def"}}, 50 {"ABC1DEF", []string{"ABC", "1", "DEF"}}, 51 52 // empty 53 {"", []string{""}}, 54 } 55 56 for _, test := range tests { 57 tc := test 58 t.Run(tc.in, func(t *testing.T) { 59 t.Parallel() 60 assert.Equal(t, tc.parts, Name(tc.in).Split()) 61 }) 62 } 63} 64 65func TestName(t *testing.T) { 66 t.Parallel() 67 68 tests := []struct { 69 in []string 70 ucc string 71 lcc string 72 ssc string 73 lsc string 74 usc string 75 ldn string 76 udn string 77 }{ 78 { 79 in: []string{"fooBar", "FooBar", "foo_bar", "Foo_Bar", "foo_Bar", "foo.Bar", "Foo.Bar"}, 80 ucc: "FooBar", 81 lcc: "fooBar", 82 ssc: "FOO_BAR", 83 lsc: "foo_bar", 84 usc: "Foo_Bar", 85 ldn: "foo.bar", 86 udn: "Foo.Bar", 87 }, 88 { 89 in: []string{"JSONString", "JSON_String", "JSON_string", "JSON.string"}, 90 ucc: "JSONString", 91 lcc: "jsonString", 92 ssc: "JSON_STRING", 93 lsc: "json_string", 94 usc: "JSON_String", 95 ldn: "json.string", 96 udn: "JSON.String", 97 }, 98 { 99 in: []string{"myJSON", "my_JSON", "My_JSON", "my.JSON"}, 100 ucc: "MyJSON", 101 lcc: "myJSON", 102 ssc: "MY_JSON", 103 lsc: "my_json", 104 usc: "My_JSON", 105 ldn: "my.json", 106 udn: "My.JSON", 107 }, 108 } 109 110 for _, test := range tests { 111 tc := test 112 for _, in := range tc.in { 113 n := Name(in) 114 t.Run(string(n), func(t *testing.T) { 115 t.Parallel() 116 117 t.Run("UpperCamelCase", func(t *testing.T) { 118 t.Parallel() 119 assert.Equal(t, tc.ucc, n.UpperCamelCase().String()) 120 }) 121 122 t.Run("lowerCamelCase", func(t *testing.T) { 123 t.Parallel() 124 assert.Equal(t, tc.lcc, n.LowerCamelCase().String()) 125 }) 126 127 t.Run("SCREAMING_SNAKE_CASE", func(t *testing.T) { 128 t.Parallel() 129 assert.Equal(t, tc.ssc, n.ScreamingSnakeCase().String()) 130 }) 131 132 t.Run("lower_snake_case", func(t *testing.T) { 133 t.Parallel() 134 assert.Equal(t, tc.lsc, n.LowerSnakeCase().String()) 135 }) 136 137 t.Run("Upper_Snake_Case", func(t *testing.T) { 138 t.Parallel() 139 assert.Equal(t, tc.usc, n.UpperSnakeCase().String()) 140 }) 141 142 t.Run("lower.dot.notation", func(t *testing.T) { 143 t.Parallel() 144 assert.Equal(t, tc.ldn, n.LowerDotNotation().String()) 145 }) 146 147 t.Run("Upper.Dot.Notation", func(t *testing.T) { 148 t.Parallel() 149 assert.Equal(t, tc.udn, n.UpperDotNotation().String()) 150 }) 151 }) 152 } 153 } 154} 155 156func TestNameTransformer_Chain(t *testing.T) { 157 t.Parallel() 158 159 nt := NameTransformer(strings.ToUpper) 160 nt = nt.Chain(func(s string) string { return "_" + s }) 161 162 assert.Equal(t, "_FOO", nt("foo")) 163} 164 165func TestFilePath(t *testing.T) { 166 t.Parallel() 167 168 fp := FilePath("alpha/beta/gamma.proto") 169 assert.Equal(t, "alpha/beta/gamma.proto", fp.String()) 170 assert.Equal(t, "alpha/beta", fp.Dir().String()) 171 assert.Equal(t, "gamma.proto", fp.Base()) 172 assert.Equal(t, ".proto", fp.Ext()) 173 assert.Equal(t, "gamma", fp.BaseName()) 174 assert.Equal(t, "alpha/beta/gamma.foo", fp.SetExt(".foo").String()) 175 assert.Equal(t, "alpha/beta/delta.bar", fp.SetBase("delta.bar").String()) 176 assert.Equal(t, "alpha/beta", fp.Pop().String()) 177 assert.Equal(t, "alpha/beta/delta", fp.Dir().Push("delta").String()) 178} 179 180func ExampleName_UpperCamelCase() { 181 names := []string{ 182 "foo_bar", 183 "myJSON", 184 "PDFTemplate", 185 } 186 187 for _, n := range names { 188 fmt.Println(Name(n).UpperCamelCase()) 189 } 190 191 // Output: 192 // FooBar 193 // MyJSON 194 // PDFTemplate 195} 196 197func ExampleName_LowerCamelCase() { 198 names := []string{ 199 "foo_bar", 200 "myJSON", 201 "PDFTemplate", 202 } 203 204 for _, n := range names { 205 fmt.Println(Name(n).LowerCamelCase()) 206 } 207 208 // Output: 209 // fooBar 210 // myJSON 211 // pdfTemplate 212} 213 214func ExampleName_ScreamingSnakeCase() { 215 names := []string{ 216 "foo_bar", 217 "myJSON", 218 "PDFTemplate", 219 } 220 221 for _, n := range names { 222 fmt.Println(Name(n).ScreamingSnakeCase()) 223 } 224 225 // Output: 226 // FOO_BAR 227 // MY_JSON 228 // PDF_TEMPLATE 229} 230 231func ExampleName_LowerSnakeCase() { 232 names := []string{ 233 "foo_bar", 234 "myJSON", 235 "PDFTemplate", 236 } 237 238 for _, n := range names { 239 fmt.Println(Name(n).LowerSnakeCase()) 240 } 241 242 // Output: 243 // foo_bar 244 // my_json 245 // pdf_template 246} 247 248func ExampleName_UpperSnakeCase() { 249 names := []string{ 250 "foo_bar", 251 "myJSON", 252 "PDFTemplate", 253 } 254 255 for _, n := range names { 256 fmt.Println(Name(n).UpperSnakeCase()) 257 } 258 259 // Output: 260 // Foo_Bar 261 // My_JSON 262 // PDF_Template 263} 264 265func ExampleName_SnakeCase() { 266 names := []string{ 267 "foo_bar", 268 "myJSON", 269 "PDFTemplate", 270 } 271 272 for _, n := range names { 273 fmt.Println(Name(n).SnakeCase()) 274 } 275 276 // Output: 277 // foo_bar 278 // my_JSON 279 // PDF_Template 280} 281 282func ExampleName_LowerDotNotation() { 283 names := []string{ 284 "foo_bar", 285 "myJSON", 286 "PDFTemplate", 287 } 288 289 for _, n := range names { 290 fmt.Println(Name(n).LowerDotNotation()) 291 } 292 293 // Output: 294 // foo.bar 295 // my.json 296 // pdf.template 297} 298 299func ExampleName_UpperDotNotation() { 300 names := []string{ 301 "foo_bar", 302 "myJSON", 303 "PDFTemplate", 304 } 305 306 for _, n := range names { 307 fmt.Println(Name(n).UpperDotNotation()) 308 } 309 310 // Output: 311 // Foo.Bar 312 // My.JSON 313 // PDF.Template 314} 315