podman

1
package ut
2

3
import (
4
	"encoding/json"
5
	"fmt"
6
	"os"
7
	"path/filepath"
8

9
	"io"
10

11
	"github.com/go-playground/locales"
12
)
13

14
type translation struct {
15
	Locale           string      `json:"locale"`
16
	Key              interface{} `json:"key"` // either string or integer
17
	Translation      string      `json:"trans"`
18
	PluralType       string      `json:"type,omitempty"`
19
	PluralRule       string      `json:"rule,omitempty"`
20
	OverrideExisting bool        `json:"override,omitempty"`
21
}
22

23
const (
24
	cardinalType = "Cardinal"
25
	ordinalType  = "Ordinal"
26
	rangeType    = "Range"
27
)
28

29
// ImportExportFormat is the format of the file import or export
30
type ImportExportFormat uint8
31

32
// supported Export Formats
33
const (
34
	FormatJSON ImportExportFormat = iota
35
)
36

37
// Export writes the translations out to a file on disk.
38
//
39
// NOTE: this currently only works with string or int translations keys.
40
func (t *UniversalTranslator) Export(format ImportExportFormat, dirname string) error {
41

42
	_, err := os.Stat(dirname)
43
	if err != nil {
44

45
		if !os.IsNotExist(err) {
46
			return err
47
		}
48

49
		if err = os.MkdirAll(dirname, 0744); err != nil {
50
			return err
51
		}
52
	}
53

54
	// build up translations
55
	var trans []translation
56
	var b []byte
57
	var ext string
58

59
	for _, locale := range t.translators {
60

61
		for k, v := range locale.(*translator).translations {
62
			trans = append(trans, translation{
63
				Locale:      locale.Locale(),
64
				Key:         k,
65
				Translation: v.text,
66
			})
67
		}
68

69
		for k, pluralTrans := range locale.(*translator).cardinalTanslations {
70

71
			for i, plural := range pluralTrans {
72

73
				// leave enough for all plural rules
74
				// but not all are set for all languages.
75
				if plural == nil {
76
					continue
77
				}
78

79
				trans = append(trans, translation{
80
					Locale:      locale.Locale(),
81
					Key:         k.(string),
82
					Translation: plural.text,
83
					PluralType:  cardinalType,
84
					PluralRule:  locales.PluralRule(i).String(),
85
				})
86
			}
87
		}
88

89
		for k, pluralTrans := range locale.(*translator).ordinalTanslations {
90

91
			for i, plural := range pluralTrans {
92

93
				// leave enough for all plural rules
94
				// but not all are set for all languages.
95
				if plural == nil {
96
					continue
97
				}
98

99
				trans = append(trans, translation{
100
					Locale:      locale.Locale(),
101
					Key:         k.(string),
102
					Translation: plural.text,
103
					PluralType:  ordinalType,
104
					PluralRule:  locales.PluralRule(i).String(),
105
				})
106
			}
107
		}
108

109
		for k, pluralTrans := range locale.(*translator).rangeTanslations {
110

111
			for i, plural := range pluralTrans {
112

113
				// leave enough for all plural rules
114
				// but not all are set for all languages.
115
				if plural == nil {
116
					continue
117
				}
118

119
				trans = append(trans, translation{
120
					Locale:      locale.Locale(),
121
					Key:         k.(string),
122
					Translation: plural.text,
123
					PluralType:  rangeType,
124
					PluralRule:  locales.PluralRule(i).String(),
125
				})
126
			}
127
		}
128

129
		switch format {
130
		case FormatJSON:
131
			b, err = json.MarshalIndent(trans, "", "    ")
132
			ext = ".json"
133
		}
134

135
		if err != nil {
136
			return err
137
		}
138

139
		err = os.WriteFile(filepath.Join(dirname, fmt.Sprintf("%s%s", locale.Locale(), ext)), b, 0644)
140
		if err != nil {
141
			return err
142
		}
143

144
		trans = trans[0:0]
145
	}
146

147
	return nil
148
}
149

150
// Import reads the translations out of a file or directory on disk.
151
//
152
// NOTE: this currently only works with string or int translations keys.
153
func (t *UniversalTranslator) Import(format ImportExportFormat, dirnameOrFilename string) error {
154

155
	fi, err := os.Stat(dirnameOrFilename)
156
	if err != nil {
157
		return err
158
	}
159

160
	processFn := func(filename string) error {
161

162
		f, err := os.Open(filename)
163
		if err != nil {
164
			return err
165
		}
166
		defer f.Close()
167

168
		return t.ImportByReader(format, f)
169
	}
170

171
	if !fi.IsDir() {
172
		return processFn(dirnameOrFilename)
173
	}
174

175
	// recursively go through directory
176
	walker := func(path string, info os.FileInfo, err error) error {
177

178
		if info.IsDir() {
179
			return nil
180
		}
181

182
		switch format {
183
		case FormatJSON:
184
			// skip non JSON files
185
			if filepath.Ext(info.Name()) != ".json" {
186
				return nil
187
			}
188
		}
189

190
		return processFn(path)
191
	}
192

193
	return filepath.Walk(dirnameOrFilename, walker)
194
}
195

196
// ImportByReader imports the the translations found within the contents read from the supplied reader.
197
//
198
// NOTE: generally used when assets have been embedded into the binary and are already in memory.
199
func (t *UniversalTranslator) ImportByReader(format ImportExportFormat, reader io.Reader) error {
200

201
	b, err := io.ReadAll(reader)
202
	if err != nil {
203
		return err
204
	}
205

206
	var trans []translation
207

208
	switch format {
209
	case FormatJSON:
210
		err = json.Unmarshal(b, &trans)
211
	}
212

213
	if err != nil {
214
		return err
215
	}
216

217
	for _, tl := range trans {
218

219
		locale, found := t.FindTranslator(tl.Locale)
220
		if !found {
221
			return &ErrMissingLocale{locale: tl.Locale}
222
		}
223

224
		pr := stringToPR(tl.PluralRule)
225

226
		if pr == locales.PluralRuleUnknown {
227

228
			err = locale.Add(tl.Key, tl.Translation, tl.OverrideExisting)
229
			if err != nil {
230
				return err
231
			}
232

233
			continue
234
		}
235

236
		switch tl.PluralType {
237
		case cardinalType:
238
			err = locale.AddCardinal(tl.Key, tl.Translation, pr, tl.OverrideExisting)
239
		case ordinalType:
240
			err = locale.AddOrdinal(tl.Key, tl.Translation, pr, tl.OverrideExisting)
241
		case rangeType:
242
			err = locale.AddRange(tl.Key, tl.Translation, pr, tl.OverrideExisting)
243
		default:
244
			return &ErrBadPluralDefinition{tl: tl}
245
		}
246

247
		if err != nil {
248
			return err
249
		}
250
	}
251

252
	return nil
253
}
254

255
func stringToPR(s string) locales.PluralRule {
256

257
	switch s {
258
	case "Zero":
259
		return locales.PluralRuleZero
260
	case "One":
261
		return locales.PluralRuleOne
262
	case "Two":
263
		return locales.PluralRuleTwo
264
	case "Few":
265
		return locales.PluralRuleFew
266
	case "Many":
267
		return locales.PluralRuleMany
268
	case "Other":
269
		return locales.PluralRuleOther
270
	default:
271
		return locales.PluralRuleUnknown
272
	}
273

274
}
275