node-sword-interface 1.0.39 → 1.0.41

package/.github/workflows/build.yml

@@ -5,7 +5,7 @@ on: push
 jobs:
     build-linux:
         name: Run Linux build
-        runs-on: ubuntu-20.04
+        runs-on: ubuntu-24.04
         steps:
         - uses: actions/checkout@v2
         - uses: actions/setup-node@v2

package/API.md

@@ -50,6 +50,7 @@ This is the main class of node-sword-interface and it provides a set of static f
     * [.isModuleReadable(moduleCode)](#NodeSwordInterface+isModuleReadable) ⇒ <code>Boolean</code>
     * [.getModuleDescription(moduleCode)](#NodeSwordInterface+getModuleDescription) ⇒ <code>String</code>
     * [.enableMarkup()](#NodeSwordInterface+enableMarkup)
+    * [.disableMarkup()](#NodeSwordInterface+disableMarkup)
     * [.enableStrongsWithNbsp()](#NodeSwordInterface+enableStrongsWithNbsp)
     * [.getRawModuleEntry(moduleCode, key)](#NodeSwordInterface+getRawModuleEntry) ⇒ <code>String</code>
     * [.getReferenceText(moduleCode, key)](#NodeSwordInterface+getReferenceText) ⇒ [<code>VerseObject</code>](#VerseObject)
@@ -67,7 +68,7 @@ This is the main class of node-sword-interface and it provides a set of static f
     * [.getBookIntroduction(moduleCode, bookCode)](#NodeSwordInterface+getBookIntroduction) ⇒ <code>String</code>
     * [.moduleHasBook(moduleCode, bookCode)](#NodeSwordInterface+moduleHasBook) ⇒ <code>Boolean</code>
     * [.getDictModuleKeys(moduleCode)](#NodeSwordInterface+getDictModuleKeys) ⇒ <code>Array.&lt;String&gt;</code>
-    * [.getModuleSearchResults(moduleCode, searchTerm, progressCB, searchType, searchScope, isCaseSensitive, useExtendedVerseBoundaries)](#NodeSwordInterface+getModuleSearchResults) ⇒ <code>Promise</code>
+    * [.getModuleSearchResults(moduleCode, searchTerm, progressCB, searchType, searchScope, isCaseSensitive, useExtendedVerseBoundaries, filterOnWordBoundaries)](#NodeSwordInterface+getModuleSearchResults) ⇒ <code>Promise</code>
     * [.terminateModuleSearch()](#NodeSwordInterface+terminateModuleSearch)
     * [.hebrewStrongsAvailable()](#NodeSwordInterface+hebrewStrongsAvailable) ⇒ <code>Boolean</code>
     * [.greekStrongsAvailable()](#NodeSwordInterface+greekStrongsAvailable) ⇒ <code>Boolean</code>
@@ -311,6 +312,13 @@ Returns the description of a module.
 Enables available markup (like Strongs, foot notes, etc.)
 This influences the output for getChapterText, getBookText and getBibleText.
 
+**Kind**: instance method of [<code>NodeSwordInterface</code>](#NodeSwordInterface)  
+<a name="NodeSwordInterface+disableMarkup"></a>
+
+### nodeSwordInterface.disableMarkup()
+Disable available markup (like Strongs, foot notes, etc.)
+This influences the output for getChapterText, getBookText and getBibleText.
+
 **Kind**: instance method of [<code>NodeSwordInterface</code>](#NodeSwordInterface)  
 <a name="NodeSwordInterface+enableStrongsWithNbsp"></a>
 
@@ -524,7 +532,7 @@ Returns the keys of a dictionary module.
 
 <a name="NodeSwordInterface+getModuleSearchResults"></a>
 
-### nodeSwordInterface.getModuleSearchResults(moduleCode, searchTerm, progressCB, searchType, searchScope, isCaseSensitive, useExtendedVerseBoundaries) ⇒ <code>Promise</code>
+### nodeSwordInterface.getModuleSearchResults(moduleCode, searchTerm, progressCB, searchType, searchScope, isCaseSensitive, useExtendedVerseBoundaries, filterOnWordBoundaries) ⇒ <code>Promise</code>
 Returns the results of a module search.
 
 **Kind**: instance method of [<code>NodeSwordInterface</code>](#NodeSwordInterface)  
@@ -538,6 +546,7 @@ Returns the results of a module search.
 | 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. |
+| filterOnWordBoundaries | <code>Boolean</code> | <code>false</code> | Whether to filter results based on word boundaries. |
 
 <a name="NodeSwordInterface+terminateModuleSearch"></a>
 

package/index.js

@@ -592,15 +592,17 @@ class NodeSwordInterface {
    * @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.
+   * @param {Boolean} filterOnWordBoundaries - Whether to filter results based on word boundaries.
    * @return {Promise}
    */
   getModuleSearchResults(moduleCode,
                          searchTerm,
-                         progressCB=undefined,
-                         searchType="phrase",
-                         searchScope="BIBLE",
-                         isCaseSensitive=false,
-                         useExtendedVerseBoundaries=false) {
+                         progressCB = undefined,
+                         searchType = "phrase",
+                         searchScope = "BIBLE",
+                         isCaseSensitive = false,
+                         useExtendedVerseBoundaries = false,
+                         filterOnWordBoundaries = false) {
 
     if (progressCB === undefined) {
       progressCB = function(progress) {};
@@ -614,6 +616,7 @@ class NodeSwordInterface {
                                                     searchScope,
                                                     isCaseSensitive,
                                                     useExtendedVerseBoundaries,
+                                                    filterOnWordBoundaries,
                                                     progressCB,
                                                     function(searchResults) { resolve(searchResults); });
       } catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-sword-interface",
-  "version": "1.0.39",
+  "version": "1.0.41",
   "description": "Javascript (N-API) interface to SWORD library",
   "keywords": [
     "C++",
@@ -31,7 +31,7 @@
     "url": "git+https://github.com/ezra-bible-app/node-sword-interface.git"
   },
   "devDependencies": {
-    "jsdoc-to-markdown": "^8.0.3",
+    "jsdoc-to-markdown": "^9.1.1",
     "node-gyp": "^9.1.0"
   }
 }

package/scripts/get_sword_build_win32.ps1

@@ -34,7 +34,7 @@ $headers = @{}
 $github_token = $env:GITHUB_TOKEN
 
 # --- Set the uri for the release
-$URI = "https://api.github.com/repos/ezra-bible-app/sword-build-win32/releases/tags/v1.9.0-2025-03-03"
+$URI = "https://api.github.com/repos/ezra-bible-app/sword-build-win32/releases/tags/v1.8.900-2022-11-06"
 
 if ($Env:CI -eq "true") {
 		Write-Host "GitHub actions build ... using GITHUB_TOKEN for authentication!"

package/src/napi_module/module_search_worker.cpp

@@ -37,7 +37,8 @@ void ModuleSearchWorker::Execute(const ExecutionProgress& progress)
                                                                          this->_searchType,
                                                                          this->_searchScope,
                                                                          this->_isCaseSensitive,
-                                                                         this->_useExtendedVerseBoundaries);
+                                                                         this->_useExtendedVerseBoundaries,
+                                                                         this->_filterOnWordBoundaries); // Pass the parameter
     
     if (this->_searchTerminated) {
       this->_stdSearchResults.clear();

package/src/napi_module/module_search_worker.hpp

@@ -38,7 +38,8 @@ public:
                        SearchType searchType,
                        SearchScope searchScope,
                        bool isCaseSensitive=false,
-                       bool useExtendedVerseBoundaries=false)
+                       bool useExtendedVerseBoundaries=false,
+                       bool filterOnWordBoundaries=false)
 
         : ProgressWorker(repoInterface, jsProgressCallback, callback),
         _searchMutex(searchMutex),
@@ -49,6 +50,7 @@ public:
         _searchScope(searchScope),
         _isCaseSensitive(isCaseSensitive),
         _useExtendedVerseBoundaries(useExtendedVerseBoundaries),
+        _filterOnWordBoundaries(filterOnWordBoundaries),
         _searchTerminated(false) {
 
         this->_napiSwordHelper = new NapiSwordHelper(moduleHelper, moduleStore);
@@ -71,6 +73,7 @@ private:
     SearchScope _searchScope;
     bool _isCaseSensitive;
     bool _useExtendedVerseBoundaries;
+    bool _filterOnWordBoundaries; // New member variable
     bool _searchTerminated;
 };
 

package/src/napi_module/node_sword_interface.cpp

@@ -760,6 +760,7 @@ Napi::Value NodeSwordInterface::getModuleSearchResults(const Napi::CallbackInfo&
                             ParamType::string, // searchScope
                             ParamType::boolean, // isCaseSensitive
                             ParamType::boolean, // useExtendedVerseBoundaries
+                            ParamType::boolean, // filterOnWordBoundaries
                             ParamType::function, // progressCallback
                             ParamType::function); // final Callback
 
@@ -769,8 +770,9 @@ Napi::Value NodeSwordInterface::getModuleSearchResults(const Napi::CallbackInfo&
     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>();
+    Napi::Boolean filterOnWordBoundaries = info[6].As<Napi::Boolean>();
+    Napi::Function jsProgressCallback = info[7].As<Napi::Function>();
+    Napi::Function callback = info[8].As<Napi::Function>();
     SearchType searchType = SearchType::multiWord;
     
     if (searchTypeString == "phrase") {
@@ -813,7 +815,8 @@ Napi::Value NodeSwordInterface::getModuleSearchResults(const Napi::CallbackInfo&
                                                               searchType,
                                                               searchScope,
                                                               isCaseSensitive,
-                                                              useExtendedVerseBoundaries);
+                                                              useExtendedVerseBoundaries,
+                                                              filterOnWordBoundaries); // Pass the new parameter
     this->_currentModuleSearchWorker->Queue();
     return env.Undefined();
 }

package/src/sword_backend/module_search.cpp

@@ -21,6 +21,8 @@
 #include <string>
 #include <vector>
 #include <algorithm>
+#include <regex>
+#include <sstream>
 
 // sword includes
 #include <swmgr.h>
@@ -32,6 +34,7 @@
 #include "module_store.hpp"
 #include "module_helper.hpp"
 #include "text_processor.hpp"
+#include "string_helper.hpp"
 
 /* REGEX definitions from regex.h */
 /* POSIX `cflags' bits (i.e., information for `regcomp').  */
@@ -93,29 +96,32 @@ ListKey ModuleSearch::getScopeKey(SWModule* module, SearchScope scope)
     return key;
 }
 
+inline bool isDisallowedCharacter(char c) {
+    static const string disallowedPunctuation = ",;.:'´‘’\"“”?!()-=<>/";
+    return disallowedPunctuation.find(c) != string::npos;
+}
+
 vector<Verse> ModuleSearch::getModuleSearchResults(string moduleName,
                                                    string searchTerm,
                                                    SearchType searchType,
                                                    SearchScope searchScope,
                                                    bool isCaseSensitive,
-                                                   bool useExtendedVerseBoundaries)
+                                                   bool useExtendedVerseBoundaries,
+                                                   bool filterOnWordBoundaries)
 {
     this->_currentModuleName = moduleName;
     SWModule* module = this->_moduleStore.getSearchSwMgr()->getModule(moduleName.c_str());
     ListKey listKey;
     SWKey* scope = 0;
     int flags = 0;
-    // This holds the text that we will return
     vector<Verse> searchResults;
     vector<string> searchResultReferences;
 
     if (!isCaseSensitive) {
-        // for case insensitivity
         flags |= REG_ICASE;
     }
 
     if (!useExtendedVerseBoundaries) {
-        // Use strict search boundaries (only search within individual verses). TODO: Make this configurable.
         flags |= SWModule::SEARCHFLAG_STRICTBOUNDARIES;
     }
 
@@ -137,71 +143,106 @@ vector<Verse> ModuleSearch::getModuleSearchResults(string moduleName,
 
         if (searchType == SearchType::strongsNumber) {
             if (!hasStrongs) {
-                // Return immediately if search type is Strong's, but the module does not have Strong's support
                 return searchResults;
             }
 
-            // Cut out the number from the Strong's key (starting at index 1 until end of string)
             string strongsNumber = searchTerm.substr(1, searchTerm.size());
 
             if (searchTerm[0] == 'H') {
-
                 if (this->_textProcessor.moduleHasStrongsPaddedZeroPrefixes(module)) {
                     string paddedStrongsNumber = this->_textProcessor.padStrongsNumber(strongsNumber);
                     searchTerm = "H" + paddedStrongsNumber;
-
                 } else if (this->_textProcessor.moduleHasStrongsZeroPrefixes(module)) {
-                    // If the Strong's key is OT we need to insert a zero in front of the key
-                    // This is necessary because the Sword modules with Strong's have a zero in front of the Hebrew Strong's numbers
-                    // Overwrite the searchTerm with an inserted 0
                     searchTerm = "H0" + strongsNumber;
                 }
-
             } else if (searchTerm[0] == 'G') {
-
                 if (this->_textProcessor.moduleHasStrongsPaddedZeroPrefixes(module)) {
                     string paddedStrongsNumber = this->_textProcessor.padStrongsNumber(strongsNumber);
                     searchTerm = "G" + paddedStrongsNumber;
                 }
             }
 
-            // from swmodule.h api docs:
-            // for use with entryAttrib search type to match whole entry to value, e.g., G1234 and not G12345
             flags |= SWModule::SEARCHFLAG_MATCHWHOLEENTRY;
-
             searchTerm = "Word//Lemma./" + searchTerm;
         }
 
-        map<string, int> absoluteVerseNumbers = this->_moduleHelper.getAbsoluteVerseNumberMap(module);
-
         // Perform search
         listKey = module->search(searchTerm.c_str(), int(searchType), flags, scope, 0, internalModuleSearchProgressCB);
 
-        // Populate searchResults vector
+        // Disable markup before filtering on word boundaries
+        this->_textProcessor.disableMarkup();
+
+        vector<string> filteredReferences;
+
+        // Make the search term lower case if case sensitivity is not required
+        string lowerCaseSearchTerm = searchTerm;
+        if (!isCaseSensitive) {
+            std::transform(lowerCaseSearchTerm.begin(), lowerCaseSearchTerm.end(), lowerCaseSearchTerm.begin(), ::tolower);
+        }
+
+        // Split the search term into individual words
+        vector<string> searchWords = StringHelper::split(lowerCaseSearchTerm, " ");
+
+        // Filter verses based on word boundaries
         while (!listKey.popError()) {
             module->setKey(listKey.getElement());
-
             string verseText = this->_textProcessor.getCurrentVerseText(module,
                                                                         hasStrongs,
                                                                         hasInconsistentClosingEndDivs,
                                                                         moduleMarkupIsBroken);
 
-            string currentReference = module->getKey()->getShortText();
-
-            if (std::find(searchResultReferences.begin(),
-                          searchResultReferences.end(),                         // Only accept the result if we do not
-                          currentReference) == searchResultReferences.end()) {  // have it yet!
-            
-                Verse currentVerse;
-                currentVerse.reference = module->getKey()->getShortText();
-                currentVerse.absoluteVerseNumber = absoluteVerseNumbers[currentVerse.reference];
-                currentVerse.content = verseText;
-                searchResults.push_back(currentVerse);
-                searchResultReferences.push_back(currentReference);
+            // Make the verse text lower case if case sensitivity is not required
+            string lowerCaseVerseText = verseText;
+            if (!isCaseSensitive) {
+                std::transform(lowerCaseVerseText.begin(), lowerCaseVerseText.end(), lowerCaseVerseText.begin(), ::tolower);
+            }
+
+            if (filterOnWordBoundaries) {
+                // Replace disallowed characters with spaces
+                std::replace_if(lowerCaseVerseText.begin(), lowerCaseVerseText.end(),
+                                [](char c) { return isDisallowedCharacter(c); }, ' ');
+
+                vector<string> words = StringHelper::split(lowerCaseVerseText, " ");
+
+                // Check if all parts of the search term match any word in the verse
+                bool allPartsMatch = true;
+                for (const auto& searchWord : searchWords) {
+                    if (std::find(words.begin(), words.end(), searchWord) == words.end()) {
+                        allPartsMatch = false;
+                        break;
+                    }
+                }
+
+                if (allPartsMatch) {
+                    filteredReferences.push_back(module->getKey()->getShortText());
+                }
+            } else {
+                filteredReferences.push_back(module->getKey()->getShortText());
             }
 
             listKey++;
         }
+
+        // Enable markup again after word boundary filtering
+        this->_textProcessor.enableMarkup();
+
+        map<string, int> absoluteVerseNumbers = this->_moduleHelper.getAbsoluteVerseNumberMap(module);
+
+        // Populate searchResults vector
+        for (const auto& reference : filteredReferences) {
+            module->setKey(reference.c_str());
+            string verseText = this->_textProcessor.getCurrentVerseText(module,
+                                                                        hasStrongs,
+                                                                        hasInconsistentClosingEndDivs,
+                                                                        moduleMarkupIsBroken);
+
+            Verse currentVerse;
+            currentVerse.reference = reference;
+            currentVerse.absoluteVerseNumber = absoluteVerseNumbers[reference];
+            currentVerse.content = verseText;
+
+            searchResults.push_back(currentVerse);
+        }
     }
 
     this->_currentModuleName = "";

package/src/sword_backend/module_search.hpp

@@ -60,7 +60,8 @@ public:
                                               SearchType searchType=SearchType::multiWord,
                                               SearchScope searchScope=SearchScope::BIBLE,
                                               bool isCaseSensitive=false,
-                                              bool useExtendedVerseBoundaries=false);
+                                              bool useExtendedVerseBoundaries=false,
+                                              bool filterOnWordBoundaries=false);
     
     void terminate();