node-sword-interface 1.0.16 → 1.0.17

package/package.json

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

package/src/node_sword_cli.cpp

@@ -145,7 +145,9 @@ void test_unlock_key(ModuleInstaller& module_installer, ModuleStore& module_stor
 
 void get_strongs_entry(TextProcessor& text_processor)
 {
-    StrongsEntry* entry = text_processor.getStrongsEntry("G2766");
+    //StrongsEntry* entry = text_processor.getStrongsEntry("G2443");
+    //StrongsEntry* entry = text_processor.getStrongsEntry("G3762");
+    StrongsEntry* entry = text_processor.getStrongsEntry("G4572");
     if (entry != 0) {
         cout << entry->key << endl;
         cout << entry->transcription << endl;
@@ -215,7 +217,7 @@ int main(int argc, char** argv)
     /*sword_facade.installModule("StrongsHebrew");
     sword_facade.installModule("StrongsGreek");*/
 
-    //get_strongs_entry(textProcessor);
+    get_strongs_entry(textProcessor);
 
     //get_module_text(textProcessor);
 
@@ -232,7 +234,7 @@ int main(int argc, char** argv)
         cout << searchResults[i].reference << endl;
     }*/
 
-    get_updated_repo_modules(repoInterface);
+    //get_updated_repo_modules(repoInterface);
 
     /*get_book_headers(textProcessor);*/
 

package/src/sword_backend/strongs_entry.cpp

@@ -71,10 +71,17 @@ bool StrongsReference::hasValidKey()
     return StrongsEntry::isValidStrongsKey(this->key);
 }
 
-StrongsEntry::StrongsEntry(string key, string rawEntry)
+StrongsEntry::StrongsEntry(string key, string rawEntry, string moduleVersion)
 {
     this->key = key;
-    this->parseFromRawEntry(rawEntry);
+
+    char moduleMinorVersion = moduleVersion[0];
+
+    if (moduleMinorVersion == '1') {
+        this->parseFromVersion1RawEntry(rawEntry);
+    } else {
+        this->parseFromVersion2RawEntry(rawEntry);
+    }
 }
 
 bool StrongsEntry::isValidStrongsKey(std::string key)
@@ -113,10 +120,13 @@ StrongsEntry* StrongsEntry::getStrongsEntry(SWModule* module, string key)
         return 0;
     }
 
+    string moduleVersion = module->getConfigEntry("Version");
+
     // Cut off the first character (H or G), since the Sword engine uses the actual number strings as the key for Strong's
     string strongsNumberString = key.substr(1);
     module->setKey(strongsNumberString.c_str());
-    StrongsEntry* strongsEntry = new StrongsEntry(key, module->getRawEntry());
+
+    StrongsEntry* strongsEntry = new StrongsEntry(key, module->getRawEntry(), moduleVersion);
 
     return strongsEntry;
 }
