tools/localize/merge_res_and_xliff.cpp

#include "merge_res_and_xliff.h"

#include "file_utils.h"
#include "Perforce.h"
#include "log.h"
#include <stdio.h>

static set<StringResource>::const_iterator
find_id(const set<StringResource>& s, const string& id, int index)
{
    for (set<StringResource>::const_iterator it = s.begin(); it != s.end(); it++) {
        if (it->id == id && it->index == index) {
            return it;
        }
    }
    return s.end();
}

static set<StringResource>::const_iterator
find_in_xliff(const set<StringResource>& s, const string& filename, const string& id, int index,
                int version, const Configuration& config)
{
    for (set<StringResource>::const_iterator it = s.begin(); it != s.end(); it++) {
        if (it->file == filename && it->id == id && it->index == index && it->version == version
                && it->config == config) {
            return it;
        }
    }
    return s.end();
}


static void
printit(const set<StringResource>& s, const set<StringResource>::const_iterator& it)
{
    if (it == s.end()) {
        printf("(none)\n");
    } else {
        printf("id=%s index=%d config=%s file=%s value='%s'\n", it->id.c_str(), it->index,
                it->config.ToString().c_str(), it->file.c_str(),
                it->value->ToString(ANDROID_NAMESPACES).c_str());
    }
}

StringResource
convert_resource(const StringResource& s, const string& file, const Configuration& config,
                    int version, const string& versionString)
{
    return StringResource(s.pos, file, config, s.id, s.index, s.value ? s.value->Clone() : NULL,
            version, versionString, s.comment);
}

static bool
resource_has_contents(const StringResource& res)
{
    XMLNode* value = res.value;
    if (value == NULL) {
        return false;
    }
    string contents = value->ContentsToString(ANDROID_NAMESPACES);
    return contents != "";
}

ValuesFile*
merge_res_and_xliff(const ValuesFile* en_currentFile,
        const ValuesFile* xx_currentFile, const ValuesFile* xx_oldFile,
        const string& filename, const XLIFFFile* xliffFile)
{
    bool success = true;

    Configuration en_config = xliffFile->SourceConfig();
    Configuration xx_config = xliffFile->TargetConfig();
    string currentVersion = xliffFile->CurrentVersion();

    ValuesFile* result = new ValuesFile(xx_config);

    set<StringResource> en_cur = en_currentFile->GetStrings();
    set<StringResource> xx_cur = xx_currentFile->GetStrings();
    set<StringResource> xx_old = xx_oldFile->GetStrings();
    set<StringResource> xliff = xliffFile->GetStringResources();

    // for each string in en_current
    for (set<StringResource>::const_iterator en_c = en_cur.begin();
            en_c != en_cur.end(); en_c++) {
        set<StringResource>::const_iterator xx_c = find_id(xx_cur, en_c->id, en_c->index);
        set<StringResource>::const_iterator xx_o = find_id(xx_old, en_c->id, en_c->index);
        set<StringResource>::const_iterator xlf = find_in_xliff(xliff, en_c->file, en_c->id,
                                                        en_c->index, CURRENT_VERSION, xx_config);

        if (false) {
            printf("\nen_c: "); printit(en_cur, en_c);
            printf("xx_c: "); printit(xx_cur, xx_c);
            printf("xx_o: "); printit(xx_old, xx_o);
            printf("xlf:  "); printit(xliff, xlf);
        }

        // if it changed between xx_old and xx_current, use xx_current
        // (someone changed it by hand)
        if (xx_o != xx_old.end() && xx_c != xx_cur.end()) {
            string xx_o_value = xx_o->value->ToString(ANDROID_NAMESPACES);
            string xx_c_value = xx_c->value->ToString(ANDROID_NAMESPACES);
            if (xx_o_value != xx_c_value && xx_c_value != "") {
                StringResource r(convert_resource(*xx_c, filename, xx_config,
                                                    CURRENT_VERSION, currentVersion));
                if (resource_has_contents(r)) {
                    result->AddString(r);
                }
                continue;
            }
        }

        // if it is present in xliff, use that
        // (it just got translated)
        if (xlf != xliff.end() && xlf->value->ToString(ANDROID_NAMESPACES) != "") {
            StringResource r(convert_resource(*xlf, filename, xx_config,
                                                CURRENT_VERSION, currentVersion));
            if (resource_has_contents(r)) {
                result->AddString(r);
            }
        }

        // if it is present in xx_current, use that
        // (it was already translated, and not retranslated)
        // don't filter out empty strings if they were added by hand, the above code just
        // guarantees that this tool never adds an empty one.
        if (xx_c != xx_cur.end()) {
            StringResource r(convert_resource(*xx_c, filename, xx_config,
                                                CURRENT_VERSION, currentVersion));
            result->AddString(r);
        }

        // othwerwise, leave it out.  The resource fall-through code will use the English
        // one at runtime, and the xliff export code will pick it up for translation next time.
    }

    if (success) {
        return result;
    } else {
        delete result;
        return NULL;
    }
}


