podman

1
package ut
2

3
import (
4
	"fmt"
5
	"strconv"
6
	"strings"
7

8
	"github.com/go-playground/locales"
9
)
10

11
const (
12
	paramZero          = "{0}"
13
	paramOne           = "{1}"
14
	unknownTranslation = ""
15
)
16

17
// Translator is universal translators
18
// translator instance which is a thin wrapper
19
// around locales.Translator instance providing
20
// some extra functionality
21
type Translator interface {
22
	locales.Translator
23

24
	// adds a normal translation for a particular language/locale
25
	// {#} is the only replacement type accepted and are ad infinitum
26
	// eg. one: '{0} day left' other: '{0} days left'
27
	Add(key interface{}, text string, override bool) error
28

29
	// adds a cardinal plural translation for a particular language/locale
30
	// {0} is the only replacement type accepted and only one variable is accepted as
31
	// multiple cannot be used for a plural rule determination, unless it is a range;
32
	// see AddRange below.
33
	// eg. in locale 'en' one: '{0} day left' other: '{0} days left'
34
	AddCardinal(key interface{}, text string, rule locales.PluralRule, override bool) error
35

36
	// adds an ordinal plural translation for a particular language/locale
37
	// {0} is the only replacement type accepted and only one variable is accepted as
38
	// multiple cannot be used for a plural rule determination, unless it is a range;
39
	// see AddRange below.
40
	// eg. in locale 'en' one: '{0}st day of spring' other: '{0}nd day of spring'
41
	// - 1st, 2nd, 3rd...
42
	AddOrdinal(key interface{}, text string, rule locales.PluralRule, override bool) error
43

44
	// adds a range plural translation for a particular language/locale
45
	// {0} and {1} are the only replacement types accepted and only these are accepted.
46
	// eg. in locale 'nl' one: '{0}-{1} day left' other: '{0}-{1} days left'
47
	AddRange(key interface{}, text string, rule locales.PluralRule, override bool) error
48

49
	// creates the translation for the locale given the 'key' and params passed in
50
	T(key interface{}, params ...string) (string, error)
51

52
	// creates the cardinal translation for the locale given the 'key', 'num' and 'digit' arguments
53
	//  and param passed in
54
	C(key interface{}, num float64, digits uint64, param string) (string, error)
55

56
	// creates the ordinal translation for the locale given the 'key', 'num' and 'digit' arguments
57
	// and param passed in
58
	O(key interface{}, num float64, digits uint64, param string) (string, error)
59

60
	//  creates the range translation for the locale given the 'key', 'num1', 'digit1', 'num2' and
61
	//  'digit2' arguments and 'param1' and 'param2' passed in
62
	R(key interface{}, num1 float64, digits1 uint64, num2 float64, digits2 uint64, param1, param2 string) (string, error)
63

64
	// VerifyTranslations checks to ensures that no plural rules have been
65
	// missed within the translations.
66
	VerifyTranslations() error
67
}
68

69
var _ Translator = new(translator)
70
var _ locales.Translator = new(translator)
71

72
type translator struct {
73
	locales.Translator
74
	translations        map[interface{}]*transText
75
	cardinalTanslations map[interface{}][]*transText // array index is mapped to locales.PluralRule index + the locales.PluralRuleUnknown
76
	ordinalTanslations  map[interface{}][]*transText
77
	rangeTanslations    map[interface{}][]*transText
78
}
79

80
type transText struct {
81
	text    string
82
	indexes []int
83
}
84

85
func newTranslator(trans locales.Translator) Translator {
86
	return &translator{
87
		Translator:          trans,
88
		translations:        make(map[interface{}]*transText), // translation text broken up by byte index
89
		cardinalTanslations: make(map[interface{}][]*transText),
90
		ordinalTanslations:  make(map[interface{}][]*transText),
91
		rangeTanslations:    make(map[interface{}][]*transText),
92
	}
93
}
94

