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