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