e6d897df5d3ed99570f0232b2a0a5f4d7323e44d
[librarian.git] / src / librarian / pdf.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 """PDF creation library.
7
8 Creates one big XML from the book and its children, converts it to LaTeX
9 with TeXML, then runs it by XeLaTeX.
10
11 """
12 from __future__ import print_function, unicode_literals
13
14 import os
15 import os.path
16 import shutil
17 from tempfile import mkdtemp, NamedTemporaryFile
18 import re
19 from copy import deepcopy
20 from subprocess import call, PIPE
21 from itertools import chain
22
23 from Texml.processor import process
24 from lxml import etree
25 from lxml.etree import XMLSyntaxError, XSLTApplyError
26 import six
27
28 from librarian.dcparser import Person
29 from librarian.parser import WLDocument
30 from librarian import ParseError, DCNS, get_resource, OutputFile, RDFNS
31 from librarian import functions
32 from librarian.cover import make_cover
33 from .sponsor import sponsor_logo
34
35
36 functions.reg_substitute_entities()
37 functions.reg_strip()
38 functions.reg_starts_white()
39 functions.reg_ends_white()
40 functions.reg_texcommand()
41
42 STYLESHEETS = {
43     'wl2tex': 'pdf/wl2tex.xslt',
44 }
45
46 # CUSTOMIZATIONS = [
47 #     'nofootnotes',
48 #     'nothemes',
49 #     'defaultleading',
50 #     'onehalfleading',
51 #     'doubleleading',
52 #     'nowlfont',
53 # ]
54
55
56 def insert_tags(doc, split_re, tagname, exclude=None):
57     """ inserts <tagname> for every occurence of `split_re' in text nodes in the `doc' tree
58
59     >>> t = etree.fromstring('<a><b>A-B-C</b>X-Y-Z</a>')
60     >>> insert_tags(t, re.compile('-'), 'd')
61     >>> print(etree.tostring(t, encoding='unicode'))
62     <a><b>A<d/>B<d/>C</b>X<d/>Y<d/>Z</a>
63     """
64
65     for elem in doc.iter(tag=etree.Element):
66         if exclude and elem.tag in exclude:
67             continue
68         if elem.text:
69             chunks = split_re.split(elem.text)
70             while len(chunks) > 1:
71                 ins = etree.Element(tagname)
72                 ins.tail = chunks.pop()
73                 elem.insert(0, ins)
74             elem.text = chunks.pop(0)
75         if elem.tail:
76             chunks = split_re.split(elem.tail)
77             parent = elem.getparent()
78             ins_index = parent.index(elem) + 1
79             while len(chunks) > 1:
80                 ins = etree.Element(tagname)
81                 ins.tail = chunks.pop()
82                 parent.insert(ins_index, ins)
83             elem.tail = chunks.pop(0)
84
85
86 def substitute_hyphens(doc):
87     insert_tags(doc,
88                 re.compile("(?<=[^-\s])-(?=[^-\s])"),
89                 "dywiz",
90                 exclude=[DCNS("identifier.url"), DCNS("rights.license"), "meta"]
91                 )
92
93
94 def fix_hanging(doc):
95     insert_tags(doc,
96                 re.compile("(?<=\s\w)\s+"),
97                 "nbsp",
98                 exclude=[DCNS("identifier.url"), DCNS("rights.license")]
99                 )
100
101
102 def fix_tables(doc):
103     for kol in doc.iter(tag='kol'):
104         if kol.tail is not None:
105             if not kol.tail.strip():
106                 kol.tail = None
107     for table in chain(doc.iter(tag='tabela'), doc.iter(tag='tabelka')):
108         if table.get('ramka') == '1' or table.get('ramki') == '1':
109             table.set('_format', '|' + 'X|' * len(table[0]))
110         else:
111             table.set('_format', 'X' * len(table[0]))
112
113
114 def mark_subauthors(doc):
115     root_author = ', '.join(elem.text for elem in doc.findall('./' + RDFNS('RDF') + '//' + DCNS('creator_parsed')))
116     last_author = None
117     # jeśli autor jest inny niż autor całości i niż poprzedni autor
118     # to wstawiamy jakiś znacznik w rdf?
119     for subutwor in doc.xpath('/utwor/utwor'):
120         author = ', '.join(elem.text for elem in subutwor.findall('.//' + DCNS('creator_parsed')))
121         if author not in (last_author, root_author):
122             subutwor.find('.//' + RDFNS('RDF')).append(etree.Element('use_subauthor'))
123         last_author = author
124
125
126 def move_motifs_inside(doc):
127     """ moves motifs to be into block elements """
128     for master in doc.xpath('//powiesc|//opowiadanie|//liryka_l|//liryka_lp|'
129                             '//dramat_wierszowany_l|//dramat_wierszowany_lp|//dramat_wspolczesny'):
130         for motif in master.xpath('motyw'):
131             for sib in motif.itersiblings():
132                 if sib.tag not in ('sekcja_swiatlo', 'sekcja_asterysk', 'separator_linia',
133                                    'begin', 'end', 'motyw', 'extra', 'uwaga'):
134                     # motif shouldn't have a tail - it would be untagged text
135                     motif.tail = None
136                     motif.getparent().remove(motif)
137                     sib.insert(0, motif)
138                     break
139
140
141 def hack_motifs(doc):
142     """ dirty hack for the marginpar-creates-orphans LaTeX problem
143     see http://www.latex-project.org/cgi-bin/ltxbugs2html?pr=latex/2304
144
145     moves motifs in stanzas from first verse to second
146     and from next to last to last, then inserts negative vspace before them
147     """
148     for motif in doc.findall('//strofa//motyw'):
149         # find relevant verse-level tag
150         verse, stanza = motif, motif.getparent()
151         while stanza is not None and stanza.tag != 'strofa':
152             verse, stanza = stanza, stanza.getparent()
153         breaks_before = sum(1 for i in verse.itersiblings('br', preceding=True))
154         breaks_after = sum(1 for i in verse.itersiblings('br'))
155         if (breaks_before == 0 and breaks_after > 0) or breaks_after == 1:
156             move_by = 1
157             if breaks_after == 2:
158                 move_by += 1
159             moved_motif = deepcopy(motif)
160             motif.tag = 'span'
161             motif.text = None
162             moved_motif.tail = None
163             moved_motif.set('moved', str(move_by))
164
165             for br in verse.itersiblings('br'):
166                 if move_by > 1:
167                     move_by -= 1
168                     continue
169                 br.addnext(moved_motif)
170                 break
171
172
173 def parse_creator(doc):
174     """Generates readable versions of creator and translator tags.
175
176     Finds all dc:creator and dc.contributor.translator tags
177     and adds *_parsed versions with forenames first.
178     """
179     for person in doc.xpath("|".join('//dc:' + tag for tag in ('creator', 'contributor.translator')),
180                             namespaces={'dc': str(DCNS)})[::-1]:
181         if not person.text:
182             continue
183         p = Person.from_text(person.text)
184         person_parsed = deepcopy(person)
185         person_parsed.tag = person.tag + '_parsed'
186         person_parsed.set('sortkey', person.text)
187         person_parsed.text = p.readable()
188         person.getparent().insert(0, person_parsed)
189
190
191 def get_stylesheet(name):
192     return get_resource(STYLESHEETS[name])
193
194
195 def package_available(package, args='', verbose=False):
196     """ check if a verion of a latex package accepting given args is available """
197     tempdir = mkdtemp('-wl2pdf-test')
198     fpath = os.path.join(tempdir, 'test.tex')
199     f = open(fpath, 'w')
200     f.write("""
201         \\documentclass{wl}
202         \\usepackage[%s]{%s}
203         \\begin{document}
204         \\end{document}
205         """ % (args, package))
206     f.close()
207     if verbose:
208         p = call(['xelatex', '-output-directory', tempdir, fpath])
209     else:
210         p = call(['xelatex', '-interaction=batchmode', '-output-directory', tempdir, fpath], stdout=PIPE, stderr=PIPE)
211     shutil.rmtree(tempdir)
212     return p == 0
213
214
215 def transform(wldoc, verbose=False, save_tex=None, morefloats=None,
216               cover=None, flags=None, customizations=None, ilustr_path='', latex_dir=False):
217     """ produces a PDF file with XeLaTeX
218
219     wldoc: a WLDocument
220     verbose: prints all output from LaTeX
221     save_tex: path to save the intermediary LaTeX file to
222     morefloats (old/new/none): force specific morefloats
223     cover: a cover.Cover factory or True for default
224     flags: less-advertising,
225     customizations: user requested customizations regarding various formatting parameters (passed to wl LaTeX class)
226     """
227
228     # Parse XSLT
229     try:
230         book_info = wldoc.book_info
231         document = load_including_children(wldoc)
232         root = document.edoc.getroot()
233
234         if cover:
235             if cover is True:
236                 cover = make_cover
237             bound_cover = cover(book_info, width=1200)
238             root.set('data-cover-width', str(bound_cover.width))
239             root.set('data-cover-height', str(bound_cover.height))
240             if bound_cover.uses_dc_cover:
241                 if book_info.cover_by:
242                     root.set('data-cover-by', book_info.cover_by)
243                 if book_info.cover_source:
244                     root.set('data-cover-source', book_info.cover_source)
245         if flags:
246             for flag in flags:
247                 root.set('flag-' + flag, 'yes')
248
249         # check for LaTeX packages
250         if morefloats:
251             root.set('morefloats', morefloats.lower())
252         elif package_available('morefloats', 'maxfloats=19'):
253             root.set('morefloats', 'new')
254
255         # add customizations
256         if customizations is not None:
257             root.set('customizations', u','.join(customizations))
258
259         # add editors info
260         editors = document.editors()
261         if editors:
262             root.set('editors', u', '.join(sorted(
263                 editor.readable() for editor in editors)))
264         if document.book_info.funders:
265             root.set('funders', u', '.join(document.book_info.funders))
266         if document.book_info.thanks:
267             root.set('thanks', document.book_info.thanks)
268
269         # hack the tree
270         move_motifs_inside(document.edoc)
271         hack_motifs(document.edoc)
272         parse_creator(document.edoc)
273         substitute_hyphens(document.edoc)
274         fix_hanging(document.edoc)
275         fix_tables(document.edoc)
276         mark_subauthors(document.edoc)
277
278         # wl -> TeXML
279         style_filename = get_stylesheet("wl2tex")
280         style = etree.parse(style_filename)
281         functions.reg_mathml_latex()
282
283         # TeXML -> LaTeX
284         temp = mkdtemp('-wl2pdf')
285
286         for ilustr in document.edoc.findall("//ilustr"):
287             shutil.copy(os.path.join(ilustr_path, ilustr.get("src")), temp)
288
289         for sponsor in book_info.sponsors:
290             ins = etree.Element("data-sponsor", name=sponsor)
291             logo = sponsor_logo(sponsor)
292             if logo:
293                 fname = 'sponsor-%s' % os.path.basename(logo)
294                 shutil.copy(logo, os.path.join(temp, fname))
295                 ins.set('src', fname)
296             root.insert(0, ins)
297                 
298         if book_info.sponsor_note:
299             root.set("sponsor-note", book_info.sponsor_note)
300
301         texml = document.transform(style)
302
303         if cover:
304             with open(os.path.join(temp, 'cover.png'), 'w') as f:
305                 bound_cover.save(f, quality=80)
306
307         del document  # no longer needed large object :)
308
309         tex_path = os.path.join(temp, 'doc.tex')
310         fout = open(tex_path, 'wb')
311         process(six.BytesIO(texml), fout, 'utf-8')
312         fout.close()
313         del texml
314
315         if save_tex:
316             shutil.copy(tex_path, save_tex)
317
318         # LaTeX -> PDF
319         shutil.copy(get_resource('pdf/wl.cls'), temp)
320         shutil.copy(get_resource('res/wl-logo.png'), temp)
321
322         if latex_dir:
323             return temp
324
325         try:
326             cwd = os.getcwd()
327         except OSError:
328             cwd = None
329         os.chdir(temp)
330
331         # some things work better when compiled twice
332         # (table of contents, [line numbers - disabled])
333         for run in range(2):
334             if verbose:
335                 p = call(['xelatex', tex_path])
336             else:
337                 p = call(['xelatex', '-interaction=batchmode', tex_path], stdout=PIPE, stderr=PIPE)
338             if p:
339                 raise ParseError("Error parsing .tex file")
340
341         if cwd is not None:
342             os.chdir(cwd)
343
344         output_file = NamedTemporaryFile(prefix='librarian', suffix='.pdf', delete=False)
345         pdf_path = os.path.join(temp, 'doc.pdf')
346         shutil.move(pdf_path, output_file.name)
347         shutil.rmtree(temp)
348         return OutputFile.from_filename(output_file.name)
349
350     except (XMLSyntaxError, XSLTApplyError) as e:
351         raise ParseError(e)
352
353
354 def load_including_children(wldoc=None, provider=None, uri=None):
355     """ Makes one big xml file with children inserted at end.
356     
357     Either wldoc or provider and URI must be provided.
358     """
359
360     if uri and provider:
361         f = provider.by_uri(uri)
362         text = f.read().decode('utf-8')
363         f.close()
364     elif wldoc is not None:
365         text = etree.tostring(wldoc.edoc, encoding='unicode')
366         provider = wldoc.provider
367     else:
368         raise ValueError('Neither a WLDocument, nor provider and URI were provided.')
369
370     text = re.sub(r"([\u0400-\u04ff]+)", r"<alien>\1</alien>", text)
371
372     document = WLDocument.from_bytes(text.encode('utf-8'), parse_dublincore=True, provider=provider)
373     document.swap_endlines()
374
375     for child_uri in document.book_info.parts:
376         child = load_including_children(provider=provider, uri=child_uri)
377         document.edoc.getroot().append(child.edoc.getroot())
378     return document