node-sword-interface 1.0.38 → 1.0.40

package/index.js

@@ -331,6 +331,14 @@ class NodeSwordInterface {
     return this.nativeInterface.enableMarkup();
   }
 
+  /**
+   * Disable available markup (like Strongs, foot notes, etc.)
+   * This influences the output for getChapterText, getBookText and getBibleText.
+   */
+  disableMarkup() {
+    return this.nativeInterface.disableMarkup();
+  }
+
   /**
    * Enables rendering of Strongs elements with non-breaking spaces.
    */
@@ -584,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) {};
@@ -606,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.38",
+  "version": "1.0.40",
   "description": "Javascript (N-API) interface to SWORD library",
   "keywords": [
     "C++",

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

@@ -90,6 +90,7 @@ Napi::Object NodeSwordInterface::Init(Napi::Env env, Napi::Object exports)
         InstanceMethod("getModuleDescription", &NodeSwordInterface::getModuleDescription),
         InstanceMethod("getLocalModule", &NodeSwordInterface::getLocalModule),
         InstanceMethod("enableMarkup", &NodeSwordInterface::enableMarkup),
+        InstanceMethod("disableMarkup", &NodeSwordInterface::disableMarkup),
         InstanceMethod("enableStrongsWithNbsp", &NodeSwordInterface::enableStrongsWithNbsp),
         InstanceMethod("getRawModuleEntry", &NodeSwordInterface::getRawModuleEntry),
         InstanceMethod("getReferenceText", &NodeSwordInterface::getReferenceText),
@@ -527,6 +528,16 @@ Napi::Value NodeSwordInterface::enableMarkup(const Napi::CallbackInfo& info)
     return info.Env().Undefined();
 }
 
+Napi::Value NodeSwordInterface::disableMarkup(const Napi::CallbackInfo& info)
+{
+    lockApi();
+    Napi::Env env = info.Env();
+    Napi::HandleScope scope(env);
+    this->_textProcessor->disableMarkup();
+    unlockApi();
+    return info.Env().Undefined();
+}
+
 Napi::Value NodeSwordInterface::enableStrongsWithNbsp(const Napi::CallbackInfo& info)
 {
     lockApi();
@@ -749,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
 
@@ -758,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") {
@@ -802,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/napi_module/node_sword_interface.hpp

@@ -70,6 +70,7 @@ private:
     Napi::Value getLocalModule(const Napi::CallbackInfo& info);
 
     Napi::Value enableMarkup(const Napi::CallbackInfo& info);
+    Napi::Value disableMarkup(const Napi::CallbackInfo& info);
     Napi::Value enableStrongsWithNbsp(const Napi::CallbackInfo& info);
     
     Napi::Value getRawModuleEntry(const Napi::CallbackInfo& info);

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();