imp: readding loadDtds function

Author: Nagyjano

libxml-syntax-error.cpp

@@ -60,4 +60,14 @@ void XmlSyntaxError::PushToArray(void *errs, xmlError *error)
   }
   Napi::Value castedError = {XmlSyntaxError::BuildSyntaxError(error, *XmlSyntaxError::env)};
   errors.Set(errors.Length(), castedError);
+}
+
+void XmlSyntaxError::PushToArray(Napi::Array& errors, const char* errorMessage)
+{
+  if (errors.Length() >= maxError)
+  {
+    return;
+  }
+  Napi::String messageToPush = Napi::String::New(*XmlSyntaxError::env, errorMessage);
+  errors.Set(errors.Length(), messageToPush);
 }

libxml-syntax-error.h

@@ -13,10 +13,11 @@ class XmlSyntaxError
   static Napi::Env* env;
   static void ChangeMaxNumberOfError(int max);
 
-  // push xmlError onto v8::Array
+  // push xmlError onto Napi::Array
   static void PushToArray(void *errs, xmlError *error);
+  static void PushToArray(Napi::Array& errs, const char* errorMessage);
 
-  // create a v8 object for the syntax eror
+  // create a Napi object for the syntax eror
   static Napi::Value BuildSyntaxError(xmlError *error, Napi::Env env);
 };
 

libxml.cpp

@@ -14,6 +14,7 @@ Napi::Object Libxml::Init(Napi::Env env, Napi::Object exports)
   Napi::Function func = DefineClass(env, "Libxml", {
     InstanceMethod("loadXml", &Libxml::loadXml),
     InstanceMethod("loadXmlFromString", &Libxml::loadXmlFromString),
+    InstanceMethod("loadDtds", &Libxml::loadDtds),
     InstanceMethod("getDtd", &Libxml::getDtd),
     InstanceMethod("freeXml", &Libxml::freeXml)
     });
@@ -118,6 +119,47 @@ Napi::Value Libxml::loadXmlFromString(const Napi::CallbackInfo& info) {
   return Napi::Boolean::New(env, true);
 }
 
+Napi::Value Libxml::loadDtds(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 1){
+    Napi::TypeError::New(env, "loadDtds requires at least 1 argument, an array of DTDs").ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+  if(!info[0].IsArray()){
+    Napi::TypeError::New(env, "loadDtds requires an array").ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+  Napi::EscapableHandleScope scope(env);
+  Napi::Array dtdPaths = info[0].As<Napi::Array>();
+  Napi::Array errors = Napi::Array::New(env);
+  xmlResetLastError();
+  XmlSyntaxError::env = &env;
+  xmlSetStructuredErrorFunc(reinterpret_cast<void*>(&errors),
+                            XmlSyntaxError::PushToArray);
+  for (unsigned int i = 0; i < dtdPaths.Length(); i++){
+    //Skip elements silently which are not strings
+    if(dtdPaths.Get(i).IsString()) {
+      std::string dtdPath = dtdPaths.Get(i).ToString().Utf8Value();
+      xmlChar* pathDTDCasted = xmlCharStrdup(dtdPath.c_str());
+      xmlDtdPtr dtd =  xmlParseDTD(NULL, pathDTDCasted);
+      if (dtd == nullptr) {
+        //DTD is bad, we set error and not assign it
+        XmlSyntaxError::PushToArray(errors, dtdPath.c_str());
+        continue;
+      }
+      this->dtdsPaths.push_back(dtd);
+    }
+  }
+  xmlSetStructuredErrorFunc(nullptr, nullptr);
+  // We set dtdsLoadedErrors property for js side
+  if(errors.Length()){
+    this->Value().Set("dtdsLoadedErrors", errors);
+  } else {
+    this->Value().Delete("dtdsLoadedErrors");
+  }
+  return env.Undefined();
+}
+
 Napi::Value Libxml::getDtd(const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
   Napi::HandleScope scope(env);

libxml.h

@@ -40,7 +40,7 @@ class Libxml : public Napi::ObjectWrap<Libxml>
   static Napi::FunctionReference constructor;
   Napi::Value loadXml(const Napi::CallbackInfo &info);
   Napi::Value loadXmlFromString(const Napi::CallbackInfo& info);
-  // static Napi::Value loadDtds(const Napi::CallbackInfo& info);
+  Napi::Value loadDtds(const Napi::CallbackInfo& info);
   // // static Napi::Value loadDtdsFromString(const Napi::CallbackInfo& info);
   // static Napi::Value loadSchemas(const Napi::CallbackInfo& info);
   // static Napi::Value validateAgainstDtds(const Napi::CallbackInfo& info);

test/libxml-test.js

@@ -5,15 +5,15 @@ 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 () {
-  //   let libxml = new Libxml();
-  //   libxml.loadDtds(['test/dtd/mydoctype-not-existing.dtd']);
-  //   expect(libxml).to.have.a.property('dtdsLoadedErrors');
-  //   expect(libxml.dtdsLoadedErrors).to.be.a('array');
-  //   expect(libxml.dtdsLoadedErrors).to.include('test/dtd/mydoctype-not-existing.dtd');
-  //   libxml.freeXml();
-  //   libxml.freeDtds();
-  // });
+  it('Should return a list of errored path if dtd path is bad', function () {
+    let libxml = new Libxml();
+    libxml.loadDtds(['test/dtd/mydoctype-not-existing.dtd']);
+    expect(libxml).to.have.a.property('dtdsLoadedErrors');
+    expect(libxml.dtdsLoadedErrors).to.be.a('array');
+    expect(libxml.dtdsLoadedErrors).to.include('test/dtd/mydoctype-not-existing.dtd');
+    libxml.freeXml();
+    // libxml.freeDtds();
+  });
   // Wellformed & valid
   // it('Should return wellformed & valid on a wellformed & valid xml', function () {
   //   let libxml = new Libxml();