@@ -165,7 +175,7 @@ void StrongsEntry::parseDefinitionAndReferences(vector<string>& lines)
 
     for (unsigned int i = 0; i < lines.size(); i++) {
         string currentLine = lines[i];
-        if (currentLine.substr(0,5) == " see ") {
+        if (currentLine.substr(0,5) == " see " || currentLine.substr(0,4) == "see ") {
             StringHelper::trim(currentLine);
             StrongsReference reference(currentLine);
             // Only put the current line into the list of references if it's not already in there
@@ -193,7 +203,7 @@ void StrongsEntry::parseDefinitionAndReferences(vector<string>& lines)
     this->references = references;
 }
 
-void StrongsEntry::parseFromRawEntry(string rawEntry)
+void StrongsEntry::parseFromVersion1RawEntry(string rawEntry)
 {
     this->rawEntry = rawEntry;
 
@@ -219,3 +229,88 @@ void StrongsEntry::parseFromRawEntry(string rawEntry)
     this->eraseEmptyLines(allLines);
     this->parseDefinitionAndReferences(allLines);
 }
+
+void StrongsEntry::parseFromVersion2RawEntry(string rawEntry)
+{
+    this->rawEntry = rawEntry;
+
+    cout << rawEntry << endl;
+
+    vector<string> allLines = StringHelper::split(this->rawEntry, "\n");
+    if (allLines.size() == 0) {
+        return;
+    }
+
+    string details = allLines[0];
+    string phoneticTranscription = details;
+
+    // Parse the transcription
+    string transcriptionTag = "<orth rend=\"bold\" type=\"trans\">";
+    string transcriptionEndTag = "</orth>";
+    this->transcription = this->parseFromVersion2Element(details, transcriptionTag, transcriptionEndTag);
+
+    // Parse the phonetic transcription
+    string phoneticTranscriptionTag = "<pron rend=\"italic\">{";
+    string phoneticTranscriptionEndTag = "}";
+    this->phoneticTranscription = this->parseFromVersion2Element(phoneticTranscription, phoneticTranscriptionTag, phoneticTranscriptionEndTag);
+
+    // Parse the definition
+    string definition = rawEntry;
+    definition = this->parseFromVersion2Element(rawEntry, "<def>", "</def>");
+    string references = definition;
+
+    std::size_t lineBreakPosition = definition.find("<lb");
+    string defEndTag = "</def>";
+    std::size_t defEndTagPosition = definition.find(defEndTag);
+
+    StringHelper::trim(definition);
+
+    string lineBreak = "<lb/>";
+    lineBreakPosition = definition.find(lineBreak);
+
+    if (lineBreakPosition != string::npos) {
+        definition.erase(lineBreakPosition, string::npos);
+    }
+
+    // Parse the references
+    lineBreakPosition = references.find(lineBreak);
+
+    if (lineBreakPosition != string::npos) {
+        references.erase(0, lineBreakPosition);
+        
+        defEndTagPosition = references.find(defEndTag);
+
+        if (defEndTagPosition != string::npos) {
+            references.erase(defEndTagPosition, string::npos);
+        }
+
+        references.erase(0, lineBreak.size());
+    }
+
+    StringHelper::trim(references);
+    vector<string> referenceLines = StringHelper::split(references, "<lb/> ");
+    this->parseDefinitionAndReferences(referenceLines);
+
+    // Store definition from variable above.
+    this->definition = definition;
+}
+
+string StrongsEntry::parseFromVersion2Element(string rawEntry, string startTag, string endTag)
+{
+    std::size_t startTagPosition = rawEntry.find(startTag);
+    if (startTagPosition != string::npos) {
+        rawEntry.erase(0, startTagPosition);
+    }
+
+    std::size_t endTagPosition = rawEntry.find(endTag);
+    
+    if (endTagPosition != string::npos) {
+        rawEntry.erase(endTagPosition, string::npos);
+    }
+
+    if (startTag.size() <= rawEntry.size()) {
+        rawEntry.erase(0, startTag.size());
+    }
+
+    return rawEntry;
+}

package/src/sword_backend/strongs_entry.hpp

@@ -44,7 +44,7 @@ private:
 class StrongsEntry
 {
 public:
-    StrongsEntry(std::string key, std::string rawEntry);
+    StrongsEntry(std::string key, std::string rawEntry, std::string moduleVersion);
     virtual ~StrongsEntry(){}
 
     static bool isValidStrongsKey(std::string key);
@@ -58,7 +58,9 @@ public:
     std::vector<StrongsReference> references;
 
 private:
-    void parseFromRawEntry(std::string rawEntry);
+    void parseFromVersion1RawEntry(std::string rawEntry);
+    void parseFromVersion2RawEntry(std::string rawEntry);
+    std::string parseFromVersion2Element(std::string rawEntry, std::string startTag, std::string endTag);
     void parseFirstLine(std::string firstLine);
     void eraseEmptyLines(std::vector<std::string>& lines);
     void parseDefinitionAndReferences(std::vector<std::string>& lines);