minirst: improve layout of field lists

Before, we used the padding following the key to compute where to wrap
the text. Long keys would thus give a big indentation. It also
required careful alignment of the source text, making it cumbersome to
items to the list.

We now compute the maximum key length and use that for all items in
the list. We also put a cap on the indentation: keys longer than 10
characters are put on their own line. This is similar to how rst2html
handles large keys: it uses 14 as the cutoff point, but I felt that 10
was better for monospaced text in the console.

mercurial/minirst.py

@@ -1,277 +1,316 b''
 # minirst.py - minimal reStructuredText parser
 #
 # Copyright 2009 Matt Mackall <[e-mail]> and others
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2, incorporated herein by reference.
 
 """simplified reStructuredText parser.
 
 This parser knows just enough about reStructuredText to parse the
 Mercurial docstrings.
 
 It cheats in a major way: nested blocks are not really nested. They
 are just indented blocks that look like they are nested. This relies
 on the user to keep the right indentation for the blocks.
 
 It only supports a small subset of reStructuredText:
 
 - sections
 
 - paragraphs
 
 - literal blocks
 
 - definition lists
 
 - bullet lists (items must start with '-')
 
 - enumerated lists (no autonumbering)
 
 - field lists (colons cannot be escaped)
 
 - option lists (supports only long options without arguments)
 
 - inline literals (no other inline markup is not recognized)
 """
 
 import re, sys, textwrap
 
 
 def findblocks(text):
     """Find continuous blocks of lines in text.
 
     Returns a list of dictionaries representing the blocks. Each block
     has an 'indent' field and a 'lines' field.
     """
     blocks = [[]]
     lines = text.splitlines()
     for line in lines:
         if line.strip():
             blocks[-1].append(line)
         elif blocks[-1]:
             blocks.append([])
     if not blocks[-1]:
         del blocks[-1]
 
     for i, block in enumerate(blocks):
         indent = min((len(l) - len(l.lstrip())) for l in block)
         blocks[i] = dict(indent=indent, lines=[l[indent:] for l in block])
     return blocks
 
 
 def findliteralblocks(blocks):
     """Finds literal blocks and adds a 'type' field to the blocks.
 
     Literal blocks are given the type 'literal', all other blocks are
     given type the 'paragraph'.
     """
     i = 0
     while i < len(blocks):
         # Searching for a block that looks like this:
         #
         # +------------------------------+
         # | paragraph                    |
         # | (ends with "::")             |
         # +------------------------------+
         #    +---------------------------+
         #    | indented literal block    |
         #    +---------------------------+
         blocks[i]['type'] = 'paragraph'
         if blocks[i]['lines'][-1].endswith('::') and i+1 < len(blocks):
             indent = blocks[i]['indent']
             adjustment = blocks[i+1]['indent'] - indent
 
             if blocks[i]['lines'] == ['::']:
                 # Expanded form: remove block
                 del blocks[i]
                 i -= 1
             elif blocks[i]['lines'][-1].endswith(' ::'):
                 # Partially minimized form: remove space and both
                 # colons.
                 blocks[i]['lines'][-1] = blocks[i]['lines'][-1][:-3]
             else:
                 # Fully minimized form: remove just one colon.
                 blocks[i]['lines'][-1] = blocks[i]['lines'][-1][:-1]
 
             # List items are formatted with a hanging indent. We must
             # correct for this here while we still have the original
             # information on the indentation of the subsequent literal
             # blocks available.
             m = _bulletre.match(blocks[i]['lines'][0])
             if m:
                 indent += m.end()
                 adjustment -= m.end()
 
             # Mark the following indented blocks.
             while i+1 < len(blocks) and blocks[i+1]['indent'] > indent:
                 blocks[i+1]['type'] = 'literal'
                 blocks[i+1]['indent'] -= adjustment
                 i += 1
         i += 1
     return blocks
 
 _bulletre = re.compile(r'(-|[0-9A-Za-z]+\.|\(?[0-9A-Za-z]+\)) ')
 _optionre = re.compile(r'^(--[a-z-]+)((?:[ =][a-zA-Z][\w-]*)?  +)(.*)$')
