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