source: XmlTools2/trunk/xmlpatch.cpp@ 961

Last change on this file since 961 was 960, checked in by s10k, 11 years ago

XmlTools
Added double single quotes to allow single quotes in XPath expressions in @COMMAND
File size: 20.7 KB
Line 
1#include "xmlpatch.h"
2
3XmlPatch::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
20void 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
47void 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
115void 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
188void 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
214QScriptValue echo(QScriptContext *context, QScriptEngine *engine)
215{
216 std::cout << context->argument(0).toString().toUtf8().constData() << std::endl;
217
218 return "";
219}
220
221void 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
311void 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
344void 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
493QString 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
518void 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}
Note: See TracBrowser for help on using the repository browser.