mercurial-scm/hg-stable: mercurial/minirst.py annotate

annotate mercurial/minirst.py @ 18749:8aa053b99c24

minirst: don't generate TH elements for the first row in table We mainly use them for option tables -- browsers bolding and centering them looks wrong.

author	Dan Villiom Podlaski Christiansen <danchr@gmail.com>
date	Sat, 09 Feb 2013 21:51:21 +0000
parents	6e676fb6ea44
children	c9d923f5d8ae

rev	line source
9156 c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	1 # minirst.py - minimal reStructuredText parser
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	2 #
10443 62d484a81dfe minirst: support containers Martin Geisler <mg@lazybytes.net> parents: 10282 diff changeset	3 # Copyright 2009, 2010 Matt Mackall <mpm@selenic.com> and others
9156 c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	4 #
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	5 # This software may be used and distributed according to the terms of the
10263 25e572394f5c Update license to GPLv2+ Matt Mackall <mpm@selenic.com> parents: 9741 diff changeset	6 # GNU General Public License version 2 or any later version.
9156 c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	7
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	8 """simplified reStructuredText parser.
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	9
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	10 This parser knows just enough about reStructuredText to parse the
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	11 Mercurial docstrings.
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	12
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	13 It cheats in a major way: nested blocks are not really nested. They
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	14 are just indented blocks that look like they are nested. This relies
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	15 on the user to keep the right indentation for the blocks.
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	16
12958 8957c39867f6 minirst: link to HelpStyleGuide in docstring Martin Geisler <mg@aragost.com> parents: 12867 diff changeset	17 Remember to update http://mercurial.selenic.com/wiki/HelpStyleGuide
8957c39867f6 minirst: link to HelpStyleGuide in docstring Martin Geisler <mg@aragost.com> parents: 12867 diff changeset	18 when adding support for new constructs.
9156 c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	19 """
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	20
15038 3f4d337cb80a minirst: drop debug code Matt Mackall <mpm@selenic.com> parents: 15037 diff changeset	21 import re
11464 521c8e0c93bf minirst: use unicode string as intermediate form for replacement FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 11297 diff changeset	22 import util, encoding
12388 75f044d4dbf5 minirst: Support for admonitions Erik Zielke <ez@aragost.com> parents: 11464 diff changeset	23 from i18n import _
75f044d4dbf5 minirst: Support for admonitions Erik Zielke <ez@aragost.com> parents: 11464 diff changeset	24
18748 6e676fb6ea44 help: use a full header for topic titles Dan Villiom Podlaski Christiansen <danchr@gmail.com> parents: 17424 diff changeset	25 def section(s):
6e676fb6ea44 help: use a full header for topic titles Dan Villiom Podlaski Christiansen <danchr@gmail.com> parents: 17424 diff changeset	26 return "%s\n%s\n\n" % (s, "\"" * encoding.colwidth(s))
6e676fb6ea44 help: use a full header for topic titles Dan Villiom Podlaski Christiansen <danchr@gmail.com> parents: 17424 diff changeset	27
6e676fb6ea44 help: use a full header for topic titles Dan Villiom Podlaski Christiansen <danchr@gmail.com> parents: 17424 diff changeset	28 def subsection(s):
6e676fb6ea44 help: use a full header for topic titles Dan Villiom Podlaski Christiansen <danchr@gmail.com> parents: 17424 diff changeset	29 return "%s\n%s\n\n" % (s, '=' * encoding.colwidth(s))
6e676fb6ea44 help: use a full header for topic titles Dan Villiom Podlaski Christiansen <danchr@gmail.com> parents: 17424 diff changeset	30
6e676fb6ea44 help: use a full header for topic titles Dan Villiom Podlaski Christiansen <danchr@gmail.com> parents: 17424 diff changeset	31 def subsubsection(s):
6e676fb6ea44 help: use a full header for topic titles Dan Villiom Podlaski Christiansen <danchr@gmail.com> parents: 17424 diff changeset	32 return "%s\n%s\n\n" % (s, "-" * encoding.colwidth(s))
6e676fb6ea44 help: use a full header for topic titles Dan Villiom Podlaski Christiansen <danchr@gmail.com> parents: 17424 diff changeset	33
6e676fb6ea44 help: use a full header for topic titles Dan Villiom Podlaski Christiansen <danchr@gmail.com> parents: 17424 diff changeset	34 def subsubsubsection(s):
6e676fb6ea44 help: use a full header for topic titles Dan Villiom Podlaski Christiansen <danchr@gmail.com> parents: 17424 diff changeset	35 return "%s\n%s\n\n" % (s, "." * encoding.colwidth(s))
6e676fb6ea44 help: use a full header for topic titles Dan Villiom Podlaski Christiansen <danchr@gmail.com> parents: 17424 diff changeset	36
11464 521c8e0c93bf minirst: use unicode string as intermediate form for replacement FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 11297 diff changeset	37 def replace(text, substs):
15393 87bb6b7644f6 minirst: use unicode string as intermediate form for replacement FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 15262 diff changeset	38 '''
87bb6b7644f6 minirst: use unicode string as intermediate form for replacement FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 15262 diff changeset	39 Apply a list of (find, replace) pairs to a text.
87bb6b7644f6 minirst: use unicode string as intermediate form for replacement FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 15262 diff changeset	40
87bb6b7644f6 minirst: use unicode string as intermediate form for replacement FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 15262 diff changeset	41 >>> replace("foo bar", [('f', 'F'), ('b', 'B')])
87bb6b7644f6 minirst: use unicode string as intermediate form for replacement FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 15262 diff changeset	42 'Foo Bar'
87bb6b7644f6 minirst: use unicode string as intermediate form for replacement FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 15262 diff changeset	43 >>> encoding.encoding = 'latin1'
87bb6b7644f6 minirst: use unicode string as intermediate form for replacement FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 15262 diff changeset	44 >>> replace('\\x81\\\\', [('\\\\', '/')])
87bb6b7644f6 minirst: use unicode string as intermediate form for replacement FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 15262 diff changeset	45 '\\x81/'
87bb6b7644f6 minirst: use unicode string as intermediate form for replacement FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 15262 diff changeset	46 >>> encoding.encoding = 'shiftjis'
87bb6b7644f6 minirst: use unicode string as intermediate form for replacement FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 15262 diff changeset	47 >>> replace('\\x81\\\\', [('\\\\', '/')])
87bb6b7644f6 minirst: use unicode string as intermediate form for replacement FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 15262 diff changeset	48 '\\x81\\\\'
87bb6b7644f6 minirst: use unicode string as intermediate form for replacement FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 15262 diff changeset	49 '''
87bb6b7644f6 minirst: use unicode string as intermediate form for replacement FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 15262 diff changeset	50
87bb6b7644f6 minirst: use unicode string as intermediate form for replacement FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 15262 diff changeset	51 # some character encodings (cp932 for Japanese, at least) use
87bb6b7644f6 minirst: use unicode string as intermediate form for replacement FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 15262 diff changeset	52 # ASCII characters other than control/alphabet/digit as a part of
87bb6b7644f6 minirst: use unicode string as intermediate form for replacement FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 15262 diff changeset	53 # multi-bytes characters, so direct replacing with such characters
87bb6b7644f6 minirst: use unicode string as intermediate form for replacement FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 15262 diff changeset	54 # on strings in local encoding causes invalid byte sequences.
87bb6b7644f6 minirst: use unicode string as intermediate form for replacement FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 15262 diff changeset	55 utext = text.decode(encoding.encoding)
11464 521c8e0c93bf minirst: use unicode string as intermediate form for replacement FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 11297 diff changeset	56 for f, t in substs:
15393 87bb6b7644f6 minirst: use unicode string as intermediate form for replacement FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 15262 diff changeset	57 utext = utext.replace(f, t)
87bb6b7644f6 minirst: use unicode string as intermediate form for replacement FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 15262 diff changeset	58 return utext.encode(encoding.encoding)
12651 17f28de168a4 minirst: refactor/simplify findblocks Martin Geisler <mg@lazybytes.net> parents: 12620 diff changeset	59
17f28de168a4 minirst: refactor/simplify findblocks Martin Geisler <mg@lazybytes.net> parents: 12620 diff changeset	60 _blockre = re.compile(r"\n(?:\s*\n)+")
17f28de168a4 minirst: refactor/simplify findblocks Martin Geisler <mg@lazybytes.net> parents: 12620 diff changeset	61
9156 c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	62 def findblocks(text):
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	63 """Find continuous blocks of lines in text.
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	64
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	65 Returns a list of dictionaries representing the blocks. Each block
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	66 has an 'indent' field and a 'lines' field.
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	67 """
12651 17f28de168a4 minirst: refactor/simplify findblocks Martin Geisler <mg@lazybytes.net> parents: 12620 diff changeset	68 blocks = []
15036 bb96e12a3242 minirst: only strip leading newlines, not indentation Matt Mackall <mpm@selenic.com> parents: 15015 diff changeset	69 for b in _blockre.split(text.lstrip('\n').rstrip()):
12651 17f28de168a4 minirst: refactor/simplify findblocks Martin Geisler <mg@lazybytes.net> parents: 12620 diff changeset	70 lines = b.splitlines()
15123 9b41ccb2043e minirst: don't choke on empty text Matt Mackall <mpm@selenic.com> parents: 15122 diff changeset	71 if lines:
9b41ccb2043e minirst: don't choke on empty text Matt Mackall <mpm@selenic.com> parents: 15122 diff changeset	72 indent = min((len(l) - len(l.lstrip())) for l in lines)
9b41ccb2043e minirst: don't choke on empty text Matt Mackall <mpm@selenic.com> parents: 15122 diff changeset	73 lines = [l[indent:] for l in lines]
9b41ccb2043e minirst: don't choke on empty text Matt Mackall <mpm@selenic.com> parents: 15122 diff changeset	74 blocks.append(dict(indent=indent, lines=lines))
9156 c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	75 return blocks
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	76
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	77 def findliteralblocks(blocks):
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	78 """Finds literal blocks and adds a 'type' field to the blocks.
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	79
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	80 Literal blocks are given the type 'literal', all other blocks are
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	81 given type the 'paragraph'.
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	82 """
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	83 i = 0
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	84 while i < len(blocks):
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	85 # Searching for a block that looks like this:
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	86 #
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	87 # +------------------------------+
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	88 # \| paragraph \|
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	89 # \| (ends with "::") \|
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	90 # +------------------------------+
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	91 # +---------------------------+
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	92 # \| indented literal block \|
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	93 # +---------------------------+
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	94 blocks[i]['type'] = 'paragraph'
10282 08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10264 diff changeset	95 if blocks[i]['lines'][-1].endswith('::') and i + 1 < len(blocks):
9156 c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	96 indent = blocks[i]['indent']
10282 08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10264 diff changeset	97 adjustment = blocks[i + 1]['indent'] - indent
9156 c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	98
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	99 if blocks[i]['lines'] == ['::']:
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	100 # Expanded form: remove block
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	101 del blocks[i]
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	102 i -= 1
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	103 elif blocks[i]['lines'][-1].endswith(' ::'):
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	104 # Partially minimized form: remove space and both
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	105 # colons.
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	106 blocks[i]['lines'][-1] = blocks[i]['lines'][-1][:-3]
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	107 else:
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	108 # Fully minimized form: remove just one colon.
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	109 blocks[i]['lines'][-1] = blocks[i]['lines'][-1][:-1]
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	110
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	111 # List items are formatted with a hanging indent. We must
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	112 # correct for this here while we still have the original
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	113 # information on the indentation of the subsequent literal
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	114 # blocks available.
9738 f52c4f7a4732 minirst: prepare for general types of bullet lists Martin Geisler <mg@lazybytes.net> parents: 9737 diff changeset	115 m = _bulletre.match(blocks[i]['lines'][0])
f52c4f7a4732 minirst: prepare for general types of bullet lists Martin Geisler <mg@lazybytes.net> parents: 9737 diff changeset	116 if m:
f52c4f7a4732 minirst: prepare for general types of bullet lists Martin Geisler <mg@lazybytes.net> parents: 9737 diff changeset	117 indent += m.end()
f52c4f7a4732 minirst: prepare for general types of bullet lists Martin Geisler <mg@lazybytes.net> parents: 9737 diff changeset	118 adjustment -= m.end()
9156 c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	119
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	120 # Mark the following indented blocks.
10282 08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10264 diff changeset	121 while i + 1 < len(blocks) and blocks[i + 1]['indent'] > indent:
08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10264 diff changeset	122 blocks[i + 1]['type'] = 'literal'
08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10264 diff changeset	123 blocks[i + 1]['indent'] -= adjustment
9156 c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	124 i += 1
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	125 i += 1
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	126 return blocks
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	127
10447 e957cc7cbd14 minirst: support line blocks Martin Geisler <mg@lazybytes.net> parents: 10444 diff changeset	128 _bulletre = re.compile(r'(-\|[0-9A-Za-z]+\.\|$?[0-9A-Za-z]+$\|\\|) ')
13011 4936a04b6792 minirst: improved support for option lists. Erik Zielke <ez@aragost.com> parents: 13009 diff changeset	129 _optionre = re.compile(r'^(-([a-zA-Z0-9]), )?(--[a-z0-9-]+)'
4936a04b6792 minirst: improved support for option lists. Erik Zielke <ez@aragost.com> parents: 13009 diff changeset	130 r'((.) +)(.)$')
10065 a1ae0ed78d1a minirst: improve layout of field lists Martin Geisler <mg@lazybytes.net> parents: 10064 diff changeset	131 _fieldre = re.compile(r':(?![: ])([^:])(?<! ):[ ]+(.)')
9737 5f101af4a921 minirst: combine list parsing in one function Martin Geisler <mg@lazybytes.net> parents: 9735 diff changeset	132 _definitionre = re.compile(r'[^ ]')
15037 df47381b41d6 minirst: add simple table support Matt Mackall <mpm@selenic.com> parents: 15036 diff changeset	133 _tablere = re.compile(r'(=+\s+)*=+')
9737 5f101af4a921 minirst: combine list parsing in one function Martin Geisler <mg@lazybytes.net> parents: 9735 diff changeset	134
5f101af4a921 minirst: combine list parsing in one function Martin Geisler <mg@lazybytes.net> parents: 9735 diff changeset	135 def splitparagraphs(blocks):
5f101af4a921 minirst: combine list parsing in one function Martin Geisler <mg@lazybytes.net> parents: 9735 diff changeset	136 """Split paragraphs into lists."""
5f101af4a921 minirst: combine list parsing in one function Martin Geisler <mg@lazybytes.net> parents: 9735 diff changeset	137 # Tuples with (list type, item regexp, single line items?). Order
5f101af4a921 minirst: combine list parsing in one function Martin Geisler <mg@lazybytes.net> parents: 9735 diff changeset	138 # matters: definition lists has the least specific regexp and must
5f101af4a921 minirst: combine list parsing in one function Martin Geisler <mg@lazybytes.net> parents: 9735 diff changeset	139 # come last.
5f101af4a921 minirst: combine list parsing in one function Martin Geisler <mg@lazybytes.net> parents: 9735 diff changeset	140 listtypes = [('bullet', _bulletre, True),
5f101af4a921 minirst: combine list parsing in one function Martin Geisler <mg@lazybytes.net> parents: 9735 diff changeset	141 ('option', _optionre, True),
5f101af4a921 minirst: combine list parsing in one function Martin Geisler <mg@lazybytes.net> parents: 9735 diff changeset	142 ('field', _fieldre, True),
5f101af4a921 minirst: combine list parsing in one function Martin Geisler <mg@lazybytes.net> parents: 9735 diff changeset	143 ('definition', _definitionre, False)]
5f101af4a921 minirst: combine list parsing in one function Martin Geisler <mg@lazybytes.net> parents: 9735 diff changeset	144
5f101af4a921 minirst: combine list parsing in one function Martin Geisler <mg@lazybytes.net> parents: 9735 diff changeset	145 def match(lines, i, itemre, singleline):
5f101af4a921 minirst: combine list parsing in one function Martin Geisler <mg@lazybytes.net> parents: 9735 diff changeset	146 """Does itemre match an item at line i?
5f101af4a921 minirst: combine list parsing in one function Martin Geisler <mg@lazybytes.net> parents: 9735 diff changeset	147
17424 e7cfe3587ea4 fix trivial spelling errors Mads Kiilerich <mads@kiilerich.com> parents: 16815 diff changeset	148 A list item can be followed by an indented line or another list
9737 5f101af4a921 minirst: combine list parsing in one function Martin Geisler <mg@lazybytes.net> parents: 9735 diff changeset	149 item (but only if singleline is True).
5f101af4a921 minirst: combine list parsing in one function Martin Geisler <mg@lazybytes.net> parents: 9735 diff changeset	150 """
5f101af4a921 minirst: combine list parsing in one function Martin Geisler <mg@lazybytes.net> parents: 9735 diff changeset	151 line1 = lines[i]
10282 08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10264 diff changeset	152 line2 = i + 1 < len(lines) and lines[i + 1] or ''
9737 5f101af4a921 minirst: combine list parsing in one function Martin Geisler <mg@lazybytes.net> parents: 9735 diff changeset	153 if not itemre.match(line1):
5f101af4a921 minirst: combine list parsing in one function Martin Geisler <mg@lazybytes.net> parents: 9735 diff changeset	154 return False
5f101af4a921 minirst: combine list parsing in one function Martin Geisler <mg@lazybytes.net> parents: 9735 diff changeset	155 if singleline:
5f101af4a921 minirst: combine list parsing in one function Martin Geisler <mg@lazybytes.net> parents: 9735 diff changeset	156 return line2 == '' or line2[0] == ' ' or itemre.match(line2)
5f101af4a921 minirst: combine list parsing in one function Martin Geisler <mg@lazybytes.net> parents: 9735 diff changeset	157 else:
5f101af4a921 minirst: combine list parsing in one function Martin Geisler <mg@lazybytes.net> parents: 9735 diff changeset	158 return line2.startswith(' ')
5f101af4a921 minirst: combine list parsing in one function Martin Geisler <mg@lazybytes.net> parents: 9735 diff changeset	159
5f101af4a921 minirst: combine list parsing in one function Martin Geisler <mg@lazybytes.net> parents: 9735 diff changeset	160 i = 0
5f101af4a921 minirst: combine list parsing in one function Martin Geisler <mg@lazybytes.net> parents: 9735 diff changeset	161 while i < len(blocks):
5f101af4a921 minirst: combine list parsing in one function Martin Geisler <mg@lazybytes.net> parents: 9735 diff changeset	162 if blocks[i]['type'] == 'paragraph':
5f101af4a921 minirst: combine list parsing in one function Martin Geisler <mg@lazybytes.net> parents: 9735 diff changeset	163 lines = blocks[i]['lines']
5f101af4a921 minirst: combine list parsing in one function Martin Geisler <mg@lazybytes.net> parents: 9735 diff changeset	164 for type, itemre, singleline in listtypes:
5f101af4a921 minirst: combine list parsing in one function Martin Geisler <mg@lazybytes.net> parents: 9735 diff changeset	165 if match(lines, 0, itemre, singleline):
5f101af4a921 minirst: combine list parsing in one function Martin Geisler <mg@lazybytes.net> parents: 9735 diff changeset	166 items = []
5f101af4a921 minirst: combine list parsing in one function Martin Geisler <mg@lazybytes.net> parents: 9735 diff changeset	167 for j, line in enumerate(lines):
5f101af4a921 minirst: combine list parsing in one function Martin Geisler <mg@lazybytes.net> parents: 9735 diff changeset	168 if match(lines, j, itemre, singleline):
5f101af4a921 minirst: combine list parsing in one function Martin Geisler <mg@lazybytes.net> parents: 9735 diff changeset	169 items.append(dict(type=type, lines=[],
5f101af4a921 minirst: combine list parsing in one function Martin Geisler <mg@lazybytes.net> parents: 9735 diff changeset	170 indent=blocks[i]['indent']))
5f101af4a921 minirst: combine list parsing in one function Martin Geisler <mg@lazybytes.net> parents: 9735 diff changeset	171 items[-1]['lines'].append(line)
10282 08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10264 diff changeset	172 blocks[i:i + 1] = items
9737 5f101af4a921 minirst: combine list parsing in one function Martin Geisler <mg@lazybytes.net> parents: 9735 diff changeset	173 break
5f101af4a921 minirst: combine list parsing in one function Martin Geisler <mg@lazybytes.net> parents: 9735 diff changeset	174 i += 1
5f101af4a921 minirst: combine list parsing in one function Martin Geisler <mg@lazybytes.net> parents: 9735 diff changeset	175 return blocks
5f101af4a921 minirst: combine list parsing in one function Martin Geisler <mg@lazybytes.net> parents: 9735 diff changeset	176
15861 ee8f5e4ce7b8 minirst: simplify and standardize field list formatting Olav Reinert <seroton10@gmail.com> parents: 15393 diff changeset	177 _fieldwidth = 14
10065 a1ae0ed78d1a minirst: improve layout of field lists Martin Geisler <mg@lazybytes.net> parents: 10064 diff changeset	178
a1ae0ed78d1a minirst: improve layout of field lists Martin Geisler <mg@lazybytes.net> parents: 10064 diff changeset	179 def updatefieldlists(blocks):
15861 ee8f5e4ce7b8 minirst: simplify and standardize field list formatting Olav Reinert <seroton10@gmail.com> parents: 15393 diff changeset	180 """Find key for field lists."""
10065 a1ae0ed78d1a minirst: improve layout of field lists Martin Geisler <mg@lazybytes.net> parents: 10064 diff changeset	181 i = 0
a1ae0ed78d1a minirst: improve layout of field lists Martin Geisler <mg@lazybytes.net> parents: 10064 diff changeset	182 while i < len(blocks):
a1ae0ed78d1a minirst: improve layout of field lists Martin Geisler <mg@lazybytes.net> parents: 10064 diff changeset	183 if blocks[i]['type'] != 'field':
a1ae0ed78d1a minirst: improve layout of field lists Martin Geisler <mg@lazybytes.net> parents: 10064 diff changeset	184 i += 1
a1ae0ed78d1a minirst: improve layout of field lists Martin Geisler <mg@lazybytes.net> parents: 10064 diff changeset	185 continue
a1ae0ed78d1a minirst: improve layout of field lists Martin Geisler <mg@lazybytes.net> parents: 10064 diff changeset	186
a1ae0ed78d1a minirst: improve layout of field lists Martin Geisler <mg@lazybytes.net> parents: 10064 diff changeset	187 j = i
a1ae0ed78d1a minirst: improve layout of field lists Martin Geisler <mg@lazybytes.net> parents: 10064 diff changeset	188 while j < len(blocks) and blocks[j]['type'] == 'field':
a1ae0ed78d1a minirst: improve layout of field lists Martin Geisler <mg@lazybytes.net> parents: 10064 diff changeset	189 m = _fieldre.match(blocks[j]['lines'][0])
a1ae0ed78d1a minirst: improve layout of field lists Martin Geisler <mg@lazybytes.net> parents: 10064 diff changeset	190 key, rest = m.groups()
a1ae0ed78d1a minirst: improve layout of field lists Martin Geisler <mg@lazybytes.net> parents: 10064 diff changeset	191 blocks[j]['lines'][0] = rest
a1ae0ed78d1a minirst: improve layout of field lists Martin Geisler <mg@lazybytes.net> parents: 10064 diff changeset	192 blocks[j]['key'] = key
a1ae0ed78d1a minirst: improve layout of field lists Martin Geisler <mg@lazybytes.net> parents: 10064 diff changeset	193 j += 1
a1ae0ed78d1a minirst: improve layout of field lists Martin Geisler <mg@lazybytes.net> parents: 10064 diff changeset	194
a1ae0ed78d1a minirst: improve layout of field lists Martin Geisler <mg@lazybytes.net> parents: 10064 diff changeset	195 i = j + 1
a1ae0ed78d1a minirst: improve layout of field lists Martin Geisler <mg@lazybytes.net> parents: 10064 diff changeset	196
a1ae0ed78d1a minirst: improve layout of field lists Martin Geisler <mg@lazybytes.net> parents: 10064 diff changeset	197 return blocks
a1ae0ed78d1a minirst: improve layout of field lists Martin Geisler <mg@lazybytes.net> parents: 10064 diff changeset	198
13011 4936a04b6792 minirst: improved support for option lists. Erik Zielke <ez@aragost.com> parents: 13009 diff changeset	199 def updateoptionlists(blocks):
4936a04b6792 minirst: improved support for option lists. Erik Zielke <ez@aragost.com> parents: 13009 diff changeset	200 i = 0
4936a04b6792 minirst: improved support for option lists. Erik Zielke <ez@aragost.com> parents: 13009 diff changeset	201 while i < len(blocks):
4936a04b6792 minirst: improved support for option lists. Erik Zielke <ez@aragost.com> parents: 13009 diff changeset	202 if blocks[i]['type'] != 'option':
4936a04b6792 minirst: improved support for option lists. Erik Zielke <ez@aragost.com> parents: 13009 diff changeset	203 i += 1
4936a04b6792 minirst: improved support for option lists. Erik Zielke <ez@aragost.com> parents: 13009 diff changeset	204 continue
4936a04b6792 minirst: improved support for option lists. Erik Zielke <ez@aragost.com> parents: 13009 diff changeset	205
4936a04b6792 minirst: improved support for option lists. Erik Zielke <ez@aragost.com> parents: 13009 diff changeset	206 optstrwidth = 0
4936a04b6792 minirst: improved support for option lists. Erik Zielke <ez@aragost.com> parents: 13009 diff changeset	207 j = i
4936a04b6792 minirst: improved support for option lists. Erik Zielke <ez@aragost.com> parents: 13009 diff changeset	208 while j < len(blocks) and blocks[j]['type'] == 'option':
4936a04b6792 minirst: improved support for option lists. Erik Zielke <ez@aragost.com> parents: 13009 diff changeset	209 m = _optionre.match(blocks[j]['lines'][0])
4936a04b6792 minirst: improved support for option lists. Erik Zielke <ez@aragost.com> parents: 13009 diff changeset	210
4936a04b6792 minirst: improved support for option lists. Erik Zielke <ez@aragost.com> parents: 13009 diff changeset	211 shortoption = m.group(2)
4936a04b6792 minirst: improved support for option lists. Erik Zielke <ez@aragost.com> parents: 13009 diff changeset	212 group3 = m.group(3)
4936a04b6792 minirst: improved support for option lists. Erik Zielke <ez@aragost.com> parents: 13009 diff changeset	213 longoption = group3[2:].strip()
4936a04b6792 minirst: improved support for option lists. Erik Zielke <ez@aragost.com> parents: 13009 diff changeset	214 desc = m.group(6).strip()
4936a04b6792 minirst: improved support for option lists. Erik Zielke <ez@aragost.com> parents: 13009 diff changeset	215 longoptionarg = m.group(5).strip()
4936a04b6792 minirst: improved support for option lists. Erik Zielke <ez@aragost.com> parents: 13009 diff changeset	216 blocks[j]['lines'][0] = desc
4936a04b6792 minirst: improved support for option lists. Erik Zielke <ez@aragost.com> parents: 13009 diff changeset	217
4936a04b6792 minirst: improved support for option lists. Erik Zielke <ez@aragost.com> parents: 13009 diff changeset	218 noshortop = ''
4936a04b6792 minirst: improved support for option lists. Erik Zielke <ez@aragost.com> parents: 13009 diff changeset	219 if not shortoption:
4936a04b6792 minirst: improved support for option lists. Erik Zielke <ez@aragost.com> parents: 13009 diff changeset	220 noshortop = ' '
4936a04b6792 minirst: improved support for option lists. Erik Zielke <ez@aragost.com> parents: 13009 diff changeset	221
4936a04b6792 minirst: improved support for option lists. Erik Zielke <ez@aragost.com> parents: 13009 diff changeset	222 opt = "%s%s" % (shortoption and "-%s " % shortoption or '',
4936a04b6792 minirst: improved support for option lists. Erik Zielke <ez@aragost.com> parents: 13009 diff changeset	223 ("%s--%s %s") % (noshortop, longoption,
4936a04b6792 minirst: improved support for option lists. Erik Zielke <ez@aragost.com> parents: 13009 diff changeset	224 longoptionarg))
4936a04b6792 minirst: improved support for option lists. Erik Zielke <ez@aragost.com> parents: 13009 diff changeset	225 opt = opt.rstrip()
4936a04b6792 minirst: improved support for option lists. Erik Zielke <ez@aragost.com> parents: 13009 diff changeset	226 blocks[j]['optstr'] = opt
4936a04b6792 minirst: improved support for option lists. Erik Zielke <ez@aragost.com> parents: 13009 diff changeset	227 optstrwidth = max(optstrwidth, encoding.colwidth(opt))
4936a04b6792 minirst: improved support for option lists. Erik Zielke <ez@aragost.com> parents: 13009 diff changeset	228 j += 1
4936a04b6792 minirst: improved support for option lists. Erik Zielke <ez@aragost.com> parents: 13009 diff changeset	229
4936a04b6792 minirst: improved support for option lists. Erik Zielke <ez@aragost.com> parents: 13009 diff changeset	230 for block in blocks[i:j]:
4936a04b6792 minirst: improved support for option lists. Erik Zielke <ez@aragost.com> parents: 13009 diff changeset	231 block['optstrwidth'] = optstrwidth
4936a04b6792 minirst: improved support for option lists. Erik Zielke <ez@aragost.com> parents: 13009 diff changeset	232 i = j + 1
4936a04b6792 minirst: improved support for option lists. Erik Zielke <ez@aragost.com> parents: 13009 diff changeset	233 return blocks
4936a04b6792 minirst: improved support for option lists. Erik Zielke <ez@aragost.com> parents: 13009 diff changeset	234
10443 62d484a81dfe minirst: support containers Martin Geisler <mg@lazybytes.net> parents: 10282 diff changeset	235 def prunecontainers(blocks, keep):
62d484a81dfe minirst: support containers Martin Geisler <mg@lazybytes.net> parents: 10282 diff changeset	236 """Prune unwanted containers.
62d484a81dfe minirst: support containers Martin Geisler <mg@lazybytes.net> parents: 10282 diff changeset	237
62d484a81dfe minirst: support containers Martin Geisler <mg@lazybytes.net> parents: 10282 diff changeset	238 The blocks must have a 'type' field, i.e., they should have been
62d484a81dfe minirst: support containers Martin Geisler <mg@lazybytes.net> parents: 10282 diff changeset	239 run through findliteralblocks first.
62d484a81dfe minirst: support containers Martin Geisler <mg@lazybytes.net> parents: 10282 diff changeset	240 """
10444 e99e0e077bc4 minirst: report pruned container types Martin Geisler <mg@lazybytes.net> parents: 10443 diff changeset	241 pruned = []
10443 62d484a81dfe minirst: support containers Martin Geisler <mg@lazybytes.net> parents: 10282 diff changeset	242 i = 0
62d484a81dfe minirst: support containers Martin Geisler <mg@lazybytes.net> parents: 10282 diff changeset	243 while i + 1 < len(blocks):
62d484a81dfe minirst: support containers Martin Geisler <mg@lazybytes.net> parents: 10282 diff changeset	244 # Searching for a block that looks like this:
62d484a81dfe minirst: support containers Martin Geisler <mg@lazybytes.net> parents: 10282 diff changeset	245 #
62d484a81dfe minirst: support containers Martin Geisler <mg@lazybytes.net> parents: 10282 diff changeset	246 # +-------+---------------------------+
62d484a81dfe minirst: support containers Martin Geisler <mg@lazybytes.net> parents: 10282 diff changeset	247 # \| ".. container ::" type \|
62d484a81dfe minirst: support containers Martin Geisler <mg@lazybytes.net> parents: 10282 diff changeset	248 # +---+ \|
62d484a81dfe minirst: support containers Martin Geisler <mg@lazybytes.net> parents: 10282 diff changeset	249 # \| blocks \|
62d484a81dfe minirst: support containers Martin Geisler <mg@lazybytes.net> parents: 10282 diff changeset	250 # +-------------------------------+
62d484a81dfe minirst: support containers Martin Geisler <mg@lazybytes.net> parents: 10282 diff changeset	251 if (blocks[i]['type'] == 'paragraph' and
62d484a81dfe minirst: support containers Martin Geisler <mg@lazybytes.net> parents: 10282 diff changeset	252 blocks[i]['lines'][0].startswith('.. container::')):
62d484a81dfe minirst: support containers Martin Geisler <mg@lazybytes.net> parents: 10282 diff changeset	253 indent = blocks[i]['indent']
62d484a81dfe minirst: support containers Martin Geisler <mg@lazybytes.net> parents: 10282 diff changeset	254 adjustment = blocks[i + 1]['indent'] - indent
62d484a81dfe minirst: support containers Martin Geisler <mg@lazybytes.net> parents: 10282 diff changeset	255 containertype = blocks[i]['lines'][0][15:]
62d484a81dfe minirst: support containers Martin Geisler <mg@lazybytes.net> parents: 10282 diff changeset	256 prune = containertype not in keep
10444 e99e0e077bc4 minirst: report pruned container types Martin Geisler <mg@lazybytes.net> parents: 10443 diff changeset	257 if prune:
e99e0e077bc4 minirst: report pruned container types Martin Geisler <mg@lazybytes.net> parents: 10443 diff changeset	258 pruned.append(containertype)
10443 62d484a81dfe minirst: support containers Martin Geisler <mg@lazybytes.net> parents: 10282 diff changeset	259
62d484a81dfe minirst: support containers Martin Geisler <mg@lazybytes.net> parents: 10282 diff changeset	260 # Always delete "..container:: type" block
62d484a81dfe minirst: support containers Martin Geisler <mg@lazybytes.net> parents: 10282 diff changeset	261 del blocks[i]
62d484a81dfe minirst: support containers Martin Geisler <mg@lazybytes.net> parents: 10282 diff changeset	262 j = i
15102 a7e375d087f6 minirst: fix container stripping logic Matt Mackall <mpm@selenic.com> parents: 15039 diff changeset	263 i -= 1
10443 62d484a81dfe minirst: support containers Martin Geisler <mg@lazybytes.net> parents: 10282 diff changeset	264 while j < len(blocks) and blocks[j]['indent'] > indent:
62d484a81dfe minirst: support containers Martin Geisler <mg@lazybytes.net> parents: 10282 diff changeset	265 if prune:
62d484a81dfe minirst: support containers Martin Geisler <mg@lazybytes.net> parents: 10282 diff changeset	266 del blocks[j]
62d484a81dfe minirst: support containers Martin Geisler <mg@lazybytes.net> parents: 10282 diff changeset	267 else:
62d484a81dfe minirst: support containers Martin Geisler <mg@lazybytes.net> parents: 10282 diff changeset	268 blocks[j]['indent'] -= adjustment
62d484a81dfe minirst: support containers Martin Geisler <mg@lazybytes.net> parents: 10282 diff changeset	269 j += 1
62d484a81dfe minirst: support containers Martin Geisler <mg@lazybytes.net> parents: 10282 diff changeset	270 i += 1
10444 e99e0e077bc4 minirst: report pruned container types Martin Geisler <mg@lazybytes.net> parents: 10443 diff changeset	271 return blocks, pruned
10443 62d484a81dfe minirst: support containers Martin Geisler <mg@lazybytes.net> parents: 10282 diff changeset	272
10984 68b7d2d668ce minirst: support all recommended title adornments Martin Geisler <mg@lazybytes.net> parents: 10983 diff changeset	273 _sectionre = re.compile(r"""^([-=`:.'"~^_*+#])\1+$""")
68b7d2d668ce minirst: support all recommended title adornments Martin Geisler <mg@lazybytes.net> parents: 10983 diff changeset	274
15037 df47381b41d6 minirst: add simple table support Matt Mackall <mpm@selenic.com> parents: 15036 diff changeset	275 def findtables(blocks):
df47381b41d6 minirst: add simple table support Matt Mackall <mpm@selenic.com> parents: 15036 diff changeset	276 '''Find simple tables
df47381b41d6 minirst: add simple table support Matt Mackall <mpm@selenic.com> parents: 15036 diff changeset	277
df47381b41d6 minirst: add simple table support Matt Mackall <mpm@selenic.com> parents: 15036 diff changeset	278 Only simple one-line table elements are supported
df47381b41d6 minirst: add simple table support Matt Mackall <mpm@selenic.com> parents: 15036 diff changeset	279 '''
df47381b41d6 minirst: add simple table support Matt Mackall <mpm@selenic.com> parents: 15036 diff changeset	280
df47381b41d6 minirst: add simple table support Matt Mackall <mpm@selenic.com> parents: 15036 diff changeset	281 for block in blocks:
df47381b41d6 minirst: add simple table support Matt Mackall <mpm@selenic.com> parents: 15036 diff changeset	282 # Searching for a block that looks like this:
df47381b41d6 minirst: add simple table support Matt Mackall <mpm@selenic.com> parents: 15036 diff changeset	283 #
df47381b41d6 minirst: add simple table support Matt Mackall <mpm@selenic.com> parents: 15036 diff changeset	284 # === ==== ===
df47381b41d6 minirst: add simple table support Matt Mackall <mpm@selenic.com> parents: 15036 diff changeset	285 # A B C
df47381b41d6 minirst: add simple table support Matt Mackall <mpm@selenic.com> parents: 15036 diff changeset	286 # === ==== === <- optional
df47381b41d6 minirst: add simple table support Matt Mackall <mpm@selenic.com> parents: 15036 diff changeset	287 # 1 2 3
df47381b41d6 minirst: add simple table support Matt Mackall <mpm@selenic.com> parents: 15036 diff changeset	288 # x y z
df47381b41d6 minirst: add simple table support Matt Mackall <mpm@selenic.com> parents: 15036 diff changeset	289 # === ==== ===
df47381b41d6 minirst: add simple table support Matt Mackall <mpm@selenic.com> parents: 15036 diff changeset	290 if (block['type'] == 'paragraph' and
15192 3834ca04664a rst: fix detection of single-row tables Matt Mackall <mpm@selenic.com> parents: 15145 diff changeset	291 len(block['lines']) > 2 and
15037 df47381b41d6 minirst: add simple table support Matt Mackall <mpm@selenic.com> parents: 15036 diff changeset	292 _tablere.match(block['lines'][0]) and
df47381b41d6 minirst: add simple table support Matt Mackall <mpm@selenic.com> parents: 15036 diff changeset	293 block['lines'][0] == block['lines'][-1]):
df47381b41d6 minirst: add simple table support Matt Mackall <mpm@selenic.com> parents: 15036 diff changeset	294 block['type'] = 'table'
df47381b41d6 minirst: add simple table support Matt Mackall <mpm@selenic.com> parents: 15036 diff changeset	295 block['header'] = False
df47381b41d6 minirst: add simple table support Matt Mackall <mpm@selenic.com> parents: 15036 diff changeset	296 div = block['lines'][0]
15144 87bb975a1844 minirst: fix column handling for simple tables Matt Mackall <mpm@selenic.com> parents: 15125 diff changeset	297
87bb975a1844 minirst: fix column handling for simple tables Matt Mackall <mpm@selenic.com> parents: 15125 diff changeset	298 # column markers are ASCII so we can calculate column
87bb975a1844 minirst: fix column handling for simple tables Matt Mackall <mpm@selenic.com> parents: 15125 diff changeset	299 # position in bytes
15037 df47381b41d6 minirst: add simple table support Matt Mackall <mpm@selenic.com> parents: 15036 diff changeset	300 columns = [x for x in xrange(len(div))
df47381b41d6 minirst: add simple table support Matt Mackall <mpm@selenic.com> parents: 15036 diff changeset	301 if div[x] == '=' and (x == 0 or div[x - 1] == ' ')]
df47381b41d6 minirst: add simple table support Matt Mackall <mpm@selenic.com> parents: 15036 diff changeset	302 rows = []
df47381b41d6 minirst: add simple table support Matt Mackall <mpm@selenic.com> parents: 15036 diff changeset	303 for l in block['lines'][1:-1]:
df47381b41d6 minirst: add simple table support Matt Mackall <mpm@selenic.com> parents: 15036 diff changeset	304 if l == div:
df47381b41d6 minirst: add simple table support Matt Mackall <mpm@selenic.com> parents: 15036 diff changeset	305 block['header'] = True
df47381b41d6 minirst: add simple table support Matt Mackall <mpm@selenic.com> parents: 15036 diff changeset	306 continue
df47381b41d6 minirst: add simple table support Matt Mackall <mpm@selenic.com> parents: 15036 diff changeset	307 row = []
15144 87bb975a1844 minirst: fix column handling for simple tables Matt Mackall <mpm@selenic.com> parents: 15125 diff changeset	308 # we measure columns not in bytes or characters but in
87bb975a1844 minirst: fix column handling for simple tables Matt Mackall <mpm@selenic.com> parents: 15125 diff changeset	309 # colwidth which makes things tricky
87bb975a1844 minirst: fix column handling for simple tables Matt Mackall <mpm@selenic.com> parents: 15125 diff changeset	310 pos = columns[0] # leading whitespace is bytes
15037 df47381b41d6 minirst: add simple table support Matt Mackall <mpm@selenic.com> parents: 15036 diff changeset	311 for n, start in enumerate(columns):
df47381b41d6 minirst: add simple table support Matt Mackall <mpm@selenic.com> parents: 15036 diff changeset	312 if n + 1 < len(columns):
15144 87bb975a1844 minirst: fix column handling for simple tables Matt Mackall <mpm@selenic.com> parents: 15125 diff changeset	313 width = columns[n + 1] - start
87bb975a1844 minirst: fix column handling for simple tables Matt Mackall <mpm@selenic.com> parents: 15125 diff changeset	314 v = encoding.getcols(l, pos, width) # gather columns
87bb975a1844 minirst: fix column handling for simple tables Matt Mackall <mpm@selenic.com> parents: 15125 diff changeset	315 pos += len(v) # calculate byte position of end
87bb975a1844 minirst: fix column handling for simple tables Matt Mackall <mpm@selenic.com> parents: 15125 diff changeset	316 row.append(v.strip())
15037 df47381b41d6 minirst: add simple table support Matt Mackall <mpm@selenic.com> parents: 15036 diff changeset	317 else:
15144 87bb975a1844 minirst: fix column handling for simple tables Matt Mackall <mpm@selenic.com> parents: 15125 diff changeset	318 row.append(l[pos:].strip())
15037 df47381b41d6 minirst: add simple table support Matt Mackall <mpm@selenic.com> parents: 15036 diff changeset	319 rows.append(row)
15144 87bb975a1844 minirst: fix column handling for simple tables Matt Mackall <mpm@selenic.com> parents: 15125 diff changeset	320
15037 df47381b41d6 minirst: add simple table support Matt Mackall <mpm@selenic.com> parents: 15036 diff changeset	321 block['table'] = rows
df47381b41d6 minirst: add simple table support Matt Mackall <mpm@selenic.com> parents: 15036 diff changeset	322
df47381b41d6 minirst: add simple table support Matt Mackall <mpm@selenic.com> parents: 15036 diff changeset	323 return blocks
df47381b41d6 minirst: add simple table support Matt Mackall <mpm@selenic.com> parents: 15036 diff changeset	324
9156 c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	325 def findsections(blocks):
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	326 """Finds sections.
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	327
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	328 The blocks must have a 'type' field, i.e., they should have been
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	329 run through findliteralblocks first.
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	330 """
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	331 for block in blocks:
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	332 # Searching for a block that looks like this:
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	333 #
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	334 # +------------------------------+
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	335 # \| Section title \|
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	336 # \| ------------- \|
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	337 # +------------------------------+
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	338 if (block['type'] == 'paragraph' and
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	339 len(block['lines']) == 2 and
12867 eda77c3e246a minirst: use colwidth to match title lengths (issue2455) Matt Mackall <mpm@selenic.com> parents: 12819 diff changeset	340 encoding.colwidth(block['lines'][0]) == len(block['lines'][1]) and
10984 68b7d2d668ce minirst: support all recommended title adornments Martin Geisler <mg@lazybytes.net> parents: 10983 diff changeset	341 _sectionre.match(block['lines'][1])):
10983 287a5cdf7743 minirst: correctly format sections containing inline markup Martin Geisler <mg@lazybytes.net> parents: 10972 diff changeset	342 block['underline'] = block['lines'][1][0]
9156 c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	343 block['type'] = 'section'
10983 287a5cdf7743 minirst: correctly format sections containing inline markup Martin Geisler <mg@lazybytes.net> parents: 10972 diff changeset	344 del block['lines'][1]
9156 c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	345 return blocks
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	346
9623 32727ce029de minirst: convert ``foo`` into "foo" upon display Martin Geisler <mg@lazybytes.net> parents: 9540 diff changeset	347 def inlineliterals(blocks):
11464 521c8e0c93bf minirst: use unicode string as intermediate form for replacement FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 11297 diff changeset	348 substs = [('``', '"')]
9623 32727ce029de minirst: convert ``foo`` into "foo" upon display Martin Geisler <mg@lazybytes.net> parents: 9540 diff changeset	349 for b in blocks:
10983 287a5cdf7743 minirst: correctly format sections containing inline markup Martin Geisler <mg@lazybytes.net> parents: 10972 diff changeset	350 if b['type'] in ('paragraph', 'section'):
11464 521c8e0c93bf minirst: use unicode string as intermediate form for replacement FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 11297 diff changeset	351 b['lines'] = [replace(l, substs) for l in b['lines']]
9623 32727ce029de minirst: convert ``foo`` into "foo" upon display Martin Geisler <mg@lazybytes.net> parents: 9540 diff changeset	352 return blocks
32727ce029de minirst: convert ``foo`` into "foo" upon display Martin Geisler <mg@lazybytes.net> parents: 9540 diff changeset	353
10972 0a2c6948f5f4 doc, minirst: support hg interpreted text role Martin Geisler <mg@aragost.com> parents: 10937 diff changeset	354 def hgrole(blocks):
11464 521c8e0c93bf minirst: use unicode string as intermediate form for replacement FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 11297 diff changeset	355 substs = [(':hg:`', '"hg '), ('`', '"')]
10972 0a2c6948f5f4 doc, minirst: support hg interpreted text role Martin Geisler <mg@aragost.com> parents: 10937 diff changeset	356 for b in blocks:
10983 287a5cdf7743 minirst: correctly format sections containing inline markup Martin Geisler <mg@lazybytes.net> parents: 10972 diff changeset	357 if b['type'] in ('paragraph', 'section'):
11192 babf9a5f5528 minirst: handle line breaks in hg role Martin Geisler <mg@aragost.com> parents: 11189 diff changeset	358 # Turn :hg:`command` into "hg command". This also works
babf9a5f5528 minirst: handle line breaks in hg role Martin Geisler <mg@aragost.com> parents: 11189 diff changeset	359 # when there is a line break in the command and relies on
babf9a5f5528 minirst: handle line breaks in hg role Martin Geisler <mg@aragost.com> parents: 11189 diff changeset	360 # the fact that we have no stray back-quotes in the input
babf9a5f5528 minirst: handle line breaks in hg role Martin Geisler <mg@aragost.com> parents: 11189 diff changeset	361 # (run the blocks through inlineliterals first).
11464 521c8e0c93bf minirst: use unicode string as intermediate form for replacement FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 11297 diff changeset	362 b['lines'] = [replace(l, substs) for l in b['lines']]
10972 0a2c6948f5f4 doc, minirst: support hg interpreted text role Martin Geisler <mg@aragost.com> parents: 10937 diff changeset	363 return blocks
0a2c6948f5f4 doc, minirst: support hg interpreted text role Martin Geisler <mg@aragost.com> parents: 10937 diff changeset	364
9156 c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	365 def addmargins(blocks):
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	366 """Adds empty blocks for vertical spacing.
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	367
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	368 This groups bullets, options, and definitions together with no vertical
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	369 space between them, and adds an empty block between all other blocks.
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	370 """
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	371 i = 1
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	372 while i < len(blocks):
10282 08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10264 diff changeset	373 if (blocks[i]['type'] == blocks[i - 1]['type'] and
10936 2853c891ac41 minirst: add margin around definition items Martin Geisler <mg@lazybytes.net> parents: 10447 diff changeset	374 blocks[i]['type'] in ('bullet', 'option', 'field')):
9156 c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	375 i += 1
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	376 else:
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	377 blocks.insert(i, dict(lines=[''], indent=0, type='margin'))
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	378 i += 2
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	379 return blocks
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	380
12819 5082e2f3f8e0 minirst: ignore comments Martin Geisler <mg@lazybytes.net> parents: 12652 diff changeset	381 def prunecomments(blocks):
5082e2f3f8e0 minirst: ignore comments Martin Geisler <mg@lazybytes.net> parents: 12652 diff changeset	382 """Remove comments."""
5082e2f3f8e0 minirst: ignore comments Martin Geisler <mg@lazybytes.net> parents: 12652 diff changeset	383 i = 0
5082e2f3f8e0 minirst: ignore comments Martin Geisler <mg@lazybytes.net> parents: 12652 diff changeset	384 while i < len(blocks):
5082e2f3f8e0 minirst: ignore comments Martin Geisler <mg@lazybytes.net> parents: 12652 diff changeset	385 b = blocks[i]
13009 54be08fa4d1d minirst: modified minirst to also recognize empty comments. Erik Zielke <ez@aragost.com> parents: 13003 diff changeset	386 if b['type'] == 'paragraph' and (b['lines'][0].startswith('.. ') or
54be08fa4d1d minirst: modified minirst to also recognize empty comments. Erik Zielke <ez@aragost.com> parents: 13003 diff changeset	387 b['lines'] == ['..']):
12819 5082e2f3f8e0 minirst: ignore comments Martin Geisler <mg@lazybytes.net> parents: 12652 diff changeset	388 del blocks[i]
13003 876a931dd230 minirst: better interaction between comments and margins Martin Geisler <mg@aragost.com> parents: 12958 diff changeset	389 if i < len(blocks) and blocks[i]['type'] == 'margin':
876a931dd230 minirst: better interaction between comments and margins Martin Geisler <mg@aragost.com> parents: 12958 diff changeset	390 del blocks[i]
12819 5082e2f3f8e0 minirst: ignore comments Martin Geisler <mg@lazybytes.net> parents: 12652 diff changeset	391 else:
5082e2f3f8e0 minirst: ignore comments Martin Geisler <mg@lazybytes.net> parents: 12652 diff changeset	392 i += 1
5082e2f3f8e0 minirst: ignore comments Martin Geisler <mg@lazybytes.net> parents: 12652 diff changeset	393 return blocks
5082e2f3f8e0 minirst: ignore comments Martin Geisler <mg@lazybytes.net> parents: 12652 diff changeset	394
12620 9a9312e84e4e minirst: small code cleanup Martin Geisler <mg@lazybytes.net> parents: 12388 diff changeset	395 _admonitionre = re.compile(r"\.\. (admonition\|attention\|caution\|danger\|"
9a9312e84e4e minirst: small code cleanup Martin Geisler <mg@lazybytes.net> parents: 12388 diff changeset	396 r"error\|hint\|important\|note\|tip\|warning)::",
9a9312e84e4e minirst: small code cleanup Martin Geisler <mg@lazybytes.net> parents: 12388 diff changeset	397 flags=re.IGNORECASE)
9a9312e84e4e minirst: small code cleanup Martin Geisler <mg@lazybytes.net> parents: 12388 diff changeset	398
12388 75f044d4dbf5 minirst: Support for admonitions Erik Zielke <ez@aragost.com> parents: 11464 diff changeset	399 def findadmonitions(blocks):
75f044d4dbf5 minirst: Support for admonitions Erik Zielke <ez@aragost.com> parents: 11464 diff changeset	400 """
75f044d4dbf5 minirst: Support for admonitions Erik Zielke <ez@aragost.com> parents: 11464 diff changeset	401 Makes the type of the block an admonition block if
75f044d4dbf5 minirst: Support for admonitions Erik Zielke <ez@aragost.com> parents: 11464 diff changeset	402 the first line is an admonition directive
75f044d4dbf5 minirst: Support for admonitions Erik Zielke <ez@aragost.com> parents: 11464 diff changeset	403 """
75f044d4dbf5 minirst: Support for admonitions Erik Zielke <ez@aragost.com> parents: 11464 diff changeset	404 i = 0
75f044d4dbf5 minirst: Support for admonitions Erik Zielke <ez@aragost.com> parents: 11464 diff changeset	405 while i < len(blocks):
12620 9a9312e84e4e minirst: small code cleanup Martin Geisler <mg@lazybytes.net> parents: 12388 diff changeset	406 m = _admonitionre.match(blocks[i]['lines'][0])
12388 75f044d4dbf5 minirst: Support for admonitions Erik Zielke <ez@aragost.com> parents: 11464 diff changeset	407 if m:
75f044d4dbf5 minirst: Support for admonitions Erik Zielke <ez@aragost.com> parents: 11464 diff changeset	408 blocks[i]['type'] = 'admonition'
75f044d4dbf5 minirst: Support for admonitions Erik Zielke <ez@aragost.com> parents: 11464 diff changeset	409 admonitiontitle = blocks[i]['lines'][0][3:m.end() - 2].lower()
75f044d4dbf5 minirst: Support for admonitions Erik Zielke <ez@aragost.com> parents: 11464 diff changeset	410
75f044d4dbf5 minirst: Support for admonitions Erik Zielke <ez@aragost.com> parents: 11464 diff changeset	411 firstline = blocks[i]['lines'][0][m.end() + 1:]
12620 9a9312e84e4e minirst: small code cleanup Martin Geisler <mg@lazybytes.net> parents: 12388 diff changeset	412 if firstline:
9a9312e84e4e minirst: small code cleanup Martin Geisler <mg@lazybytes.net> parents: 12388 diff changeset	413 blocks[i]['lines'].insert(1, ' ' + firstline)
12388 75f044d4dbf5 minirst: Support for admonitions Erik Zielke <ez@aragost.com> parents: 11464 diff changeset	414
75f044d4dbf5 minirst: Support for admonitions Erik Zielke <ez@aragost.com> parents: 11464 diff changeset	415 blocks[i]['admonitiontitle'] = admonitiontitle
75f044d4dbf5 minirst: Support for admonitions Erik Zielke <ez@aragost.com> parents: 11464 diff changeset	416 del blocks[i]['lines'][0]
75f044d4dbf5 minirst: Support for admonitions Erik Zielke <ez@aragost.com> parents: 11464 diff changeset	417 i = i + 1
75f044d4dbf5 minirst: Support for admonitions Erik Zielke <ez@aragost.com> parents: 11464 diff changeset	418 return blocks
9156 c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	419
12652 3c31c0e42b11 minirst: pull admonition titles out formatblock function Martin Geisler <mg@lazybytes.net> parents: 12651 diff changeset	420 _admonitiontitles = {'attention': _('Attention:'),
3c31c0e42b11 minirst: pull admonition titles out formatblock function Martin Geisler <mg@lazybytes.net> parents: 12651 diff changeset	421 'caution': _('Caution:'),
3c31c0e42b11 minirst: pull admonition titles out formatblock function Martin Geisler <mg@lazybytes.net> parents: 12651 diff changeset	422 'danger': _('!Danger!') ,
3c31c0e42b11 minirst: pull admonition titles out formatblock function Martin Geisler <mg@lazybytes.net> parents: 12651 diff changeset	423 'error': _('Error:'),
3c31c0e42b11 minirst: pull admonition titles out formatblock function Martin Geisler <mg@lazybytes.net> parents: 12651 diff changeset	424 'hint': _('Hint:'),
3c31c0e42b11 minirst: pull admonition titles out formatblock function Martin Geisler <mg@lazybytes.net> parents: 12651 diff changeset	425 'important': _('Important:'),
3c31c0e42b11 minirst: pull admonition titles out formatblock function Martin Geisler <mg@lazybytes.net> parents: 12651 diff changeset	426 'note': _('Note:'),
3c31c0e42b11 minirst: pull admonition titles out formatblock function Martin Geisler <mg@lazybytes.net> parents: 12651 diff changeset	427 'tip': _('Tip:'),
3c31c0e42b11 minirst: pull admonition titles out formatblock function Martin Geisler <mg@lazybytes.net> parents: 12651 diff changeset	428 'warning': _('Warning!')}
3c31c0e42b11 minirst: pull admonition titles out formatblock function Martin Geisler <mg@lazybytes.net> parents: 12651 diff changeset	429
13011 4936a04b6792 minirst: improved support for option lists. Erik Zielke <ez@aragost.com> parents: 13009 diff changeset	430 def formatoption(block, width):
4936a04b6792 minirst: improved support for option lists. Erik Zielke <ez@aragost.com> parents: 13009 diff changeset	431 desc = ' '.join(map(str.strip, block['lines']))
4936a04b6792 minirst: improved support for option lists. Erik Zielke <ez@aragost.com> parents: 13009 diff changeset	432 colwidth = encoding.colwidth(block['optstr'])
4936a04b6792 minirst: improved support for option lists. Erik Zielke <ez@aragost.com> parents: 13009 diff changeset	433 usablewidth = width - 1
4936a04b6792 minirst: improved support for option lists. Erik Zielke <ez@aragost.com> parents: 13009 diff changeset	434 hanging = block['optstrwidth']
4936a04b6792 minirst: improved support for option lists. Erik Zielke <ez@aragost.com> parents: 13009 diff changeset	435 initindent = '%s%s ' % (block['optstr'], ' ' * ((hanging - colwidth)))
4936a04b6792 minirst: improved support for option lists. Erik Zielke <ez@aragost.com> parents: 13009 diff changeset	436 hangindent = ' ' * (encoding.colwidth(initindent) + 1)
15125 bdc595059108 minirst: end all blocks with newlines Matt Mackall <mpm@selenic.com> parents: 15123 diff changeset	437 return ' %s\n' % (util.wrap(desc, usablewidth,
13011 4936a04b6792 minirst: improved support for option lists. Erik Zielke <ez@aragost.com> parents: 13009 diff changeset	438 initindent=initindent,
4936a04b6792 minirst: improved support for option lists. Erik Zielke <ez@aragost.com> parents: 13009 diff changeset	439 hangindent=hangindent))
4936a04b6792 minirst: improved support for option lists. Erik Zielke <ez@aragost.com> parents: 13009 diff changeset	440
9156 c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	441 def formatblock(block, width):
c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	442 """Format a block according to width."""
9417 4c3fb45123e5 util, minirst: do not crash with COLUMNS=0 Martin Geisler <mg@lazybytes.net> parents: 9293 diff changeset	443 if width <= 0:
4c3fb45123e5 util, minirst: do not crash with COLUMNS=0 Martin Geisler <mg@lazybytes.net> parents: 9293 diff changeset	444 width = 78
9156 c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	445 indent = ' ' * block['indent']
12388 75f044d4dbf5 minirst: Support for admonitions Erik Zielke <ez@aragost.com> parents: 11464 diff changeset	446 if block['type'] == 'admonition':
12652 3c31c0e42b11 minirst: pull admonition titles out formatblock function Martin Geisler <mg@lazybytes.net> parents: 12651 diff changeset	447 admonition = _admonitiontitles[block['admonitiontitle']]
12388 75f044d4dbf5 minirst: Support for admonitions Erik Zielke <ez@aragost.com> parents: 11464 diff changeset	448 hang = len(block['lines'][-1]) - len(block['lines'][-1].lstrip())
75f044d4dbf5 minirst: Support for admonitions Erik Zielke <ez@aragost.com> parents: 11464 diff changeset	449
75f044d4dbf5 minirst: Support for admonitions Erik Zielke <ez@aragost.com> parents: 11464 diff changeset	450 defindent = indent + hang * ' '
75f044d4dbf5 minirst: Support for admonitions Erik Zielke <ez@aragost.com> parents: 11464 diff changeset	451 text = ' '.join(map(str.strip, block['lines']))
15125 bdc595059108 minirst: end all blocks with newlines Matt Mackall <mpm@selenic.com> parents: 15123 diff changeset	452 return '%s\n%s\n' % (indent + admonition,
bdc595059108 minirst: end all blocks with newlines Matt Mackall <mpm@selenic.com> parents: 15123 diff changeset	453 util.wrap(text, width=width,
bdc595059108 minirst: end all blocks with newlines Matt Mackall <mpm@selenic.com> parents: 15123 diff changeset	454 initindent=defindent,
bdc595059108 minirst: end all blocks with newlines Matt Mackall <mpm@selenic.com> parents: 15123 diff changeset	455 hangindent=defindent))
9156 c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	456 if block['type'] == 'margin':
15125 bdc595059108 minirst: end all blocks with newlines Matt Mackall <mpm@selenic.com> parents: 15123 diff changeset	457 return '\n'
9735 97d0d910fa5d minirst: remove unnecessary "elif:" statements Martin Geisler <mg@lazybytes.net> parents: 9623 diff changeset	458 if block['type'] == 'literal':
9291 cd5b6a11b607 minirst: indent literal blocks with two spaces Martin Geisler <mg@lazybytes.net> parents: 9156 diff changeset	459 indent += ' '
15125 bdc595059108 minirst: end all blocks with newlines Matt Mackall <mpm@selenic.com> parents: 15123 diff changeset	460 return indent + ('\n' + indent).join(block['lines']) + '\n'
9735 97d0d910fa5d minirst: remove unnecessary "elif:" statements Martin Geisler <mg@lazybytes.net> parents: 9623 diff changeset	461 if block['type'] == 'section':
12867 eda77c3e246a minirst: use colwidth to match title lengths (issue2455) Matt Mackall <mpm@selenic.com> parents: 12819 diff changeset	462 underline = encoding.colwidth(block['lines'][0]) * block['underline']
15125 bdc595059108 minirst: end all blocks with newlines Matt Mackall <mpm@selenic.com> parents: 15123 diff changeset	463 return "%s%s\n%s%s\n" % (indent, block['lines'][0],indent, underline)
15037 df47381b41d6 minirst: add simple table support Matt Mackall <mpm@selenic.com> parents: 15036 diff changeset	464 if block['type'] == 'table':
df47381b41d6 minirst: add simple table support Matt Mackall <mpm@selenic.com> parents: 15036 diff changeset	465 table = block['table']
df47381b41d6 minirst: add simple table support Matt Mackall <mpm@selenic.com> parents: 15036 diff changeset	466 # compute column widths
df47381b41d6 minirst: add simple table support Matt Mackall <mpm@selenic.com> parents: 15036 diff changeset	467 widths = [max([encoding.colwidth(e) for e in c]) for c in zip(*table)]
df47381b41d6 minirst: add simple table support Matt Mackall <mpm@selenic.com> parents: 15036 diff changeset	468 text = ''
df47381b41d6 minirst: add simple table support Matt Mackall <mpm@selenic.com> parents: 15036 diff changeset	469 span = sum(widths) + len(widths) - 1
df47381b41d6 minirst: add simple table support Matt Mackall <mpm@selenic.com> parents: 15036 diff changeset	470 indent = ' ' * block['indent']
df47381b41d6 minirst: add simple table support Matt Mackall <mpm@selenic.com> parents: 15036 diff changeset	471 hang = ' ' * (len(indent) + span - widths[-1])
df47381b41d6 minirst: add simple table support Matt Mackall <mpm@selenic.com> parents: 15036 diff changeset	472
df47381b41d6 minirst: add simple table support Matt Mackall <mpm@selenic.com> parents: 15036 diff changeset	473 for row in table:
15144 87bb975a1844 minirst: fix column handling for simple tables Matt Mackall <mpm@selenic.com> parents: 15125 diff changeset	474 l = []
87bb975a1844 minirst: fix column handling for simple tables Matt Mackall <mpm@selenic.com> parents: 15125 diff changeset	475 for w, v in zip(widths, row):
87bb975a1844 minirst: fix column handling for simple tables Matt Mackall <mpm@selenic.com> parents: 15125 diff changeset	476 pad = ' ' * (w - encoding.colwidth(v))
87bb975a1844 minirst: fix column handling for simple tables Matt Mackall <mpm@selenic.com> parents: 15125 diff changeset	477 l.append(v + pad)
87bb975a1844 minirst: fix column handling for simple tables Matt Mackall <mpm@selenic.com> parents: 15125 diff changeset	478 l = ' '.join(l)
15037 df47381b41d6 minirst: add simple table support Matt Mackall <mpm@selenic.com> parents: 15036 diff changeset	479 l = util.wrap(l, width=width, initindent=indent, hangindent=hang)
df47381b41d6 minirst: add simple table support Matt Mackall <mpm@selenic.com> parents: 15036 diff changeset	480 if not text and block['header']:
df47381b41d6 minirst: add simple table support Matt Mackall <mpm@selenic.com> parents: 15036 diff changeset	481 text = l + '\n' + indent + '-' * (min(width, span)) + '\n'
df47381b41d6 minirst: add simple table support Matt Mackall <mpm@selenic.com> parents: 15036 diff changeset	482 else:
df47381b41d6 minirst: add simple table support Matt Mackall <mpm@selenic.com> parents: 15036 diff changeset	483 text += l + "\n"
df47381b41d6 minirst: add simple table support Matt Mackall <mpm@selenic.com> parents: 15036 diff changeset	484 return text
9735 97d0d910fa5d minirst: remove unnecessary "elif:" statements Martin Geisler <mg@lazybytes.net> parents: 9623 diff changeset	485 if block['type'] == 'definition':
9156 c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	486 term = indent + block['lines'][0]
9737 5f101af4a921 minirst: combine list parsing in one function Martin Geisler <mg@lazybytes.net> parents: 9735 diff changeset	487 hang = len(block['lines'][-1]) - len(block['lines'][-1].lstrip())
5f101af4a921 minirst: combine list parsing in one function Martin Geisler <mg@lazybytes.net> parents: 9735 diff changeset	488 defindent = indent + hang * ' '
9156 c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	489 text = ' '.join(map(str.strip, block['lines'][1:]))
15125 bdc595059108 minirst: end all blocks with newlines Matt Mackall <mpm@selenic.com> parents: 15123 diff changeset	490 return '%s\n%s\n' % (term, util.wrap(text, width=width,
bdc595059108 minirst: end all blocks with newlines Matt Mackall <mpm@selenic.com> parents: 15123 diff changeset	491 initindent=defindent,
bdc595059108 minirst: end all blocks with newlines Matt Mackall <mpm@selenic.com> parents: 15123 diff changeset	492 hangindent=defindent))
10937 a9d5943d2a30 minirst: removed unnecessary initindent variable Martin Geisler <mg@lazybytes.net> parents: 10936 diff changeset	493 subindent = indent
9735 97d0d910fa5d minirst: remove unnecessary "elif:" statements Martin Geisler <mg@lazybytes.net> parents: 9623 diff changeset	494 if block['type'] == 'bullet':
10447 e957cc7cbd14 minirst: support line blocks Martin Geisler <mg@lazybytes.net> parents: 10444 diff changeset	495 if block['lines'][0].startswith('\| '):
e957cc7cbd14 minirst: support line blocks Martin Geisler <mg@lazybytes.net> parents: 10444 diff changeset	496 # Remove bullet for line blocks and add no extra
e957cc7cbd14 minirst: support line blocks Martin Geisler <mg@lazybytes.net> parents: 10444 diff changeset	497 # indention.
e957cc7cbd14 minirst: support line blocks Martin Geisler <mg@lazybytes.net> parents: 10444 diff changeset	498 block['lines'][0] = block['lines'][0][2:]
e957cc7cbd14 minirst: support line blocks Martin Geisler <mg@lazybytes.net> parents: 10444 diff changeset	499 else:
e957cc7cbd14 minirst: support line blocks Martin Geisler <mg@lazybytes.net> parents: 10444 diff changeset	500 m = _bulletre.match(block['lines'][0])
e957cc7cbd14 minirst: support line blocks Martin Geisler <mg@lazybytes.net> parents: 10444 diff changeset	501 subindent = indent + m.end() * ' '
9737 5f101af4a921 minirst: combine list parsing in one function Martin Geisler <mg@lazybytes.net> parents: 9735 diff changeset	502 elif block['type'] == 'field':
10065 a1ae0ed78d1a minirst: improve layout of field lists Martin Geisler <mg@lazybytes.net> parents: 10064 diff changeset	503 key = block['key']
a1ae0ed78d1a minirst: improve layout of field lists Martin Geisler <mg@lazybytes.net> parents: 10064 diff changeset	504 subindent = indent + _fieldwidth * ' '
a1ae0ed78d1a minirst: improve layout of field lists Martin Geisler <mg@lazybytes.net> parents: 10064 diff changeset	505 if len(key) + 2 > _fieldwidth:
a1ae0ed78d1a minirst: improve layout of field lists Martin Geisler <mg@lazybytes.net> parents: 10064 diff changeset	506 # key too large, use full line width
a1ae0ed78d1a minirst: improve layout of field lists Martin Geisler <mg@lazybytes.net> parents: 10064 diff changeset	507 key = key.ljust(width)
a1ae0ed78d1a minirst: improve layout of field lists Martin Geisler <mg@lazybytes.net> parents: 10064 diff changeset	508 else:
15861 ee8f5e4ce7b8 minirst: simplify and standardize field list formatting Olav Reinert <seroton10@gmail.com> parents: 15393 diff changeset	509 # key fits within field width
10065 a1ae0ed78d1a minirst: improve layout of field lists Martin Geisler <mg@lazybytes.net> parents: 10064 diff changeset	510 key = key.ljust(_fieldwidth)
a1ae0ed78d1a minirst: improve layout of field lists Martin Geisler <mg@lazybytes.net> parents: 10064 diff changeset	511 block['lines'][0] = key + block['lines'][0]
9737 5f101af4a921 minirst: combine list parsing in one function Martin Geisler <mg@lazybytes.net> parents: 9735 diff changeset	512 elif block['type'] == 'option':
13011 4936a04b6792 minirst: improved support for option lists. Erik Zielke <ez@aragost.com> parents: 13009 diff changeset	513 return formatoption(block, width)
9156 c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	514
9737 5f101af4a921 minirst: combine list parsing in one function Martin Geisler <mg@lazybytes.net> parents: 9735 diff changeset	515 text = ' '.join(map(str.strip, block['lines']))
11297 d320e70442a5 replace Python standard textwrap by MBCS sensitive one for i18n text FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 11192 diff changeset	516 return util.wrap(text, width=width,
d320e70442a5 replace Python standard textwrap by MBCS sensitive one for i18n text FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 11192 diff changeset	517 initindent=indent,
15125 bdc595059108 minirst: end all blocks with newlines Matt Mackall <mpm@selenic.com> parents: 15123 diff changeset	518 hangindent=subindent) + '\n'
9156 c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	519
15261 e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	520 def formathtml(blocks):
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	521 """Format RST blocks as HTML"""
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	522
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	523 out = []
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	524 headernest = ''
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	525 listnest = []
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	526
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	527 def openlist(start, level):
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	528 if not listnest or listnest[-1][0] != start:
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	529 listnest.append((start, level))
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	530 out.append('<%s>\n' % start)
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	531
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	532 blocks = [b for b in blocks if b['type'] != 'margin']
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	533
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	534 for pos, b in enumerate(blocks):
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	535 btype = b['type']
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	536 level = b['indent']
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	537 lines = b['lines']
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	538
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	539 if btype == 'admonition':
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	540 admonition = _admonitiontitles[b['admonitiontitle']]
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	541 text = ' '.join(map(str.strip, lines))
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	542 out.append('<p>\n<b>%s</b> %s\n</p>\n' % (admonition, text))
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	543 elif btype == 'paragraph':
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	544 out.append('<p>\n%s\n</p>\n' % '\n'.join(lines))
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	545 elif btype == 'margin':
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	546 pass
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	547 elif btype == 'literal':
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	548 out.append('<pre>\n%s\n</pre>\n' % '\n'.join(lines))
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	549 elif btype == 'section':
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	550 i = b['underline']
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	551 if i not in headernest:
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	552 headernest += i
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	553 level = headernest.index(i) + 1
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	554 out.append('<h%d>%s</h%d>\n' % (level, lines[0], level))
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	555 elif btype == 'table':
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	556 table = b['table']
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	557 t = []
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	558 for row in table:
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	559 l = []
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	560 for v in zip(row):
18749 8aa053b99c24 minirst: don't generate TH elements for the first row in table Dan Villiom Podlaski Christiansen <danchr@gmail.com> parents: 18748 diff changeset	561 l.append('<td>%s</td>' % v)
15261 e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	562 t.append(' <tr>%s</tr>\n' % ''.join(l))
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	563 out.append('<table>\n%s</table>\n' % ''.join(t))
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	564 elif btype == 'definition':
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	565 openlist('dl', level)
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	566 term = lines[0]
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	567 text = ' '.join(map(str.strip, lines[1:]))
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	568 out.append(' <dt>%s\n <dd>%s\n' % (term, text))
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	569 elif btype == 'bullet':
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	570 bullet, head = lines[0].split(' ', 1)
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	571 if bullet == '-':
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	572 openlist('ul', level)
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	573 else:
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	574 openlist('ol', level)
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	575 out.append(' <li> %s\n' % ' '.join([head] + lines[1:]))
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	576 elif btype == 'field':
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	577 openlist('dl', level)
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	578 key = b['key']
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	579 text = ' '.join(map(str.strip, lines))
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	580 out.append(' <dt>%s\n <dd>%s\n' % (key, text))
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	581 elif btype == 'option':
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	582 openlist('dl', level)
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	583 opt = b['optstr']
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	584 desc = ' '.join(map(str.strip, lines))
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	585 out.append(' <dt>%s\n <dd>%s\n' % (opt, desc))
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	586
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	587 # close lists if indent level of next block is lower
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	588 if listnest:
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	589 start, level = listnest[-1]
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	590 if pos == len(blocks) - 1:
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	591 out.append('</%s>\n' % start)
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	592 listnest.pop()
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	593 else:
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	594 nb = blocks[pos + 1]
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	595 ni = nb['indent']
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	596 if (ni < level or
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	597 (ni == level and
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	598 nb['type'] not in 'definition bullet field option')):
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	599 out.append('</%s>\n' % start)
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	600 listnest.pop()
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	601
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	602 return ''.join(out)
e2df5b866d22 minirst: add basic HTML formatting support Matt Mackall <mpm@selenic.com> parents: 15192 diff changeset	603
15012 ee766af457ed minirst: add parse method to get document structure Matt Mackall <mpm@selenic.com> parents: 14433 diff changeset	604 def parse(text, indent=0, keep=None):
ee766af457ed minirst: add parse method to get document structure Matt Mackall <mpm@selenic.com> parents: 14433 diff changeset	605 """Parse text into a list of blocks"""
ee766af457ed minirst: add parse method to get document structure Matt Mackall <mpm@selenic.com> parents: 14433 diff changeset	606 pruned = []
9156 c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	607 blocks = findblocks(text)
9540 cad36e496640 help: un-indent help topics Martin Geisler <mg@lazybytes.net> parents: 9417 diff changeset	608 for b in blocks:
cad36e496640 help: un-indent help topics Martin Geisler <mg@lazybytes.net> parents: 9417 diff changeset	609 b['indent'] += indent
9156 c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	610 blocks = findliteralblocks(blocks)
15037 df47381b41d6 minirst: add simple table support Matt Mackall <mpm@selenic.com> parents: 15036 diff changeset	611 blocks = findtables(blocks)
10444 e99e0e077bc4 minirst: report pruned container types Martin Geisler <mg@lazybytes.net> parents: 10443 diff changeset	612 blocks, pruned = prunecontainers(blocks, keep or [])
10983 287a5cdf7743 minirst: correctly format sections containing inline markup Martin Geisler <mg@lazybytes.net> parents: 10972 diff changeset	613 blocks = findsections(blocks)
9623 32727ce029de minirst: convert ``foo`` into "foo" upon display Martin Geisler <mg@lazybytes.net> parents: 9540 diff changeset	614 blocks = inlineliterals(blocks)
10972 0a2c6948f5f4 doc, minirst: support hg interpreted text role Martin Geisler <mg@aragost.com> parents: 10937 diff changeset	615 blocks = hgrole(blocks)
9737 5f101af4a921 minirst: combine list parsing in one function Martin Geisler <mg@lazybytes.net> parents: 9735 diff changeset	616 blocks = splitparagraphs(blocks)
10065 a1ae0ed78d1a minirst: improve layout of field lists Martin Geisler <mg@lazybytes.net> parents: 10064 diff changeset	617 blocks = updatefieldlists(blocks)
13011 4936a04b6792 minirst: improved support for option lists. Erik Zielke <ez@aragost.com> parents: 13009 diff changeset	618 blocks = updateoptionlists(blocks)
13003 876a931dd230 minirst: better interaction between comments and margins Martin Geisler <mg@aragost.com> parents: 12958 diff changeset	619 blocks = addmargins(blocks)
12819 5082e2f3f8e0 minirst: ignore comments Martin Geisler <mg@lazybytes.net> parents: 12652 diff changeset	620 blocks = prunecomments(blocks)
12388 75f044d4dbf5 minirst: Support for admonitions Erik Zielke <ez@aragost.com> parents: 11464 diff changeset	621 blocks = findadmonitions(blocks)
15012 ee766af457ed minirst: add parse method to get document structure Matt Mackall <mpm@selenic.com> parents: 14433 diff changeset	622 return blocks, pruned
ee766af457ed minirst: add parse method to get document structure Matt Mackall <mpm@selenic.com> parents: 14433 diff changeset	623
15013 4a1e3c761ec7 minirst: add formatblocks helper Matt Mackall <mpm@selenic.com> parents: 15012 diff changeset	624 def formatblocks(blocks, width):
15125 bdc595059108 minirst: end all blocks with newlines Matt Mackall <mpm@selenic.com> parents: 15123 diff changeset	625 text = ''.join(formatblock(b, width) for b in blocks)
15013 4a1e3c761ec7 minirst: add formatblocks helper Matt Mackall <mpm@selenic.com> parents: 15012 diff changeset	626 return text
4a1e3c761ec7 minirst: add formatblocks helper Matt Mackall <mpm@selenic.com> parents: 15012 diff changeset	627
15262 e8076af14498 minirst: add style flag to format Matt Mackall <mpm@selenic.com> parents: 15261 diff changeset	628 def format(text, width=80, indent=0, keep=None, style='plain'):
15012 ee766af457ed minirst: add parse method to get document structure Matt Mackall <mpm@selenic.com> parents: 14433 diff changeset	629 """Parse and format the text according to width."""
ee766af457ed minirst: add parse method to get document structure Matt Mackall <mpm@selenic.com> parents: 14433 diff changeset	630 blocks, pruned = parse(text, indent, keep or [])
15262 e8076af14498 minirst: add style flag to format Matt Mackall <mpm@selenic.com> parents: 15261 diff changeset	631 if style == 'html':
e8076af14498 minirst: add style flag to format Matt Mackall <mpm@selenic.com> parents: 15261 diff changeset	632 text = formathtml(blocks)
e8076af14498 minirst: add style flag to format Matt Mackall <mpm@selenic.com> parents: 15261 diff changeset	633 else:
e8076af14498 minirst: add style flag to format Matt Mackall <mpm@selenic.com> parents: 15261 diff changeset	634 text = ''.join(formatblock(b, width) for b in blocks)
10444 e99e0e077bc4 minirst: report pruned container types Martin Geisler <mg@lazybytes.net> parents: 10443 diff changeset	635 if keep is None:
e99e0e077bc4 minirst: report pruned container types Martin Geisler <mg@lazybytes.net> parents: 10443 diff changeset	636 return text
e99e0e077bc4 minirst: report pruned container types Martin Geisler <mg@lazybytes.net> parents: 10443 diff changeset	637 else:
e99e0e077bc4 minirst: report pruned container types Martin Geisler <mg@lazybytes.net> parents: 10443 diff changeset	638 return text, pruned
9156 c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	639
15014 a814e986859f minirst: add getsections helper Matt Mackall <mpm@selenic.com> parents: 15013 diff changeset	640 def getsections(blocks):
a814e986859f minirst: add getsections helper Matt Mackall <mpm@selenic.com> parents: 15013 diff changeset	641 '''return a list of (section name, nesting level, blocks) tuples'''
a814e986859f minirst: add getsections helper Matt Mackall <mpm@selenic.com> parents: 15013 diff changeset	642 nest = ""
a814e986859f minirst: add getsections helper Matt Mackall <mpm@selenic.com> parents: 15013 diff changeset	643 level = 0
a814e986859f minirst: add getsections helper Matt Mackall <mpm@selenic.com> parents: 15013 diff changeset	644 secs = []
a814e986859f minirst: add getsections helper Matt Mackall <mpm@selenic.com> parents: 15013 diff changeset	645 for b in blocks:
a814e986859f minirst: add getsections helper Matt Mackall <mpm@selenic.com> parents: 15013 diff changeset	646 if b['type'] == 'section':
a814e986859f minirst: add getsections helper Matt Mackall <mpm@selenic.com> parents: 15013 diff changeset	647 i = b['underline']
a814e986859f minirst: add getsections helper Matt Mackall <mpm@selenic.com> parents: 15013 diff changeset	648 if i not in nest:
a814e986859f minirst: add getsections helper Matt Mackall <mpm@selenic.com> parents: 15013 diff changeset	649 nest += i
a814e986859f minirst: add getsections helper Matt Mackall <mpm@selenic.com> parents: 15013 diff changeset	650 level = nest.index(i) + 1
a814e986859f minirst: add getsections helper Matt Mackall <mpm@selenic.com> parents: 15013 diff changeset	651 nest = nest[:level]
a814e986859f minirst: add getsections helper Matt Mackall <mpm@selenic.com> parents: 15013 diff changeset	652 secs.append((b['lines'][0], level, [b]))
a814e986859f minirst: add getsections helper Matt Mackall <mpm@selenic.com> parents: 15013 diff changeset	653 else:
a814e986859f minirst: add getsections helper Matt Mackall <mpm@selenic.com> parents: 15013 diff changeset	654 if not secs:
a814e986859f minirst: add getsections helper Matt Mackall <mpm@selenic.com> parents: 15013 diff changeset	655 # add an initial empty section
a814e986859f minirst: add getsections helper Matt Mackall <mpm@selenic.com> parents: 15013 diff changeset	656 secs = [('', 0, [])]
a814e986859f minirst: add getsections helper Matt Mackall <mpm@selenic.com> parents: 15013 diff changeset	657 secs[-1][2].append(b)
a814e986859f minirst: add getsections helper Matt Mackall <mpm@selenic.com> parents: 15013 diff changeset	658 return secs
9156 c9c7e8cdac9c minimal reStructuredText parser Martin Geisler <mg@lazybytes.net> parents: diff changeset	659
15015 ee6988aea74e minirst: add decorateblocks search helper Matt Mackall <mpm@selenic.com> parents: 15014 diff changeset	660 def decorateblocks(blocks, width):
ee6988aea74e minirst: add decorateblocks search helper Matt Mackall <mpm@selenic.com> parents: 15014 diff changeset	661 '''generate a list of (section name, line text) pairs for search'''
ee6988aea74e minirst: add decorateblocks search helper Matt Mackall <mpm@selenic.com> parents: 15014 diff changeset	662 lines = []
ee6988aea74e minirst: add decorateblocks search helper Matt Mackall <mpm@selenic.com> parents: 15014 diff changeset	663 for s in getsections(blocks):
ee6988aea74e minirst: add decorateblocks search helper Matt Mackall <mpm@selenic.com> parents: 15014 diff changeset	664 section = s[0]
ee6988aea74e minirst: add decorateblocks search helper Matt Mackall <mpm@selenic.com> parents: 15014 diff changeset	665 text = formatblocks(s[2], width)
ee6988aea74e minirst: add decorateblocks search helper Matt Mackall <mpm@selenic.com> parents: 15014 diff changeset	666 lines.append([(section, l) for l in text.splitlines(True)])
ee6988aea74e minirst: add decorateblocks search helper Matt Mackall <mpm@selenic.com> parents: 15014 diff changeset	667 return lines
15039 c981f4a9ea74 minirst: add a helper function to build an RST table from an array Matt Mackall <mpm@selenic.com> parents: 15038 diff changeset	668
c981f4a9ea74 minirst: add a helper function to build an RST table from an array Matt Mackall <mpm@selenic.com> parents: 15038 diff changeset	669 def maketable(data, indent=0, header=False):
16815 e740746ea557 minirst: generate tables as a list of joined lines Olav Reinert <seroton10@gmail.com> parents: 15861 diff changeset	670 '''Generate an RST table for the given table data as a list of lines'''
15039 c981f4a9ea74 minirst: add a helper function to build an RST table from an array Matt Mackall <mpm@selenic.com> parents: 15038 diff changeset	671
c981f4a9ea74 minirst: add a helper function to build an RST table from an array Matt Mackall <mpm@selenic.com> parents: 15038 diff changeset	672 widths = [max(encoding.colwidth(e) for e in c) for c in zip(*data)]
c981f4a9ea74 minirst: add a helper function to build an RST table from an array Matt Mackall <mpm@selenic.com> parents: 15038 diff changeset	673 indent = ' ' * indent
c981f4a9ea74 minirst: add a helper function to build an RST table from an array Matt Mackall <mpm@selenic.com> parents: 15038 diff changeset	674 div = indent + ' '.join('=' * w for w in widths) + '\n'
c981f4a9ea74 minirst: add a helper function to build an RST table from an array Matt Mackall <mpm@selenic.com> parents: 15038 diff changeset	675
c981f4a9ea74 minirst: add a helper function to build an RST table from an array Matt Mackall <mpm@selenic.com> parents: 15038 diff changeset	676 out = [div]
c981f4a9ea74 minirst: add a helper function to build an RST table from an array Matt Mackall <mpm@selenic.com> parents: 15038 diff changeset	677 for row in data:
15144 87bb975a1844 minirst: fix column handling for simple tables Matt Mackall <mpm@selenic.com> parents: 15125 diff changeset	678 l = []
87bb975a1844 minirst: fix column handling for simple tables Matt Mackall <mpm@selenic.com> parents: 15125 diff changeset	679 for w, v in zip(widths, row):
87bb975a1844 minirst: fix column handling for simple tables Matt Mackall <mpm@selenic.com> parents: 15125 diff changeset	680 pad = ' ' * (w - encoding.colwidth(v))
87bb975a1844 minirst: fix column handling for simple tables Matt Mackall <mpm@selenic.com> parents: 15125 diff changeset	681 l.append(v + pad)
87bb975a1844 minirst: fix column handling for simple tables Matt Mackall <mpm@selenic.com> parents: 15125 diff changeset	682 out.append(indent + ' '.join(l) + "\n")
15039 c981f4a9ea74 minirst: add a helper function to build an RST table from an array Matt Mackall <mpm@selenic.com> parents: 15038 diff changeset	683 if header and len(data) > 1:
c981f4a9ea74 minirst: add a helper function to build an RST table from an array Matt Mackall <mpm@selenic.com> parents: 15038 diff changeset	684 out.insert(2, div)
c981f4a9ea74 minirst: add a helper function to build an RST table from an array Matt Mackall <mpm@selenic.com> parents: 15038 diff changeset	685 out.append(div)
16815 e740746ea557 minirst: generate tables as a list of joined lines Olav Reinert <seroton10@gmail.com> parents: 15861 diff changeset	686 return out

Mercurial > public > mercurial-scm > hg-stable

annotate mercurial/minirst.py @ 18749:8aa053b99c24