codexparser 0.0.77 → 0.0.79

package/bcv-single-test.js

@@ -4,13 +4,14 @@ const util = require("util")
 const dump = (item) => {
     console.log(util.inspect(item, { depth: null, colors: true }))
 }
-const text = "Ap 8:27"
+const text = "Psalm 34:12f"
 
 const parser = new bcv_parser({
     invalid_sequence_strategy: "include",
     invalid_passage_strategy: "include",
 })
 const textParser = parser.parse(text)
+console.log(textParser)
 const passages = textParser.parsed_entities()
 passages.forEach((passage) => {
     dump(passage)

package/find-test.js

@@ -0,0 +1,20 @@
+const BibleParser = require("./src/CodexParser.js")
+
+let text = `Joel 10:13 The passages Luke 2:32 and Lk 1:23 that we are looking at tonight 1 Cor 12:34 2 Cor 3:4 are found Jude 6, in Jude 5, Genesis 2:1 - 3:19, 1 John 3:16-17, 1 Peter 1:1, and Romans 10:13, 15, 17. Please turn in your Bibles. Ps 109:4,5,6,8.  Isaiah 61.2-3 Mt 5.4
+
+Ge 27.27-29,89-40 Heb 11.20 Heb. 12.17 Jonah 3
+
+Jd. 5
+Jd 6
+
+1 Cor 12:34 2 Cor 3:4. He 4.12 Re 1.16
+
+Leviticus 16:6 He 5.3 He 7.27
+
+Hos 10:1-3, 8 and 1 John 2:23f
+
+exod15.18. 2 Cor 12:23 Malachi 3:32`
+
+const parser = new BibleParser()
+const result = parser.find("Isaiah 29:16; 45:9 // Romans 9:20").enhance()
+console.log(result)

package/jstester.js

@@ -1,3 +1,5 @@
+const BibleParser = require("./src/CodexParser.js")
+const parser = new BibleParser()
 const books = [
     "Gen",
     "Ge",
@@ -298,13 +300,16 @@ booksAt.sort(function (a, b) {
 })
 newText = ""
 let chNoInText = 0
+
+let passages = []
 for (let b = 0; b < booksAt.length; b++) {
     while (chNoInText < booksAt[b][1]) {
         //copy across characters to start of book
         newText += text.charAt(chNoInText)
         chNoInText++
     }
-    newText += booksAt[b][0]
+    newText += "<span class='passage'>" + booksAt[b][0]
+    let passage = booksAt[b][0]
     chNoInText += booksAt[b][0].length //skip the 'fill-in characters
     for (let i = 0; i < 100; i++) {
         chNoInText++
@@ -313,8 +318,12 @@ for (let b = 0; b < booksAt.length; b++) {
         if (nextCh.match(/^[a-z]+$/)) break
         if (nextCh.match(/^[A-Z]+$/)) break
         newText += text.charAt(chNoInText - 1)
+        passage += text.charAt(chNoInText - 1)
     }
-    newText += " "
+    passages.push(passage.trim())
+    newText += "</span>&nbsp;"
 }
 
-console.log(newText)
+const found = parser.find(text)
+
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codexparser",
-  "version": "0.0.77",
+  "version": "0.0.79",
   "description": "This is a Javascript Bible parser and text scanner. It will search through texts and collate all scripture references into an array and parse them into objects, and it will parse passages into objects by book, chapter, verse, and testament. ",
   "main": "index.js",
   "scripts": {

package/src/CodexParser.js

@@ -125,7 +125,8 @@ class CodexParser {
                     next = this.found[i + 1]
                 }
             }
-            if (passage.type === "range" && passage.book === result.end.b) {
+
+            if (passage.type === "range" && result.start.b === result.end.b) {
                 if (result.start.c !== result.end.c) {
                     passage.verses = [result.start.v]
                     passage.to = {
@@ -157,7 +158,7 @@ class CodexParser {
 
     versify(passage) {
         if (passage.start.v !== passage.end.v) {
-            if (passage.type === "range") {
+            if (passage.type === "range" || passage.type === "ff") {
                 if (passage.start.b === passage.end.b) {
                     return [`${passage.start.v}-${passage.end.v}`]
                 } else {
@@ -231,62 +232,331 @@ class CodexParser {
             .trim()
     }
     find(text) {
-        const bookNames = this.bookRegex.toString().split("|").slice(8)
-        const books = [...this.bible.old, ...this.bible.new, ...bookNames]
-        for (let i = 0; i < books.length; i++) {
-            const book = books[i].toLowerCase()
-            const index = text.toLowerCase().indexOf(book)
-            // Checks to see if the previous character is a colon. If it is, skip.
-            // This makes sure that if you have a case like Genesis 1:1 John 1:1, the code knows that
-            // the book cannot be 1 John.
-            if (text[index - 1] && text[index - 1].includes(":") && text[index - 1].match(/[a-zA-Z]/)) continue
+        const books = [
+            "Gen",
+            "Ge",
+            "Gn",
+            "Exo",
+            "Ex",
+            "Exod",
+            "Lev",
+            "Le",
+            "Lv",
+            "Num",
+            "Nu",
+            "Nm",
+            "Nb",
+            "Deut",
+            "Dt",
+            "Josh",
+            "Jos",
+            "Jsh",
+            "Judg",
+            "Jdg",
+            "Jg",
+            "Jdgs",
+            "Rth",
+            "Ru",
+            "Sam",
+            "Samuel",
+            "Kings",
+            "Kgs",
+            "Kin",
+            "Chron",
+            "Chronicles",
+            "Ezra",
+            "Ezr",
+            "Ez",
+            "Neh",
+            "Ne",
+            "Esth",
+            "Es",
+            "Job",
+            "Job",
+            "Jb",
+            "Pslm",
+            "Ps",
+            "Psalms",
+            "Psa",
+            "Psm",
+            "Pss",
+            "Prov",
+            "Pr",
+            "Prv",
+            "Eccles",
+            "Ec",
+            "Song",
+            "So",
+            "Canticles",
+            "Song of Songs",
+            "SOS",
+            "Isa",
+            "Is",
+            "Jer",
+            "Je",
+            "Jr",
+            "Lam",
+            "La",
+            "Ezek",
+            "Eze",
+            "Ezk",
+            "Dan",
+            "Da",
+            "Dn",
+            "Hos",
+            "Ho",
+            "Joel",
+            "Joe",
+            "Jl",
+            "Amos",
+            "Am",
+            "Obad",
+            "Ob",
+            "Jnh",
+            "Jon",
+            "Micah",
+            "Mic",
+            "Nah",
+            "Na",
+            "Hab",
+            "Zeph",
+            "Zep",
+            "Zp",
+            "Haggai",
+            "Hag",
+            "Hg",
+            "Zech",
+            "Zec",
+            "Zc",
+            "Mal",
+            "Mal",
+            "Ml",
+            "Matt",
+            "Mt",
+            "Mrk",
+            "Mk",
+            "Mr",
+            "Luk",
+            "Lk",
+            "John",
+            "Jn",
+            "Jhn",
+            "Acts",
+            "Ac",
+            "Rom",
+            "Ro",
+            "Rm",
+            "Co",
+            "Cor",
+            "Corinthians",
+            "Gal",
+            "Ga",
+            "Ephes",
+            "Eph",
+            "Phil",
+            "Php",
+            "Col",
+            "Col",
+            "Th",
+            "Thes",
+            "Thess",
+            "Thessalonians",
+            "Ti",
+            "Tim",
+            "Timothy",
+            "Titus",
+            "Tit",
+            "Philem",
+            "Phm",
+            "Hebrews",
+            "Heb",
+            "He",
+            "James",
+            "Jas",
+            "Jm",
+            "Pe",
+            "Pet",
+            "Pt",
+            "Peter",
+            "Jn",
+            "Jo",
+            "Joh",
+            "Jhn",
+            "John",
+            "Jude",
+            "Jd",
+            "Jud",
+            "Jud",
+            "Rev",
+            "The Revelation",
+            "Genesis",
+            "Exodus",
+            "Leviticus",
+            "Numbers",
+            "Deuteronomy",
+            "Joshua",
+            "Judges",
+            "Ruth",
+            "Samuel",
+            "Kings",
+            "Chronicles",
+            "Ezra",
+            "Nehemiah",
+            "Esther",
+            "Job",
+            "Psalms",
+            "Psalm",
+            "Proverbs",
+            "Ecclesiastes",
+            "Song of Solomon",
+            "Isaiah",
+            "Jeremiah",
+            "Lamentations",
+            "Ezekiel",
+            "Daniel",
+            "Hosea",
+            "Joel",
+            "Amos",
+            "Obadiah",
+            "Jonah",
+            "Micah",
+            "Nahum",
+            "Habakkuk",
+            "Zephaniah",
+            "Haggai",
+            "Zechariah",
+            "Malachi",
+            "Matthew",
+            "Mark",
+            "Luke",
+            "John",
+            "Acts",
+            "Romans",
+            "Corinthians",
+            "Galatians",
+            "Ephesians",
+            "Philippians",
+            "Colossians",
+            "Thessalonians",
+            "Timothy",
+            "Titus",
+            "Philemon",
+            "Hebrews",
+            "James",
+            "Peter",
+            "John",
+            "Revelation",
+            "Re",
+            "Ap",
+            "Jd.",
+            "Heb.",
+        ]
 
-            // Get the book and chapter
-            if (index > -1) {
-                const bookEndIndex = index + book.length - 1
-                const passage = {
-                    book: text.substring(index, bookEndIndex + 1),
-                }
-                let chapter = 0
-                let chapterStartIndex = null
-                let chapterEndIndex = null
-                let j = bookEndIndex + 1
-                while (j < text.length && !text[j].match(/[a-zA-Z]/)) {
-                    const match = text.substring(j).match(/^\s*(\d+)/)
-                    if (match) {
-                        chapter = parseInt(match[1])
-                        chapterStartIndex = j
-                        chapterEndIndex = j + match[0].length
-                        break
-                    }
-                    j++
-                }
+        const preStrings = ["III", "II", "I", "1st", "2nd", "3rd", "First", "Second", "Third", "1", "2", "3"]
+        const preStringed = [
+            "Sam",
+            "Samuel",
+            "Kings",
+            "Kgs",
+            "Kin",
+            "Chron",
+            "Chronicles",
+            "Corinthians",
+            "Co",
+            "Cor",
+            "Thessalonians",
+            "Th",
+            "Thes",
+            "Thess",
+            "Timothy",
+            "Ti",
+            "Tim",
+            "Peter",
+            "Pe",
+            "Pet",
+            "Pt",
+            "John",
+            "Jn",
+            "Jhn",
+        ]
+        let newText = ""
 
-                let verseIndex = chapterEndIndex + 1
-                let verseStartIndex = null
-                let verseEndIndex = null
-                let verse
-                while (verseIndex < text.length && !text[verseIndex].match(/[a-zA-Z]/)) {
-                    const match = text.substring(verseIndex).match(/^\s*?(\d+)[^a-zA-Z]*/)
-                    if (match) {
-                        verseStartIndex = verseIndex
-                        verseEndIndex = verseIndex + match[0].length
-                        break
+        //add the prestringed versions e.g. 1 Peter
+        for (let b = 0; b < preStringed.length; b++) {
+            for (let pre = 0; pre < preStrings.length; pre++) {
+                books.push(preStrings[pre] + " " + preStringed[b])
+            }
+        }
+        // add the book name with . at the end as this seems to be added sometimes, at least to the shortened forms
+        const length = books.length
+        for (let b = 0; b < length; b++) {
+            books.push(books[b] + ".")
+        }
+
+        // sort descending - longer items first
+        books.sort((a, b) => b.length - a.length)
+        let booksAt = []
+        // go thro' each book finding where it matches in text
+        for (let b = 0; b < books.length; b++) {
+            const book = books[b]
+            let chNoInText = 0
+            while (chNoInText < text.length) {
+                let j = text.indexOf(book, chNoInText)
+                if (j < 0) break
+                if (j + book.length < text.length && !text.charAt(j + book.length).match(/^[a-z]+$/)) {
+                    booksAt.push([book, j])
+                    let replacement = book
+                    for (let k = 0; k < book.length; k++) {
+                        replacement = replacement.replace(book.charAt(k), "X")
                     }
-                    verseIndex++
+                    text = text.replace(book, replacement) // to prevent a shorter version matching
                 }
-                verse = parseInt(text.substring(verseStartIndex, verseEndIndex))
-
-                if (chapter > 0) passage.chapter = chapter
-                if (verse > 0) passage.verse = verse
+                chNoInText = j + book.length + 1
+            }
+        }
+        // into ascending order of start position
+        booksAt.sort(function (a, b) {
+            return a[1] - b[1]
+        })
+        newText = ""
+        let chNoInText = 0
+        for (let b = 0; b < booksAt.length; b++) {
+            while (chNoInText < booksAt[b][1]) {
+                //copy across characters to start of book
+                newText += text.charAt(chNoInText)
+                chNoInText++
+            }
+            newText += "<span class='passage'>" + booksAt[b][0]
+            let passage = booksAt[b][0]
+            chNoInText += booksAt[b][0].length //skip the 'fill-in characters
+            for (let i = 0; i < 100; i++) {
+                chNoInText++
+                const nextCh = text.charAt(chNoInText)
+                //test whether are at the end of the chapter(s) and verse(s)
+                if (nextCh.match(/^[a-z]+$/) && nextCh !== "f" && nextCh !== "ff") break
+                if (nextCh.match(/^[A-Z]+$/)) break
+                newText += text.charAt(chNoInText - 1)
+                passage += text.charAt(chNoInText - 1)
+            }
+            this.found.push(passage.trim())
+            newText += "</span>&nbsp;"
+        }
+        return this
+    }
 
-                passage.index = {
-                    start: index,
+    enhance() {
+        if (this.found.length > 0) {
+            for (let i = 0; i < this.found.length; i++) {
+                const passage = {
+                    original: this.found[i],
+                    book: this.bookify(this.found[i].match(this.bookRegex)[0]),
+                    chapter: this.found[i].match(this.chapterRegex),
+                    verse: this.found[i].match(/(?<=[.:])(\d+.+)/),
                 }
                 this.passages.push(passage)
             }
         }
-        return this
+        return this.passages
     }
 
     regex(text) {

package/sub-verse-scripture-test.js

@@ -11,5 +11,5 @@ parser.options({
     invalid_sequence_strategy: "include",
     single_chapter_1_strategy: "verse",
 })
-const result = parser.parse("Genesis 3:17-19 // Genesis 3:17 Genesis 3:18-19 Genesis 3:19")
+const result = parser.parse("Isaiah 8:21-9:6")
 dump(result.getPassages())