translator.go raw
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