struct MergedFile {
    XLIFFFile* xliff;
    string xliffFilename;
    string original;
    string translated;
    ValuesFile* en_current;
    ValuesFile* xx_current;
    ValuesFile* xx_old;
    ValuesFile* xx_new;
    string xx_new_text;
    string xx_new_filename;
    bool new_file;
    bool deleted_file;

    MergedFile();
    MergedFile(const MergedFile&);
};

struct compare_filenames {
    bool operator()(const MergedFile& lhs, const MergedFile& rhs) const
    {
        return lhs.original < rhs.original;
    }
};

MergedFile::MergedFile()
    :xliff(NULL),
     xliffFilename(),
     original(),
     translated(),
     en_current(NULL),
     xx_current(NULL),
     xx_old(NULL),
     xx_new(NULL),
     xx_new_text(),
     xx_new_filename(),
     new_file(false),
     deleted_file(false)
{
}

MergedFile::MergedFile(const MergedFile& that)
    :xliff(that.xliff),
     xliffFilename(that.xliffFilename),
     original(that.original),
     translated(that.translated),
     en_current(that.en_current),
     xx_current(that.xx_current),
     xx_old(that.xx_old),
     xx_new(that.xx_new),
     xx_new_text(that.xx_new_text),
     xx_new_filename(that.xx_new_filename),
     new_file(that.new_file),
     deleted_file(that.deleted_file)
{
}


typedef set<MergedFile, compare_filenames> MergedFileSet;