-_fieldre = re.compile(r':(?![: ])([^:]*)(?<! ):( +)(.*)')
+_fieldre = re.compile(r':(?![: ])([^:]*)(?<! ):[ ]+(.*)')
 _definitionre = re.compile(r'[^ ]')
 
 def splitparagraphs(blocks):
     """Split paragraphs into lists."""
     # Tuples with (list type, item regexp, single line items?). Order
     # matters: definition lists has the least specific regexp and must
     # come last.
     listtypes = [('bullet', _bulletre, True),
                  ('option', _optionre, True),
                  ('field', _fieldre, True),
                  ('definition', _definitionre, False)]
 
     def match(lines, i, itemre, singleline):
         """Does itemre match an item at line i?
 
         A list item can be followed by an idented line or another list
         item (but only if singleline is True).
         """
         line1 = lines[i]
         line2 = i+1 < len(lines) and lines[i+1] or ''
         if not itemre.match(line1):
             return False
         if singleline:
             return line2 == '' or line2[0] == ' ' or itemre.match(line2)
         else:
             return line2.startswith(' ')
 
     i = 0
     while i < len(blocks):
         if blocks[i]['type'] == 'paragraph':
             lines = blocks[i]['lines']
             for type, itemre, singleline in listtypes:
                 if match(lines, 0, itemre, singleline):
                     items = []
                     for j, line in enumerate(lines):
                         if match(lines, j, itemre, singleline):
                             items.append(dict(type=type, lines=[],
                                               indent=blocks[i]['indent']))
                         items[-1]['lines'].append(line)
                     blocks[i:i+1] = items
                     break
         i += 1
     return blocks
 
 
+_fieldwidth = 12
+
+def updatefieldlists(blocks):
+    """Find key and maximum key width for field lists."""
+    i = 0
+    while i < len(blocks):
+        if blocks[i]['type'] != 'field':
+            i += 1
+            continue
+
+        keywidth = 0
+        j = i
+        while j < len(blocks) and blocks[j]['type'] == 'field':
+            m = _fieldre.match(blocks[j]['lines'][0])
+            key, rest = m.groups()
+            blocks[j]['lines'][0] = rest
+            blocks[j]['key'] = key
+            keywidth = max(keywidth, len(key))
+            j += 1
+
+        for block in blocks[i:j]:
+            block['keywidth'] = keywidth
+        i = j + 1
+
+    return blocks
+
+
 def findsections(blocks):
     """Finds sections.
 
     The blocks must have a 'type' field, i.e., they should have been
     run through findliteralblocks first.
     """
     for block in blocks:
         # Searching for a block that looks like this:
         #
         # +------------------------------+
         # | Section title                |
         # | -------------                |
         # +------------------------------+
         if (block['type'] == 'paragraph' and
             len(block['lines']) == 2 and
             block['lines'][1] == '-' * len(block['lines'][0])):
             block['type'] = 'section'
     return blocks
 
 
 def inlineliterals(blocks):
     for b in blocks:
         if b['type'] == 'paragraph':
             b['lines'] = [l.replace('``', '"') for l in b['lines']]
     return blocks
 
 
 def addmargins(blocks):
     """Adds empty blocks for vertical spacing.
 
     This groups bullets, options, and definitions together with no vertical
     space between them, and adds an empty block between all other blocks.
     """
     i = 1
     while i < len(blocks):
         if (blocks[i]['type'] == blocks[i-1]['type'] and
             blocks[i]['type'] in ('bullet', 'option', 'field', 'definition')):
             i += 1
         else:
             blocks.insert(i, dict(lines=[''], indent=0, type='margin'))
             i += 2
     return blocks
 
 
 def formatblock(block, width):
     """Format a block according to width."""
     if width <= 0:
         width = 78
     indent = ' ' * block['indent']
     if block['type'] == 'margin':
         return ''
     if block['type'] == 'literal':
         indent += '  '
         return indent + ('\n' + indent).join(block['lines'])
     if block['type'] == 'section':
         return indent + ('\n' + indent).join(block['lines'])
     if block['type'] == 'definition':
         term = indent + block['lines'][0]
         hang = len(block['lines'][-1]) - len(block['lines'][-1].lstrip())
         defindent = indent + hang * ' '
         text = ' '.join(map(str.strip, block['lines'][1:]))
         return "%s\n%s" % (term, textwrap.fill(text, width=width,
                                                initial_indent=defindent,
                                                subsequent_indent=defindent))
     initindent = subindent = indent
     if block['type'] == 'bullet':
         m = _bulletre.match(block['lines'][0])
         subindent = indent + m.end() * ' '
     elif block['type'] == 'field':