95
// Add adds a normal translation for a particular language/locale
96
// {#} is the only replacement type accepted and are ad infinitum
97
// eg. one: '{0} day left' other: '{0} days left'
98
func (t *translator) Add(key interface{}, text string, override bool) error {
99

100
	if _, ok := t.translations[key]; ok && !override {
101
		return &ErrConflictingTranslation{locale: t.Locale(), key: key, text: text}
102
	}
103

104
	lb := strings.Count(text, "{")
105
	rb := strings.Count(text, "}")
106

107
	if lb != rb {
108
		return &ErrMissingBracket{locale: t.Locale(), key: key, text: text}
109
	}
110

111
	trans := &transText{
112
		text: text,
113
	}
114

115
	var idx int
116

117
	for i := 0; i < lb; i++ {
118
		s := "{" + strconv.Itoa(i) + "}"
119
		idx = strings.Index(text, s)
120
		if idx == -1 {
121
			return &ErrBadParamSyntax{locale: t.Locale(), param: s, key: key, text: text}
122
		}
123

124
		trans.indexes = append(trans.indexes, idx)
125
		trans.indexes = append(trans.indexes, idx+len(s))
126
	}
127

128
	t.translations[key] = trans
129

130
	return nil
131
}
132

133
// AddCardinal adds a cardinal plural translation for a particular language/locale
134
// {0} is the only replacement type accepted and only one variable is accepted as
135
// multiple cannot be used for a plural rule determination, unless it is a range;
136
// see AddRange below.
137
// eg. in locale 'en' one: '{0} day left' other: '{0} days left'
138
func (t *translator) AddCardinal(key interface{}, text string, rule locales.PluralRule, override bool) error {
139

140
	var verified bool
141

142
	// verify plural rule exists for locale
143
	for _, pr := range t.PluralsCardinal() {
144
		if pr == rule {
145
			verified = true
146
			break
147
		}
148
	}
149

150
	if !verified {
151
		return &ErrCardinalTranslation{text: fmt.Sprintf("error: cardinal plural rule '%s' does not exist for locale '%s' key: '%v' text: '%s'", rule, t.Locale(), key, text)}
152
	}
153

154
	tarr, ok := t.cardinalTanslations[key]
155
	if ok {
156
		// verify not adding a conflicting record
157
		if len(tarr) > 0 && tarr[rule] != nil && !override {
158
			return &ErrConflictingTranslation{locale: t.Locale(), key: key, rule: rule, text: text}
159
		}
160

161
	} else {
162
		tarr = make([]*transText, 7)
163
		t.cardinalTanslations[key] = tarr
164
	}
165

166
	trans := &transText{
167
		text:    text,
168
		indexes: make([]int, 2),
169
	}
170

171
	tarr[rule] = trans
172

173
	idx := strings.Index(text, paramZero)
174
	if idx == -1 {
175
		tarr[rule] = nil
176
		return &ErrCardinalTranslation{text: fmt.Sprintf("error: parameter '%s' not found, may want to use 'Add' instead of 'AddCardinal'. locale: '%s' key: '%v' text: '%s'", paramZero, t.Locale(), key, text)}
177
	}
178

179
	trans.indexes[0] = idx
180
	trans.indexes[1] = idx + len(paramZero)
181

182
	return nil
183
}
184