int
do_merge(const vector<string>& xliffFilenames)
{
    int err = 0;
    MergedFileSet files;

    printf("\rPreparing..."); fflush(stdout);
    string currentChange = Perforce::GetCurrentChange(true);

    // for each xliff, make a MergedFile record and do a little error checking
    for (vector<string>::const_iterator xliffFilename=xliffFilenames.begin();
            xliffFilename!=xliffFilenames.end(); xliffFilename++) {
        XLIFFFile* xliff = XLIFFFile::Parse(*xliffFilename);
        if (xliff == NULL) {
            fprintf(stderr, "localize import: unable to read file %s\n", xliffFilename->c_str());
            err = 1;
            continue;
        }

        set<string> xf = xliff->Files();
        for (set<string>::const_iterator f=xf.begin(); f!=xf.end(); f++) {
            MergedFile mf;
            mf.xliff = xliff;
            mf.xliffFilename = *xliffFilename;
            mf.original = *f;
            mf.translated = translated_file_name(mf.original, xliff->TargetConfig().locale);
            log_printf("mf.translated=%s mf.original=%s locale=%s\n", mf.translated.c_str(),
                    mf.original.c_str(), xliff->TargetConfig().locale.c_str());

            if (files.find(mf) != files.end()) {
                fprintf(stderr, "%s: duplicate string resources for file %s\n",
                        xliffFilename->c_str(), f->c_str());
                fprintf(stderr, "%s: previously defined here.\n",
                        files.find(mf)->xliffFilename.c_str());
                err = 1;
                continue;
            }
            files.insert(mf);
        }
    }

    size_t deletedFileCount = 0;
    size_t J = files.size() * 3;
    size_t j = 1;
    // Read all of the files from perforce.
    for (MergedFileSet::iterator mf = files.begin(); mf != files.end(); mf++) {
        MergedFile* file = const_cast<MergedFile*>(&(*mf));
        // file->en_current
        print_file_status(j++, J);
        file->en_current = get_values_file(file->original, file->xliff->SourceConfig(),
                                            CURRENT_VERSION, currentChange, true);
        if (file->en_current == NULL) {
            // deleted file
            file->deleted_file = true;
            deletedFileCount++;
            continue;
        }

        // file->xx_current;
        print_file_status(j++, J);
        file->xx_current = get_values_file(file->translated, file->xliff->TargetConfig(),
                                            CURRENT_VERSION, currentChange, false);
        if (file->xx_current == NULL) {
            file->xx_current = new ValuesFile(file->xliff->TargetConfig());
            file->new_file = true;
        }

        // file->xx_old (note that the xliff's current version is our old version, because that
        // was the current version when it was exported)
        print_file_status(j++, J);
        file->xx_old = get_values_file(file->translated, file->xliff->TargetConfig(),
                                            OLD_VERSION, file->xliff->CurrentVersion(), false);
        if (file->xx_old == NULL) {
            file->xx_old = new ValuesFile(file->xliff->TargetConfig());
            file->new_file = true;
        }
    }

    // merge them
    for (MergedFileSet::iterator mf = files.begin(); mf != files.end(); mf++) {
        MergedFile* file = const_cast<MergedFile*>(&(*mf));
        if (file->deleted_file) {
            continue;
        }
        file->xx_new = merge_res_and_xliff(file->en_current, file->xx_current, file->xx_old,
                                            file->original, file->xliff);
    }

    // now is a good time to stop if there was an error
    if (err != 0) {
        return err;
    }

    // locate the files
    j = 1;
    for (MergedFileSet::iterator mf = files.begin(); mf != files.end(); mf++) {
        MergedFile* file = const_cast<MergedFile*>(&(*mf));
        print_file_status(j++, J, "Locating");

        file->xx_new_filename = Perforce::Where(file->translated, true);
        if (file->xx_new_filename == "") {
            fprintf(stderr, "\nWas not able to determine the location of depot file %s\n",
                    file->translated.c_str());
            err = 1;
        }
    }

    if (err != 0) {
        return err;
    }

    // p4 edit the files
    // only do this if it changed - no need to submit files that haven't changed meaningfully
    vector<string> filesToEdit;
    vector<string> filesToAdd;
    vector<string> filesToDelete;
    for (MergedFileSet::iterator mf = files.begin(); mf != files.end(); mf++) {
        MergedFile* file = const_cast<MergedFile*>(&(*mf));
        if (file->deleted_file) {
            filesToDelete.push_back(file->xx_new_filename);
            continue;
        }
        string xx_current_text = file->xx_current->ToString();
        string xx_new_text = file->xx_new->ToString();
        if (xx_current_text != xx_new_text) {
            if (file->xx_new->GetStrings().size() == 0) {
                file->deleted_file = true;
                filesToDelete.push_back(file->xx_new_filename);
            } else {
                file->xx_new_text = xx_new_text;
                if (file->new_file) {
                    filesToAdd.push_back(file->xx_new_filename);
                } else {
                    filesToEdit.push_back(file->xx_new_filename);
                }
            }
        }
    }
    if (filesToAdd.size() == 0 && filesToEdit.size() == 0 && deletedFileCount == 0) {
        printf("\nAll of the files are the same.  Nothing to change.\n");
        return 0;
    }
    if (filesToEdit.size() > 0) {
        printf("\np4 editing files...\n");
        if (0 != Perforce::EditFiles(filesToEdit, true)) {
            return 1;
        }
    }


    printf("\n");

    for (MergedFileSet::iterator mf = files.begin(); mf != files.end(); mf++) {
        MergedFile* file = const_cast<MergedFile*>(&(*mf));
        if (file->deleted_file) {
            continue;
        }
        if (file->xx_new_text != "" && file->xx_new_filename != "") {
            if (0 != write_to_file(file->xx_new_filename, file->xx_new_text)) {
                err = 1;
            }
        }
    }

    if (err != 0) {
        return err;
    }

    if (filesToAdd.size() > 0) {
        printf("p4 adding %zd new files...\n", filesToAdd.size());
        err = Perforce::AddFiles(filesToAdd, true);
    }

    if (filesToDelete.size() > 0) {
        printf("p4 deleting %zd removed files...\n", filesToDelete.size());
        err = Perforce::DeleteFiles(filesToDelete, true);
    }

    if (err != 0) {
        return err;
    }

    printf("\n"
           "Theoretically, this merge was successfull.  Next you should\n"
           "review the diffs, get a code review, and submit it.  Enjoy.\n\n");
    return 0;
}