-        m = _fieldre.match(block['lines'][0])
-        key, spaces, rest = m.groups()
-        # Turn ":foo: bar" into "foo   bar".
-        block['lines'][0] = '%s  %s%s' % (key, spaces, rest)
-        subindent = indent + (2 + len(key) + len(spaces)) * ' '
+        keywidth = block['keywidth']
+        key = block['key']
+
+        subindent = indent + _fieldwidth * ' '
+        if len(key) + 2 > _fieldwidth:
+            # key too large, use full line width
+            key = key.ljust(width)
+        elif keywidth + 2 < _fieldwidth:
+            # all keys are small, add only two spaces
+            key = key.ljust(keywidth + 2)
+            subindent = indent + (keywidth + 2) * ' '
+        else:
+            # mixed sizes, use fieldwidth for this one
+            key = key.ljust(_fieldwidth)
+        block['lines'][0] = key + block['lines'][0]
     elif block['type'] == 'option':
         m = _optionre.match(block['lines'][0])
         option, arg, rest = m.groups()
         subindent = indent + (len(option) + len(arg)) * ' '
 
     text = ' '.join(map(str.strip, block['lines']))
     return textwrap.fill(text, width=width,
                          initial_indent=initindent,
                          subsequent_indent=subindent)
 
 
 def format(text, width, indent=0):
     """Parse and format the text according to width."""
     blocks = findblocks(text)
     for b in blocks:
         b['indent'] += indent
     blocks = findliteralblocks(blocks)
     blocks = inlineliterals(blocks)
     blocks = splitparagraphs(blocks)
+    blocks = updatefieldlists(blocks)
     blocks = findsections(blocks)
     blocks = addmargins(blocks)
     return '\n'.join(formatblock(b, width) for b in blocks)
 
 
 if __name__ == "__main__":
     from pprint import pprint
 
     def debug(func, blocks):
         blocks = func(blocks)
         print "*** after %s:" % func.__name__
         pprint(blocks)
         print
         return blocks
 
     text = open(sys.argv[1]).read()
     blocks = debug(findblocks, text)
     blocks = debug(findliteralblocks, blocks)
     blocks = debug(inlineliterals, blocks)
     blocks = debug(splitparagraphs, blocks)
+    blocks = debug(updatefieldlists, blocks)
     blocks = debug(findsections, blocks)
     blocks = debug(addmargins, blocks)
     print '\n'.join(formatblock(b, 30) for b in blocks)

tests/test-minirst.py

