node-sword-interface 1.0.88 → 1.0.90

package/API.md

@@ -79,6 +79,8 @@ This is the main class of node-sword-interface and it provides a set of static f
     * [.isModuleAvailableInRepo(moduleCode)](#NodeSwordInterface+isModuleAvailableInRepo) ⇒ <code>Boolean</code>
     * [.getSwordTranslation(originalString, localeCode)](#NodeSwordInterface+getSwordTranslation)
     * [.getBookAbbreviation(moduleName, bookCode, localeCode)](#NodeSwordInterface+getBookAbbreviation)
+    * [.unTarGZ(filePath, destPath)](#NodeSwordInterface+unTarGZ) ⇒ <code>Boolean</code>
+    * [.unZip(filePath, destPath)](#NodeSwordInterface+unZip) ⇒ <code>Boolean</code>
     * [.getSwordVersion()](#NodeSwordInterface+getSwordVersion) ⇒ <code>String</code>
     * [.getSwordPath()](#NodeSwordInterface+getSwordPath) ⇒ <code>String</code>
 
@@ -643,6 +645,32 @@ Uses the Sword LocaleMgr to translate a book abbreviation.
 | bookCode | <code>String</code> | 
 | localeCode | <code>String</code> | 
 
+<a name="NodeSwordInterface+unTarGZ"></a>
+
+### nodeSwordInterface.unTarGZ(filePath, destPath) ⇒ <code>Boolean</code>
+Extracts a tar.gz file to a destination path.
+
+**Kind**: instance method of [<code>NodeSwordInterface</code>](#NodeSwordInterface)  
+**Returns**: <code>Boolean</code> - True if successful, false otherwise.  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| filePath | <code>String</code> | The path to the tar.gz file. |
+| destPath | <code>String</code> | The destination path where the file should be extracted. |
+
+<a name="NodeSwordInterface+unZip"></a>
+
+### nodeSwordInterface.unZip(filePath, destPath) ⇒ <code>Boolean</code>
+Extracts a zip file to a destination path.
+
+**Kind**: instance method of [<code>NodeSwordInterface</code>](#NodeSwordInterface)  
+**Returns**: <code>Boolean</code> - True if successful, false otherwise.  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| filePath | <code>String</code> | The path to the zip file. |
+| destPath | <code>String</code> | The destination path where the file should be extracted. |
+
 <a name="NodeSwordInterface+getSwordVersion"></a>
 
 ### nodeSwordInterface.getSwordVersion() ⇒ <code>String</code>

package/binding.gyp

@@ -88,6 +88,8 @@
             "src/sword_backend/module_installer.cpp",
             "src/sword_backend/sword_status_reporter.cpp",
             "src/sword_backend/text_processor.cpp",
+            "src/sword_backend/unzip/unzip.c",
+            "src/sword_backend/unzip/ioapi.c",
             "src/napi_module/install_module_worker.cpp",
             "src/napi_module/module_search_worker.cpp",
             "src/napi_module/napi_sword_helper.cpp",

package/index.js

@@ -754,6 +754,26 @@ class NodeSwordInterface {
     return this.nativeInterface.getBookAbbreviation(moduleName, bookCode, localeCode);
   }
 
+  /**
+   * Extracts a tar.gz file to a destination path.
+   * @param {String} filePath - The path to the tar.gz file.
+   * @param {String} destPath - The destination path where the file should be extracted.
+   * @return {Boolean} True if successful, false otherwise.
+   */
+  unTarGZ(filePath, destPath) {
+    return this.nativeInterface.unTarGZ(filePath, destPath);
+  }
+
+  /**
+   * Extracts a zip file to a destination path.
+   * @param {String} filePath - The path to the zip file.
+   * @param {String} destPath - The destination path where the file should be extracted.
+   * @return {Boolean} True if successful, false otherwise.
+   */
+  unZip(filePath, destPath) {
+    return this.nativeInterface.unZip(filePath, destPath);
+  }
+
   /**
    * Returns the version of the SWORD library
    * @return {String} SWORD library version.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-sword-interface",
-  "version": "1.0.88",
+  "version": "1.0.90",
   "description": "Javascript (N-API) interface to SWORD library",
   "keywords": [
     "C++",

package/src/napi_module/node_sword_interface.cpp

@@ -117,7 +117,9 @@ Napi::Object NodeSwordInterface::Init(Napi::Env env, Napi::Object exports)
         InstanceMethod("getSwordTranslation", &NodeSwordInterface::getSwordTranslation),
         InstanceMethod("getBookAbbreviation", &NodeSwordInterface::getBookAbbreviation),
         InstanceMethod("getSwordVersion", &NodeSwordInterface::getSwordVersion),
-        InstanceMethod("getSwordPath", &NodeSwordInterface::getSwordPath)
+        InstanceMethod("getSwordPath", &NodeSwordInterface::getSwordPath),
+        InstanceMethod("unTarGZ", &NodeSwordInterface::unTarGZ),
+        InstanceMethod("unZip", &NodeSwordInterface::unZip)
     });
 
     constructor = Napi::Persistent(func);
@@ -1024,3 +1026,35 @@ Napi::Value NodeSwordInterface::getSwordPath(const Napi::CallbackInfo& info)
     unlockApi();
     return swordPath;
 }
+
+Napi::Value NodeSwordInterface::unTarGZ(const Napi::CallbackInfo& info)
+{
+    Napi::Env env = info.Env();
+    INIT_SCOPE_AND_VALIDATE(ParamType::string, ParamType::string);
+    lockApi();
+
+    string filePath = info[0].As<Napi::String>().Utf8Value();
+    string destPath = info[1].As<Napi::String>().Utf8Value();
+
+    FileSystemHelper fsHelper;
+    bool ret = fsHelper.unTarGZ(filePath, destPath);
+
+    unlockApi();
+    return Napi::Boolean::New(env, ret);
+}
+
+Napi::Value NodeSwordInterface::unZip(const Napi::CallbackInfo& info)
+{
+    Napi::Env env = info.Env();
+    INIT_SCOPE_AND_VALIDATE(ParamType::string, ParamType::string);
+    lockApi();
+
+    string filePath = info[0].As<Napi::String>().Utf8Value();
+    string destPath = info[1].As<Napi::String>().Utf8Value();
+
+    FileSystemHelper fsHelper;
+    bool ret = fsHelper.unZip(filePath, destPath);
+
+    unlockApi();
+    return Napi::Boolean::New(env, ret);
+}

package/src/napi_module/node_sword_interface.hpp

@@ -102,6 +102,8 @@ private:
     Napi::Value getBookAbbreviation(const Napi::CallbackInfo& info);
     Napi::Value getSwordVersion(const Napi::CallbackInfo& info);
     Napi::Value getSwordPath(const Napi::CallbackInfo& info);
+    Napi::Value unTarGZ(const Napi::CallbackInfo& info);
+    Napi::Value unZip(const Napi::CallbackInfo& info);
 
     int validateParams(const Napi::CallbackInfo& info, std::vector<ParamType> paramSpec);
     ModuleType getModuleTypeFromString(std::string moduleTypeString);

package/src/sword_backend/file_system_helper.cpp

@@ -42,6 +42,11 @@
 #include <sstream>
 #include <vector>
 
+#include <zipcomprs.h>
+#include "unzip/unzip.h"
+#include <filemgr.h>
+#include <fcntl.h>
+
 #include "file_system_helper.hpp"
 
 using namespace std;
@@ -402,4 +407,71 @@ void FileSystemHelper::removeDir(std::string dirName)
     remove(path);
 }
 #endif
-#endif
+#endif
+
+bool FileSystemHelper::unTarGZ(std::string filePath, std::string destPath)
+{
+    sword::FileDesc* fd = sword::FileMgr::getSystemFileMgr()->open(filePath.c_str(), sword::FileMgr::RDONLY);
+    if (!fd) {
+        return false;
+    }
+
+    char ret = sword::ZipCompress::unTarGZ(fd->getFd(), destPath.c_str());
+    sword::FileMgr::getSystemFileMgr()->close(fd);
+
+    return (ret == 0);
+}
+
+bool FileSystemHelper::unZip(std::string filePath, std::string destPath)
+{
+    unzFile uf = unzOpen(filePath.c_str());
+    if (uf == NULL) {
+        return false;
+    }
+
+    int err = unzGoToFirstFile(uf);
+    while (err == UNZ_OK) {
+        char filename[256];
+        unz_file_info file_info;
+        err = unzGetCurrentFileInfo(uf, &file_info, filename, sizeof(filename), NULL, 0, NULL, 0);
+
+        if (err != UNZ_OK) break;
+
+        string fullPath = destPath;
+        if (fullPath.back() != '/' && fullPath.back() != '\\') {
+            fullPath += '/';
+        }
+        fullPath += filename;
+
+        // Check if directory
+        size_t filenameLen = strlen(filename);
+        if (filename[filenameLen - 1] == '/') {
+            // Create directory
+            string dummy = fullPath + "dummy";
+            sword::FileMgr::createParent(dummy.c_str());
+        } else {
+            // It's a file
+            sword::FileMgr::createParent(fullPath.c_str());
+            
+            err = unzOpenCurrentFile(uf);
+            if (err == UNZ_OK) {
+                sword::FileDesc* fd = sword::FileMgr::getSystemFileMgr()->open(fullPath.c_str(), sword::FileMgr::WRONLY | sword::FileMgr::CREAT | sword::FileMgr::TRUNC);
+                if (fd) {
+                    char buf[4096];
+                    int readBytes;
+                    while ((readBytes = unzReadCurrentFile(uf, buf, sizeof(buf))) > 0) {
+                        sword::FileMgr::write(fd->getFd(), buf, readBytes);
+                    }
+                    sword::FileMgr::getSystemFileMgr()->close(fd);
+                }
+                unzCloseCurrentFile(uf);
+            }
+        }
+
+        err = unzGoToNextFile(uf);
+    }
+
+    unzClose(uf);
+
+    return true;
+}

package/src/sword_backend/file_system_helper.hpp

@@ -48,6 +48,8 @@ public:
     std::string getUserSwordDir();
     std::string getSystemSwordDir();
     std::vector<std::string> getFilesInDir(std::string dirName);
+    bool unTarGZ(std::string filePath, std::string destPath);
+    bool unZip(std::string filePath, std::string destPath);
     std::string getPathSeparator();
     
     bool fileExists(std::string fileName);

package/src/sword_backend/unzip/ioapi.c

@@ -0,0 +1,257 @@
+/* ioapi.h -- IO base function header for compress/uncompress .zip
+   part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html )
+
+         Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html )
+
+         Modifications for Zip64 support
+         Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )
+
+         For more info read MiniZip_info.txt
+
+*/
+
+#if defined(_WIN32) && (!(defined(_CRT_SECURE_NO_WARNINGS)))
+        #define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#if defined(__APPLE__) || defined(IOAPI_NO_64)
+// In darwin and perhaps other BSD variants off_t is a 64 bit value, hence no need for specific 64 bit functions
+#define FOPEN_FUNC(filename, mode) fopen(filename, mode)
+#define FTELLO_FUNC(stream) ftello(stream)
+#define FSEEKO_FUNC(stream, offset, origin) fseeko(stream, offset, origin)
+#else
+#define FOPEN_FUNC(filename, mode) fopen64(filename, mode)
+#define FTELLO_FUNC(stream) ftello64(stream)
+#define FSEEKO_FUNC(stream, offset, origin) fseeko64(stream, offset, origin)
+#endif
+
+
+#include "ioapi.h"
+
+voidpf call_zopen64 (const zlib_filefunc64_32_def* pfilefunc,const void*filename,int mode)
+{
+    if (pfilefunc->zfile_func64.zopen64_file != NULL)
+        return (*(pfilefunc->zfile_func64.zopen64_file)) (pfilefunc->zfile_func64.opaque,filename,mode);
+    else
+    {
+        return (*(pfilefunc->zopen32_file))(pfilefunc->zfile_func64.opaque,(const char*)filename,mode);
+    }
+}
+
+long call_zseek64 (const zlib_filefunc64_32_def* pfilefunc,voidpf filestream, ZPOS64_T offset, int origin)
+{
+    if (pfilefunc->zfile_func64.zseek64_file != NULL)
+        return (*(pfilefunc->zfile_func64.zseek64_file)) (pfilefunc->zfile_func64.opaque,filestream,offset,origin);
+    else
+    {
+        uLong offsetTruncated = (uLong)offset;
+        if (offsetTruncated != offset)
+            return -1;
+        else
+            return (*(pfilefunc->zseek32_file))(pfilefunc->zfile_func64.opaque,filestream,offsetTruncated,origin);
+    }
+}
+
+ZPOS64_T call_ztell64 (const zlib_filefunc64_32_def* pfilefunc,voidpf filestream)
+{
+    if (pfilefunc->zfile_func64.zseek64_file != NULL)
+        return (*(pfilefunc->zfile_func64.ztell64_file)) (pfilefunc->zfile_func64.opaque,filestream);
+    else
+    {
+        uLong tell_uLong = (uLong)(*(pfilefunc->ztell32_file))(pfilefunc->zfile_func64.opaque,filestream);
+        if ((tell_uLong) == MAXU32)
+            return (ZPOS64_T)-1;
+        else
+            return tell_uLong;
+    }
+}
+
+void fill_zlib_filefunc64_32_def_from_filefunc32(zlib_filefunc64_32_def* p_filefunc64_32,const zlib_filefunc_def* p_filefunc32)
+{
+    p_filefunc64_32->zfile_func64.zopen64_file = NULL;
+    p_filefunc64_32->zopen32_file = p_filefunc32->zopen_file;
+    p_filefunc64_32->zfile_func64.zerror_file = p_filefunc32->zerror_file;
+    p_filefunc64_32->zfile_func64.zread_file = p_filefunc32->zread_file;
+    p_filefunc64_32->zfile_func64.zwrite_file = p_filefunc32->zwrite_file;
+    p_filefunc64_32->zfile_func64.ztell64_file = NULL;
+    p_filefunc64_32->zfile_func64.zseek64_file = NULL;
+    p_filefunc64_32->zfile_func64.zclose_file = p_filefunc32->zclose_file;
+    p_filefunc64_32->zfile_func64.zerror_file = p_filefunc32->zerror_file;
+    p_filefunc64_32->zfile_func64.opaque = p_filefunc32->opaque;
+    p_filefunc64_32->zseek32_file = p_filefunc32->zseek_file;
+    p_filefunc64_32->ztell32_file = p_filefunc32->ztell_file;
+}
+
+
+
+static voidpf  ZCALLBACK fopen_file_func OF((voidpf opaque, const char* filename, int mode));
+static uLong   ZCALLBACK fread_file_func OF((voidpf opaque, voidpf stream, void* buf, uLong size));
+static uLong   ZCALLBACK fwrite_file_func OF((voidpf opaque, voidpf stream, const void* buf,uLong size));
+static ZPOS64_T ZCALLBACK ftell64_file_func OF((voidpf opaque, voidpf stream));
+static long    ZCALLBACK fseek64_file_func OF((voidpf opaque, voidpf stream, ZPOS64_T offset, int origin));
+static int     ZCALLBACK fclose_file_func OF((voidpf opaque, voidpf stream));
+static int     ZCALLBACK ferror_file_func OF((voidpf opaque, voidpf stream));
+
+static voidpf ZCALLBACK fopen_file_func (voidpf opaque, const char* filename, int mode)
+{
+    (void)opaque;
+    FILE* file = NULL;
+    const char* mode_fopen = NULL;
+    if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ)
+        mode_fopen = "rb";
+    else
+    if (mode & ZLIB_FILEFUNC_MODE_EXISTING)
+        mode_fopen = "r+b";
+    else
+    if (mode & ZLIB_FILEFUNC_MODE_CREATE)
+        mode_fopen = "wb";
+
+    if ((filename!=NULL) && (mode_fopen != NULL))
+        file = fopen(filename, mode_fopen);
+    return file;
+}
+
+static voidpf ZCALLBACK fopen64_file_func (voidpf opaque, const void* filename, int mode)
+{
+    (void)opaque;
+    FILE* file = NULL;
+    const char* mode_fopen = NULL;
+    if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ)
+        mode_fopen = "rb";
+    else
+    if (mode & ZLIB_FILEFUNC_MODE_EXISTING)
+        mode_fopen = "r+b";
+    else
+    if (mode & ZLIB_FILEFUNC_MODE_CREATE)
+        mode_fopen = "wb";
+
+    if ((filename!=NULL) && (mode_fopen != NULL))
+        file = FOPEN_FUNC((const char*)filename, mode_fopen);
+    return file;
+}
+
+
+static uLong ZCALLBACK fread_file_func (voidpf opaque, voidpf stream, void* buf, uLong size)
+{
+    (void)opaque;
+    uLong ret;
+    ret = (uLong)fread(buf, 1, (size_t)size, (FILE *)stream);
+    return ret;
+}
+
+static uLong ZCALLBACK fwrite_file_func (voidpf opaque, voidpf stream, const void* buf, uLong size)
+{
+    (void)opaque;
+    uLong ret;
+    ret = (uLong)fwrite(buf, 1, (size_t)size, (FILE *)stream);
+    return ret;
+}
+
+static long ZCALLBACK ftell_file_func (voidpf opaque, voidpf stream)
+{
+    (void)opaque;
+    long ret;
+    ret = ftell((FILE *)stream);
+    return ret;
+}
+
+
+static ZPOS64_T ZCALLBACK ftell64_file_func (voidpf opaque, voidpf stream)
+{
+    (void)opaque;
+    ZPOS64_T ret;
+    ret = (ZPOS64_T)FTELLO_FUNC((FILE *)stream);
+    return ret;
+}
+
+static long ZCALLBACK fseek_file_func (voidpf  opaque, voidpf stream, uLong offset, int origin)
+{
+    (void)opaque;
+    int fseek_origin=0;
+    long ret;
+    switch (origin)
+    {
+    case ZLIB_FILEFUNC_SEEK_CUR :
+        fseek_origin = SEEK_CUR;
+        break;
+    case ZLIB_FILEFUNC_SEEK_END :
+        fseek_origin = SEEK_END;
+        break;
+    case ZLIB_FILEFUNC_SEEK_SET :
+        fseek_origin = SEEK_SET;
+        break;
+    default: return -1;
+    }
+    ret = 0;
+    if (fseek((FILE *)stream, (long)offset, fseek_origin) != 0)
+        ret = -1;
+    return ret;
+}
+
+static long ZCALLBACK fseek64_file_func (voidpf  opaque, voidpf stream, ZPOS64_T offset, int origin)
+{
+    (void)opaque;
+    int fseek_origin=0;
+    long ret;
+    switch (origin)
+    {
+    case ZLIB_FILEFUNC_SEEK_CUR :
+        fseek_origin = SEEK_CUR;
+        break;
+    case ZLIB_FILEFUNC_SEEK_END :
+        fseek_origin = SEEK_END;
+        break;
+    case ZLIB_FILEFUNC_SEEK_SET :
+        fseek_origin = SEEK_SET;
+        break;
+    default: return -1;
+    }
+    ret = 0;
+
+    if(FSEEKO_FUNC((FILE *)stream, (long)offset, fseek_origin) != 0)
+                        ret = -1;
+
+    return ret;
+}
+
+
+static int ZCALLBACK fclose_file_func (voidpf opaque, voidpf stream)
+{
+    (void)opaque;
+    int ret;
+    ret = fclose((FILE *)stream);
+    return ret;
+}
+
+static int ZCALLBACK ferror_file_func (voidpf opaque, voidpf stream)
+{
+    (void)opaque;
+    int ret;
+    ret = ferror((FILE *)stream);
+    return ret;
+}
+
+void fill_fopen_filefunc (pzlib_filefunc_def)
+  zlib_filefunc_def* pzlib_filefunc_def;
+{
+    pzlib_filefunc_def->zopen_file = fopen_file_func;
+    pzlib_filefunc_def->zread_file = fread_file_func;
+    pzlib_filefunc_def->zwrite_file = fwrite_file_func;
+    pzlib_filefunc_def->ztell_file = ftell_file_func;
+    pzlib_filefunc_def->zseek_file = fseek_file_func;
+    pzlib_filefunc_def->zclose_file = fclose_file_func;
+    pzlib_filefunc_def->zerror_file = ferror_file_func;
+    pzlib_filefunc_def->opaque = NULL;
+}
+
+void fill_fopen64_filefunc (zlib_filefunc64_def*  pzlib_filefunc_def)
+{
+    pzlib_filefunc_def->zopen64_file = fopen64_file_func;
+    pzlib_filefunc_def->zread_file = fread_file_func;
+    pzlib_filefunc_def->zwrite_file = fwrite_file_func;
+    pzlib_filefunc_def->ztell64_file = ftell64_file_func;
+    pzlib_filefunc_def->zseek64_file = fseek64_file_func;
+    pzlib_filefunc_def->zclose_file = fclose_file_func;
+    pzlib_filefunc_def->zerror_file = ferror_file_func;
+    pzlib_filefunc_def->opaque = NULL;
+}