XmlTools2/trunk/xmlpatch.cpp

#include "xmlpatch.h"

XmlPatch::XmlPatch(QString patchFilesWildcard, QString forceTargetFilesWildcard, bool noBackups, bool noVerbose)
{
    this->patchFilesToProcess=UtilXmlTools::getAllPatchFilesByWildcard(patchFilesWildcard);
    this->forceTargetFilesWildcard=forceTargetFilesWildcard;
    this->backupsEnabled=!noBackups;
    this->verboseEnabled=!noVerbose;

    if(forceTargetFilesWildcard!=""){
        std::cout << "User forced patch in the target file(s): " << forceTargetFilesWildcard.toUtf8().constData() << std::endl;
    }

    if(this->patchFilesToProcess.isEmpty()){
        UtilXmlTools::displayErrorMessage("Loading patch files","No .patch or .oni-patch files were found for the wildcard: "+patchFilesWildcard);
    }

}

void XmlPatch::readAndProcessPatchFile(){

    // Process all PatchFiles
    for(int i=0; i<this->patchFilesToProcess.size(); i++){

        QFile inputFile(this->patchFilesToProcess[i]);

        if (inputFile.open(QIODevice::ReadOnly))
        {

            QTextStream fileStream(&inputFile);

            checkPatchVersion(this->patchFilesToProcess[i], fileStream);
            checkAndProcessValidCommands(fileStream);

            inputFile.close();
        }
        else{
            UtilXmlTools::displayErrorMessage("Read patch file", "Error opening patch file: '" + this->patchFilesToProcess[i] + "'.\n" + inputFile.errorString());
        }

    }

    UtilXmlTools::displaySuccessMessage(this->patchFilesToProcess.size(),"Patch File(s)");

}

void XmlPatch::insertNodesOperation(const QString &xmlString, XmlFilter &filters, const QString &xPathExpression, const QString &filesWildcard){

    QStringList filesToProcess;
    QList<pugi::xml_node> nodesToInsertion;
    pugi::xml_document newNode;
    pugi::xml_parse_result result;

    filesToProcess=UtilXmlTools::getAllXmlFilesByWildcard(filesWildcard);

    if(filesToProcess.isEmpty()){
        UtilXmlTools::displayErrorMessage("@ADD_INSIDE_NODES","No XML files were found for the wildcard: "+filesWildcard);
    }

    result=newNode.load(xmlString.toUtf8().constData()); // load xml to insert

    if(result.status!=pugi::status_ok){
        UtilXmlTools::displayErrorMessage("@ADD_INSIDE_NODES", "The xml node to insert is invalid.\n" + Util::toQString(result.description()));
    }

    // Process all XmlFiles
    for(int i=0; i<filesToProcess.size(); i++){

        UtilXmlTools::loadXmlFile(filesToProcess[i],this->document,this->rootNode,this->backupsEnabled,this->verboseEnabled,"@ADD_INSIDE_NODES");

        // Check how the element will be fetched via element name or xpath expression
        if(xPathExpression.isEmpty()){
            UtilXmlTools::getAllNamedElements(this->rootNode,nodesToInsertion,filters);
        }
        else{
            UtilXmlTools::getAllXpathElements(xPathExpression,this->document,nodesToInsertion);
        }

        if(nodesToInsertion[0].type()==pugi::node_null){

            QString errMessage;

            if(xPathExpression.isEmpty()){
                errMessage = "No node was found with an ElementName: '" + filters.getElementName() + "'";
                if(filters.getParentElementName()!=""){
                    errMessage += " and a ParentElementName: '" + filters.getParentElementName() + "'";
                }
                if(filters.getAttributeName()!=""){
                    errMessage += " and an AttributeName: '" + filters.getAttributeName() + "' and an AttributeValue: '" + filters.getAttributeValue() + "'";
                }
            }
            else{
                errMessage = "No node was found with an XPathExpression: '" + xPathExpression + "'";
            }

            UtilXmlTools::displayErrorMessage("@ADD_INSIDE_NODES",errMessage);
        }

        for(int j=0; j<nodesToInsertion.size(); j++){
            for (pugi::xml_node currNodeToInsert = newNode.first_child(); currNodeToInsert; currNodeToInsert = currNodeToInsert.next_sibling())
            {
                nodesToInsertion[j].append_copy(currNodeToInsert); // append the new node
            }

        }

        UtilXmlTools::saveXmlFile(filesToProcess[i],this->document, "@ADD_INSIDE_NODES");

        nodesToInsertion.clear();
    }

    UtilXmlTools::displaySuccessMessage(filesToProcess.size(),"@ADD_INSIDE_NODES");
}