185
// AddOrdinal adds an ordinal plural translation for a particular language/locale
186
// {0} is the only replacement type accepted and only one variable is accepted as
187
// multiple cannot be used for a plural rule determination, unless it is a range;
188
// see AddRange below.
189
// eg. in locale 'en' one: '{0}st day of spring' other: '{0}nd day of spring' - 1st, 2nd, 3rd...
190
func (t *translator) AddOrdinal(key interface{}, text string, rule locales.PluralRule, override bool) error {
191

192
	var verified bool
193

194
	// verify plural rule exists for locale
195
	for _, pr := range t.PluralsOrdinal() {
196
		if pr == rule {
197
			verified = true
198
			break
199
		}
200
	}
201

202
	if !verified {
203
		return &ErrOrdinalTranslation{text: fmt.Sprintf("error: ordinal plural rule '%s' does not exist for locale '%s' key: '%v' text: '%s'", rule, t.Locale(), key, text)}
204
	}
205

206
	tarr, ok := t.ordinalTanslations[key]
207
	if ok {
208
		// verify not adding a conflicting record
209
		if len(tarr) > 0 && tarr[rule] != nil && !override {
210
			return &ErrConflictingTranslation{locale: t.Locale(), key: key, rule: rule, text: text}
211
		}
212

213
	} else {
214
		tarr = make([]*transText, 7)
215
		t.ordinalTanslations[key] = tarr
216
	}
217

218
	trans := &transText{
219
		text:    text,
220
		indexes: make([]int, 2),
221
	}
222

223
	tarr[rule] = trans
224

225
	idx := strings.Index(text, paramZero)
226
	if idx == -1 {
227
		tarr[rule] = nil
228
		return &ErrOrdinalTranslation{text: fmt.Sprintf("error: parameter '%s' not found, may want to use 'Add' instead of 'AddOrdinal'. locale: '%s' key: '%v' text: '%s'", paramZero, t.Locale(), key, text)}
229
	}
230

231
	trans.indexes[0] = idx
232
	trans.indexes[1] = idx + len(paramZero)
233

234
	return nil
235
}
236

237
// AddRange adds a range plural translation for a particular language/locale
238
// {0} and {1} are the only replacement types accepted and only these are accepted.
239
// eg. in locale 'nl' one: '{0}-{1} day left' other: '{0}-{1} days left'
240
func (t *translator) AddRange(key interface{}, text string, rule locales.PluralRule, override bool) error {
241

242
	var verified bool
243

244
	// verify plural rule exists for locale
245
	for _, pr := range t.PluralsRange() {
246
		if pr == rule {
247
			verified = true
248
			break
249
		}
250
	}
251

252
	if !verified {
253
		return &ErrRangeTranslation{text: fmt.Sprintf("error: range plural rule '%s' does not exist for locale '%s' key: '%v' text: '%s'", rule, t.Locale(), key, text)}
254
	}
255

256
	tarr, ok := t.rangeTanslations[key]
257
	if ok {
258
		// verify not adding a conflicting record
259
		if len(tarr) > 0 && tarr[rule] != nil && !override {
260
			return &ErrConflictingTranslation{locale: t.Locale(), key: key, rule: rule, text: text}
261
		}
262

263
	} else {
264
		tarr = make([]*transText, 7)
265
		t.rangeTanslations[key] = tarr
266
	}
267

268
	trans := &transText{
269
		text:    text,
270
		indexes: make([]int, 4),
271
	}
272

273
	tarr[rule] = trans
274

275
	idx := strings.Index(text, paramZero)
276
	if idx == -1 {
277
		tarr[rule] = nil
278
		return &ErrRangeTranslation{text: fmt.Sprintf("error: parameter '%s' not found, are you sure you're adding a Range Translation? locale: '%s' key: '%v' text: '%s'", paramZero, t.Locale(), key, text)}
279
	}
280

281
	trans.indexes[0] = idx
282
	trans.indexes[1] = idx + len(paramZero)
283

284
	idx = strings.Index(text, paramOne)
285
	if idx == -1 {
286
		tarr[rule] = nil
287
		return &ErrRangeTranslation{text: fmt.Sprintf("error: parameter '%s' not found, a Range Translation requires two parameters. locale: '%s' key: '%v' text: '%s'", paramOne, t.Locale(), key, text)}
288
	}
289

290
	trans.indexes[2] = idx
291
	trans.indexes[3] = idx + len(paramOne)
292

293
	return nil
294
}
295

