Adding possibility to load XML via string

MatthD · MatthD · commit cb914222fb41 · 2018-04-08T19:49:20.000+02:00
diff --git a/Readme.md b/Readme.md
@@ -9,6 +9,7 @@ It can perform:
 - Validity against DTD/XSD(Schema) check, 
 - Get doctype informations (about dtd)
 - GetXpath Values
+- Load XMl from string or file path
 
 ## Requirements: 
 
@@ -23,6 +24,7 @@ Node-libxml has been thought differently than [libxmljs](https://github.com/libx
 - You wan to validate against DTD (libxmljs can't)
 - You want a silent program if xml is not wellformed (node-libxml returns wellformed error in object; libxmljs throws)
 - You want to do xml processing in parallel forks
+- You want to load XML from file path OR string
 - You want to validate against DTD / schema on multiple documents with just ONE dtd/schema loaded in memory (libxmljs loads it on each validation request), so it's clearly by far fastest!
 
 
@@ -40,6 +42,8 @@ Node-libxml has been thought differently than [libxmljs](https://github.com/libx
   let libxml = new Libxml();
 
   let xmlIsWellformed = libxml.loadXml('path/to/xml');
+  let xmlIsWellformedStr = libxml.loadXmlFromString('<name>test</name>');
+
   console.log(xmlIsWellformed);
   console.log(xmlIsWellformed.wellformedErrors);
 
@@ -72,6 +76,11 @@ A function of libxml to load the XML file
 `TAKE a path & RETURN true if wellformed | false if not`
 `SET a an array 'wellformedErrors' in libxml element containing wellformed errors`
 
+##### loadXmlFromString(string)
+A function of libxml to create the xml Dom from a string
+`TAKE a string containing xml & RETURN true if wellformed | false if not`
+`SET a an array 'wellformedErrors' in libxml element containing wellformed errors`
+
 
 ##### loadDtds(array)
 A function of libxml to load the DTDs files
diff --git a/libxml.cpp b/libxml.cpp
@@ -41,7 +41,9 @@ NAN_MODULE_INIT(Libxml::Init) {
   tpl->InstanceTemplate()->SetInternalFieldCount(1);
 
   Nan::SetPrototypeMethod(tpl, "loadXml", loadXml);
+  Nan::SetPrototypeMethod(tpl, "loadXmlFromString", loadXmlFromString);
   Nan::SetPrototypeMethod(tpl, "loadDtds", loadDtds);
+  // Nan::SetPrototypeMethod(tpl, "loadDtdsFromString", loadDtdsFromString);
   Nan::SetPrototypeMethod(tpl, "loadSchemas", loadSchemas);
   Nan::SetPrototypeMethod(tpl, "validateAgainstDtds", validateAgainstDtds);
   Nan::SetPrototypeMethod(tpl, "validateAgainstSchemas", validateAgainstSchemas);
@@ -102,6 +104,36 @@ NAN_METHOD(Libxml::loadXml) {
   }
 }
 
+NAN_METHOD(Libxml::loadXmlFromString) {
+  if (info.Length() < 1){
+    return Nan::ThrowTypeError("loadXmlFromString requires at least 1 argument");
+  }
+  v8::Local<v8::Array> errors = Nan::New<v8::Array>();
+  xmlResetLastError();
+  xmlSetStructuredErrorFunc(reinterpret_cast<void *>(&errors),
+            XmlSyntaxError::PushToArray);
+  Libxml* libxml = Nan::ObjectWrap::Unwrap<Libxml>(info.Holder());
+  String::Utf8Value str(info[0]->ToString());
+  string txt (*str);
+  // Those options shoudl be send by the user, it enable/disbale errors, warnings ..
+  int options;
+  options = (XML_PARSE_NOERROR | XML_PARSE_NOWARNING | XML_PARSE_NONET);
+  if(libxml->docPtr != NULL){
+    xmlFreeDoc(libxml->docPtr);
+    libxml->docPtr = nullptr;
+  }
+  libxml->docPtr = xmlReadMemory(txt.c_str(), txt.length(), NULL, NULL, options);
+  xmlSetStructuredErrorFunc(NULL, NULL);
+
+  if(libxml->docPtr == NULL){
+    // We set property to libxml element only if notWellformed
+    info.Holder()->Set(Nan::New<v8::String>("wellformedErrors").ToLocalChecked(), errors);
+    info.GetReturnValue().Set(Nan::False());
+  }else{
+    info.GetReturnValue().Set(Nan::True());
+  }
+}
+
 NAN_METHOD(Libxml::getDtd){
   Nan::HandleScope scope;
   Libxml* libxml = Nan::ObjectWrap::Unwrap<Libxml>(info.Holder());
@@ -173,6 +205,58 @@ NAN_METHOD(Libxml::loadDtds){
   }
 }
 
+// NAN_METHOD(Libxml::loadDtdsFromString){
+//   if (info.Length() < 1){
+//     return Nan::ThrowTypeError("loadDtds requires at least 1 argument, an array of DTDs");
+//   }
+//   if(!info[0]->IsArray()){
+//     return Nan::ThrowTypeError("loadDtds requires an array");
+//   }
+//   Nan::EscapableHandleScope scope;
+//   Libxml* libxml = Nan::ObjectWrap::Unwrap<Libxml>(info.Holder());
+//   Local<Array> dtdsStrLocal = Local<Array>::Cast(info[0]);
+//   Local<Array> errors = Nan::New<Array>();
+//   int options;
+//   options = (XML_PARSE_NOERROR | XML_PARSE_NOWARNING | XML_PARSE_NONET);
+//   // disbale errors erreurs etc
+//   //v8::Local<v8::Array> errorsDTD = Nan::New<v8::Array>();
+//   xmlResetLastError();
+//   xmlSetStructuredErrorFunc(reinterpret_cast<void *>(&errors),
+//             XmlSyntaxError::PushToArray);
+//   for (unsigned int i = 0; i < dtdsStrLocal->Length(); i++){
+//     if (Nan::Has(dtdsStrLocal, i).FromJust() && Nan::Get(dtdsStrLocal, i).ToLocalChecked()->IsString()) {
+//       Local<String> value = Nan::Get(dtdsStrLocal, i).ToLocalChecked()->ToString();
+//       String::Utf8Value strV8(value->ToString());
+//       string pathStr (*strV8);
+//       xmlDocPtr dtdDoc = xmlReadMemory(pathStr.c_str(),pathStr.length(),NULL,NULL,options);;
+//       if (dtdDoc == NULL) {
+//         //DTD is bad, we set error and not assign it + next
+//         errors->Set(i, Nan::New<String>(pathStr.c_str()).ToLocalChecked());
+//         continue;
+//       }
+//       // Parse DTD from memory
+//       xmlParserInputBufferPtr dtdBuf = xmlParserInputBufferCreateMem(pathStr.c_str(), pathStr.size(),
+//                                                                XML_CHAR_ENCODING_UTF8);
+//       if (!dtdBuf) {
+//         errors->Set(i, Nan::New<String>(pathStr.c_str()).ToLocalChecked());
+//         continue;
+//       }
+//       xmlDtdPtr pDtd = xmlIOParseDTD(NULL, dtdBuf, XML_CHAR_ENCODING_UTF8);
+//       if (pDtd == NULL) {
+//         xmlFreeDtd(pDtd);
+//         errors->Set(i, Nan::New<String>(pathStr.c_str()).ToLocalChecked());
+//         continue;
+//       }
+//       libxml->dtdsPaths.push_back(pDtd);
+//     }
+//   }
+//   xmlSetStructuredErrorFunc(NULL, NULL);
+//   // We set dtdsLoadedErrors property for js side
+//   if(errors->Length()){
+//     info.Holder()->Set(Nan::New<v8::String>("dtdsLoadedErrors").ToLocalChecked(), errors);
+//   }
+// }
+
 NAN_METHOD(Libxml::loadSchemas){
   if (info.Length() < 1){
     return Nan::ThrowTypeError("loadSchemas requires at least 1 argument, an array of Schemas");
diff --git a/libxml.h b/libxml.h
@@ -40,7 +40,9 @@ class Libxml : public Nan::ObjectWrap {
 
   static NAN_METHOD(New);
   static NAN_METHOD(loadXml);
+  static NAN_METHOD(loadXmlFromString);
   static NAN_METHOD(loadDtds);
+  // static NAN_METHOD(loadDtdsFromString);
   static NAN_METHOD(loadSchemas);
   static NAN_METHOD(validateAgainstDtds);
   static NAN_METHOD(validateAgainstSchemas);
diff --git a/test/libxml-test.js b/test/libxml-test.js
@@ -2,6 +2,7 @@
 
 const Libxml = require('../index.js');
 const expect = require('chai').expect;
+const fs = require('fs');
 
 describe('Node-Libxml', function () {
   it('Should return a list of errored path if dtd path is bad', function () {
@@ -24,12 +25,38 @@ describe('Node-Libxml', function () {
     libxml.freeXml();
     libxml.freeDtds();
   });
+  // it('Should return wellformed & valid on a wellformed & valid xml From String', function () {
+  //   let libxml = new Libxml();
+  //   let testDefaultStr = fs.readFileSync('test/data/test-default.xml','utf8');
+  //   let myDtd = "<!ELEMENT xpath (to)>\n" +
+  //     "<!ELEMENT to (my)>\n" +
+  //     "<!ELEMENT my (infos,infosdust)>\n" +
+  //     "<!ATTLIST infos\n" +
+  //     "xmlns CDATA #FIXED ''\n" +
+  //     "attrib NMTOKEN #IMPLIED>\n" +
+  //     "<!ELEMENT infos (#PCDATA)>\n" +
+  //     "<!ELEMENT infosdust (#PCDATA)>";
+  //   let testDefaultWf = libxml.loadXmlFromString(testDefaultStr);
+  //   libxml.loadDtdsFromString([myDtd]);
+  //   let testDefaultV = libxml.validateAgainstDtds();
+  //   expect(testDefaultWf).to.be.true;
+  //   expect(testDefaultV).to.be.a('string');
+  //   libxml.freeXml();
+  //   libxml.freeDtds();
+  // });
   it('should return wellformed on a wellformed XMl in utf8-bom & other encoding', function () {
     let libxml = new Libxml();
     let testNotUtf8 = libxml.loadXml('test/data/test-default-not-utf8.xml');
     expect(testNotUtf8).to.be.true
     libxml.freeXml();
   });
+  it('should return wellformed on a wellformed XMl in utf8-bom & other encoding FROM STRING', function () {
+    let libxml = new Libxml();
+    let defaultNotUtf8 = fs.readFileSync('test/data/test-default-not-utf8.xml','utf8');
+    let testNotUtf8 = libxml.loadXmlFromString(defaultNotUtf8);
+    expect(testNotUtf8).to.be.true;
+    libxml.freeXml();
+  });
   // Wellformed & invalid
   it('Should return wellformed & invalid on a wellformed BUT invalid xml', function () {
     let libxml = new Libxml();
@@ -44,6 +71,20 @@ describe('Node-Libxml', function () {
     libxml.freeDtds();
     libxml.freeXml();
   });
+  it('Should return wellformed & invalid on a wellformed BUT invalid xml FROM STRING XML', function () {
+    let libxml = new Libxml();
+    let testInvalidWfStr = fs.readFileSync('test/data/test-not-valid-dtd.xml');
+    let testInvalidWf = libxml.loadXmlFromString(testInvalidWfStr);
+    libxml.loadDtds(['test/dtd/mydoctype.dtd']);
+    let testInvalid = libxml.validateAgainstDtds(3);
+    expect(testInvalidWf).to.be.true;
+    expect(testInvalid).to.be.false;
+    expect(libxml).to.have.property('validationDtdErrors');
+    expect(libxml.validationDtdErrors).to.be.an('object');
+    expect(libxml.validationDtdErrors['test/dtd/mydoctype.dtd'].length).to.be.equal(3);
+    libxml.freeDtds();
+    libxml.freeXml();
+  });
   // not wellformed
   it('Should return Not Wellformed & invalid on a not wellformed xml', function () {
     let libxml = new Libxml();