void XmlPatch::removeNodesOperation(XmlFilter &filters, const QString &xPathExpression, const QString &filesWildcard){

    QStringList filesToProcess;

    QList<pugi::xml_node> nodesToDeletion;

    filesToProcess=UtilXmlTools::getAllXmlFilesByWildcard(filesWildcard);

    if(filesToProcess.isEmpty()){
        UtilXmlTools::displayErrorMessage("@REMOVE_NODES","No XML files were found for the wildcard: "+filesWildcard);
    }

    // Process all XmlFiles
    for(int i=0; i<filesToProcess.size(); i++){

        UtilXmlTools::loadXmlFile(filesToProcess[i],this->document,this->rootNode,this->backupsEnabled,this->verboseEnabled,"@REMOVE_NODES");

        // Check how the element will be fetched via element name or xpath expression
        if(xPathExpression.isEmpty()){
            UtilXmlTools::getAllNamedElements(this->rootNode,nodesToDeletion,filters);
        }
        else{
            UtilXmlTools::getAllXpathElements(xPathExpression,this->document,nodesToDeletion);
        }

        if(nodesToDeletion[0].type()==pugi::node_null){

            QString errMessage;

            if(xPathExpression.isEmpty()){
                errMessage = "No node was found with an ElementName: '" + filters.getElementName() + "'";
                if(filters.getParentElementName()!=""){
                    errMessage += " and a ParentElementName: '" + filters.getParentElementName() + "'";
                }
                if(filters.getAttributeName()!=""){
                    errMessage += " and an AttributeName: '" + filters.getAttributeName() + "' and an AttributeValue: '" + filters.getAttributeValue() + "'";
                }
            }
            else{
                errMessage = "No node was found with an XPathExpression: '" + xPathExpression + "'";
            }

            UtilXmlTools::displayErrorMessage("@REMOVE_NODES",errMessage);
        }

        // Delete all the specified nodes
        for(int j=0; j<nodesToDeletion.size(); j++){
            if(!nodesToDeletion[j].parent().remove_child(nodesToDeletion[j])){  // remove the node

                QString errMessage;
                if(xPathExpression.isEmpty()){
                    errMessage = "Couldn't remove the node with Element '" + filters.getElementName() + "'";

                    if(filters.getParentElementName()!=""){
                        errMessage += " and a ParentElement: '" + filters.getParentElementName() + "'";
                    }
                }
                else{
                    errMessage = "Couldn't remove the node with the XPathExpression '" + xPathExpression + "'";
                }

                UtilXmlTools::displayErrorMessage("@REMOVE_NODES",errMessage);
            }
        }

        UtilXmlTools::saveXmlFile(filesToProcess[i],this->document, "@REMOVE_NODES");

        nodesToDeletion.clear();
    }

    UtilXmlTools::displaySuccessMessage(filesToProcess.size(), "@REMOVE_NODES");
}

void XmlPatch::executeCommandOperation(const QString &commandString){

    // Avoid infinite fork loops
    if(commandString.contains("-p ") || commandString.contains("--patch-files ")){
        UtilXmlTools::displayErrorMessage("@COMMAND","Use of --patch-files option is not allowed inside a patch file");
    }

    // Reserved to AEI
    if(commandString.contains("--aei-patch-files-list ")){
        UtilXmlTools::displayErrorMessage("@COMMAND","Use of --aei-patch-files-list option is not allowed inside a patch file");
    }

    std::cout << "@COMMAND patch operation output:\n"
              << "########################################################################"
              << std::endl;

    OptionsParser myParser(Util::QStringToArgsArray(commandString));
    myParser.parse();

    std::cout
            << "########################################################################"
            << std::endl;

    UtilXmlTools::displaySuccessMessage(1,"@COMMAND");
}

QScriptValue echo(QScriptContext *context, QScriptEngine *engine)
{
    std::cout << context->argument(0).toString().toUtf8().constData() << std::endl;

    return "";
}

void XmlPatch::executeCustomCommandOperation(const QString &jsString, const QString &filesWildcard){

    QString rexmlString, jsxmlString;
    QStringList filesToProcess=UtilXmlTools::getAllXmlFilesByWildcard(filesWildcard);

    if(filesToProcess.isEmpty()){
        UtilXmlTools::displayErrorMessage("@CUSTOM_CODE","No XML files were found for the wildcard: "+filesWildcard);
    }

    QFile rexmlfile(":/resources/libs/rexml.js");
    QFile jsxmlfile(":/resources/libs/jsxml.js");

    rexmlfile.open(QFile::ReadOnly | QFile::Text);
    jsxmlfile.open(QFile::ReadOnly | QFile::Text);

    rexmlString=QTextStream(&rexmlfile).readAll();
    jsxmlString=QTextStream(&jsxmlfile).readAll();

    // Process all XmlFiles
#pragma omp parallel for
    for(int i=0; i<filesToProcess.size(); i++){

        QString currXmlFileString;

        QScriptEngine engine;
        QScriptValue engineResult; // variable to check for js_errors
        double elapsed_secs; // elapsed seconds that a user script took
        clock_t begin; // seconds that a script started

        // Add echo function so user can debug the code
        QScriptValue echoFunction = engine.newFunction(echo);
        engine.globalObject().setProperty("echo", echoFunction);

        engine.evaluate(rexmlString); // load js libraries
        engine.evaluate(jsxmlString);

        if(this->backupsEnabled){
            UtilXmlTools::backupFile(filesToProcess[i], this->verboseEnabled);
        }

        QFile currXmlFile(filesToProcess[i]);

        if(!currXmlFile.open(QFile::ReadOnly | QFile::Text)){
            UtilXmlTools::displayErrorMessage("@CUSTOM_CODE","Error loading '" + filesToProcess[i] + "' file for read operation.");
        }

        currXmlFileString=QTextStream(&currXmlFile).readAll();

        currXmlFile.close(); // close reading

        engine.globalObject().setProperty("$xmlData",currXmlFileString);

        begin = clock();

        // main needs to be called so the user code is evaluated
        // alternatively you can do: myFunc=engine.evaluate('(function main(){})'); myFunc.call();
        // Note the () around the function
        engineResult=engine.evaluate("main(); function main() {"+jsString+"}"); // main funtion allows to use return to exit prematurely from user code

        if(this->verboseEnabled){
            elapsed_secs = double(clock() - begin) / CLOCKS_PER_SEC;

            // Warn the user if the script took much time
            if(elapsed_secs>SLOW_SCRIPT_TIME){
                std::cout << "Warning: Slow javascript code detected.\n" <<
                             "Warning: Script execution seconds: " << elapsed_secs
                          << std::endl;
            }
        }

        if (engine.hasUncaughtException()) {
            displayJsException(engine,engineResult);
        }

        if(!currXmlFile.open(QFile::WriteOnly | QFile::Text | QIODevice::Truncate)){
            UtilXmlTools::displayErrorMessage("@CUSTOM_CODE","Error loading '" + filesToProcess[i] + "' file for @CUSTOM_CODE write operation.");
        }

        engineResult=engine.globalObject().property("$xmlData");

        if (engine.hasUncaughtException()) {
            displayJsException(engine,engineResult);
        }

        QTextStream(&currXmlFile) << engineResult.toString(); // retreive the modified xml by javascript and save it to the file
    }

    UtilXmlTools::displaySuccessMessage(filesToProcess.size(), "@CUSTOM_CODE");
}

