863436c2810df316920bcbaac187618c41474d57
[librarian.git] / src / librarian / elements / base.py
1 # This file is part of Librarian, licensed under GNU Affero GPLv3 or later.
2 # Copyright © Fundacja Wolne Lektury. See NOTICE for more information.
3 #
4 import copy
5 import re
6 from lxml import etree
7 from librarian import dcparser, RDFNS
8 from librarian.util import get_translation
9
10 def last_words(text, n):
11     words = []
12     for w in reversed(text.split()):
13         words.append(w)
14         if len(w) > 2:
15             n -= 1
16             if not n: break
17     if n:
18         return n, text
19     else:
20         return n, ' '.join(reversed(words))
21
22
23 class WLElement(etree.ElementBase):
24     SECTION_PRECEDENCE = None
25     ASIDE = False
26
27     TXT_TOP_MARGIN = 0
28     TXT_BOTTOM_MARGIN = 0
29     TXT_PREFIX = ""
30     TXT_SUFFIX = ""
31
32     HTML_TAG = None
33     HTML_ATTR = {}
34     HTML_CLASS = None
35
36     EPUB_TAG = None
37     EPUB_ATTR = {}
38     EPUB_CLASS = None
39     EPUB_START_CHUNK = False
40    
41     CAN_HAVE_TEXT = True
42     STRIP = False
43
44     text_substitutions = [
45         ('---', '—'),
46         ('--', '–'),
47         #('...', '…'),  # Temporary turnoff for epub
48         (',,', '„'),
49         ('"', '”'),
50         ('\ufeff', ''),
51
52         ("'", "\u2019"),    # This was enabled for epub.
53     ]
54
55     @property
56     def meta_object(self):
57         if not hasattr(self, '_meta_object'):
58             elem = self.find(RDFNS('RDF'))
59             if elem is not None:
60                 self._meta_object = dcparser.BookInfo.from_element(elem)
61             else:
62                 self._meta_object = None
63         return self._meta_object
64
65     @property
66     def meta(self):
67         if self.meta_object is not None:
68             return self.meta_object
69         else:
70             if self.getparent() is not None:
71                 return self.getparent().meta
72             else:
73                 return self.document.base_meta
74
75     @property
76     def gettext(self):
77         return get_translation(self.meta.language).gettext
78
79     def in_context_of(self, setting):
80         parent = self.getparent()
81         if parent is None:
82             return False
83         try:
84             return getattr(parent, setting)
85         except AttributeError:
86             return parent.in_context_of(setting)
87
88     def signal(self, signal):
89         parent = self.getparent()
90         if parent is not None:
91             parent.signal(signal)
92     
93     def raw_printable_text(self, builder):
94         from librarian.html import raw_printable_text
95
96         # TODO: podtagi, wyroznienia, etc
97         t = ''
98         t += self.normalize_text(self.text, builder)
99         for c in self:
100             if not isinstance(c, WLElement):
101                 continue
102             if c.tag not in ('pe', 'pa', 'pt', 'pr', 'motyw'):
103                 t += c.raw_printable_text(builder)
104             t += self.normalize_text(c.tail, builder)
105         return t
106     
107     def normalize_text(self, text, builder):
108         text = text or ''
109         for e, s in self.text_substitutions:
110             text = text.replace(e, s)
111             # FIXME: TEmporary turnoff
112 #        text = re.sub(r'\s+', ' ', text)
113 ### TODO: Added now for epub
114
115         if getattr(builder, 'hyphenator', None) is not None:
116             newt = ''
117             wlist = re.compile(r'\w+|[^\w]', re.UNICODE).findall(text)
118             for w in wlist:
119                 newt += builder.hyphenator.inserted(w, '\u00AD')
120             text = newt
121
122         if builder.orphans:
123             text = re.sub(r'(?<=\s\w)\s+', '\u00A0', text)
124
125         return text
126
127     def _build_inner(self, builder, build_method):
128         child_count = len(self)
129         if self.CAN_HAVE_TEXT and self.text:
130             text = self.normalize_text(self.text, builder)
131             if self.STRIP:
132                 text = text.lstrip()
133                 if not child_count:
134                     text = text.rstrip()
135             builder.push_text(text)
136         for i, child in enumerate(self):
137             if isinstance(child, WLElement):
138                 getattr(child, build_method)(builder)
139             if self.CAN_HAVE_TEXT and child.tail:
140                 text = self.normalize_text(child.tail, builder)
141                 if self.STRIP and i == child_count - 1:
142                     text = text.rstrip()
143                 builder.push_text(text)
144
145     def _txt_build_inner(self, builder):
146         self._build_inner(builder, 'txt_build')
147
148     def txt_build(self, builder):
149         if hasattr(self, 'TXT_LEGACY_TOP_MARGIN'):
150             builder.push_legacy_margin(self.TXT_LEGACY_TOP_MARGIN)
151         else:
152             builder.push_margin(self.TXT_TOP_MARGIN)
153         builder.push_text(self.TXT_PREFIX, True)
154         self._txt_build_inner(builder)
155         builder.push_text(self.TXT_SUFFIX, True)
156         if hasattr(self, 'TXT_LEGACY_BOTTOM_MARGIN'):
157             builder.push_legacy_margin(self.TXT_LEGACY_BOTTOM_MARGIN)
158         else:
159             builder.push_margin(self.TXT_BOTTOM_MARGIN)
160
161     def _html_build_inner(self, builder):
162         self._build_inner(builder, 'html_build')
163
164     def get_html_attr(self, builder):
165         attr = self.HTML_ATTR.copy()
166         if self.HTML_CLASS:
167             attr['class'] = self.HTML_CLASS
168         # always copy the id attribute (?)
169         if self.attrib.get('id'):
170             attr['id'] = self.attrib['id']
171         elif getattr(self, 'SHOULD_HAVE_ID', False) and '_compat_section_id' in self.attrib:
172             attr['id'] = self.attrib['_compat_section_id']
173         return attr
174
175     def html_build(self, builder):
176         if self.HTML_TAG:
177             builder.start_element(
178                 self.HTML_TAG,
179                 self.get_html_attr(builder),
180             )
181
182         self._html_build_inner(builder)
183         if self.HTML_TAG:
184             builder.end_element()
185
186     def _epub_build_inner(self, builder):
187         self._build_inner(builder, 'epub_build')
188
189     def get_epub_attr(self, builder):
190         attr = self.EPUB_ATTR.copy()
191         if self.EPUB_CLASS:
192             attr['class'] = self.EPUB_CLASS
193         return attr
194
195     def epub_build(self, builder):
196         from librarian.elements.masters import Master
197
198         # TEMPORARY
199         self.CAN_HAVE_TEXT = True
200         self.STRIP = False
201        
202         start_chunk = self.EPUB_START_CHUNK and isinstance(self.getparent(), Master)
203
204         if start_chunk:
205             builder.start_chunk()
206
207         fragment = None
208         if self.SECTION_PRECEDENCE and not self.in_context_of('NO_TOC'):
209             if not start_chunk:
210                 fragment = 'sub%d' % builder.assign_section_number()
211                 self.attrib['id'] = fragment
212
213             builder.add_toc_entry(
214                 fragment,
215                 self.raw_printable_text(builder),
216                 self.SECTION_PRECEDENCE
217             )
218             
219         if self.EPUB_TAG:
220             attr = self.get_epub_attr(builder)
221             if fragment:
222                 attr['id'] = fragment
223             builder.start_element(
224                 self.EPUB_TAG,
225                 attr
226             )
227
228         self._epub_build_inner(builder)
229         if self.EPUB_TAG:
230             builder.end_element()
231
232     def validate(self):
233         from librarian.elements.masters import Master
234         from librarian.elements.blocks import DlugiCytat, PoezjaCyt
235         from librarian.elements.footnotes import Footnote
236
237         if self.SECTION_PRECEDENCE:
238             assert isinstance(self.getparent(), (Master, DlugiCytat, PoezjaCyt, Footnote)), \
239                     'Header {} inside a <{}> instead of a master.'.format(
240                             etree.tostring(self, encoding='unicode'), self.getparent().tag)
241
242         for c in self:
243             if isinstance(c, WLElement):
244                 c.validate()
245
246
247     def sanitize(self):
248         # TODO: Remove insanity here.
249         for e in self:
250             if isinstance(e, WLElement):
251                 e.sanitize()
252
253     def snip(self, words, before=None, sub=False):
254         if sub and self.ASIDE:
255             return words, []
256
257         snippet = []
258         if before is not None:
259             i = self.index(before)
260         else:
261             i = len(self)
262
263         while i > 0:
264             i -= 1
265             if self[i].tail:
266                 if words:
267                     words, text = last_words(self[i].tail, words)
268                     snippet = [('text', text)] + snippet
269
270             if words:
271                 words, subsnip = self[i].snip(words, sub=True)
272                 snippet = subsnip + snippet
273
274         if words and self.text:
275             words, text = last_words(self.text, words)
276             snippet = [('text', text)] + snippet
277                     
278         snippet = [('start', self.tag, self.attrib)] + snippet + [('end',)]
279
280         if not sub and words and not self.ASIDE:
281             # do we dare go up?
282             parent = self.getparent()
283             if parent is not None and parent.CAN_HAVE_TEXT:
284                 words, parsnip = parent.snip(words, before=self)
285                 return words, parsnip[:-1] + snippet + parsnip[-1:]
286
287         return words, snippet
288
289     def get_snippet(self, words=15):
290         from librarian.parser import parser
291
292         words, snippet = self.getparent().snip(words=words, before=self)
293         
294         cursor = snipelem = parser.makeelement('snippet')
295         snipelem._meta_object = self.meta
296         for s in snippet:
297             if s[0] == 'start':
298                 elem = parser.makeelement(s[1], **s[2])
299                 cursor.append(elem)
300                 cursor = elem
301             elif s[0] == 'end':
302                 cursor = cursor.getparent()
303             else:
304                 if len(cursor):
305                     cursor[-1].tail = (cursor[-1].tail or '') + s[1]
306                 else:
307                     cursor.text = (cursor.text or '') + s[1]
308
309         return snipelem
310
311     def get_link(self):
312         sec = getattr(self, 'SHOULD_HAVE_ID', False) and self.attrib.get('_compat_section_id')
313         if sec:
314             return sec
315         parent_index = self.getparent().index(self)
316         if parent_index:
317             return self.getparent()[parent_index - 1].get_link()
318         else:
319             return self.getparent().get_link()
320
321
322 class Snippet(WLElement):
323     pass