func (ms *MergeStrings) combineStringInfosPerDirectory(directory string) error {
files, directories := getFilesAndDir(directory)
fileList := ms.matchFileToSourceLanguage(files, ms.SourceLanguage)
combinedMap := map[string]common.I18nStringInfo{}
for _, file := range fileList {
StringInfos, err := common.LoadI18nStringInfos(file)
if err != nil {
return err
}
combineStringInfo(StringInfos, combinedMap)
}
filePath := filepath.Join(directory, ms.SourceLanguage+".all.json")
ms.I18nStringInfos = common.I18nStringInfoMapValues2Array(combinedMap)
sort.Sort(ms)
common.SaveI18nStringInfos(ms, ms.Options(), ms.I18nStringInfos, filePath)
ms.Println("i18n4go: saving combined language file: " + filePath)
if ms.Recurse {
for _, directory = range directories {
err := ms.combineStringInfosPerDirectory(directory)
if err != nil {
return err
}
}
}
return nil
}
func (sms *ShowMissingStrings) showMissingStrings() error {
//Load en_US.all.json
stringInfos, err := common.LoadI18nStringInfos(sms.I18nStringsFilename)
if err != nil {
return err
}
sms.I18nStringInfos = stringInfos
//Run AST to get list of strings
err = sms.parseFiles()
if err != nil {
return err
}
//Compare list of strings with <lang>.all.json
err = sms.showMissingTranslatedStrings()
if err != nil {
return err
}
//Compare list of translated strings with strings in codebase
return sms.showExtraStrings()
}
func (ct *createTranslations) createTranslationFileWithGoogleTranslate(language string) (string, error) {
fileName, _, err := common.CheckFile(ct.Filename)
if err != nil {
return "", err
}
err = common.CreateOutputDirsIfNeeded(ct.OutputDirname)
if err != nil {
ct.Println(err)
return "", fmt.Errorf("i18n4go: could not create output directory: %s", ct.OutputDirname)
}
destFilename := filepath.Join(ct.OutputDirname, strings.Replace(fileName, ct.options.SourceLanguageFlag, language, -1))
i18nStringInfos, err := common.LoadI18nStringInfos(ct.Filename)
if err != nil {
ct.Println(err)
return "", fmt.Errorf("i18n4go: could not load i18n strings from file: %s", ct.Filename)
}
if len(i18nStringInfos) == 0 {
return "", fmt.Errorf("i18n4go: input file: %s is empty", ct.Filename)
}
ct.Println("i18n4go: attempting to use Google Translate to translate source strings in: ", language)
modifiedI18nStringInfos := make([]common.I18nStringInfo, len(i18nStringInfos))
for i, i18nStringInfo := range i18nStringInfos {
translation, _, err := ct.googleTranslate(i18nStringInfo.Translation, language)
if err != nil {
ct.Println("i18n4go: error invoking Google Translate for string:", i18nStringInfo.Translation)
} else {
modifiedI18nStringInfos[i] = common.I18nStringInfo{ID: i18nStringInfo.ID, Translation: translation}
}
}
err = common.SaveI18nStringInfos(ct, ct.Options(), modifiedI18nStringInfos, destFilename)
if err != nil {
ct.Println(err)
return "", fmt.Errorf("i18n4go: could not save Google Translate i18n strings to file: %s", destFilename)
}
if ct.options.PoFlag {
poFilename := destFilename[:len(destFilename)-len(".json")] + ".po"
err = common.SaveI18nStringsInPo(ct, ct.Options(), modifiedI18nStringInfos, poFilename)
if err != nil {
ct.Println(err)
return "", fmt.Errorf("i18n4go: could not save PO file: %s", poFilename)
}
}
ct.Println()
return destFilename, nil
}
func (fix *Fixup) findI18nStrings(i18nFile string) (i18nStrings map[string]common.I18nStringInfo, err error) {
i18nStrings = make(map[string]common.I18nStringInfo)
stringInfos, err := common.LoadI18nStringInfos(i18nFile)
if err != nil {
return nil, err
}
return common.CreateI18nStringInfoMap(stringInfos)
}
func (rp *rewritePackage) loadStringsToBeTranslated(fileName string) error {
if fileName != "" {
stringList, err := common.LoadI18nStringInfos(fileName)
if err != nil {
return err
}
rp.ExtractedStrings, err = common.CreateI18nStringInfoMap(stringList)
if err != nil {
return err
}
rp.UpdatedExtractedStrings = common.CopyI18nStringInfoMap(rp.ExtractedStrings)
}
return nil
}
func (cu *Checkup) findI18nStrings(i18nFiles []string) (i18nStrings map[string]string, err error) {
i18nStrings = make(map[string]string)
for _, i18nFile := range i18nFiles {
stringInfos, err := common.LoadI18nStringInfos(i18nFile)
if err != nil {
return nil, err
}
for _, info := range stringInfos {
i18nStrings[info.ID] = info.Translation
}
}
return
}
func (ct *createTranslations) createTranslationFile(sourceFilename string, language string) (string, error) {
fileName, _, err := common.CheckFile(sourceFilename)
if err != nil {
return "", err
}
i18nStringInfos, err := common.LoadI18nStringInfos(sourceFilename)
if err != nil {
ct.Println(err)
return "", fmt.Errorf("i18n4go: could not load i18n strings from file: %s", sourceFilename)
}
if len(i18nStringInfos) == 0 {
return "", fmt.Errorf("i18n4go: input file: %s is empty", sourceFilename)
}
destFilename := filepath.Join(ct.OutputDirname, strings.Replace(fileName, ct.options.SourceLanguageFlag, language, -1))
ct.Println("i18n4go: creating translation file:", destFilename)
return destFilename, common.CopyFileContents(sourceFilename, destFilename)
}
func (vs *verifyStrings) verify(inputFilename string, targetFilename string) error {
common.CheckFile(targetFilename)
inputI18nStringInfos, err := common.LoadI18nStringInfos(inputFilename)
if err != nil {
vs.Println("i18n4go: Error loading the i18n strings from input filename:", inputFilename)
return err
}
if len(inputI18nStringInfos) == 0 {
return fmt.Errorf("i18n4go: Error input file: %s is empty", inputFilename)
}
inputMap, err := common.CreateI18nStringInfoMap(inputI18nStringInfos)
if err != nil {
return fmt.Errorf("File has duplicated key: %s\n%s", inputFilename, err)
}
targetI18nStringInfos, err := common.LoadI18nStringInfos(targetFilename)
if err != nil {
vs.Println("i18n4go: Error loading the i18n strings from target filename:", targetFilename)
return err
}
var targetExtraStringInfos, targetInvalidStringInfos []common.I18nStringInfo
for _, stringInfo := range targetI18nStringInfos {
if _, ok := inputMap[stringInfo.ID]; ok {
if common.IsTemplatedString(stringInfo.ID) && vs.isTemplatedStringTranslationInvalid(stringInfo) {
vs.Println("i18n4go: WARNING target file has invalid templated translations with key ID: ", stringInfo.ID)
targetInvalidStringInfos = append(targetInvalidStringInfos, stringInfo)
}
delete(inputMap, stringInfo.ID)
} else {
vs.Println("i18n4go: WARNING target file has extra key with ID: ", stringInfo.ID)
targetExtraStringInfos = append(targetExtraStringInfos, stringInfo)
}
}
var verficationError error
if len(targetExtraStringInfos) > 0 {
vs.Println("i18n4go: WARNING target file contains total of extra keys:", len(targetExtraStringInfos))
diffFilename, err := vs.generateExtraKeysDiffFile(targetExtraStringInfos, targetFilename)
if err != nil {
vs.Println("i18n4go: ERROR could not create the diff file:", err)
return err
}
vs.Println("i18n4go: generated diff file:", diffFilename)
verficationError = fmt.Errorf("i18n4go: target file has extra i18n strings with IDs: %s", strings.Join(keysForI18nStringInfos(targetExtraStringInfos), ","))
}
if len(targetInvalidStringInfos) > 0 {
vs.Println("i18n4go: WARNING target file contains total of invalid translations:", len(targetInvalidStringInfos))
diffFilename, err := vs.generateInvalidTranslationDiffFile(targetInvalidStringInfos, targetFilename)
if err != nil {
vs.Println("i18n4go: ERROR could not create the diff file:", err)
return err
}
vs.Println("i18n4go: generated diff file:", diffFilename)
verficationError = fmt.Errorf("i18n4go: target file has invalid i18n strings with IDs: %s", strings.Join(keysForI18nStringInfos(targetInvalidStringInfos), ","))
}
if len(inputMap) > 0 {
vs.Println("i18n4go: ERROR input file does not match target file:", targetFilename)
diffFilename, err := vs.generateMissingKeysDiffFile(valuesForI18nStringInfoMap(inputMap), targetFilename)
if err != nil {
vs.Println("i18n4go: ERROR could not create the diff file:", err)
return err
}
vs.Println("i18n4go: generated diff file:", diffFilename)
verficationError = fmt.Errorf("i18n4go: target file is missing i18n strings with IDs: %s", strings.Join(keysForI18nStringInfoMap(inputMap), ","))
}
return verficationError
}
exitCode := cmd.Wait()
Ω(exitCode).Should(BeNil())
})
Context("When the user says the translation was updated", func() {
JustBeforeEach(func() {
Ω(getNextOutputLine(stdoutReader)).Should(ContainSubstring("Is the string \"I like apples.\" a new or updated string? [new/upd]"))
stdinPipe.Write([]byte("upd\n"))
stdinPipe.Write([]byte("1\n"))
})
It("Updates the keys for all translation files", func() {
cmd.Wait()
translations, err := common.LoadI18nStringInfos(filepath.Join(".", "translations", "en_US.all.json"))
Ω(err).ShouldNot(HaveOccurred())
mappedTranslations, err := common.CreateI18nStringInfoMap(translations)
Ω(err).ShouldNot(HaveOccurred())
Ω(mappedTranslations["I like bananas."]).Should(Equal(common.I18nStringInfo{}))
Ω(mappedTranslations["I like apples."]).ShouldNot(Equal(common.I18nStringInfo{}))
translations, err = common.LoadI18nStringInfos(filepath.Join(".", "translations", "zh_CN.all.json"))
Ω(err).ShouldNot(HaveOccurred())
mappedTranslations, err = common.CreateI18nStringInfoMap(translations)
Ω(err).ShouldNot(HaveOccurred())
Ω(mappedTranslations["I like bananas."]).Should(Equal(common.I18nStringInfo{}))
Ω(mappedTranslations["I like apples."]).ShouldNot(Equal(common.I18nStringInfo{}))
})
It("Updates all the translation", func() {