void XmlPatch::checkPatchVersion(const QString &file, QTextStream &fileStream){

    QString line, patchVersion="";

    // First get the patch version and check it validity
    while ( !fileStream.atEnd() ){
        line = fileStream.readLine();

        if(line.startsWith('#')){ // Ignore comments
            continue;
        }
        else if(line.startsWith("@XML_TOOLS")){

            patchVersion=getPatchParameterValue(line,"Version");

            if(!patchVersion.startsWith("2.0")){
                QString errMessage;

                errMessage = "The current patch version is incompatible with this XmlTools version:\n";
                errMessage += "Patch file name: '" + file + "'\n";
                errMessage += "XmlTools version:  " + GlobalVars::AppVersion + "\n" + "CurrPatch version: " + patchVersion + "";
                UtilXmlTools::displayErrorMessage("@XML_TOOLS",errMessage);
            }
            break; // We have got what we wanted
        }
    }

    if(patchVersion==""){
        UtilXmlTools::displayErrorMessage("@XML_TOOLS","Patch version not found.");
    }

}

void XmlPatch::checkAndProcessValidCommands(QTextStream &fileStream){

    QString line, filesWildcard;
    QString xmlToInsert, command, jsCode;
    QString xPathExpression;
    XmlFilter filters;

    // Process the rest of the commands in patch file
    while ( !fileStream.atEnd() ){
        line = fileStream.readLine();

        if(line.startsWith('#')){ // Ignore comments
            continue;
        }
        else if(line.startsWith("@ADD_INSIDE_NODES")){
            xPathExpression=getPatchParameterValue(line,"XPathExpression");
            filters.setElementName(getPatchParameterValue(line,"ElementName"));
            filters.setParentElementName(getPatchParameterValue(line,"ParentElementName"));
            filters.setAttributeName(getPatchParameterValue(line,"AttributeName"));
            filters.setAttributeValue(getPatchParameterValue(line,"AttributeValue"));

            if(this->forceTargetFilesWildcard!=""){
                filesWildcard=this->forceTargetFilesWildcard;
            }
            else{
                filesWildcard=getPatchParameterValue(line,"Files");
            }

            // Check options
            if(xPathExpression.isEmpty() && filters.getElementName().isEmpty()){
                UtilXmlTools::displayErrorMessage("@ADD_INSIDE_NODES","ElementName option or XPathExpression option is required.");
            }
            else if(!xPathExpression.isEmpty() && !filters.getElementName().isEmpty()){
                UtilXmlTools::displayErrorMessage("@ADD_INSIDE_NODES","ElementName option and XPathExpression option cannot be used simultaneously.");
            }
            if(filters.getAttributeName()!="" && filters.getAttributeValue()==""){
                UtilXmlTools::displayErrorMessage("@ADD_INSIDE_NODES","AttributeValue option is required if using AttributeName option.");
            }

            if(filters.getAttributeValue()!="" && filters.getAttributeName()==""){
                UtilXmlTools::displayErrorMessage("@ADD_INSIDE_NODES","AttributeName option is required if using AttributeValue option.");
            }

            while ( !fileStream.atEnd() && !line.startsWith("</xml>")){
                line = fileStream.readLine();

                if(!line.startsWith("<xml>") && !line.startsWith("</xml>")){
                    xmlToInsert += line + "\n";
                }
            }

            insertNodesOperation(xmlToInsert,filters,xPathExpression,filesWildcard);

            xmlToInsert.clear();
            filters.clear();
            xPathExpression.clear();
            filesWildcard.clear();
        }
        else if(line.startsWith("@REMOVE_NODES")){

            xPathExpression=getPatchParameterValue(line,"XPathExpression");
            filters.setElementName(getPatchParameterValue(line,"ElementName"));
            filters.setParentElementName(getPatchParameterValue(line,"ParentElementName"));
            filters.setAttributeName(getPatchParameterValue(line,"AttributeName"));
            filters.setAttributeValue(getPatchParameterValue(line,"AttributeValue"));

            if(this->forceTargetFilesWildcard!=""){
                filesWildcard=this->forceTargetFilesWildcard;
            }
            else{
                filesWildcard=getPatchParameterValue(line,"Files");
            }

            // Check options
            if(xPathExpression.isEmpty() && filters.getElementName().isEmpty()){
                UtilXmlTools::displayErrorMessage("@REMOVE_NODES","ElementName option or XPathExpression option is required.");
            }
            else if(!xPathExpression.isEmpty() && !filters.getElementName().isEmpty()){
                UtilXmlTools::displayErrorMessage("@REMOVE_NODES","ElementName option and XPathExpression option cannot be used simultaneously.");
            }

            if(filters.getAttributeName()!="" && filters.getAttributeValue()==""){
                UtilXmlTools::displayErrorMessage("@REMOVE_NODES","AttributeValue option is required if using AttributeName option.");
            }

            if(filters.getAttributeValue()!="" && filters.getAttributeName()==""){
                UtilXmlTools::displayErrorMessage("@REMOVE_NODES","AttributeName option is required if using AttributeValue option.");
            }

            removeNodesOperation(filters,xPathExpression,filesWildcard);

            filters.clear();
            xPathExpression.clear();
            filesWildcard.clear();
        }
        else if(line.startsWith("@COMMAND")){

            command=GlobalVars::AppExecutable;

            // Append files if forced to
            if(!this->forceTargetFilesWildcard.isEmpty()){
                command+=" --files '"+this->forceTargetFilesWildcard+"' ";
            }

            command+=" "+getPatchParameterValue(line,"Options");

            // Add --no-backups and --no-verbose if patch was called with that arguments
            if(!this->backupsEnabled){
                command.append(" --no-backups ");
            }

            if(!this->verboseEnabled){
                command.append(" --no-verbose ");
            }

            command.replace("'","\""); //replace apostrophe by quotes, to avoid problems
            command.replace("\"\"","'"); // this allow to use '' as ' ('' is transformed in "" and then in ')

            executeCommandOperation(command);

            command.clear();
            filesWildcard.clear();
        }
        else if(line.startsWith("@CUSTOM_CODE")){

            if(this->forceTargetFilesWildcard!=""){
                filesWildcard=this->forceTargetFilesWildcard;
            }
            else{
                filesWildcard=getPatchParameterValue(line,"Files");
            }

            while ( !fileStream.atEnd() && !line.startsWith("</code>")){

                line = fileStream.readLine();

                if(!line.startsWith("<code>") && !line.startsWith("</code>")){
                    jsCode += line + "\n";
                }
            }

            executeCustomCommandOperation(jsCode,filesWildcard);

            jsCode.clear();
            filesWildcard.clear();
        }
    }
}