296
// T creates the translation for the locale given the 'key' and params passed in
297
func (t *translator) T(key interface{}, params ...string) (string, error) {
298

299
	trans, ok := t.translations[key]
300
	if !ok {
301
		return unknownTranslation, ErrUnknowTranslation
302
	}
303

304
	b := make([]byte, 0, 64)
305

306
	var start, end, count int
307

308
	for i := 0; i < len(trans.indexes); i++ {
309
		end = trans.indexes[i]
310
		b = append(b, trans.text[start:end]...)
311
		b = append(b, params[count]...)
312
		i++
313
		start = trans.indexes[i]
314
		count++
315
	}
316

317
	b = append(b, trans.text[start:]...)
318

319
	return string(b), nil
320
}
321

322
// C creates the cardinal translation for the locale given the 'key', 'num' and 'digit' arguments and param passed in
323
func (t *translator) C(key interface{}, num float64, digits uint64, param string) (string, error) {
324

325
	tarr, ok := t.cardinalTanslations[key]
326
	if !ok {
327
		return unknownTranslation, ErrUnknowTranslation
328
	}
329

330
	rule := t.CardinalPluralRule(num, digits)
331

332
	trans := tarr[rule]
333

334
	b := make([]byte, 0, 64)
335
	b = append(b, trans.text[:trans.indexes[0]]...)
336
	b = append(b, param...)
337
	b = append(b, trans.text[trans.indexes[1]:]...)
338

339
	return string(b), nil
340
}
341

342
// O creates the ordinal translation for the locale given the 'key', 'num' and 'digit' arguments and param passed in
343
func (t *translator) O(key interface{}, num float64, digits uint64, param string) (string, error) {
344

345
	tarr, ok := t.ordinalTanslations[key]
346
	if !ok {
347
		return unknownTranslation, ErrUnknowTranslation
348
	}
349

350
	rule := t.OrdinalPluralRule(num, digits)
351

352
	trans := tarr[rule]
353

354
	b := make([]byte, 0, 64)
355
	b = append(b, trans.text[:trans.indexes[0]]...)
356
	b = append(b, param...)
357
	b = append(b, trans.text[trans.indexes[1]:]...)
358

359
	return string(b), nil
360
}
361

362
// R creates the range translation for the locale given the 'key', 'num1', 'digit1', 'num2' and 'digit2' arguments
363
// and 'param1' and 'param2' passed in
364
func (t *translator) R(key interface{}, num1 float64, digits1 uint64, num2 float64, digits2 uint64, param1, param2 string) (string, error) {
365

366
	tarr, ok := t.rangeTanslations[key]
367
	if !ok {
368
		return unknownTranslation, ErrUnknowTranslation
369
	}
370

371
	rule := t.RangePluralRule(num1, digits1, num2, digits2)
372

373
	trans := tarr[rule]
374

375
	b := make([]byte, 0, 64)
376
	b = append(b, trans.text[:trans.indexes[0]]...)
377
	b = append(b, param1...)
378
	b = append(b, trans.text[trans.indexes[1]:trans.indexes[2]]...)
379
	b = append(b, param2...)
380
	b = append(b, trans.text[trans.indexes[3]:]...)
381

382
	return string(b), nil
383
}
384

385
// VerifyTranslations checks to ensures that no plural rules have been
386
// missed within the translations.
387
func (t *translator) VerifyTranslations() error {
388

389
	for k, v := range t.cardinalTanslations {
390

391
		for _, rule := range t.PluralsCardinal() {
392

393
			if v[rule] == nil {
394
				return &ErrMissingPluralTranslation{locale: t.Locale(), translationType: "plural", rule: rule, key: k}
395
			}
396
		}
397
	}
398

399
	for k, v := range t.ordinalTanslations {
400

401
		for _, rule := range t.PluralsOrdinal() {
402

403
			if v[rule] == nil {
404
				return &ErrMissingPluralTranslation{locale: t.Locale(), translationType: "ordinal", rule: rule, key: k}
405
			}
406
		}
407
	}
408

409
	for k, v := range t.rangeTanslations {
410

411
		for _, rule := range t.PluralsRange() {
412

413
			if v[rule] == nil {
414
				return &ErrMissingPluralTranslation{locale: t.Locale(), translationType: "range", rule: rule, key: k}
415
			}
416
		}
417
	}
418

419
	return nil
420
}
421