f8e4a83bd3a03951d24ecec6f4e1ffaaae930f06
[librarian.git] / librarian / html.py
1 # -*- coding: utf-8 -*-
2 #
3 # This file is part of Librarian, licensed under GNU Affero GPLv3 or later.
4 # Copyright © Fundacja Nowoczesna Polska. See NOTICE for more information.
5 #
6 from __future__ import print_function, unicode_literals
7
8 import os
9 import re
10 import copy
11
12 from lxml import etree
13 from librarian import XHTMLNS, ParseError, OutputFile
14 from librarian import functions
15
16 from lxml.etree import XMLSyntaxError, XSLTApplyError
17 import six
18
19
20 functions.reg_substitute_entities()
21 functions.reg_person_name()
22
23 STYLESHEETS = {
24     'legacy': 'xslt/book2html.xslt',
25     'full': 'xslt/wl2html_full.xslt',
26     'partial': 'xslt/wl2html_partial.xslt'
27 }
28
29
30 def get_stylesheet(name):
31     return os.path.join(os.path.dirname(__file__), STYLESHEETS[name])
32
33
34 def html_has_content(text):
35     return etree.ETXPath('//p|//{%(ns)s}p|//h1|//{%(ns)s}h1' % {'ns': str(XHTMLNS)})(text)
36
37
38 def transform_abstrakt(abstrakt_element):
39     style_filename = get_stylesheet('legacy')
40     style = etree.parse(style_filename)
41     xml = etree.tostring(abstrakt_element, encoding='unicode')
42     document = etree.parse(six.StringIO(xml.replace('abstrakt', 'dlugi_cytat')))  # HACK
43     result = document.xslt(style)
44     html = re.sub('<a name="sec[0-9]*"/>', '', etree.tostring(result, encoding='unicode'))
45     return re.sub('</?blockquote[^>]*>', '', html)
46
47
48 def transform(wldoc, stylesheet='legacy', options=None, flags=None, css=None):
49     """Transforms the WL document to XHTML.
50
51     If output_filename is None, returns an XML,
52     otherwise returns True if file has been written,False if it hasn't.
53     File won't be written if it has no content.
54     """
55     # Parse XSLT
56     try:
57         style_filename = get_stylesheet(stylesheet)
58         style = etree.parse(style_filename)
59
60         document = copy.deepcopy(wldoc)
61         del wldoc
62         document.swap_endlines()
63
64         if flags:
65             for flag in flags:
66                 document.edoc.getroot().set(flag, 'yes')
67
68         document.clean_ed_note()
69         document.clean_ed_note('abstrakt')
70
71         if not options:
72             options = {}
73         options.setdefault('gallery', "''")
74
75         css = css or 'https://static.wolnelektury.pl/css/compressed/book_text.css'
76         css = "'%s'" % css
77         result = document.transform(style, css=css, **options)
78         del document  # no longer needed large object :)
79
80         if html_has_content(result):
81             add_anchors(result.getroot())
82             add_table_of_themes(result.getroot())
83             add_table_of_contents(result.getroot())
84
85             return OutputFile.from_bytes(etree.tostring(
86                 result, method='html', xml_declaration=False, pretty_print=True, encoding='utf-8'))
87         else:
88             return None
89     except KeyError:
90         raise ValueError("'%s' is not a valid stylesheet.")
91     except (XMLSyntaxError, XSLTApplyError) as e:
92         raise ParseError(e)
93
94
95 @six.python_2_unicode_compatible
96 class Fragment(object):
97     def __init__(self, id, themes):
98         super(Fragment, self).__init__()
99         self.id = id
100         self.themes = themes
101         self.events = []
102
103     def append(self, event, element):
104         self.events.append((event, element))
105
106     def closed_events(self):
107         stack = []
108         for event, element in self.events:
109             if event == 'start':
110                 stack.append(('end', element))
111             elif event == 'end':
112                 try:
113                     stack.pop()
114                 except IndexError:
115                     print('CLOSED NON-OPEN TAG:', element)
116
117         stack.reverse()
118         return self.events + stack
119
120     def to_string(self):
121         result = []
122         for event, element in self.closed_events():
123             if event == 'start':
124                 result.append(u'<%s %s>' % (
125                     element.tag, ' '.join('%s="%s"' % (k, v) for k, v in element.attrib.items())))
126                 if element.text:
127                     result.append(element.text)
128             elif event == 'end':
129                 result.append(u'</%s>' % element.tag)
130                 if element.tail:
131                     result.append(element.tail)
132             else:
133                 result.append(element)
134
135         return ''.join(result)
136
137     def __str__(self):
138         return self.to_string()
139
140
141 def extract_fragments(input_filename):
142     """Extracts theme fragments from input_filename."""
143     open_fragments = {}
144     closed_fragments = {}
145
146     # iterparse would die on a HTML document
147     parser = etree.HTMLParser(encoding='utf-8')
148     buf = six.BytesIO()
149     buf.write(etree.tostring(etree.parse(input_filename, parser).getroot()[0][0], encoding='utf-8'))
150     buf.seek(0)
151
152     for event, element in etree.iterparse(buf, events=('start', 'end')):
153         # Process begin and end elements
154         if element.get('class', '') in ('theme-begin', 'theme-end'):
155             if not event == 'end':
156                 continue  # Process elements only once, on end event
157
158             # Open new fragment
159             if element.get('class', '') == 'theme-begin':
160                 fragment = Fragment(id=element.get('fid'), themes=element.text)
161
162                 # Append parents
163                 parent = element.getparent()
164                 parents = []
165                 while parent.get('id', None) != 'book-text':
166                     cparent = copy.deepcopy(parent)
167                     cparent.text = None
168                     parents.append(cparent)
169                     parent = parent.getparent()
170
171                 parents.reverse()
172                 for parent in parents:
173                     fragment.append('start', parent)
174
175                 open_fragments[fragment.id] = fragment
176
177             # Close existing fragment
178             else:
179                 try:
180                     fragment = open_fragments[element.get('fid')]
181                 except KeyError:
182                     print('%s:closed not open fragment #%s' % (input_filename, element.get('fid')))
183                 else:
184                     closed_fragments[fragment.id] = fragment
185                     del open_fragments[fragment.id]
186
187             # Append element tail to lost_text (we don't want to lose any text)
188             if element.tail:
189                 for fragment_id in open_fragments:
190                     open_fragments[fragment_id].append('text', element.tail)
191
192         # Process all elements except begin and end
193         else:
194             # Omit annotation tags
195             if (len(element.get('name', '')) or 
196                     element.get('class', '') in ('annotation', 'anchor')):
197                 if event == 'end' and element.tail:
198                     for fragment_id in open_fragments:
199                         open_fragments[fragment_id].append('text', element.tail)
200             else:
201                 for fragment_id in open_fragments:
202                     open_fragments[fragment_id].append(event, copy.copy(element))
203
204     return closed_fragments, open_fragments
205
206
207 def add_anchor(element, prefix, with_link=True, with_target=True, link_text=None):
208     parent = element.getparent()
209     index = parent.index(element)
210
211     if with_link:
212         if link_text is None:
213             link_text = prefix
214         anchor = etree.Element('a', href='#%s' % prefix)
215         anchor.set('class', 'anchor')
216         anchor.text = six.text_type(link_text)
217         parent.insert(index, anchor)
218
219     if with_target:
220         anchor_target = etree.Element('a', name='%s' % prefix)
221         anchor_target.set('class', 'target')
222         anchor_target.text = u' '
223         parent.insert(index, anchor_target)
224
225
226 def any_ancestor(element, test):
227     for ancestor in element.iterancestors():
228         if test(ancestor):
229             return True
230     return False
231
232
233 def add_anchors(root):
234     counter = 1
235     for element in root.iterdescendants():
236         def f(e):
237             return e.get('class') in ('note', 'motto', 'motto_podpis', 'dedication', 'frame') or \
238                 e.get('id') == 'nota_red' or e.tag == 'blockquote'
239         if any_ancestor(element, f):
240             continue
241
242         if element.tag == 'div' and 'verse' in element.get('class', ''):
243             if counter == 1 or counter % 5 == 0:
244                 add_anchor(element, "f%d" % counter, link_text=counter)
245             counter += 1
246         elif 'paragraph' in element.get('class', ''):
247             add_anchor(element, "f%d" % counter, link_text=counter)
248             counter += 1
249
250
251 def raw_printable_text(element):
252     working = copy.deepcopy(element)
253     for e in working.findall('a'):
254         if e.get('class') in ('annotation', 'theme-begin'):
255             e.text = ''
256     return etree.tostring(working, method='text', encoding='unicode').strip()
257
258
259 def add_table_of_contents(root):
260     sections = []
261     counter = 1
262     for element in root.iterdescendants():
263         if element.tag in ('h2', 'h3'):
264             if any_ancestor(element,
265                             lambda e: e.get('id') in ('footnotes', 'nota_red') or e.get('class') in ('person-list',)):
266                 continue
267
268             element_text = raw_printable_text(element)
269             if element.tag == 'h3' and len(sections) and sections[-1][1] == 'h2':
270                 sections[-1][3].append((counter, element.tag, element_text, []))
271             else:
272                 sections.append((counter, element.tag, element_text, []))
273             add_anchor(element, "s%d" % counter, with_link=False)
274             counter += 1
275
276     toc = etree.Element('div')
277     toc.set('id', 'toc')
278     toc_header = etree.SubElement(toc, 'h2')
279     toc_header.text = u'Spis treści'
280     toc_list = etree.SubElement(toc, 'ol')
281
282     for n, section, text, subsections in sections:
283         section_element = etree.SubElement(toc_list, 'li')
284         add_anchor(section_element, "s%d" % n, with_target=False, link_text=text)
285
286         if len(subsections):
287             subsection_list = etree.SubElement(section_element, 'ol')
288             for n1, subsection, subtext, _ in subsections:
289                 subsection_element = etree.SubElement(subsection_list, 'li')
290                 add_anchor(subsection_element, "s%d" % n1, with_target=False, link_text=subtext)
291
292     root.insert(0, toc)
293
294     
295 def add_table_of_themes(root):
296     try:
297         from sortify import sortify
298     except ImportError:
299         def sortify(x):
300             return x
301
302     book_themes = {}
303     for fragment in root.findall('.//a[@class="theme-begin"]'):
304         if not fragment.text:
305             continue
306         theme_names = [s.strip() for s in fragment.text.split(',')]
307         for theme_name in theme_names:
308             book_themes.setdefault(theme_name, []).append(fragment.get('name'))
309     book_themes = list(book_themes.items())
310     book_themes.sort(key=lambda s: sortify(s[0]))
311     themes_div = etree.Element('div', id="themes")
312     themes_ol = etree.SubElement(themes_div, 'ol')
313     for theme_name, fragments in book_themes:
314         themes_li = etree.SubElement(themes_ol, 'li')
315         themes_li.text = "%s: " % theme_name
316         for i, fragment in enumerate(fragments):
317             item = etree.SubElement(themes_li, 'a', href="#%s" % fragment)
318             item.text = str(i + 1)
319             item.tail = ' '
320     root.insert(0, themes_div)
321
322
323 def extract_annotations(html_path):
324     """Extracts annotations from HTML for annotations dictionary.
325
326     For each annotation, yields a tuple of:
327     anchor, footnote type, valid qualifiers, text, html.
328
329     """
330     from .fn_qualifiers import FN_QUALIFIERS
331
332     parser = etree.HTMLParser(encoding='utf-8')
333     tree = etree.parse(html_path, parser)
334     footnotes = tree.find('//*[@id="footnotes"]')
335     re_qualifier = re.compile(r'[^\u2014]+\s+\(([^\)]+)\)\s+\u2014')
336     if footnotes is not None:
337         for footnote in footnotes.findall('div'):
338             fn_type = footnote.get('class').split('-')[1]
339             anchor = footnote.find('a[@class="annotation"]').get('href')[1:]
340             del footnote[:2]
341             footnote.text = None
342             if len(footnote) and footnote[-1].tail == '\n':
343                 footnote[-1].tail = None
344             text_str = etree.tostring(footnote, method='text', encoding='unicode').strip()
345             html_str = etree.tostring(footnote, method='html', encoding='unicode').strip()
346
347             match = re_qualifier.match(text_str)
348             if match:
349                 qualifier_str = match.group(1)
350                 qualifiers = []
351                 for candidate in re.split('[;,]', qualifier_str):
352                     candidate = candidate.strip()
353                     if candidate in FN_QUALIFIERS:
354                         qualifiers.append(candidate)
355                     elif candidate.startswith('z '):
356                         subcandidate = candidate.split()[1]
357                         if subcandidate in FN_QUALIFIERS:
358                             qualifiers.append(subcandidate)
359             else:
360                 qualifiers = []
361
362             yield anchor, fn_type, qualifiers, text_str, html_str