test_verses_parser.py

from django.test import TestCase

from portal.lib.verses_parser import extract_verses, refs_with_chapter, split_refs


class VersesParserTestCase(TestCase):
    maxDiff = None

    def test_split_refs(self):
        given = split_refs("Gen 1:2; 3:4-5", ["bw"])
        expected = [
            dict(bible="bw", book="Gen", ref="1:2"),
            dict(bible="bw", book="Gen", ref="3:4-5"),
        ]
        self.assertEqual(expected, given)

    def test_split_refs_without_spaces(self):
        given = refs_with_chapter("Gen 1:2; 3:4-5", ["bw", "bg"])
        expected = [
            dict(bible="bw", book="Gen", ref="1:2", chapter=1),
            dict(bible="bw", book="Gen", ref="3:4-5", chapter=3),
            dict(bible="bg", book="Gen", ref="1:2", chapter=1),
            dict(bible="bg", book="Gen", ref="3:4-5", chapter=3),
        ]
        self.assertEqual(expected, given)

    def test_extract_verses(self):
        given = extract_verses("Gen 1:2,15; 3:4-7,12", ["bw"])
        expected = [
            dict(bible="bw", book="Gen", ref="1:2,15", chapter=1, verses=[2, 15]),
            dict(
                bible="bw",
                book="Gen",
                ref="3:4-7,12",
                chapter=3,
                verses=[4, 5, 6, 7, 12],
            ),
        ]
        self.assertEqual(expected, given)

    def test_extract_verses_with_nn(self):
        given = extract_verses("Gen 1:2nn", ["bw"])
        expected = [
            dict(
                bible="bw",
                book="Gen",
                ref="1:2nn",
                chapter=1,
                verses=list(range(2, 10000)),
            )
        ]
        self.assertEqual(expected, given)

verses_parser.py

import re
from .flatten import flatten


def split_refs(query, bibles):
    result = []
    for bible in bibles:
        for token in re.split(r"\s*[;\|]\s*", query):
            if matched := re.match(r"^([\d\w]\w\w)\s*(.+)", token):
                name, ref = matched.groups()
            elif matched := re.match(r"^(\d?\w+)\s*(.+)", token):
                name, ref = matched.groups()
            else:
                name, ref = result[-1]["book"], token
            try:
                int(name)
                result.append(dict(bible=bible, book=result[-1]["book"], ref=token))
            except ValueError:
                result.append(dict(bible=bible, book=name, ref=ref))
    return result


def refs_with_chapter(query, bibles):
    result = []
    for item in split_refs(query, bibles):
        item["chapter"] = int(re.split(r"\s*:\s*", item["ref"])[0])
        result.append(item)
    return result


def extract_verses(query, bibles):
    result = []
    for item in refs_with_chapter(query, bibles):
        chapter, verses_str = re.split(r"\s*:\s*", item["ref"])
        if verses_str:
            verses = []
            for verse in re.split(r"\s*,\s*", verses_str):
                try:
                    from_verse, to_verse = verse.split("-")
                except ValueError:
                    from_verse, to_verse = verse, None
                if to_verse:
                    start = int(from_verse)
                    end = int(to_verse)
                    verse_record = list(range(start, end + 1))
                elif verse.find("nn") > 0:
                    start = int(verse.replace("nn", ""))
                    verse_record = list(range(start, 10000))
                else:
                    verse_record = int(from_verse)
                verses.append(verse_record)
            item["verses"] = flatten(verses)
            result.append(item)
    return result