@@ -1,147 +1,148 b''
 #!/usr/bin/env python
 
 from mercurial import minirst
 
 def debugformat(title, text, width):
     print "%s formatted to fit within %d characters:" % (title, width)
     print "-" * 70
     print minirst.format(text, width)
     print "-" * 70
     print
 
 paragraphs = """
 This is some text in the first paragraph.
 
   A small indented paragraph.
   It is followed by some lines
   containing random whitespace.
  
   
    
 The third and final paragraph.
 """
 
 debugformat('paragraphs', paragraphs, 60)
 debugformat('paragraphs', paragraphs, 30)
 
 
 definitions = """
 A Term
   Definition. The indented
   lines make up the definition.
 Another Term
   Another definition. The final line in the
    definition determines the indentation, so
     this will be indented with four spaces.
 
   A Nested/Indented Term
     Definition.
 """
 
 debugformat('definitions', definitions, 60)
 debugformat('definitions', definitions, 30)
 
 
 literals = r"""
 The fully minimized form is the most
 convenient form::
 
   Hello
     literal
       world
 
 In the partially minimized form a paragraph
 simply ends with space-double-colon. ::
 
   ////////////////////////////////////////
   long un-wrapped line in a literal block
   \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
 
 ::
 
   This literal block is started with '::',
     the so-called expanded form. The paragraph
       with '::' disappears in the final output.
 """
 
 debugformat('literals', literals, 60)
 debugformat('literals', literals, 30)
 
 
 lists = """
 - This is the first list item.
 
   Second paragraph in the first list item.
 
 - List items need not be separated
   by a blank line.
 - And will be rendered without
   one in any case.
 
 We can have indented lists:
 
   - This is an indented list item
 
   - Another indented list item::
 
       - A literal block in the middle
             of an indented list.
 
       (The above is not a list item since we are in the literal block.)
 
 ::
 
   Literal block with no indentation (apart from
   the two spaces added to all literal blocks).
 
 1. This is an enumerated list (first item).
 2. Continuing with the second item.
 
 (1) foo
 (2) bar
 
 1) Another
 2) List
 """
 
 debugformat('lists', lists, 60)
 debugformat('lists', lists, 30)
 
 
 options = """
 There is support for simple option lists,
 but only with long options:
 
 --all      Output all.
 --both     Output both (this description is
            quite long).
 --long     Output all day long.
 
 --par      This option has two paragraphs in its description.
            This is the first.
 
            This is the second.  Blank lines may be omitted between
            options (as above) or left in (as here).
 
 The next paragraph looks like an option list, but lacks the two-space
 marker after the option. It is treated as a normal paragraph:
 
 --foo bar baz
 """
 
 debugformat('options', options, 60)
 debugformat('options', options, 30)
 
 
 fields = """
-Field lists give a simple two-column layout:
+:a: First item.
+:ab: Second item. Indentation and wrapping
+     is handled automatically.
 
-:key:         The whitespace following the key is
-  significant for the wrapping of this text.
-:another key: More text.
-    The indentation on the following
-    lines is not significant.
+Next list:
+
+:small: The larger key below triggers full indentation here.
+:much too large: This key is big enough to get its own line.
 """
 
 debugformat('fields', fields, 60)
 debugformat('fields', fields, 30)

tests/test-minirst.py.out

