def replace_bible_links(match):
ref = match.group(1)
#print "Replacing bible link", ref
vk = VK(ref)
return "href='book_%s.html#%s_start'" % (vk.getOSISBookName(),
vk.getOSISRef())
def new_guess(self):
self.key = None
while not self.key or not biblemgr.bible.mod.hasEntry(self.key):
randomnum = random.randint(1, 31102)
self.key = VK("Gen 1:%d" % randomnum)
self.user_key = UserVK(self.key)
self.reference_frame.SetReference(self.key.getText())
def SetReference(self, ref, ref_to_scroll_to=None, settings_changed=False):
"""Sets reference. This is set up to be an observer of the main frame,
so don't call internally. To set verse reference, use notify"""
self.reference = GetVerseStr(ref)
has_selected_new_verse = False
# If the settings have changed we want to do a complete reload anyway
# (since it could be something that requires a complete reload, such as changing version).
if self.dom_loaded:
if settings_changed:
self.reference, ref_to_scroll_to = self.GetCurrentReferenceAndPosition(
)
else:
osisRef = VK(self.reference).getOSISRef()
has_selected_new_verse = self.ExecuteScriptWithResult(
'select_new_verse("%s")' % osisRef)
has_selected_new_verse = (has_selected_new_verse == "true")
if has_selected_new_verse:
self.NewReferenceLoaded()
elif self.CheckChapterInBook(ref):
self.OpenURIForCurrentBook("bpbible://content/page/%s/%s" %
(self.book.version, self.reference))
if ref_to_scroll_to:
self.scroll_to_osis_ref(ref_to_scroll_to)
chapter = GetBookChapter(self.reference)
self.header_bar.set_current_chapter(pysw.internal_to_user(chapter),
chapter)
self.update_title()
def has_chapter(self, ref, mod=None):
assert self.is_verse_keyed, "Calling has_chapter for non-verse keyed module."
module = mod or self.mod
if module is None:
return False
vk = VK(ref)
if module.hasEntry(vk):
return True
vk.setVerse(1)
if module.hasEntry(vk):
return True
module.setKey(vk)
try:
old_mod_skiplinks = module.getSkipConsecutiveLinks()
module.setSkipConsecutiveLinks(True)
module.increment()
next_vk = VK.castTo(module.getKey())
return (next_vk.Book() == vk.Book() and next_vk.Chapter()
== vk.Chapter() and next_vk.Testament()
== vk.Testament()) and not self.has_error(module)
finally:
module.setSkipConsecutiveLinks(old_mod_skiplinks)
def _setupPassageLists(test):
"""Sets up the passage lists for the given test."""
test._verse_list1 = VerseList(
[VK(("gen 2:3", "gen 2:5")), "gen 3:4", "gen 5:2"])
test._verse_list2 = VerseList(
["ex 2:2", "ex 3:5", VK(("ex 3:7", "ex 3:9"))])
test._verse_list3 = VerseList([VK(("lev 2:3", "lev 2:5")), "lev 2:7"])
test._verse_list4 = VerseList(["num 3:1", VK(("num 3:4", "num 3:5"))])
test._list = PassageList.create_from_verse_list("abc", test._verse_list1)
test._list2 = PassageList.create_from_verse_list("def", test._verse_list2)
test._list3 = PassageList.create_from_verse_list("ghi", test._verse_list3)
test._list4 = PassageList.create_from_verse_list("jkl", test._verse_list4)
test._list2.add_subtopic(test._list4)
test._list.add_subtopic(test._list2)
test._list.add_subtopic(test._list3)
test._manager = PassageListManager()
test._manager.add_subtopic(test._list)
def testContainsVerseWorksWithRange(self):
self.assert_(self._passage_entry2.contains_verse(VK("gen 3:5")))
self.assert_(self._passage_entry2.contains_verse(VK("gen 3:6")))
self.assert_(self._passage_entry2.contains_verse(VK("gen 3:9")))
self.assert_(self._passage_entry2.contains_verse(VK("gen 3:10")))
self.assert_(not self._passage_entry2.contains_verse(VK("gen 3:4")))
self.assert_(not self._passage_entry2.contains_verse(VK("gen 3:11")))
def cut_down_index(self, bottom, top):
### not fully implemented for non-bibles
vk1 = VK((self.bookname, self.bookname))
vk = VK((bottom, top))
vk_dn = vk.LowerBound()
vk_up = vk.UpperBound()
# the item we are currently looking for
start_ref = None
ret = []
items = []
self.old_text = self.text
self.old_index = self.index
for match in re.finditer("(?m)^.*$", self.text):
if vk_dn <= vk1 <= vk_up:
items.append(match.group())
vk1.increment(1)
self.text = '\n'.join(items)
self.create_index_against_text(vk)
def insert_footnotes(match):
#print "Inserting footnotes", match
href = match.group(1)
url = SW.URL(href.encode("utf8"))
ftype = url.getParameterValue("type") #x or n
value = url.getParameterValue("value") #number footnote in verse
if ((not ftype) or (not value)):
dprint(WARNING, "Not type or value in showNote", href)
return ""
module = biblemgr.get_module(url.getParameterValue("module"))
passage = url.getParameterValue("passage")
back_ref = VK(passage).getOSISRef()
user_ref = book_fix(internal_to_user(passage))
if not passage or not module:
print "No passage/module?"
return ""
id = "footnote_data_%s_%s" % (back_ref, value)
#print passage, id
if ftype in ("n", "x"):
data = sword_book.GetFootnoteData(module, passage, value,
"body")
if footnotes[ftype] and footnotes[ftype][-1][0] == back_ref:
footnotes_group = footnotes[ftype][-1]
else:
footnotes_group = [
back_ref,
"<div class='verse_footnotes footnote_%s' id='verse_footnote_%s_%s'>%s for "
"<a href='#%s_start'>%s</a>%%s</div>" %
(ftype, back_ref, ftype, footnote_types[ftype],
back_ref, user_ref)
]
footnotes[ftype].append(footnotes_group)
footnotes_group.append(
"<div class='footnote_data' id='%s'><span class='footnote_marker'>%s</span>: %s</div>"
% (id, match.group(3), data))
else:
print "Footnote type was", ftype
id = "verse_footnote_%s_%s" % (back_ref, ftype)
return 'href="#%s"%s' % (id, match.group(2))
def yield_verses(mod):
from swlib.pysw import VK, TOP
vk = VK()
vk.Headings(1)
vk.setPosition(TOP)
#vk.setText("Matthew 1:1")
vk.Persist(1)
vk.thisown = False
mod.setKey(vk)
books = ("Genesis", "Matthew") #"Exodus")
while not vk.Error():
#while vk.Testament() in '\x00\x01':
#while vk.Testament() == '\x00' or vk.Book() == '\x00' or \
# vk.getBookName() in books:
yield
vk.increment(1)
def __init__(self, parent, version=""):
self.parent = parent
self.mod = None
self.observers = observerlist.ObserverList()
self.cleanup_module = observerlist.ObserverList()
self.template = VerseTemplate(body="$text")
self.templatelist = [self.template]
self.vk = VK()
self.headings = False
if self.ModuleExists(version):
self.SetModule(version)
else:
mods = self.GetModuleList()
if mods:
self.SetModule(mods[0])
else:
dprint(WARNING, "No modules of type", self.type)
self.SetModule(None)
def get_verses_on_screen(self, verses):
if not self.dom_loaded:
return []
osis_refs = [VK(verse).getOSISRef() for verse in verses]
osis_refs_on_screen = self.ExecuteScriptWithResult("""
(function(osis_refs) {
var result = [];
for (var index = 0; index < osis_refs.length; index++) {
var osisRef = osis_refs[index];
var reference_found = $('[osisRef="' + osisRef + '"]').length > 0;
if (reference_found) {
result.push(osisRef);
}
}
return JSON.stringify(result);
})(%s);
""" % json.dumps(osis_refs))
return json.loads(osis_refs_on_screen)
def get_document(self, path):
module_name, rest = path.split("/", 1)
ref, direction = rest.rsplit("/", 1)
assert direction in ("next", "previous")
dir = {"next": 1, "previous": -1}[direction]
book = biblemgr.get_module_book_wrapper(module_name)
mod = book.mod
no_more = False
if book.is_verse_keyed:
vk = VK(ref, headings=not book.chapter_view)
if book.chapter_view:
vk.chapter += dir
if vk.Error():
print "No more in that direction", dir
no_more = True
else:
# go back just a little, so that when we go forward on the module
# we won't overshoot... (at least, that is our plan - we hope it
# won't be baffled...)
vk.Verse(vk.Verse() - dir)
if vk.Error():
print "VK had an error taking away a verse", dir
if not no_more:
old_mod_skiplinks = mod.getSkipConsecutiveLinks()
mod.setSkipConsecutiveLinks(True)
try:
vk.Persist(1)
mod.setKey(vk)
#print repr(mod.Error())
mod.increment(dir)
if mod.Error() != '\x00':
print "Mod had an error"
no_more = True
else:
if book.chapter_view:
new_ref = vk.get_chapter_osis_ref()
else:
new_ref = vk.getOSISRef()
finally:
mod.setKey(SW.Key())
mod.setSkipConsecutiveLinks(old_mod_skiplinks)
elif book.is_dictionary:
# XXX: Would using an index rather than a reference (as the XUL code did) be more efficient?
book.snap_text(ref)
book.mod.increment(dir)
if mod.Error() == '\x00' and book.mod.getKey().getText():
new_ref = to_unicode(mod.getKey().getText(), mod)
else:
no_more = True
elif book.is_genbook:
ref = "/" + ref
tk = book.GetKey()
tk.Persist(1)
assert tk.thisown
newtk = book.GetKey()
newtk.thisown = True
mod.setKey(tk)
print "Getting next for", ref
tk.set_text(ref)
print tk.getText()
if mod.Error() != '\x00':
print "Error on initial set?"
mod.increment(dir)
if mod.Error() == '\x00' and tk.getText():
new_ref = to_unicode(tk.getText(),
mod)[1:] # trim off the leading /
else:
no_more = True
mod.setKey(newtk)
else:
print "Book type not handled", module_name
if no_more:
message = (_("You are at the start of this book.")
if dir == -1 else _("You are at the end of this book."))
class_name = "book-%s" % ("start" if dir == -1 else "end")
return '''
<div class="page_segment" empty="true">
<div class='no_more_text %(class_name)s'>
%(message)s
</div>
</div>''' % locals()
return '<div class="page_segment">%(content)s%(timer)s</div>' % self._get_document_parts_for_ref(
module_name, new_ref, do_current_ref=False)
def get_book(sword_book, bible_book, verse_per_line=False):
print "fetching", bible_book, "from", sword_book
bookname = str(bible_book)
chapter_bookname = book_fix(bookname)
osis_bookname = VK(bookname).getOSISBookName()
filename = "book_%s.html" % osis_bookname
preverse = '<span id="${osisRef}_start" />'
# templates
verse_number = u'''<span class="vnumber $numbertype%s"
id="${osisRef}_number">
$versenumber<span class="post_versenumber_space"> </span></span>'''
# TODO - reinstate $usercomments $tags after $text?
body = (u'''%s<span class="zwnj">‌</span>$text''') % verse_number
# <a id="${osisRef}_end" osisRef="$osisRef"></a>''') % verse_number
bible_template = SmartVerseTemplate(body=body % (''), preverse=preverse)
bible_template.body.verse_per_line = verse_per_line
toc = []
chapters = []
footnotes = {
'n': [],
'x': [],
}
footnote_types = {
'n': "Footnotes",
'x': "Cross-references",
}
for chapter in bible_book.chapters:
if chapter.chapter_number % 10 == 0:
print osis_bookname, chapter
if RESTRICTED:
break
chapter_id = "%s_%s_start" % (osis_bookname, chapter)
chapter_link = '<a class="chapter_link" href="#intro">%s</a>' % chapter_bookname
toc.append(
'''<a class="toc_chapter_link" href="#chapter_%s">%s</a>''' %
(chapter_id, chapter))
ref = "%s %s" % (osis_bookname, chapter)
content = sword_book.GetReference(ref,
end_ref=ref,
template=bible_template,
max_verses=-1)
# content = re.sub(r'<(/?)h2([^>]*)>', r'<\1h4\2>', content)
chapter_marker = '<span class="vnumber chapternumber'
# always a chance
new_content = content.replace(chapter_marker,
chapter_link + chapter_marker)
osisRef = "%s.%s.%s" % (osis_bookname, chapter, 1)
if new_content == content:
print "No chapter intro link found for %s %s" % (osis_bookname,
chapter)
new_content = (chapter_link + (verse_number % '').replace(
"$numbertype", "chapternumber").replace(
"${osisRef}", osisRef).replace("${versenumber}", "%s" %
(chapter)))
content = new_content
expected_start = preverse.replace("${osisRef}", osisRef) + chapter_link
if not content.startswith(expected_start):
print "pre-content chapter intro link found for %s %s" % (
osis_bookname, chapter)
#print "Sample starter content: " + content[:100]
content = content.replace(chapter_link, "<br / >" + chapter_link)
# now take it back out if write after a lg
q = '<blockquote class="lg" width="0">'
content = content.replace(q + '<br / >', q)
# check - did we have a closing or opening <p> last?
if 0:
# note, it's only epubcheck which complains about this. kindlegen
# complains as this support isn't perfect so it sees some unclosed
# <p> tags
add_p = True
for a in re.findall("<(/?)p>", content):
add_p = not (a)
if add_p:
content += '</p>'
def insert_footnotes(match):
#print "Inserting footnotes", match
href = match.group(1)
url = SW.URL(href.encode("utf8"))
ftype = url.getParameterValue("type") #x or n
value = url.getParameterValue("value") #number footnote in verse
if ((not ftype) or (not value)):
dprint(WARNING, "Not type or value in showNote", href)
return ""
module = biblemgr.get_module(url.getParameterValue("module"))
passage = url.getParameterValue("passage")
back_ref = VK(passage).getOSISRef()
user_ref = book_fix(internal_to_user(passage))
if not passage or not module:
print "No passage/module?"
return ""
id = "footnote_data_%s_%s" % (back_ref, value)
#print passage, id
if ftype in ("n", "x"):
data = sword_book.GetFootnoteData(module, passage, value,
"body")
if footnotes[ftype] and footnotes[ftype][-1][0] == back_ref:
footnotes_group = footnotes[ftype][-1]
else:
footnotes_group = [
back_ref,
"<div class='verse_footnotes footnote_%s' id='verse_footnote_%s_%s'>%s for "
"<a href='#%s_start'>%s</a>%%s</div>" %
(ftype, back_ref, ftype, footnote_types[ftype],
back_ref, user_ref)
]
footnotes[ftype].append(footnotes_group)
footnotes_group.append(
"<div class='footnote_data' id='%s'><span class='footnote_marker'>%s</span>: %s</div>"
% (id, match.group(3), data))
else:
print "Footnote type was", ftype
id = "verse_footnote_%s_%s" % (back_ref, ftype)
return 'href="#%s"%s' % (id, match.group(2))
content = re.sub(
r'href="newbible://content/(passagestudy\.jsp\?action=showNote&type=[nx]&value=\d+&module=\w+&passage=(?:[^"]+))"(>([^<]*)</a>)',
insert_footnotes, content)
chapters.append('''
<div class="chapter" id="chapter_%s">
<!-- <p> -->
%s
</div>
<hr />
''' % (chapter_id, content))
footnotes_html = ''
for ftype in "nx":
if footnotes[ftype]:
footnotes_html += '<div class="book_footnotes"><h3>%s for %s</h3>%s</div>' % (
footnote_types[ftype], bookname, '<hr />\n'.join(
[f[1] % ('\n\t'.join(f[2:])) for f in footnotes[ftype]]))
html_content = '''<?xml version='1.0' encoding='utf-8'?>
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>%s</title>
<link type="text/css" rel="stylesheet" href="bpbible_epub.css" />
</head>
<body>
<div id="intro">
<h3>%s</h3>
<div class="book_toc">%s</div>
<hr style="clear:both" />
<div style="clear:both">
Return to <a href="toc.html">Table of Contents</a>
</div>
</div>
<hr class="pagebreak" />
<div class="chapterview">
%s
</div>
%s
</body>
</html>
''' % (bookname, bookname, '\n'.join(toc), '\n'.join(chapters),
footnotes_html)
# TODO: sword:// links, any others?
print "Resolving bible links for", bookname
def replace_bible_links(match):
ref = match.group(1)
#print "Replacing bible link", ref
vk = VK(ref)
return "href='book_%s.html#%s_start'" % (vk.getOSISBookName(),
vk.getOSISRef())
html_content = re.sub(r'href="bible:([^"]*)"', replace_bible_links,
html_content)
return (
osis_bookname,
filename,
bookname,
html_content.encode("utf8"),
)
def random_verse(self):
randomnum = random.randint(1, 31102)
ref = VK("Gen 1:%d" % randomnum).text
self.notify(ref, source=events.RANDOM_VERSE)
def testValuesAreRight(self):
self.assertEquals(self._list.passages[0].passage, VK("gen 2:3"))
self.assertEquals(self._list.passages[2].passage, VK("gen 2:7"))
def current_segment_changed(self, new_segment_ref):
self.reference = VK(new_segment_ref).getText()
self.latest_reference = self.reference
self.ChangeCurrentReference(self.reference)
self.update_title()
def testVersesInMainTopicShouldBeContainedDirectly(self):
self.assert_(self._list.contains_verse(VK("gen 3:4")))
def testVersesInSubtopicsShouldNotBeContainedDirectly(self):
self.assert_(not self._list.contains_verse(VK("ex 2:2")))
self.assert_(not self._list.contains_verse(VK("num 2:5")))
def testVersesInSubtopicsShouldBeContainedRecursively(self):
self.assert_(self._list.contains_verse(VK("ex 2:2"), recursive=True))
self.assert_(self._list.contains_verse(VK("num 3:5"), recursive=True))
def _get_document_parts_for_ref(self,
module_name,
ref,
do_current_ref=True):
t = default_timer()
stylesheets = list(self.bible_stylesheets)
scripts = self.standard_scripts + self.bible_scripts + [
"highlight.js", "bpbible_html.js", "contrib/hyphenate.js",
"columns.js"
]
book = biblemgr.get_module_book_wrapper(module_name)
assert book, "Module wrapper not found for book " + module_name
module = book.mod
if book.chapter_view:
scripts.append("bpbible_html_chapter_view.js")
#stylesheets.append("bpbible_chapter_view.css")
#stylesheets.append("bpbible://content/quotes_skin/")
else:
scripts.append("bpbible_html_page_view.js")
stylesheets.append("bpbible_page_view.css")
if is_debugging():
stylesheets.append("bpbible_html_debug.css")
if book.is_verse_keyed:
if book.chapter_view:
if do_current_ref:
c = book.GetChapter(ref, ref,
config.current_verse_template)
else:
c = book.GetChapter(ref)
ref_id = VK(ref).get_chapter_osis_ref()
else:
c = book.GetReference(ref, headings=True)
ref_id = VK(ref).getOSISRef()
elif book.is_dictionary:
c = book.GetReference(ref)
ref_id = ref
elif book.is_genbook:
c = book.GetReference(ref)
ref_id = ref
else:
dprint(ERROR, "Book `%s' not found." % module_name)
c = ''
c = c.replace("<!P>", "</p><p>")
clas = ""
if not c:
clas = " nocontent"
lang = module.Lang() if module else "en",
c = convert_language(c, lang)
c = '<div class="segment%s" ref_id="%s">%s</div>' % (
clas, urllib.quote(ref_id.encode("utf8")), c)
return dict(
module=module,
content=c,
bodyattrs=self._get_body_attrs(module),
stylesheets=stylesheets,
scripts=scripts,
timer="<div class='timer'>Time taken: %.3f (ref_id %s)</div>" %
(default_timer() - t, ref_id))
def testVersesNotInVerseRangeShouldNotBeContained(self):
self.assert_(not self._list.contains_verse(VK("deut 3:5")))
self.assert_(
not self._list.contains_verse(VK("deut 3:5"), recursive=True))
def testVersesInVerseRangeShouldBeContained(self):
self.assert_(self._list.contains_verse(VK("gen 2:5")))
self.assert_(self._list.contains_verse(VK("gen 2:4")))
def testContainsVerseWorksWithSingleVerse(self):
self.assert_(self._passage_entry.contains_verse(VK("gen 2:2")))
self.assert_(not self._passage_entry.contains_verse(VK("gen 2:1")))
def chapter_move(self, number):
vk = VK(self.reference)
vk.chapter += number
if not vk.Error():
self.notify(vk.text, source=events.CHAPTER_MOVE)
def get_tree_item(self):
root = self.tree.GetRootItem()
text = self.GetValue()
was_book = False
for book in UserVK.books:
if ("%s" % book) == text:
was_book = True
self.currentverse = book.bookname
break
else:
try:
# try updating verse based on user text
# if we fail, just use old text (assuming there is any)
self.currentverse = GetVerseStr(text,
self.currentverse,
raiseError=True,
userInput=True,
userOutput=False)
except VerseParsingError:
if not self.currentverse:
return self.tree.GetFirstChild(root)[0]
verse_key = UserVK(VK(self.currentverse))
single_chapter_book = verse_key.getChapterMax() == 1
book, chapter = verse_key.getBookName(), verse_key.Chapter()
verse = verse_key.Verse()
chapter = process_digits(str(chapter), userOutput=True)
verse = process_digits(str(verse), userOutput=True)
if single_chapter_book:
chapter = verse
item, cookie = self.tree.GetFirstChild(root)
while item:
if self.tree.GetItemText(item) == book:
break
item, cookie = self.tree.GetNextChild(root, cookie)
assert item, book + " not found!"
if was_book or (single_chapter_book and not self.with_verses):
return item
self.tree.Expand(item)
item2, cookie = self.tree.GetFirstChild(item)
while item2:
data = unicode(self.get_data(item2))
if data == chapter:
# if : isn't in there, we take it as a chapter reference
if not self.with_verses or ":" not in text \
or single_chapter_book:
return item2
else:
break
item2, cookie = self.tree.GetNextChild(item, cookie)
assert item2, "Chapter '%s' not found in %s" % (chapter, book)
assert not single_chapter_book, "Single chapter books, but chapterMax == 1?!?"
self.tree.Expand(item2)
item3, cookie = self.tree.GetFirstChild(item2)
while item3:
data = unicode(self.get_data(item3))
if data == verse:
return item3
item3, cookie = self.tree.GetNextChild(item2, cookie)
assert item3, "Verse '%s' not found in %s %s" % (verse, book, chapter)
def verse_move(self, number):
vk = VK(self.reference)
vk += number
self.notify(vk.text, source=events.VERSE_MOVE)
def get_key(self, module):
vk = VK((self.bookname, self.bookname))
vk.Headings(0)
vk.setPosition(TOP)
return vk
def get_ref_id(self, reference):
osis_ref = VK(reference).getOSISRef()
return super(LinkedFrame, self).get_ref_id(osis_ref)
