node-sword-interface 0.238.0 → 0.242.0

package/API.md

@@ -61,7 +61,7 @@ This is the main class of node-sword-interface and it provides a set of static f
     * [.getBibleText(moduleCode)](#NodeSwordInterface+getBibleText) ⇒ [<code>Array.&lt;VerseObject&gt;</code>](#VerseObject)
     * [.getBookIntroduction(moduleCode, bookCode)](#NodeSwordInterface+getBookIntroduction) ⇒ <code>String</code>
     * [.moduleHasBook(moduleCode, bookCode)](#NodeSwordInterface+moduleHasBook) ⇒ <code>Boolean</code>
-    * [.getModuleSearchResults(moduleCode, searchTerm, progressCB, searchType, isCaseSensitive, useExtendedVerseBoundaries)](#NodeSwordInterface+getModuleSearchResults) ⇒ <code>Promise</code>
+    * [.getModuleSearchResults(moduleCode, searchTerm, progressCB, searchType, searchScope, isCaseSensitive, useExtendedVerseBoundaries)](#NodeSwordInterface+getModuleSearchResults) ⇒ <code>Promise</code>
     * [.terminateModuleSearch()](#NodeSwordInterface+terminateModuleSearch)
     * [.hebrewStrongsAvailable()](#NodeSwordInterface+hebrewStrongsAvailable) ⇒ <code>Boolean</code>
     * [.greekStrongsAvailable()](#NodeSwordInterface+greekStrongsAvailable) ⇒ <code>Boolean</code>
@@ -73,6 +73,7 @@ This is the main class of node-sword-interface and it provides a set of static f
     * [.getSwordTranslation(originalString, localeCode)](#NodeSwordInterface+getSwordTranslation)
     * [.getBookAbbreviation(moduleName, bookCode, localeCode)](#NodeSwordInterface+getBookAbbreviation)
     * [.getSwordVersion()](#NodeSwordInterface+getSwordVersion) ⇒ <code>String</code>
+    * [.getSwordPath()](#NodeSwordInterface+getSwordPath) ⇒ <code>String</code>
 
 <a name="NodeSwordInterface+repositoryConfigExisting"></a>
 
@@ -447,7 +448,7 @@ Checks whether a module has a certain book
 
 <a name="NodeSwordInterface+getModuleSearchResults"></a>
 
-### nodeSwordInterface.getModuleSearchResults(moduleCode, searchTerm, progressCB, searchType, isCaseSensitive, useExtendedVerseBoundaries) ⇒ <code>Promise</code>
+### nodeSwordInterface.getModuleSearchResults(moduleCode, searchTerm, progressCB, searchType, searchScope, isCaseSensitive, useExtendedVerseBoundaries) ⇒ <code>Promise</code>
 Returns the results of a module search.
 
 **Kind**: instance method of [<code>NodeSwordInterface</code>](#NodeSwordInterface)  
@@ -458,6 +459,7 @@ Returns the results of a module search.
 | searchTerm | <code>String</code> |  | The term to search for. |
 | progressCB | <code>function</code> |  | Optional callback function that is called on progress events. |
 | searchType | <code>String</code> | <code>phrase</code> | Options: phrase, multiWord, strongsNumber |
+| searchScope | <code>String</code> | <code>BIBLE</code> | Options: BIBLE, OT, NT |
 | isCaseSensitive | <code>Boolean</code> | <code>false</code> | Whether the search is case sensitive |
 | useExtendedVerseBoundaries | <code>Boolean</code> | <code>false</code> | Whether the search should use extended verse boundaries (Two verses instead of one) in case of a multi word search. |
 
@@ -563,6 +565,13 @@ Returns the version of the SWORD library
 
 **Kind**: instance method of [<code>NodeSwordInterface</code>](#NodeSwordInterface)  
 **Returns**: <code>String</code> - SWORD library version.  
+<a name="NodeSwordInterface+getSwordPath"></a>
+
+### nodeSwordInterface.getSwordPath() ⇒ <code>String</code>
+Returns the platform-specific path where SWORD accesses and stores its modules.
+
+**Kind**: instance method of [<code>NodeSwordInterface</code>](#NodeSwordInterface)  
+**Returns**: <code>String</code> - Platform-specific SWORD path.  
 <a name="VerseObject"></a>
 
 ## VerseObject : <code>Object</code>

package/index.js

@@ -459,20 +459,33 @@ class NodeSwordInterface {
    * @param {String} searchTerm - The term to search for.
    * @param {Function} progressCB - Optional callback function that is called on progress events.
    * @param {String} searchType - Options: phrase, multiWord, strongsNumber
+   * @param {String} searchScope - Options: BIBLE, OT, NT
    * @param {Boolean} isCaseSensitive - Whether the search is case sensitive
    * @param {Boolean} useExtendedVerseBoundaries - Whether the search should use extended verse boundaries (Two verses instead of one) in case of a multi word search.
    * @return {Promise}
    */
-  getModuleSearchResults(moduleCode, searchTerm, progressCB=undefined, searchType="phrase", isCaseSensitive=false, useExtendedVerseBoundaries=false) {
+  getModuleSearchResults(moduleCode,
+                         searchTerm,
+                         progressCB=undefined,
+                         searchType="phrase",
+                         searchScope="BIBLE",
+                         isCaseSensitive=false,
+                         useExtendedVerseBoundaries=false) {
+
     if (progressCB === undefined) {
       progressCB = function(progress) {};
     }
 
     return new Promise((resolve, reject) => {
       try {
-        this.nativeInterface.getModuleSearchResults(moduleCode, searchTerm, searchType, isCaseSensitive, useExtendedVerseBoundaries, progressCB, function(searchResults) {
-          resolve(searchResults);
-        });
+        this.nativeInterface.getModuleSearchResults(moduleCode,
+                                                    searchTerm,
+                                                    searchType,
+                                                    searchScope,
+                                                    isCaseSensitive,
+                                                    useExtendedVerseBoundaries,
+                                                    progressCB,
+                                                    function(searchResults) { resolve(searchResults); });
       } catch (error) {
         reject(error);
       }
@@ -584,6 +597,14 @@ class NodeSwordInterface {
   getSwordVersion() {
     return this.nativeInterface.getSwordVersion();
   }
+
+  /**
+   * Returns the platform-specific path where SWORD accesses and stores its modules.
+   * @returns {String} Platform-specific SWORD path.
+   */
+  getSwordPath() {
+    return this.nativeInterface.getSwordPath();
+  }
 }
 
 module.exports = NodeSwordInterface;

package/package.json

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

package/src/napi_module/module_search_worker.cpp

@@ -35,6 +35,7 @@ void ModuleSearchWorker::Execute(const ExecutionProgress& progress)
     this->_stdSearchResults = this->_moduleSearch.getModuleSearchResults(this->_moduleName,
                                                                          this->_searchTerm,
                                                                          this->_searchType,
+                                                                         this->_searchScope,
                                                                          this->_isCaseSensitive,
                                                                          this->_useExtendedVerseBoundaries);
     

package/src/napi_module/module_search_worker.hpp

@@ -36,6 +36,7 @@ public:
                        std::string moduleName,
                        std::string searchTerm,
                        SearchType searchType,
+                       SearchScope searchScope,
                        bool isCaseSensitive=false,
                        bool useExtendedVerseBoundaries=false)
 
@@ -45,6 +46,7 @@ public:
         _moduleName(moduleName),
         _searchTerm(searchTerm),
         _searchType(searchType),
+        _searchScope(searchScope),
         _isCaseSensitive(isCaseSensitive),
         _useExtendedVerseBoundaries(useExtendedVerseBoundaries),
         _searchTerminated(false) {
@@ -66,6 +68,7 @@ private:
     std::string _moduleName;
     std::string _searchTerm;
     SearchType _searchType;
+    SearchScope _searchScope;
     bool _isCaseSensitive;
     bool _useExtendedVerseBoundaries;
     bool _searchTerminated;

package/src/napi_module/node_sword_interface.cpp

@@ -111,7 +111,8 @@ Napi::Object NodeSwordInterface::Init(Napi::Env env, Napi::Object exports)
         InstanceMethod("isModuleReadable", &NodeSwordInterface::isModuleReadable),
         InstanceMethod("getSwordTranslation", &NodeSwordInterface::getSwordTranslation),
         InstanceMethod("getBookAbbreviation", &NodeSwordInterface::getBookAbbreviation),
-        InstanceMethod("getSwordVersion", &NodeSwordInterface::getSwordVersion)
+        InstanceMethod("getSwordVersion", &NodeSwordInterface::getSwordVersion),
+        InstanceMethod("getSwordPath", &NodeSwordInterface::getSwordPath)
     });
 
     constructor = Napi::Persistent(func);
@@ -695,6 +696,7 @@ Napi::Value NodeSwordInterface::getModuleSearchResults(const Napi::CallbackInfo&
     INIT_SCOPE_AND_VALIDATE(ParamType::string, // moduleName
                             ParamType::string, // searchTerm
                             ParamType::string, // searchType
+                            ParamType::string, // searchScope
                             ParamType::boolean, // isCaseSensitive
                             ParamType::boolean, // useExtendedVerseBoundaries
                             ParamType::function, // progressCallback
@@ -703,10 +705,11 @@ Napi::Value NodeSwordInterface::getModuleSearchResults(const Napi::CallbackInfo&
     Napi::String moduleName = info[0].As<Napi::String>();
     Napi::String searchTerm = info[1].As<Napi::String>();
     string searchTypeString = string(info[2].As<Napi::String>());
-    Napi::Boolean isCaseSensitive = info[3].As<Napi::Boolean>();
-    Napi::Boolean useExtendedVerseBoundaries = info[4].As<Napi::Boolean>();
-    Napi::Function jsProgressCallback = info[5].As<Napi::Function>();
-    Napi::Function callback = info[6].As<Napi::Function>();
+    string searchScopeString = string(info[3].As<Napi::String>());
+    Napi::Boolean isCaseSensitive = info[4].As<Napi::Boolean>();
+    Napi::Boolean useExtendedVerseBoundaries = info[5].As<Napi::Boolean>();
+    Napi::Function jsProgressCallback = info[6].As<Napi::Function>();
+    Napi::Function callback = info[7].As<Napi::Function>();
     SearchType searchType = SearchType::multiWord;
     
     if (searchTypeString == "phrase") {
@@ -725,6 +728,18 @@ Napi::Value NodeSwordInterface::getModuleSearchResults(const Napi::CallbackInfo&
         }
     }
 
+    SearchScope searchScope = SearchScope::BIBLE;
+
+    if (searchScopeString == "BIBLE") {
+        searchScope = SearchScope::BIBLE;
+    } else if (searchScopeString == "OT") {
+        searchScope = SearchScope::OT;
+    } else if (searchScopeString == "NT") {
+        searchScope = SearchScope::NT;
+    } else {
+        THROW_JS_EXCEPTION("Unknown search scope!");
+    }
+
     this->_currentModuleSearchWorker = new ModuleSearchWorker(*(this->_moduleHelper),
                                                               *(this->_moduleSearch),
                                                               *(this->_moduleStore),
@@ -735,6 +750,7 @@ Napi::Value NodeSwordInterface::getModuleSearchResults(const Napi::CallbackInfo&
                                                               moduleName,
                                                               searchTerm,
                                                               searchType,
+                                                              searchScope,
                                                               isCaseSensitive,
                                                               useExtendedVerseBoundaries);
     this->_currentModuleSearchWorker->Queue();
@@ -928,3 +944,15 @@ Napi::Value NodeSwordInterface::getSwordVersion(const Napi::CallbackInfo& info)
     unlockApi();
     return swVersion;
 }
+
+Napi::Value NodeSwordInterface::getSwordPath(const Napi::CallbackInfo& info)
+{
+    lockApi();
+    Napi::Env env = info.Env();
+    Napi::HandleScope scope(env);
+
+    FileSystemHelper fsHelper;
+    Napi::String swordPath = Napi::String::New(env, fsHelper.getUserSwordDir());
+    unlockApi();
+    return swordPath;
+}

package/src/napi_module/node_sword_interface.hpp

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

package/src/node_sword_cli.cpp

@@ -197,7 +197,7 @@ int main(int argc, char** argv)
 
     //get_strongs_entry(textProcessor);
 
-    get_module_text(textProcessor);
+    //get_module_text(textProcessor);
 
     //get_book_intro(textProcessor);
 
@@ -206,11 +206,11 @@ int main(int argc, char** argv)
     //string translation = sword_facade.getSwordTranslation(string("/usr/share/sword/locales.d"), string("de"), string("locales"));
     //cout << translation << endl;
 
-    /*vector<Verse> searchResults = moduleSearch.getModuleSearchResults("NASB", "Jesus faith", SearchType::multiWord, false, true);
+    vector<Verse> searchResults = moduleSearch.getModuleSearchResults("NASB", "faith", SearchType::multiWord, SearchScope::NT, true);
     cout << "Got " << searchResults.size() << " results!" << endl;
     for (unsigned int i=0; i < searchResults.size(); i++) {
         cout << searchResults[i].reference << endl;
-    }*/
+    }
 
     return 0;
 }

package/src/sword_backend/file_system_helper.cpp

@@ -82,6 +82,13 @@ void FileSystemHelper::createBasicDirectories()
     #endif
 #endif
 
+    if (!this->fileExists(this->getUserDir())) {
+      ret = this->makeDirectory(this->getUserDir());
+      if (ret != 0) {
+        cerr << "Failed to create user dir at " << this->getUserDir() << endl;
+      }
+    }
+
     if (!this->fileExists(this->getUserSwordDir())) {
         ret = this->makeDirectory(this->getUserSwordDir());
         if (ret != 0) {

package/src/sword_backend/module_search.cpp

@@ -50,17 +50,52 @@
 using namespace std;
 using namespace sword;
 
+ListKey ModuleSearch::getScopeKey(SearchScope scope)
+{
+    ListKey key;
+
+    switch (scope) {
+        case SearchScope::OT:
+        {
+            const char* otBooks = "Genesis;Exodus;Leviticus;Numbers;Joshua;Judges;"
+                                  "Ruth;I Samuel;II Samuel;I Kings;II Kings;I Chronicles;II Chronicles;"
+                                  "Ezra;Nehemiah;Esther;Job;Psalms;Proverbs;Ecclesiastes;Song of Solomon;"
+                                  "Isaiah;Jeremiah;Lamentations;Ezekiel;Daniel;Hosea;Joel;Amos;Obadiah;"
+                                  "Jonah;Micah;Nahum;Habakkuk;Zephaniah;Haggai;Zechariah;Malachi;";
+
+            key = VerseKey().parseVerseList(otBooks, "", true);
+            break;
+        }
+        
+        case SearchScope::NT:
+        {
+            const char* ntBooks = "Matthew;Mark;Luke;John;Acts;Romans;I Corinthians;II Corinthians;"
+                                  "Galatians;Ephesians;Philippians;Colossians;I Thessalonians;II Thessalonians;"
+                                  "I Timothy;II Timothy;Titus;Philemon;Hebrews;James;I Peter;II Peter;"
+                                  "I John;II John;III John;Jude;Revelation of John;";
+
+            key = VerseKey().parseVerseList(ntBooks, "", true);
+            break;
+        }
+        
+        default:
+            break;
+    }
+
+    return key;
+}
 
 vector<Verse> ModuleSearch::getModuleSearchResults(string moduleName,
                                                    string searchTerm,
                                                    SearchType searchType,
+                                                   SearchScope searchScope,
                                                    bool isCaseSensitive,
                                                    bool useExtendedVerseBoundaries)
 {
     this->_currentModuleName = moduleName;
     SWModule* module = this->_moduleStore.getLocalModule(moduleName);
     ListKey listKey;
-    ListKey* scope = 0;
+    SWKey* scope = 0;
     int flags = 0;
     // This holds the text that we will return
     vector<Verse> searchResults;
@@ -81,6 +116,13 @@ vector<Verse> ModuleSearch::getModuleSearchResults(string moduleName,
     } else if (searchTerm == "") {
         cerr << "ModuleSearch::getModuleSearchResults: cannot work with empty search term!" << endl;
     } else {
+        ListKey scopeKey;
+
+        if (searchScope != SearchScope::BIBLE) {
+            scopeKey = this->getScopeKey(searchScope);
+            scope = &scopeKey;
+        }
+
         bool hasStrongs = this->_moduleHelper.moduleHasGlobalOption(module, "Strongs");
 
         if (searchType == SearchType::strongsNumber) {

package/src/sword_backend/module_search.hpp

@@ -29,6 +29,7 @@ void internalModuleSearchProgressCB(char percent, void* userData);
 
 namespace sword {
     class SWModule;
+    class ListKey;
 };
 
 enum class SearchType {
@@ -37,6 +38,12 @@ enum class SearchType {
     strongsNumber = -3
 };
 
+enum class SearchScope {
+    BIBLE = 0,
+    OT = 1,
+    NT = 2
+};
+
 class ModuleStore;
 class ModuleHelper;
 class TextProcessor;
@@ -51,12 +58,15 @@ public:
     std::vector<Verse> getModuleSearchResults(std::string moduleName,
                                               std::string searchTerm,
                                               SearchType searchType=SearchType::multiWord,
+                                              SearchScope searchScope=SearchScope::BIBLE,
                                               bool isCaseSensitive=false,
                                               bool useExtendedVerseBoundaries=false);
     
     void terminate();
 
 private:
+    sword::ListKey getScopeKey(SearchScope scope);
+
     ModuleStore& _moduleStore;
     ModuleHelper& _moduleHelper;
     TextProcessor& _textProcessor;

package/src/sword_backend/repository_interface.cpp

@@ -67,6 +67,9 @@ void RepositoryInterface::resetMgr()
 
     this->_installMgr = new InstallMgr(this->_fileSystemHelper.getInstallMgrDir().c_str(), &this->_statusReporter);
     this->_installMgr->setUserDisclaimerConfirmed(true);
+
+    long timeoutMillis = 20000;
+    this->_installMgr->setTimeoutMillis(timeoutMillis);
 }
 
 int RepositoryInterface::refreshRepositoryConfig()