@@ -1,243 +1,248 b''
 paragraphs formatted to fit within 60 characters:
 ----------------------------------------------------------------------
 This is some text in the first paragraph.
 
   A small indented paragraph. It is followed by some lines
   containing random whitespace.
 
 The third and final paragraph.
 ----------------------------------------------------------------------
 
 paragraphs formatted to fit within 30 characters:
 ----------------------------------------------------------------------
 This is some text in the first
 paragraph.
 
   A small indented paragraph.
   It is followed by some lines
   containing random
   whitespace.
 
 The third and final paragraph.
 ----------------------------------------------------------------------
 
 definitions formatted to fit within 60 characters:
 ----------------------------------------------------------------------
 A Term
   Definition. The indented lines make up the definition.
 Another Term
     Another definition. The final line in the definition
     determines the indentation, so this will be indented
     with four spaces.
   A Nested/Indented Term
     Definition.
 ----------------------------------------------------------------------
 
 definitions formatted to fit within 30 characters:
 ----------------------------------------------------------------------
 A Term
   Definition. The indented
   lines make up the
   definition.
 Another Term
     Another definition. The
     final line in the
     definition determines the
     indentation, so this will
     be indented with four
     spaces.
   A Nested/Indented Term
     Definition.
 ----------------------------------------------------------------------
 
 literals formatted to fit within 60 characters:
 ----------------------------------------------------------------------
 The fully minimized form is the most convenient form:
 
   Hello
     literal
       world
 
 In the partially minimized form a paragraph simply ends with
 space-double-colon.
 
   ////////////////////////////////////////
   long un-wrapped line in a literal block
   \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
 
   This literal block is started with '::',
     the so-called expanded form. The paragraph
       with '::' disappears in the final output.
 ----------------------------------------------------------------------
 
 literals formatted to fit within 30 characters:
 ----------------------------------------------------------------------
 The fully minimized form is
 the most convenient form:
 
   Hello
     literal
       world
 
 In the partially minimized
 form a paragraph simply ends
 with space-double-colon.
 
   ////////////////////////////////////////
   long un-wrapped line in a literal block
   \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
 
   This literal block is started with '::',
     the so-called expanded form. The paragraph
       with '::' disappears in the final output.
 ----------------------------------------------------------------------
 
 lists formatted to fit within 60 characters:
 ----------------------------------------------------------------------
 - This is the first list item.
 
   Second paragraph in the first list item.
 
 - List items need not be separated by a blank line.
 - And will be rendered without one in any case.
 
 We can have indented lists:
 
   - This is an indented list item
   - Another indented list item:
 
       - A literal block in the middle
             of an indented list.
 
       (The above is not a list item since we are in the literal block.)
 
   Literal block with no indentation (apart from
   the two spaces added to all literal blocks).
 
 1. This is an enumerated list (first item).
 2. Continuing with the second item.
 (1) foo
 (2) bar
 1) Another
 2) List
 ----------------------------------------------------------------------
 
 lists formatted to fit within 30 characters:
 ----------------------------------------------------------------------
 - This is the first list item.
 
   Second paragraph in the
   first list item.
 
 - List items need not be
   separated by a blank line.
 - And will be rendered without
   one in any case.
 
 We can have indented lists:
 
   - This is an indented list
     item
   - Another indented list
     item:
 
       - A literal block in the middle
             of an indented list.
 
       (The above is not a list item since we are in the literal block.)
 
   Literal block with no indentation (apart from
   the two spaces added to all literal blocks).
 
 1. This is an enumerated list
    (first item).
 2. Continuing with the second
    item.
 (1) foo
 (2) bar
 1) Another
 2) List
 ----------------------------------------------------------------------
 
 options formatted to fit within 60 characters:
 ----------------------------------------------------------------------
 There is support for simple option lists, but only with long
 options:
 
 --all      Output all.
 --both     Output both (this description is quite long).
 --long     Output all day long.
 --par      This option has two paragraphs in its
            description. This is the first.
 
            This is the second.  Blank lines may be omitted
            between options (as above) or left in (as here).
 
 The next paragraph looks like an option list, but lacks the
 two-space marker after the option. It is treated as a normal
 paragraph:
 
 --foo bar baz
 ----------------------------------------------------------------------
 
 options formatted to fit within 30 characters:
 ----------------------------------------------------------------------
 There is support for simple
 option lists, but only with
 long options:
 
 --all      Output all.
 --both     Output both (this
            description is
            quite long).
 --long     Output all day
            long.
 --par      This option has two
            paragraphs in its
            description. This
            is the first.
 
            This is the second.
            Blank lines may be
            omitted between
            options (as above)
            or left in (as
            here).
 
 The next paragraph looks like
 an option list, but lacks the
 two-space marker after the
 option. It is treated as a
 normal paragraph:
 
 --foo bar baz
 ----------------------------------------------------------------------
 
 fields formatted to fit within 60 characters:
 ----------------------------------------------------------------------
-Field lists give a simple two-column layout:
+a   First item.
+ab  Second item. Indentation and wrapping is handled
+    automatically.
 
-key           The whitespace following the key is
-              significant for the wrapping of this text.
-another key   More text. The indentation on the following
-              lines is not significant.
+Next list:
+
+small       The larger key below triggers full indentation
+            here.
+much too large
+            This key is big enough to get its own line.
 ----------------------------------------------------------------------
 
 fields formatted to fit within 30 characters:
 ----------------------------------------------------------------------
-Field lists give a simple two-
-column layout:
+a   First item.
+ab  Second item. Indentation
+    and wrapping is handled
+    automatically.
+
+Next list:
 
-key           The whitespace
-              following the
-              key is
-              significant for
-              the wrapping of
-              this text.
-another key   More text. The
-              indentation on
-              the following
-              lines is not
-              significant.
+small       The larger key
+            below triggers
+            full indentation
+            here.
+much too large
+            This key is big
+            enough to get its
+            own line.
 ----------------------------------------------------------------------