%s\n' % (generate_label(formula), formula) 263 | 264 | 265 | # pylint: disable=too-many-instance-attributes 266 | class ImageFormatter: # ToDo: localisation 267 | """ImageFormatter(is_epub=False) 268 | 269 | Format converted formula to be included into HTML. A typical image 270 | attribute will contain the path to the image, style information, a CSS class 271 | to be used in custom CSS style sheets and an alternative text (the LaTeX 272 | source) for people who disabled images or for blind screen reader users. 273 | If set, LaTeX formulas exceeding a configurable maximum length will be 274 | excluded. The image will be a link which leads to the excluded image text. 275 | The alt attribute is a text-only attribute and e.g. line breaks will be lost 276 | for screen reader users, so it makes sense for longer formulas to be 277 | external to be easily readable. Furthermore the alt attribute is limited in 278 | size, so formulas that are too long need to be treated differently. 279 | If that behavior is not wanted, it can be disabled and 280 | nothing will be excluded. 281 | 282 | Keyword arguments 283 | 284 | * `base_path=""`: base path where images are stored, e.g. "images" 285 | * `link_prefix=""`: a prefix which should be added to generated links, e.g. 286 | `"https://example.com/img/"` 287 | * `exclusion_file_path=""`: the path which formula descriptions are 288 | written to which exceed a certain threshold that doesn't fit into the 289 | alt tag of the `img` tag 290 | * `is_epub`: round height/width of the linked images to comply with the 291 | EPUB standard. 292 | 293 | Intended usage: 294 | 295 | fmt = ImageFormatter() # use one of the children classes 296 | # values as returned by Tex2img 297 | fmt.format(pos, formula, img_path, displaymath=False) 298 | fmt.format(pos2, formula2, img_path2, displaymath=True) 299 | ... 300 | img.get_excluded() # a list of formulas that were too long for the alt tag 301 | """ 302 | 303 | def __init__(self, base_path=None, link_prefix='', 304 | exclusion_file_path=sink.EXCLUSION_FILE_NAME, is_epub=False): 305 | self.__inline_maxlength = 100 306 | self._excluded_formulas = collections.OrderedDict() 307 | self.__url = '' 308 | self._is_epub = is_epub 309 | self._css = {'inline': 'inlinemath', 'display': 'displaymath'} 310 | self.__replace_nonascii = False 311 | self._link_prefix = link_prefix if link_prefix else '' 312 | base_path = ("" if not base_path else base_path) 313 | self._exclusion_filepath = posixpath.join( 314 | base_path, exclusion_file_path) 315 | if os.path.exists(self._exclusion_filepath) and not os.access( 316 | self._exclusion_filepath, os.W_OK 317 | ): 318 | raise OSError(f'file {self._exclusion_filepath} not writable') 319 | 320 | def get_exclusion_file_path(self): 321 | """Return the path to the file to which formulas will be excluded too 322 | if their description exceeds the alt attribute length. 323 | 324 | May be None. 325 | """ 326 | return self._exclusion_filepath if self._exclusion_filepath else None 327 | 328 | def set_replace_nonascii(self, flag): 329 | """If True, non-ascii characters will be replaced through their LaTeX 330 | command. 331 | 332 | Note that alphabetical characters will not be replaced, to allow 333 | easier readibility. 334 | """ 335 | self.__replace_nonascii = flag 336 | 337 | def set_max_formula_length(self, length): 338 | """Set maximum length of a formula before it gets excluded into a 339 | separate file.""" 340 | self.__inline_maxlength = length 341 | 342 | def set_inline_math_css_class(self, css): 343 | """set css class for inline math.""" 344 | self._css['inline'] = css 345 | 346 | @abstractmethod 347 | def _generate_link_label(self, formula): 348 | """Generate the link to an excluded formula, consisting either of path 349 | and label or just a label. 350 | 351 | The label is generated uniquely for each label by this function. 352 | This function needs to be customised by implementors, e.g. to 353 | return "foo.html#formula" or "#formula", etc. 354 | """ 355 | 356 | def set_display_math_css_class(self, css): 357 | """set css class for display math.""" 358 | self._css['display'] = css 359 | 360 | def set_is_epub(self, flag): 361 | """Active rounding of height and weight attribute of the formula images 362 | to comply with the EPUB standard.""" 363 | self._is_epub = flag 364 | 365 | def set_url(self, prefix): 366 | """Set URL prefix which is used as a prefix to the image file in the 367 | HTML link.""" 368 | self.__url = prefix 369 | 370 | def get_excluded(self): 371 | """Return a list of LaTeX formulas that did not fit the alt tag and 372 | were hence formatted separately, e.g. into a separate document.""" 373 | return self._excluded_formulas 374 | 375 | def _process_image(self, pos, formula, img_path, displaymath=False): 376 | """Process positioning of the image and the various URI-related 377 | parameters into formatting information. 378 | 379 | :param pos dictionary containing keys depth, height and width 380 | :param formula LaTeX alternative text 381 | :param img_path: path to image 382 | :param displaymath display or inline math (default False, inline maths) 383 | :returns a dictionary with the information about the image; its keys 384 | correspond to HTML image attributes, except for "url" and "image". 385 | """ 386 | image = {'formula': formula} 387 | full_url = img_path 388 | if self.__url: 389 | full_url = self.__url.rstrip('/') + '/' + img_path 390 | image['url'] = full_url 391 | # depth is a negative offset (float, first, str later) 392 | depth = float(pos['depth']) * -1 393 | if self._is_epub: 394 | depth = str(int(depth)) 395 | else: 396 | depth = f'{depth:.2f}' 397 | image['style'] = f'vertical-align: {depth}px; margin: 0;' 398 | 399 | image['class'] = self._css['display'] if displaymath else self._css['inline'] 400 | if self._is_epub: 401 | image.update( 402 | {'height': str(int(pos['height'])), 403 | 'width': str(int(pos['width']))} 404 | ) 405 | else: 406 | image.update( 407 | {'height': f"{pos['height']:.2f}", 408 | 'width': f"{pos['width']:.2f}"} 409 | ) 410 | return image 411 | 412 | @abstractmethod 413 | def add_excluded(self, image): 414 | """Add a formula to the list of excluded formulas.""" 415 | 416 | @abstractmethod 417 | def format_internal(self, image, link_label=None): 418 | """Format an internal formula for the target output (defined by the 419 | class). 420 | 421 | :param image formula information as returned by _process_image; formula 422 | will have been shortened if it were too long 423 | :param link_label if not None, the formula image will contian a reference 424 | or link to the long version of the formula (e.g. because it didn't fit 425 | the alt attribute) 426 | """ 427 | 428 | def format(self, pos, formula, img_path, displaymath=False): 429 | """This method formats a formula. It invokes the abstract methods 430 | `format_internal` and `add_excluded`. `add_excluded` is only invoked if 431 | the formula is too long and if exclusion has been configured. This 432 | method returns the formatted image. The formatted image will contain a 433 | reference to the excluded formula source, if applicable. The formatted 434 | excluded formulas can be retrieved using get_excluded(). 435 | 436 | :param pos dictionary containing keys depth, height and width 437 | :param formula LaTeX alternative text 438 | :param img_path: path to image 439 | :param displaymath whether or not formula is in display math (default: no) 440 | :returns a tuple containing the formatted image and, if applicable, the 441 | excluded image alternate text. 442 | """ 443 | formula = typesetting.increase_readability( 444 | formula, self.__replace_nonascii) 445 | processed_data = self._process_image( 446 | pos, formula, img_path, displaymath) 447 | shortened_data = processed_data.copy() 448 | shortened_data['formula'] = formula 449 | link_destination = None 450 | if len(formula) > self.__inline_maxlength: 451 | shortened_data['formula'] = f"{formula[:self.__inline_maxlength]}..." 452 | link_destination = self._generate_link_destination(processed_data) 453 | # builds up internal list of formatted excluded formulas 454 | self.add_excluded(processed_data) 455 | return self.format_internal(shortened_data, link_destination) 456 | 457 | 458 | class HtmlImageFormatter(ImageFormatter): 459 | """Format formulas for HTML file output. 460 | 461 | See ImageFormatter for information about the usage of the class. 462 | """ 463 | 464 | def __init__(self, *args, **kwargs): 465 | super().__init__(*args, **kwargs) 466 | 467 | def _generate_link_destination(self, formula): 468 | html_label = generate_label(formula['formula']) 469 | exclusion_filelink = posixpath.join( 470 | self._link_prefix, self._exclusion_filepath 471 | ) 472 | return f'{exclusion_filelink}#{html_label}' 473 | 474 | def format_internal(self, image, link_label=None): 475 | link_start, link_end = ('', '') 476 | if link_label: 477 | link_start = f'' if link_label else '' 478 | link_end = '' if link_label else '' 479 | escaped_formula = html.escape(image['formula'], quote=True) 480 | return ( 481 | link_start 482 | + ( 483 | f'
{escaped_formula}\n')
56 |
57 |
58 | # Map the sink type to their processing function.
59 | EXCLUSION_FORMULA_SINKS = {
60 | SinkType.html_file: html_write_excluded_file,
61 | SinkType.html_body: html_write_excluded_body,
62 | }
63 |
--------------------------------------------------------------------------------
/gleetex/typesetting.py:
--------------------------------------------------------------------------------
1 | # (c) 2013-2021 Sebastian Humenda
2 | # This code is licenced under the terms of the LGPL-3+, see the file COPYING for
3 | # more details.
4 | """This module contains functionality to typeset formulas for the usage in a
5 | LaTeX document (e.g. creating the preamble, replacing non-ascii letters) and to
6 | typeset LaTeX formulas in a more readable way as alternate description of the
7 | resulting image."""
8 |
9 | import inspect
10 | import re
11 |
12 | from . import unicode
13 |
14 | FORMATTING_COMMANDS = [
15 | '\\ ',
16 | '\\,',
17 | '\\;',
18 | '\\big',
19 | '\\Big',
20 | '\\left',
21 | '\\right',
22 | '\\limits',
23 | ]
24 |
25 | # A list of LaTeX math environments which place their content in math
26 | # mode but can't be used in math mode themselves (i.e. be nested). Used
27 | # to prevent bad math environment nesting while rendering (see #21).
28 | #
29 | # Assembled from
30 | # - `https://docs.mathjax.org/en/latest/input/tex/macros/index.html#environments`
31 | # - `https://en.wikibooks.org/wiki/LaTeX/Advanced_Mathematics`,
32 | # filtered by custom tests to see if LaTeX compiles with nesting. Some
33 | # environments might still be missing, but these should cover the most
34 | # common use cases.
35 | NON_NESTABLE_MATH_ENVS = [
36 | 'align*',
37 | 'align',
38 | 'alignat*',
39 | 'alignat',
40 | 'displaymath',
41 | 'empheq',
42 | 'eqnarray*',
43 | 'eqnarray',
44 | 'equation*',
45 | 'equation',
46 | 'flalign*',
47 | 'flalign',
48 | 'gather*',
49 | 'gather',
50 | 'math',
51 | 'multline*',
52 | 'multline',
53 | 'numcases',
54 | 'prooftree',
55 | 'subnumcases',
56 | 'xalignat*',
57 | 'xalignat',
58 | 'xxalignat',
59 | ]
60 | # The pattern used to detect the presence of one of the environments
61 | # above in a given formula. We look for such an environment opening
62 | # after ignoring all initial space characters and LaTeX `%` comments
63 | # *only*, as the it is supposed to only be a formula and to avoid
64 | # complex and error-prone parsing, while still supporting the presumably
65 | # most common use cases.
66 | MATH_ENV_DETECTION_PATTERN = re.compile(
67 | r'\s*(%.*(\n|\r\n?)\s*)*\\begin\{{({})\}}'
68 | .format('|'.join(re.escape(env) for env in NON_NESTABLE_MATH_ENVS)),
69 | )
70 |
71 |
72 | class DocumentSerializationException(Exception):
73 | """This error is raised whenever a non-ascii character contained in a
74 | formula could not be replaced by a LaTeX command. It provides the following
75 | attributes:
76 |
77 | formula - the formula
78 | index - position in formula
79 | upoint - unicode point.
80 | """
81 |
82 | def __init__(self, formula, index, upoint):
83 | self.formula = formula
84 | self.index = index
85 | self.upoint = upoint
86 | super().__init__(formula, index, upoint)
87 |
88 | def __str__(self):
89 | return (
90 | 'could not find LaTeX replacement command for unicode '
91 | 'character %d, index %d in formula %s'
92 | ) % (self.upoint, self.index, self.formula)
93 |
94 |
95 | def escape_unicode_maths(formula, replace_alphabeticals=True):
96 | """This function uses the unicode table to replace any non-ascii character
97 | (identified with its unicode code point) with a LaTeX command.
98 |
99 | It also parses the formula for commands as e.g. \\\text or \\mbox
100 | and applies text-mode commands within them. This allows the
101 | conversion of formulas with unicode maths with old-style LaTeX2e,
102 | which gleetex depends on.
103 | """
104 | if not any(ord(ch) > 160 for ch in formula):
105 | return formula # no umlauts, no replacement
106 |
107 | # characters in math mode need a different replacement than in text mode.
108 | # Therefore, the string has to be split into parts of math and text mode.
109 | chunks = []
110 | if not ('\\text' in formula or '\\mbox' in formula):
111 | # no text mode, so tread a
112 | chunks = [formula]
113 | else:
114 | start = 0
115 | while '\\text' in formula[start:] or '\\mbox' in formula[start:]:
116 | index = formula[start:].find('\\text')
117 | if index < 0:
118 | index = formula[start:].find('\\mbox')
119 | opening_brace = formula[start + index:].find('{') + start + index
120 | # add text before text-alike command and the command itself to chunks
121 | chunks.append(formula[start:opening_brace])
122 | closing_brace = get_matching_brace(formula, opening_brace)
123 | # add text-mode stuff
124 | chunks.append(formula[opening_brace: closing_brace + 1])
125 | start = closing_brace + 1
126 | # add last chunk
127 | chunks.append(formula[start:])
128 |
129 | is_math = True
130 | for index, chunk in enumerate(chunks):
131 | try:
132 | chunks[index] = replace_unicode_characters(
133 | chunk, is_math, replace_alphabeticals=replace_alphabeticals
134 | )
135 | except ValueError as e: # unicode point missing
136 | index = int(e.args[0])
137 | raise DocumentSerializationException(
138 | formula, index, ord(formula[index])
139 | ) from None
140 | is_math = not is_math
141 | return ''.join(chunks)
142 |
143 |
144 | def replace_unicode_characters(characters, is_math, replace_alphabeticals=True):
145 | """Replace all non-ascii characters within the given string with their
146 | LaTeX equivalent. The boolean is_math indicates, whether text-mode commands
147 | (like in \\text{}) or the amsmath equivalents should be used. When
148 | replace_alphabeticals is False, alphabetical characters will not be
149 | replaced through their LaTeX command when in text mode, so that text
150 | within.
151 |
152 | \\text{} (and similar) is not garbled. For instance, \\text{für} is
153 | be replaced by \\text{f\"{u}r} when replace_alphabeticals=True. This
154 | is useful for the alt attribute of an image, where the reader might
155 | want to read the normal text as such. This function raises a
156 | ValueError if a unicode point is not in the table. The first
157 | argument of the ValueError is the index within the string, where the
158 | unknown unicode character has been encountered.
159 | """
160 | result = []
161 | for idx, character in enumerate(characters):
162 | if (
163 | ord(character) < 168
164 | ): # ignore normal ascii character and unicode control sequences
165 | result.append(character)
166 | # treat alphanumerical characters differently when in text mode, see doc
167 | # string; don't replace alphabeticals if specified
168 | elif character.isalpha() and not replace_alphabeticals:
169 | result.append(character)
170 | else:
171 | mode = unicode.LaTeXMode.mathmode if is_math else unicode.LaTeXMode.textmode
172 | commands = unicode.unicode_table.get(ord(character))
173 | if not commands: # unicode point missing in table
174 | # is catched one level above; provide index for more concise error output
175 | raise ValueError(characters.index(character))
176 | # if math mode and only a text alternative exists, add \\text{}
177 | # around it
178 | if mode == unicode.LaTeXMode.mathmode and mode not in commands:
179 | result.append('\\text{%s}' %
180 | commands[unicode.LaTeXMode.textmode])
181 | else:
182 | result.append(commands[mode])
183 | # if the next character is alphabetical, add space
184 | if (
185 | (idx + 1) < len(characters)
186 | and characters[idx + 1].isalpha()
187 | and commands[mode][-1].isalpha()
188 | ):
189 | result.append(' ')
190 | return ''.join(result)
191 |
192 |
193 | def get_matching_brace(string, pos_of_opening_brace):
194 | if string[pos_of_opening_brace] != '{':
195 | raise ValueError(
196 | 'index %s in string %s: not a opening brace'
197 | % (pos_of_opening_brace, repr(string))
198 | )
199 | counter = 1
200 | for index, ch in enumerate(string[pos_of_opening_brace + 1:]):
201 | if ch == '{':
202 | counter += 1
203 | elif ch == '}':
204 | counter -= 1
205 | if counter == 0:
206 | return pos_of_opening_brace + index + 1
207 | if counter != 0:
208 | raise ValueError('Unbalanced braces in formula ' + repr(string))
209 |
210 |
211 | # pylint: disable=too-many-instance-attributes
212 | class LaTeXDocument:
213 | """This class represents a LaTeX document.
214 |
215 | It is intended to contain an equation as main content and properties
216 | to customize it. Its main purpose is to provide a str method which
217 | will serialize it to a full LaTeX document.
218 | """
219 |
220 | def __init__(self, eqn):
221 | self.__encoding = None
222 | self.__equation = eqn
223 | self.__displaymath = False
224 | self.__fontsize = 12
225 | self.__background_color = None
226 | self.__foreground_color = None
227 | self._preamble = ''
228 | self.__maths_env = None
229 | self.__replace_nonascii = False
230 |
231 | def _parse_color(self, color):
232 | # could be a valid color name
233 | try: # hex number?
234 | return int(color, 16)
235 | except ValueError:
236 | return color # treat as normal dvips compatible colour name
237 |
238 | def set_background_color(self, color):
239 | """Set the background color.
240 |
241 | The `color` can be either a valid dvips name or a tuple with RGB
242 | values between 0 and 1. If unset, the image will be transparent.
243 | """
244 | self.__background_color = self._parse_color(color)
245 |
246 | def set_foreground_color(self, color):
247 | """Set the foreground color.
248 |
249 | The `color` can be either a valid dvips name or a tuple with RGB
250 | values between 0 and 1. If unset, the text will be black.
251 | """
252 | self.__foreground_color = self._parse_color(color)
253 |
254 | def set_replace_nonascii(self, flag):
255 | """If True, all non-ascii character will be replaced through a LaTeX
256 | command."""
257 | self.__replace_nonascii = flag
258 |
259 | def set_latex_environment(self, env):
260 | """Set maths environment name like `displaymath` or `flalign*`."""
261 | self.__maths_env = env
262 |
263 | def get_latex_environment(self):
264 | return self.__maths_env
265 |
266 | def get_encoding(self):
267 | """Return encoding for the document (or None)."""
268 | return self.__encoding
269 |
270 | def set_preamble_string(self, p):
271 | """Set the string to add to the preamble of the LaTeX document."""
272 | self._preamble = p
273 |
274 | def set_encoding(self, encoding):
275 | """Set the encoding as used by the inputenc package."""
276 | if encoding.lower().startswith('utf') and '8' in encoding:
277 | self.__encoding = 'utf8'
278 | elif (
279 | encoding.lower().startswith('iso') and '8859' in encoding
280 | ) or encoding.lower() == 'latin1':
281 | self.__encoding = 'latin1'
282 | else:
283 | # if you plan to add an encoding, you have to adjust the str
284 | # function, which also loads the fontenc package
285 | raise ValueError(
286 | (
287 | 'Encoding %s is not supported at the moment. If '
288 | 'you want to use LaTeX 2e, you should report a bug at the home '
289 | 'page of GladTeX.'
290 | )
291 | % encoding
292 | )
293 |
294 | def set_displaymath(self, flag):
295 | """Set whether the formula is set in displaymath."""
296 | if not isinstance(flag, bool):
297 | raise TypeError('Displaymath parameter must be of type bool.')
298 | self.__displaymath = flag
299 |
300 | def is_displaymath(self):
301 | return self.__displaymath
302 |
303 | def _get_encoding_preamble(self):
304 | # first check whether there are umlauts within the formula and if so, an
305 | # encoding has been set
306 | if any(ord(ch) > 128 for ch in self.__equation) and not self.__replace_nonascii:
307 | if not self.__encoding:
308 | raise ValueError(
309 | (
310 | 'No encoding set, but non-ascii characters '
311 | 'present. Please specify an encoding.'
312 | )
313 | )
314 | encoding_preamble = ''
315 | if self.__encoding:
316 | # try to guess language and hence character set (fontenc)
317 | import locale
318 |
319 | language = locale.getdefaultlocale()
320 | if language and language[0]: # extract just the language code
321 | language = language[0].split('_')[0]
322 | if not language or not language[0]:
323 | language = 'en'
324 | # check whether language on computer is within T1 and hence whether
325 | # it should be loaded; I know that this can be a misleading
326 | # assumption, but there's no better way that I know of
327 | if language in ['fr', 'es', 'it', 'de', 'nl', 'ro', 'en']:
328 | encoding_preamble += '\n\\usepackage[T1]{fontenc}'
329 | else:
330 | raise ValueError(
331 | (
332 | 'Language not supported by T1 fontenc '
333 | 'encoding; please report this to the GladTeX project.'
334 | )
335 | )
336 | return encoding_preamble
337 |
338 | def set_fontsize(self, size_in_pt):
339 | """Set fontsize in pt, 12 pt by default."""
340 | self.__fontsize = size_in_pt
341 |
342 | def get_fontsize(self):
343 | return self.__fontsize
344 |
345 | def __str__(self):
346 | preamble = (
347 | self._get_encoding_preamble()
348 | + ('\n\\usepackage[utf8]{inputenc}\n\\usepackage{amsmath, amssymb}' '\n')
349 | + (self._preamble if self._preamble else '')
350 | )
351 | return self._format_document(preamble)
352 |
353 | def _format_color_definition(self, which):
354 | color = getattr(self, '_%s__%s_color' %
355 | (self.__class__.__name__, which))
356 | if not color or isinstance(color, str):
357 | return ''
358 | return '\\definecolor{%s}{HTML}{%s}' % (which, hex(color)[2:].upper().zfill(6))
359 |
360 | def _format_colors(self):
361 | color_defs = (
362 | self._format_color_definition('background'),
363 | self._format_color_definition('foreground'),
364 | )
365 | color_body = ''
366 | if self.__background_color:
367 | color_body += '\\pagecolor{%s}' % (
368 | 'background' if color_defs[0] else self.__background_color
369 | )
370 | if self.__foreground_color:
371 | # opening brace isn't required here, inserted automatically
372 | color_body += '\\color{%s}' % (
373 | 'foreground' if color_defs[1] else self.__foreground_color
374 | )
375 | return (''.join(color_defs), color_body)
376 |
377 | def _format_document(self, preamble):
378 | """Return a formatted LaTeX document with the specified formula
379 | embedded."""
380 | formula = self.__equation.lstrip().rstrip()
381 | if self.__replace_nonascii:
382 | formula = escape_unicode_maths(formula, replace_alphabeticals=True)
383 | # Try to detect and support the usage of math environments which
384 | # cannot be nested in other math environments in order to
385 | # prevent invalid nesting. I.e., when found, such an environment
386 | # is not wrapped (fixing #21).
387 | if MATH_ENV_DETECTION_PATTERN.match(formula):
388 | opening = closing = ''
389 | elif self.__maths_env:
390 | opening = '\\begin{%s}' % self.__maths_env
391 | closing = '\\end{%s}' % self.__maths_env
392 | else:
393 | # determine characters with which to surround the formula
394 | opening = '\\[' if self.__displaymath else '\\('
395 | closing = '\\]' if self.__displaymath else '\\)'
396 | fontsize = 'fontsize=%ipt' % self.__fontsize
397 | color_preamble, color_body = self._format_colors()
398 | return inspect.cleandoc(
399 | f"""
400 | \\PassOptionsToPackage{{dvipsnames}}{{xcolor}}\n
401 | \\documentclass[{fontsize}, fleqn]{{scrartcl}}\n
402 | {preamble}
403 | \\usepackage{{xcolor}}
404 | {color_preamble}
405 | {color_body}
406 | % tightpage must be last, see its package docs
407 | \\usepackage[active,textmath,displaymath,tightpage]{{preview}}\n
408 | \\begin{{document}}\n
409 | \\noindent%
410 | \\begin{{preview}}{{%s
411 | {opening}{formula}{closing}}}\\end{{preview}}\n
412 | \\end{{document}}\n
413 | """
414 | )
415 |
416 |
417 | def increase_readability(formula, replace_nonascii=False):
418 | """In alternate texts for non-image users or those using a screen reader,
419 | the LaTeX code should be as readable as possible.
420 |
421 | Therefore the formula should not contain unicode characters or
422 | formatting instructions.
423 | """
424 | if replace_nonascii:
425 | # keep umlauts, etc; makes the alt more readable, yet wouldn't compile
426 | formula = escape_unicode_maths(formula, replace_alphabeticals=False)
427 | # replace formatting-only symbols which distract the reader
428 | formula_changed = True
429 | while formula_changed:
430 | formula_changed = False
431 | for command in FORMATTING_COMMANDS:
432 | idx = formula.find(command)
433 | # only replace if it's not after a \\ and not part of a longer command
434 | if (idx > 0 and formula[idx - 1] != '\\') or idx == 0:
435 | end = idx + len(command)
436 | # following conditions for replacement must be met:
437 | # command doesn't end on alphabet. char. and is followed by same
438 | # category OR end of string reached OR command does not # end on
439 | # alphabetical char. at all
440 | if (
441 | end >= len(formula)
442 | or not command[-1].isalpha()
443 | or not formula[end].isalpha()
444 | ):
445 | formula = formula[:idx] + ' ' + \
446 | formula[idx + len(command):]
447 | formula = formula.replace(' ', ' ')
448 | formula_changed = True
449 | return formula
450 |
--------------------------------------------------------------------------------
/manpage.md:
--------------------------------------------------------------------------------
1 | % GLADTEX(1)
2 | % Sebastian Humenda
3 | % 5th of June 2021
4 |
5 | # NAME
6 |
7 | **GladTeX** - generate HTML with LaTeX formulas embedded as images
8 |
9 | # SYNOPSIS
10 |
11 | **gladtex** [OPTIONS]
12 |
13 |
14 | # DESCRIPTION
15 |
16 | **GladTeX** is a formula preprocessor for HTML files. It recognizes a special tag
17 | (`Some text
191 |Circumference of a circle:
192 |
A useful matrix:
") 33 | self.assertEqual( 34 | self.p.get_data()[0], 35 | "
", 36 | 'The HTML parser should copy start tags literally.', 37 | ) 38 | 39 | def test_that_end_tags_are_copied_literally(self): 40 | self.p.feed('
') 41 | self.assertEqual(''.join(self.p.get_data()), '') 42 | 43 | def test_entities_are_unchanged(self): 44 | self.p.feed(' ') 45 | self.assertEqual(self.p.get_data()[0], ' ') 46 | 47 | def test_charsets_are_copied(self): 48 | self.p.feed('>→') 49 | self.assertEqual(''.join(self.p.get_data()[0]), '>→') 50 | 51 | def test_without_eqn_all_blocks_are_strings(self): 52 | self.p.feed('\n42
blah
') 53 | self.assertTrue( 54 | reduce(lambda x, y: x and isinstance(y, str), self.p.get_data()), 55 | 'all chunks have to be strings', 56 | ) 57 | 58 | def test_equation_is_detected(self): 59 | self.p.feed('') 66 | self.assertTrue( 67 | isinstance(self.p.get_data(), list), 68 | 'second item of data must be equation data list', 69 | ) 70 | 71 | def test_document_with_tag_then_eqn_then_tag_works(self): 72 | self.p.feed('
bar
hi
""" 155 | self.p.feed(document.encode('utf-8')) 156 | self.assertEqual(self.p._EqnParser__encoding.lower(), 'utf-8') 157 | 158 | def test_strings_can_be_passed_tO_parser_as_well(self): 159 | # no exception - everything is working as expected 160 | self.p.feed(HTML_SKELETON.format('utf-8', 'æø')) 161 | 162 | 163 | class GetPositionTest(unittest.TestCase): 164 | def test_that_line_number_is_correct(self): 165 | self.assertEqual(htmlhandling.get_position('jojo', 0)[0], 0) 166 | self.assertEqual(htmlhandling.get_position('jojo', 3)[0], 0) 167 | self.assertEqual(htmlhandling.get_position('a\njojo', 3)[0], 1) 168 | self.assertEqual(htmlhandling.get_position('a\n\njojo', 3)[0], 2) 169 | 170 | def test_that_position_on_line_is_correct(self): 171 | self.assertEqual(htmlhandling.get_position('jojo', 0)[1], 0) 172 | self.assertEqual(htmlhandling.get_position('jojo', 3)[1], 3) 173 | self.assertEqual(htmlhandling.get_position('a\njojo', 3)[1], 2) 174 | self.assertEqual(htmlhandling.get_position('a\n\njojo', 3)[1], 1) 175 | 176 | 177 | class HtmlImageTest(unittest.TestCase): 178 | def setUp(self): 179 | self.pos = {'depth': 99, 'height': 88, 'width': 77} 180 | self.original_directory = os.getcwd() 181 | self.tmpdir = tempfile.mkdtemp() 182 | os.chdir(self.tmpdir) 183 | 184 | def tearDown(self): 185 | os.chdir(self.original_directory) 186 | shutil.rmtree(self.tmpdir, ignore_errors=True) 187 | 188 | def test_that_no_file_is_written_if_no_content(self): 189 | ht = htmlhandling.HtmlImageFormatter('foo') 190 | self.assertFalse(os.path.exists('foo.html')) 191 | 192 | def test_file_if_written_when_content_exists(self): 193 | img = htmlhandling.HtmlImageFormatter() 194 | img.format(self.pos, '\\tau\\tau' * 20, 'foo.png') 195 | self.assertTrue(len(img.get_excluded()) == 1) 196 | 197 | def test_id_contains_no_special_characters(self): 198 | data = htmlhandling.generate_label("\\tau!'{}][~^") 199 | for character in {'!', "'", '\\', '{', '}'}: 200 | self.assertFalse(character in data) 201 | 202 | def test_formula_can_consist_only_of_numbers_and_id_is_generated(self): 203 | data = htmlhandling.generate_label('9*8*7=504') 204 | self.assertTrue(data.startswith('form')) 205 | self.assertTrue(data.endswith('504')) 206 | 207 | def test_that_empty_ids_raise_exception(self): 208 | self.assertRaises(ValueError, htmlhandling.generate_label, '') 209 | 210 | def test_that_same_characters_are_not_repeated(self): 211 | id = htmlhandling.generate_label('jo{{{{{{{{ha') 212 | self.assertEqual(id, 'jo_ha') 213 | 214 | def test_that_ids_are_max_150_characters_wide(self): 215 | id = htmlhandling.generate_label('\\alpha\\cdot\\gamma + ' * 999) 216 | self.assertTrue(len(id) == 150) 217 | 218 | def test_that_ids_start_with_letter(self): 219 | id = htmlhandling.generate_label('{}\\[]ÖÖÖö9343...·tau') 220 | self.assertTrue(id[0].isalpha()) 221 | 222 | def test_that_link_to_external_image_points_to_file_and_formula(self): 223 | formula = '\\tau\\tau\gamma\delta' * 42 224 | img = htmlhandling.HtmlImageFormatter() 225 | formatted_img = img.format(self.pos, formula, 'foo.png') 226 | expected_id = htmlhandling.generate_label(formula) 227 | sink.html_write_excluded_file(excl_filename, img.get_excluded()) 228 | external_file = read(excl_filename, 'r', encoding='utf-8') 229 | # find linked formula path 230 | href = re.search('href="(.*?)"', formatted_img) 231 | self.assertTrue(href != None) 232 | # extract path and id from it 233 | self.assertTrue('#' in href.groups()[0]) 234 | path, id = href.groups()[0].split('#') 235 | self.assertEqual(path, excl_filename) 236 | self.assertEqual(id, expected_id) 237 | 238 | # check external file 239 | self.assertTrue('