QString XmlPatch::getPatchParameterValue(const QString& line, QString parameter){

    int startValueIdx, endValueIdx;

    parameter=" "+parameter+" "; // Parameters include a space before and after it's value.

    if(!line.contains(parameter)){
        if(parameter==" ParentElementName " || parameter==" AttributeName " || parameter==" AttributeValue "
                || parameter==" ElementName " || parameter==" XPathExpression "){
            return ""; // not mandatory
        }
        parameter.remove(" "); // just remove the space added so it doesn't look weird when outputted to the user

        UtilXmlTools::displayErrorMessage("Read patch file parameter","Couldn't retrieve '" + parameter + "' parameter.");
    }

    startValueIdx=line.indexOf(parameter); // get the position where parameter is defined
    endValueIdx=line.indexOf("\"",startValueIdx)+1; // get the position where parameter value begins (+1 to ignore mandotory quote)

    startValueIdx=endValueIdx;
    endValueIdx=line.indexOf("\"",startValueIdx); // get the last mandatory quote of the value

    return line.mid(startValueIdx,endValueIdx-startValueIdx); // return the value of the parameter (is in the middle of the mandatory quotes)
}

void XmlPatch::displayJsException(QScriptEngine &engine, QScriptValue &engineResult){
    if (engine.hasUncaughtException()) {
        UtilXmlTools::displayErrorMessage("@CUSTOM_CODE","Uncaught js exception (user code) at line " +QString::number(engine.uncaughtExceptionLineNumber()) + ":\n" + engineResult.toString());
    }
}
Revision:	960
Committed:	Sun Feb 16 15:10:52 2014 UTC (11 years, 9 months ago) by s10k
Content type:	text/x-c++src
File size:	21176 byte(s)
Log Message:	XmlTools Added double single quotes to allow single quotes in XPath expressions in @COMMAND
#	Content
1	#include "xmlpatch.h"
2
3	XmlPatch::XmlPatch(QString patchFilesWildcard, QString forceTargetFilesWildcard, bool noBackups, bool noVerbose)
4	{
5	this->patchFilesToProcess=UtilXmlTools::getAllPatchFilesByWildcard(patchFilesWildcard);
6	this->forceTargetFilesWildcard=forceTargetFilesWildcard;
7	this->backupsEnabled=!noBackups;
8	this->verboseEnabled=!noVerbose;
9
10	if(forceTargetFilesWildcard!=""){
11	std::cout << "User forced patch in the target file(s): " << forceTargetFilesWildcard.toUtf8().constData() << std::endl;
12	}
13
14	if(this->patchFilesToProcess.isEmpty()){
15	UtilXmlTools::displayErrorMessage("Loading patch files","No .patch or .oni-patch files were found for the wildcard: "+patchFilesWildcard);
16	}
17
18	}
19
20	void XmlPatch::readAndProcessPatchFile(){
21
22	// Process all PatchFiles
23	for(int i=0; i<this->patchFilesToProcess.size(); i++){
24
25	QFile inputFile(this->patchFilesToProcess[i]);
26
27	if (inputFile.open(QIODevice::ReadOnly))
28	{
29
30	QTextStream fileStream(&inputFile);
31
32	checkPatchVersion(this->patchFilesToProcess[i], fileStream);
33	checkAndProcessValidCommands(fileStream);
34
35	inputFile.close();
36	}
37	else{
38	UtilXmlTools::displayErrorMessage("Read patch file", "Error opening patch file: '" + this->patchFilesToProcess[i] + "'.\n" + inputFile.errorString());
39	}
40
41	}
42
43	UtilXmlTools::displaySuccessMessage(this->patchFilesToProcess.size(),"Patch File(s)");
44
45	}
46
47	void XmlPatch::insertNodesOperation(const QString &xmlString, XmlFilter &filters, const QString &xPathExpression, const QString &filesWildcard){
48
49	QStringList filesToProcess;
50	QList<pugi::xml_node> nodesToInsertion;
51	pugi::xml_document newNode;
52	pugi::xml_parse_result result;
53
54	filesToProcess=UtilXmlTools::getAllXmlFilesByWildcard(filesWildcard);
55
56	if(filesToProcess.isEmpty()){
57	UtilXmlTools::displayErrorMessage("@ADD_INSIDE_NODES","No XML files were found for the wildcard: "+filesWildcard);
58	}
59
60	result=newNode.load(xmlString.toUtf8().constData()); // load xml to insert
61
62	if(result.status!=pugi::status_ok){
63	UtilXmlTools::displayErrorMessage("@ADD_INSIDE_NODES", "The xml node to insert is invalid.\n" + Util::toQString(result.description()));
64	}
65
66	// Process all XmlFiles
67	for(int i=0; i<filesToProcess.size(); i++){
68
69	UtilXmlTools::loadXmlFile(filesToProcess[i],this->document,this->rootNode,this->backupsEnabled,this->verboseEnabled,"@ADD_INSIDE_NODES");
70
71	// Check how the element will be fetched via element name or xpath expression
72	if(xPathExpression.isEmpty()){
73	UtilXmlTools::getAllNamedElements(this->rootNode,nodesToInsertion,filters);
74	}
75	else{
76	UtilXmlTools::getAllXpathElements(xPathExpression,this->document,nodesToInsertion);
77	}
78
79	if(nodesToInsertion[0].type()==pugi::node_null){
80
81	QString errMessage;
82
83	if(xPathExpression.isEmpty()){
84	errMessage = "No node was found with an ElementName: '" + filters.getElementName() + "'";
85	if(filters.getParentElementName()!=""){
86	errMessage += " and a ParentElementName: '" + filters.getParentElementName() + "'";
87	}
88	if(filters.getAttributeName()!=""){
89	errMessage += " and an AttributeName: '" + filters.getAttributeName() + "' and an AttributeValue: '" + filters.getAttributeValue() + "'";
90	}
91	}
92	else{
93	errMessage = "No node was found with an XPathExpression: '" + xPathExpression + "'";
94	}
95
96	UtilXmlTools::displayErrorMessage("@ADD_INSIDE_NODES",errMessage);
97	}
98
99	for(int j=0; j<nodesToInsertion.size(); j++){
100	for (pugi::xml_node currNodeToInsert = newNode.first_child(); currNodeToInsert; currNodeToInsert = currNodeToInsert.next_sibling())
101	{
102	nodesToInsertion[j].append_copy(currNodeToInsert); // append the new node
103	}
104
105	}
106
107	UtilXmlTools::saveXmlFile(filesToProcess[i],this->document, "@ADD_INSIDE_NODES");
108
109	nodesToInsertion.clear();
110	}
111
112	UtilXmlTools::displaySuccessMessage(filesToProcess.size(),"@ADD_INSIDE_NODES");
113	}
114
115	void XmlPatch::removeNodesOperation(XmlFilter &filters, const QString &xPathExpression, const QString &filesWildcard){
116
117	QStringList filesToProcess;
118
119	QList<pugi::xml_node> nodesToDeletion;
120
121	filesToProcess=UtilXmlTools::getAllXmlFilesByWildcard(filesWildcard);
122
123	if(filesToProcess.isEmpty()){
124	UtilXmlTools::displayErrorMessage("@REMOVE_NODES","No XML files were found for the wildcard: "+filesWildcard);
125	}
126
127	// Process all XmlFiles
128	for(int i=0; i<filesToProcess.size(); i++){
129
130	UtilXmlTools::loadXmlFile(filesToProcess[i],this->document,this->rootNode,this->backupsEnabled,this->verboseEnabled,"@REMOVE_NODES");
131
132	// Check how the element will be fetched via element name or xpath expression
133	if(xPathExpression.isEmpty()){
134	UtilXmlTools::getAllNamedElements(this->rootNode,nodesToDeletion,filters);
135	}
136	else{
137	UtilXmlTools::getAllXpathElements(xPathExpression,this->document,nodesToDeletion);
138	}
139
140	if(nodesToDeletion[0].type()==pugi::node_null){
141
142	QString errMessage;
143
144	if(xPathExpression.isEmpty()){
145	errMessage = "No node was found with an ElementName: '" + filters.getElementName() + "'";
146	if(filters.getParentElementName()!=""){
147	errMessage += " and a ParentElementName: '" + filters.getParentElementName() + "'";
148	}
149	if(filters.getAttributeName()!=""){
150	errMessage += " and an AttributeName: '" + filters.getAttributeName() + "' and an AttributeValue: '" + filters.getAttributeValue() + "'";
151	}
152	}
153	else{
154	errMessage = "No node was found with an XPathExpression: '" + xPathExpression + "'";
155	}
156
157	UtilXmlTools::displayErrorMessage("@REMOVE_NODES",errMessage);
158	}
159
160	// Delete all the specified nodes
161	for(int j=0; j<nodesToDeletion.size(); j++){
162	if(!nodesToDeletion[j].parent().remove_child(nodesToDeletion[j])){ // remove the node
163
164	QString errMessage;
165	if(xPathExpression.isEmpty()){
166	errMessage = "Couldn't remove the node with Element '" + filters.getElementName() + "'";
167
168	if(filters.getParentElementName()!=""){
169	errMessage += " and a ParentElement: '" + filters.getParentElementName() + "'";
170	}
171	}
172	else{
173	errMessage = "Couldn't remove the node with the XPathExpression '" + xPathExpression + "'";
174	}
175
176	UtilXmlTools::displayErrorMessage("@REMOVE_NODES",errMessage);
177	}
178	}
179
180	UtilXmlTools::saveXmlFile(filesToProcess[i],this->document, "@REMOVE_NODES");
181
182	nodesToDeletion.clear();
183	}
184
185	UtilXmlTools::displaySuccessMessage(filesToProcess.size(), "@REMOVE_NODES");
186	}
187
188	void XmlPatch::executeCommandOperation(const QString &commandString){
189
190	// Avoid infinite fork loops
191	if(commandString.contains("-p ") \|\| commandString.contains("--patch-files ")){
192	UtilXmlTools::displayErrorMessage("@COMMAND","Use of --patch-files option is not allowed inside a patch file");
193	}
194
195	// Reserved to AEI
196	if(commandString.contains("--aei-patch-files-list ")){
197	UtilXmlTools::displayErrorMessage("@COMMAND","Use of --aei-patch-files-list option is not allowed inside a patch file");
198	}
199
200	std::cout << "@COMMAND patch operation output:\n"
201	<< "########################################################################"
202	<< std::endl;
203
204	OptionsParser myParser(Util::QStringToArgsArray(commandString));
205	myParser.parse();
206
207	std::cout
208	<< "########################################################################"
209	<< std::endl;
210
211	UtilXmlTools::displaySuccessMessage(1,"@COMMAND");
212	}
213
214	QScriptValue echo(QScriptContext context, QScriptEngine engine)
215	{
216	std::cout << context->argument(0).toString().toUtf8().constData() << std::endl;
217
218	return "";
219	}
220
221	void XmlPatch::executeCustomCommandOperation(const QString &jsString, const QString &filesWildcard){
222
223	QString rexmlString, jsxmlString;
224	QStringList filesToProcess=UtilXmlTools::getAllXmlFilesByWildcard(filesWildcard);
225
226	if(filesToProcess.isEmpty()){
227	UtilXmlTools::displayErrorMessage("@CUSTOM_CODE","No XML files were found for the wildcard: "+filesWildcard);
228	}
229
230	QFile rexmlfile(":/resources/libs/rexml.js");
231	QFile jsxmlfile(":/resources/libs/jsxml.js");
232
233	rexmlfile.open(QFile::ReadOnly \| QFile::Text);
234	jsxmlfile.open(QFile::ReadOnly \| QFile::Text);
235
236	rexmlString=QTextStream(&rexmlfile).readAll();
237	jsxmlString=QTextStream(&jsxmlfile).readAll();
238
239	// Process all XmlFiles
240	#pragma omp parallel for
241	for(int i=0; i<filesToProcess.size(); i++){
242
243	QString currXmlFileString;
244
245	QScriptEngine engine;
246	QScriptValue engineResult; // variable to check for js_errors
247	double elapsed_secs; // elapsed seconds that a user script took
248	clock_t begin; // seconds that a script started
249
250	// Add echo function so user can debug the code
251	QScriptValue echoFunction = engine.newFunction(echo);
252	engine.globalObject().setProperty("echo", echoFunction);
253
254	engine.evaluate(rexmlString); // load js libraries
255	engine.evaluate(jsxmlString);
256
257	if(this->backupsEnabled){
258	UtilXmlTools::backupFile(filesToProcess[i], this->verboseEnabled);
259	}
260
261	QFile currXmlFile(filesToProcess[i]);
262
263	if(!currXmlFile.open(QFile::ReadOnly \| QFile::Text)){
264	UtilXmlTools::displayErrorMessage("@CUSTOM_CODE","Error loading '" + filesToProcess[i] + "' file for read operation.");
265	}
266
267	currXmlFileString=QTextStream(&currXmlFile).readAll();
268
269	currXmlFile.close(); // close reading
270
271	engine.globalObject().setProperty("$xmlData",currXmlFileString);
272
273	begin = clock();
274
275	// main needs to be called so the user code is evaluated
276	// alternatively you can do: myFunc=engine.evaluate('(function main(){})'); myFunc.call();
277	// Note the () around the function
278	engineResult=engine.evaluate("main(); function main() {"+jsString+"}"); // main funtion allows to use return to exit prematurely from user code
279
280	if(this->verboseEnabled){
281	elapsed_secs = double(clock() - begin) / CLOCKS_PER_SEC;
282
283	// Warn the user if the script took much time
284	if(elapsed_secs>SLOW_SCRIPT_TIME){
285	std::cout << "Warning: Slow javascript code detected.\n" <<
286	"Warning: Script execution seconds: " << elapsed_secs
287	<< std::endl;
288	}
289	}
290
291	if (engine.hasUncaughtException()) {
292	displayJsException(engine,engineResult);
293	}
294
295	if(!currXmlFile.open(QFile::WriteOnly \| QFile::Text \| QIODevice::Truncate)){
296	UtilXmlTools::displayErrorMessage("@CUSTOM_CODE","Error loading '" + filesToProcess[i] + "' file for @CUSTOM_CODE write operation.");
297	}
298
299	engineResult=engine.globalObject().property("$xmlData");
300
301	if (engine.hasUncaughtException()) {
302	displayJsException(engine,engineResult);
303	}
304
305	QTextStream(&currXmlFile) << engineResult.toString(); // retreive the modified xml by javascript and save it to the file
306	}
307
308	UtilXmlTools::displaySuccessMessage(filesToProcess.size(), "@CUSTOM_CODE");
309	}
310
311	void XmlPatch::checkPatchVersion(const QString &file, QTextStream &fileStream){
312
313	QString line, patchVersion="";
314
315	// First get the patch version and check it validity
316	while ( !fileStream.atEnd() ){
317	line = fileStream.readLine();
318
319	if(line.startsWith('#')){ // Ignore comments
320	continue;
321	}
322	else if(line.startsWith("@XML_TOOLS")){
323
324	patchVersion=getPatchParameterValue(line,"Version");
325
326	if(!patchVersion.startsWith("2.0")){
327	QString errMessage;
328
329	errMessage = "The current patch version is incompatible with this XmlTools version:\n";
330	errMessage += "Patch file name: '" + file + "'\n";
331	errMessage += "XmlTools version: " + GlobalVars::AppVersion + "\n" + "CurrPatch version: " + patchVersion + "";
332	UtilXmlTools::displayErrorMessage("@XML_TOOLS",errMessage);
333	}
334	break; // We have got what we wanted
335	}
336	}
337
338	if(patchVersion==""){
339	UtilXmlTools::displayErrorMessage("@XML_TOOLS","Patch version not found.");
340	}
341
342	}
343
344	void XmlPatch::checkAndProcessValidCommands(QTextStream &fileStream){
345
346	QString line, filesWildcard;
347	QString xmlToInsert, command, jsCode;
348	QString xPathExpression;
349	XmlFilter filters;
350
351	// Process the rest of the commands in patch file
352	while ( !fileStream.atEnd() ){
353	line = fileStream.readLine();
354
355	if(line.startsWith('#')){ // Ignore comments
356	continue;
357	}
358	else if(line.startsWith("@ADD_INSIDE_NODES")){
359	xPathExpression=getPatchParameterValue(line,"XPathExpression");
360	filters.setElementName(getPatchParameterValue(line,"ElementName"));
361	filters.setParentElementName(getPatchParameterValue(line,"ParentElementName"));
362	filters.setAttributeName(getPatchParameterValue(line,"AttributeName"));
363	filters.setAttributeValue(getPatchParameterValue(line,"AttributeValue"));
364
365	if(this->forceTargetFilesWildcard!=""){
366	filesWildcard=this->forceTargetFilesWildcard;
367	}
368	else{
369	filesWildcard=getPatchParameterValue(line,"Files");
370	}
371
372	// Check options
373	if(xPathExpression.isEmpty() && filters.getElementName().isEmpty()){
374	UtilXmlTools::displayErrorMessage("@ADD_INSIDE_NODES","ElementName option or XPathExpression option is required.");
375	}
376	else if(!xPathExpression.isEmpty() && !filters.getElementName().isEmpty()){
377	UtilXmlTools::displayErrorMessage("@ADD_INSIDE_NODES","ElementName option and XPathExpression option cannot be used simultaneously.");
378	}
379	if(filters.getAttributeName()!="" && filters.getAttributeValue()==""){
380	UtilXmlTools::displayErrorMessage("@ADD_INSIDE_NODES","AttributeValue option is required if using AttributeName option.");
381	}
382
383	if(filters.getAttributeValue()!="" && filters.getAttributeName()==""){
384	UtilXmlTools::displayErrorMessage("@ADD_INSIDE_NODES","AttributeName option is required if using AttributeValue option.");
385	}
386
387	while ( !fileStream.atEnd() && !line.startsWith("</xml>")){
388	line = fileStream.readLine();
389
390	if(!line.startsWith("<xml>") && !line.startsWith("</xml>")){
391	xmlToInsert += line + "\n";
392	}
393	}
394
395	insertNodesOperation(xmlToInsert,filters,xPathExpression,filesWildcard);
396
397	xmlToInsert.clear();
398	filters.clear();
399	xPathExpression.clear();
400	filesWildcard.clear();
401	}
402	else if(line.startsWith("@REMOVE_NODES")){
403
404	xPathExpression=getPatchParameterValue(line,"XPathExpression");
405	filters.setElementName(getPatchParameterValue(line,"ElementName"));
406	filters.setParentElementName(getPatchParameterValue(line,"ParentElementName"));
407	filters.setAttributeName(getPatchParameterValue(line,"AttributeName"));
408	filters.setAttributeValue(getPatchParameterValue(line,"AttributeValue"));
409
410	if(this->forceTargetFilesWildcard!=""){
411	filesWildcard=this->forceTargetFilesWildcard;
412	}
413	else{
414	filesWildcard=getPatchParameterValue(line,"Files");
415	}
416
417	// Check options
418	if(xPathExpression.isEmpty() && filters.getElementName().isEmpty()){
419	UtilXmlTools::displayErrorMessage("@REMOVE_NODES","ElementName option or XPathExpression option is required.");
420	}
421	else if(!xPathExpression.isEmpty() && !filters.getElementName().isEmpty()){
422	UtilXmlTools::displayErrorMessage("@REMOVE_NODES","ElementName option and XPathExpression option cannot be used simultaneously.");
423	}
424
425	if(filters.getAttributeName()!="" && filters.getAttributeValue()==""){
426	UtilXmlTools::displayErrorMessage("@REMOVE_NODES","AttributeValue option is required if using AttributeName option.");
427	}
428
429	if(filters.getAttributeValue()!="" && filters.getAttributeName()==""){
430	UtilXmlTools::displayErrorMessage("@REMOVE_NODES","AttributeName option is required if using AttributeValue option.");
431	}
432
433	removeNodesOperation(filters,xPathExpression,filesWildcard);
434
435	filters.clear();
436	xPathExpression.clear();
437	filesWildcard.clear();
438	}
439	else if(line.startsWith("@COMMAND")){
440
441	command=GlobalVars::AppExecutable;
442
443	// Append files if forced to
444	if(!this->forceTargetFilesWildcard.isEmpty()){
445	command+=" --files '"+this->forceTargetFilesWildcard+"' ";
446	}
447
448	command+=" "+getPatchParameterValue(line,"Options");
449
450	// Add --no-backups and --no-verbose if patch was called with that arguments
451	if(!this->backupsEnabled){
452	command.append(" --no-backups ");
453	}
454
455	if(!this->verboseEnabled){
456	command.append(" --no-verbose ");
457	}
458
459	command.replace("'","\""); //replace apostrophe by quotes, to avoid problems
460	command.replace("\"\"","'"); // this allow to use '' as ' ('' is transformed in "" and then in ')
461
462	executeCommandOperation(command);
463
464	command.clear();
465	filesWildcard.clear();
466	}
467	else if(line.startsWith("@CUSTOM_CODE")){
468
469	if(this->forceTargetFilesWildcard!=""){
470	filesWildcard=this->forceTargetFilesWildcard;
471	}
472	else{
473	filesWildcard=getPatchParameterValue(line,"Files");
474	}
475
476	while ( !fileStream.atEnd() && !line.startsWith("</code>")){
477
478	line = fileStream.readLine();
479
480	if(!line.startsWith("<code>") && !line.startsWith("</code>")){
481	jsCode += line + "\n";
482	}
483	}
484
485	executeCustomCommandOperation(jsCode,filesWildcard);
486
487	jsCode.clear();
488	filesWildcard.clear();
489	}
490	}
491	}
492
493	QString XmlPatch::getPatchParameterValue(const QString& line, QString parameter){
494
495	int startValueIdx, endValueIdx;
496
497	parameter=" "+parameter+" "; // Parameters include a space before and after it's value.
498
499	if(!line.contains(parameter)){
500	if(parameter==" ParentElementName " \|\| parameter==" AttributeName " \|\| parameter==" AttributeValue "
501	\|\| parameter==" ElementName " \|\| parameter==" XPathExpression "){
502	return ""; // not mandatory
503	}
504	parameter.remove(" "); // just remove the space added so it doesn't look weird when outputted to the user
505
506	UtilXmlTools::displayErrorMessage("Read patch file parameter","Couldn't retrieve '" + parameter + "' parameter.");
507	}
508
509	startValueIdx=line.indexOf(parameter); // get the position where parameter is defined
510	endValueIdx=line.indexOf("\"",startValueIdx)+1; // get the position where parameter value begins (+1 to ignore mandotory quote)
511
512	startValueIdx=endValueIdx;
513	endValueIdx=line.indexOf("\"",startValueIdx); // get the last mandatory quote of the value
514
515	return line.mid(startValueIdx,endValueIdx-startValueIdx); // return the value of the parameter (is in the middle of the mandatory quotes)
516	}
517
518	void XmlPatch::displayJsException(QScriptEngine &engine, QScriptValue &engineResult){
519	if (engine.hasUncaughtException()) {
520	UtilXmlTools::displayErrorMessage("@CUSTOM_CODE","Uncaught js exception (user code) at line " +QString::number(engine.uncaughtExceptionLineNumber()) + ":\n" + engineResult.toString());
521	}
522	}