node-sword-interface 1.0.41 → 1.0.42

package/.github/workflows/build.yml

@@ -10,9 +10,9 @@ jobs:
         - uses: actions/checkout@v2
         - uses: actions/setup-node@v2
           with:
-            node-version: '14'
+            node-version: '18'
 
-        - run: sudo apt update && sudo apt install -y libcurl4-gnutls-dev
+        - run: sudo apt update && sudo apt install -y libcurl4-gnutls-dev subversion
         - run: npm install
         - run: npm run doc
     
@@ -25,7 +25,7 @@ jobs:
         - uses: actions/checkout@v2
         - uses: actions/setup-node@v2
           with:
-            node-version: '14'
+            node-version: '18'
 
         - run: npm install --arch=ia32
         - run: npm run doc

package/package.json

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

package/src/sword_backend/module_search.cpp

@@ -101,21 +101,24 @@ inline bool isDisallowedCharacter(char c) {
     return disallowedPunctuation.find(c) != string::npos;
 }
 
-vector<Verse> ModuleSearch::getModuleSearchResults(string moduleName,
-                                                   string searchTerm,
-                                                   SearchType searchType,
-                                                   SearchScope searchScope,
-                                                   bool isCaseSensitive,
-                                                   bool useExtendedVerseBoundaries,
-                                                   bool filterOnWordBoundaries)
+bool ModuleSearch::validateSearchParameters(SWModule* module, const string& searchTerm)
+{
+    if (module == 0) {
+        cerr << "ModuleSearch::getModuleSearchResults: getLocalModule returned zero pointer for " << _currentModuleName << endl;
+        return false;
+    } 
+    
+    if (searchTerm == "") {
+        cerr << "ModuleSearch::getModuleSearchResults: cannot work with empty search term!" << endl;
+        return false;
+    }
+
+    return true;
+}
+
+int ModuleSearch::getSearchFlags(bool isCaseSensitive, bool useExtendedVerseBoundaries)
 {
-    this->_currentModuleName = moduleName;
-    SWModule* module = this->_moduleStore.getSearchSwMgr()->getModule(moduleName.c_str());
-    ListKey listKey;
-    SWKey* scope = 0;
     int flags = 0;
-    vector<Verse> searchResults;
-    vector<string> searchResultReferences;
 
     if (!isCaseSensitive) {
         flags |= REG_ICASE;
@@ -125,126 +128,207 @@ vector<Verse> ModuleSearch::getModuleSearchResults(string moduleName,
         flags |= SWModule::SEARCHFLAG_STRICTBOUNDARIES;
     }
 
-    if (module == 0) {
-        cerr << "ModuleSearch::getModuleSearchResults: getLocalModule returned zero pointer for " << moduleName << endl;
-    } else if (searchTerm == "") {
-        cerr << "ModuleSearch::getModuleSearchResults: cannot work with empty search term!" << endl;
-    } else {
-        ListKey scopeKey;
+    return flags;
+}
 
-        if (searchScope != SearchScope::BIBLE) {
-            scopeKey = this->getScopeKey(module, searchScope);
-            scope = &scopeKey;
+string ModuleSearch::prepareStrongsSearchTerm(string searchTerm, SearchType searchType, SWModule* module)
+{
+    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)) {
+            searchTerm = "H0" + strongsNumber;
         }
+    } else if (searchTerm[0] == 'G') {
+        if (this->_textProcessor.moduleHasStrongsPaddedZeroPrefixes(module)) {
+            string paddedStrongsNumber = this->_textProcessor.padStrongsNumber(strongsNumber);
+            searchTerm = "G" + paddedStrongsNumber;
+        }
+    }
 
-        bool hasStrongs = this->_moduleHelper.moduleHasGlobalOption(module, "Strongs");
-        bool moduleMarkupIsBroken = this->_moduleHelper.isBrokenMarkupModule(moduleName);
-        bool hasInconsistentClosingEndDivs = this->_moduleHelper.isInconsistentClosingEndDivModule(moduleName);
-
-        if (searchType == SearchType::strongsNumber) {
-            if (!hasStrongs) {
-                return searchResults;
-            }
-
-            string strongsNumber = searchTerm.substr(1, searchTerm.size());
+    return "Word//Lemma./" + searchTerm;
+}
 
-            if (searchTerm[0] == 'H') {
-                if (this->_textProcessor.moduleHasStrongsPaddedZeroPrefixes(module)) {
-                    string paddedStrongsNumber = this->_textProcessor.padStrongsNumber(strongsNumber);
-                    searchTerm = "H" + paddedStrongsNumber;
-                } else if (this->_textProcessor.moduleHasStrongsZeroPrefixes(module)) {
-                    searchTerm = "H0" + strongsNumber;
-                }
-            } else if (searchTerm[0] == 'G') {
-                if (this->_textProcessor.moduleHasStrongsPaddedZeroPrefixes(module)) {
-                    string paddedStrongsNumber = this->_textProcessor.padStrongsNumber(strongsNumber);
-                    searchTerm = "G" + paddedStrongsNumber;
+bool ModuleSearch::phraseSequenceCheck(const vector<string>& words, const vector<string>& searchWords)
+{
+    // For single word searches, sequence doesn't matter
+    if (searchWords.size() <= 1) {
+        return true;
+    }
+    
+    // Iterate through potential starting positions in the verse
+    for (size_t startPos = 0; startPos < words.size(); startPos++) {
+        // Check if this is a match for the first word
+        if (words[startPos] == searchWords[0]) {
+            // See if subsequent words match in sequence
+            bool sequenceMatch = true;
+            for (size_t i = 1; i < searchWords.size(); i++) {
+                size_t nextPos = startPos + i;
+                // Make sure we don't go beyond the verse text
+                if (nextPos >= words.size() || words[nextPos] != searchWords[i]) {
+                    sequenceMatch = false;
+                    break;
                 }
             }
-
-            flags |= SWModule::SEARCHFLAG_MATCHWHOLEENTRY;
-            searchTerm = "Word//Lemma./" + searchTerm;
+            
+            if (sequenceMatch) {
+                return true;
+            }
         }
+    }
+    
+    return false;
+}
+
+vector<string> ModuleSearch::getSearchResultReferences(SWModule* module, ListKey& listKey, 
+                                                       const string& searchTerm, SearchType searchType,
+                                                       bool isCaseSensitive, bool filterOnWordBoundaries,
+                                                       bool hasStrongs, bool hasInconsistentClosingEndDivs,
+                                                       bool moduleMarkupIsBroken)
+{
+    vector<string> filteredReferences;
+    
+    // Disable markup before filtering on word boundaries
+    this->_textProcessor.disableMarkup();
 
-        // Perform search
-        listKey = module->search(searchTerm.c_str(), int(searchType), flags, scope, 0, internalModuleSearchProgressCB);
+    // 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);
+    }
 
-        // Disable markup before filtering on word boundaries
-        this->_textProcessor.disableMarkup();
+    // Split the search term into individual words
+    vector<string> searchWords = StringHelper::split(lowerCaseSearchTerm, " ");
 
-        vector<string> filteredReferences;
+    while (!listKey.popError()) {
+        module->setKey(listKey.getElement());
+        string verseText = this->_textProcessor.getCurrentVerseText(module,
+                                                                    hasStrongs,
+                                                                    hasInconsistentClosingEndDivs,
+                                                                    moduleMarkupIsBroken);
 
-        // Make the search term lower case if case sensitivity is not required
-        string lowerCaseSearchTerm = searchTerm;
+        // Make the verse text lower case if case sensitivity is not required
+        string lowerCaseVerseText = verseText;
         if (!isCaseSensitive) {
-            std::transform(lowerCaseSearchTerm.begin(), lowerCaseSearchTerm.end(), lowerCaseSearchTerm.begin(), ::tolower);
+            std::transform(lowerCaseVerseText.begin(), lowerCaseVerseText.end(), lowerCaseVerseText.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);
-
-            // 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 (filterOnWordBoundaries) {
-                // Replace disallowed characters with spaces
-                std::replace_if(lowerCaseVerseText.begin(), lowerCaseVerseText.end(),
-                                [](char c) { return isDisallowedCharacter(c); }, ' ');
-
-                vector<string> words = StringHelper::split(lowerCaseVerseText, " ");
+            bool correctOrder = true;
 
-                // 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 (searchType == SearchType::phrase && allPartsMatch) {
+                correctOrder = phraseSequenceCheck(words, searchWords);
+            }
 
-                if (allPartsMatch) {
-                    filteredReferences.push_back(module->getKey()->getShortText());
-                }
-            } else {
+            if (allPartsMatch && correctOrder) {
                 filteredReferences.push_back(module->getKey()->getShortText());
             }
-
-            listKey++;
+        } else {
+            // If not filtering on word boundaries, we simply push the reference
+            filteredReferences.push_back(module->getKey()->getShortText());
         }
 
-        // Enable markup again after word boundary filtering
-        this->_textProcessor.enableMarkup();
+        listKey++;
+    }
+
+    // Enable markup again after word boundary filtering
+    this->_textProcessor.enableMarkup();
+    
+    return filteredReferences;
+}
+
+vector<Verse> ModuleSearch::createVersesFromReferences(SWModule* module, const vector<string>& references,
+                                                       bool hasStrongs, bool hasInconsistentClosingEndDivs,
+                                                       bool moduleMarkupIsBroken)
+{
+    vector<Verse> verses;
+    map<string, int> absoluteVerseNumbers = this->_moduleHelper.getAbsoluteVerseNumberMap(module);
+
+    for (const auto& reference : references) {
+        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;
+
+        verses.push_back(currentVerse);
+    }
+    
+    return verses;
+}
+
+vector<Verse> ModuleSearch::getModuleSearchResults(string moduleName,
+                                                   string searchTerm,
+                                                   SearchType searchType,
+                                                   SearchScope searchScope,
+                                                   bool isCaseSensitive,
+                                                   bool useExtendedVerseBoundaries,
+                                                   bool filterOnWordBoundaries)
+{
+    this->_currentModuleName = moduleName;
+    SWModule* module = this->_moduleStore.getSearchSwMgr()->getModule(moduleName.c_str());
+    ListKey listKey;
+    SWKey* scope = 0;
+    vector<Verse> searchResults;
+
+    if (!validateSearchParameters(module, searchTerm)) {
+        return searchResults;
+    }
 
-        map<string, int> absoluteVerseNumbers = this->_moduleHelper.getAbsoluteVerseNumberMap(module);
+    int flags = getSearchFlags(isCaseSensitive, useExtendedVerseBoundaries);
 
-        // Populate searchResults vector
-        for (const auto& reference : filteredReferences) {
-            module->setKey(reference.c_str());
-            string verseText = this->_textProcessor.getCurrentVerseText(module,
-                                                                        hasStrongs,
-                                                                        hasInconsistentClosingEndDivs,
-                                                                        moduleMarkupIsBroken);
+    ListKey scopeKey;
 
-            Verse currentVerse;
-            currentVerse.reference = reference;
-            currentVerse.absoluteVerseNumber = absoluteVerseNumbers[reference];
-            currentVerse.content = verseText;
+    if (searchScope != SearchScope::BIBLE) {
+        scopeKey = this->getScopeKey(module, searchScope);
+        scope = &scopeKey;
+    }
 
-            searchResults.push_back(currentVerse);
-        }
+    bool hasStrongs = this->_moduleHelper.moduleHasGlobalOption(module, "Strongs");
+    bool moduleMarkupIsBroken = this->_moduleHelper.isBrokenMarkupModule(moduleName);
+    bool hasInconsistentClosingEndDivs = this->_moduleHelper.isInconsistentClosingEndDivModule(moduleName);
+
+    if (searchType == SearchType::strongsNumber && hasStrongs) {
+        searchTerm = prepareStrongsSearchTerm(searchTerm, searchType, module);
+        flags |= SWModule::SEARCHFLAG_MATCHWHOLEENTRY;
     }
 
+    // Perform search
+    listKey = module->search(searchTerm.c_str(), int(searchType), flags, scope, 0, internalModuleSearchProgressCB);
+
+    // Get search result references while considering the word boundary filter option
+    vector<string> filteredReferences = getSearchResultReferences(module, listKey, searchTerm, searchType, 
+                                                                  isCaseSensitive, filterOnWordBoundaries, 
+                                                                  hasStrongs, hasInconsistentClosingEndDivs, 
+                                                                  moduleMarkupIsBroken);
+
+    searchResults = createVersesFromReferences(module, filteredReferences, hasStrongs, 
+                                               hasInconsistentClosingEndDivs, moduleMarkupIsBroken);
+
     this->_currentModuleName = "";
 
     return searchResults;

package/src/sword_backend/module_search.hpp

@@ -67,6 +67,19 @@ public:
 
 private:
     sword::ListKey getScopeKey(sword::SWModule* module, SearchScope scope);
+    
+    bool validateSearchParameters(sword::SWModule* module, const std::string& searchTerm);
+    int getSearchFlags(bool isCaseSensitive, bool useExtendedVerseBoundaries);
+    std::string prepareStrongsSearchTerm(std::string searchTerm, SearchType searchType, sword::SWModule* module);
+    std::vector<std::string> getSearchResultReferences(sword::SWModule* module, sword::ListKey& listKey, 
+                                                       const std::string& searchTerm, SearchType searchType,
+                                                       bool isCaseSensitive, bool filterOnWordBoundaries, 
+                                                       bool hasStrongs, bool hasInconsistentClosingEndDivs, 
+                                                       bool moduleMarkupIsBroken);
+    std::vector<Verse> createVersesFromReferences(sword::SWModule* module, const std::vector<std::string>& references,
+                                                  bool hasStrongs, bool hasInconsistentClosingEndDivs, 
+                                                  bool moduleMarkupIsBroken);
+    bool phraseSequenceCheck(const std::vector<std::string>& words, const std::vector<std::string>& searchWords);
 
     ModuleStore& _moduleStore;
     ModuleHelper& _moduleHelper;