"""
Fancy lists in the style of Pandoc.
---
# A Python implementation of John Gruber's Markdown.
# Started by Manfred Stienstra (http://www.dwerg.net/).
# Maintained for a few years by Yuri Takhteyev (http://www.freewisdom.org).
# Currently maintained by Waylan Limberg (https://github.com/waylan),
# Dmitry Shachnev (https://github.com/mitya57) and Isaac Muse (https://github.com/facelessuser).
# Copyright 2007-2023 The Python Markdown Project (v. 1.7 and later)
# Copyright 2004, 2005, 2006 Yuri Takhteyev (v. 0.2-1.6b)
# Copyright 2004 Manfred Stienstra (the original version)
# License: BSD (see LICENSE.md for details).
---
Adapted to support "fancy" behavior by Copyright 2024 Isaac Muse.
Work in progress, not fully tested.
"""
from markdown.blockprocessors import BlockProcessor
from markdown.treeprocessors import Treeprocessor
from .blocks.block import Block
from .blocks import BlocksExtension
import xml.etree.ElementTree as etree
import re
ROMAN_MAP = {'I': 1, 'V': 5, 'X': 10, 'L': 50, 'C': 100, 'D': 500, 'M': 1000}
OL_STYLE = {
'1': 'decimal',
'a': 'lower-alpha',
'A': 'upper-alpha',
'i': 'lower-roman',
'I': 'upper-roman'
}
def roman2int(s):
"""
Convert Roman numeral to integer.
Values should be validated before as no validation during conversion.
"""
s = s.upper()
# Initialize result
total = 0
i = 0
while i < len(s):
# Current index is less than the next, subtract current from next and sum value
if i + 1 < len(s) and ROMAN_MAP[s[i]] < ROMAN_MAP[s[i + 1]]:
total += ROMAN_MAP[s[i + 1]] - ROMAN_MAP[s[i]]
i += 2
# Sum the value
else:
total += ROMAN_MAP[s[i]]
i += 1
return total
class FancyOListProcessor(BlockProcessor):
"""Process fancy ordered list blocks."""
TAG = 'ol'
SIBLING_TAGS = ['ol']
OL_TYPES = {
'dot-decimal': '1',
'paren-decimal': '1',
'dot-roman': 'i',
'paren-roman': 'i',
'dot-ROMAN': 'I',
'paren-ROMAN': 'I',
'dot-alpha': 'a',
'paren-alpha': 'a',
'dot-ALPHA': 'A',
'paren-ALPHA': 'A'
}
def __init__(self, parser, config):
"""Initialize."""
super().__init__(parser)
list_types = config['additional_ordered_styles']
self.alpha_enabled = 'alpha' in list_types
self.roman_enabled = 'roman' in list_types
self.inject_style = config['inject_style']
self.inject_class = config['inject_class']
formats = ''
if 'generic' in list_types:
formats += r'| \#'
if 'roman' in list_types:
# Rules are similar to https://projecteuler.net/about=roman_numerals
# We do not follow the "rule of 3": repeated values should not occur more than 3 times.
# The above link suggests that repeats should be restricted such that lower denominations
# do not equal or exceed X, C or M. We alter this to allow equaling to help mitigate
# conflicts with alphabetical lists.
formats += r'''
| (?=[IVXLCDM]{2})
M*
(?:C[MD]|D(?:C{0,4}|C{5}\b)|(?:C{0,9}|C{10}\b))
(?:X[CL]|L(?:X{0,4}|X{5}\b)|(?:X{0,9}|X{10}\b))
(?:I[XV]|V(?:I{0,4}|I{5}\b)|(?:I{0,9}|I{10}\b))
| (?=[ivxlcdm])
m*
(?:c[md]|d(?:c{0,4}|c{5}\b)|(?:c{0,9}|c{10}\b))
(?:x[cl]|l(?:x{0,4}|x{5}\b)|(?:x{0,9}|x{10}\b))
(?:i[xv]|v(?:i{0,4}|i{5}\b)|(?:i{0,9}|i{10}\b))
'''
if 'alpha' not in list_types:
formats += r'''
| [IVXLCDM](?=\)|\.[ ]{2})
'''
if 'alpha' in list_types:
formats += r'''
| [a-z]
| [A-Z](?=\)|\.[ ]{2})
'''
# Detect an item list item.
self.list_re = re.compile(
r'^[ ]{0,%d}(?:(?:\d+%s)[).])[ ]+(.*)' % (self.tab_length - 1, formats),
re.VERBOSE
)
# Detect items on secondary lines which can be of any list type.
self.child_re = re.compile(
r'^[ ]{0,%d}((?:(?:\d+%s)[).]|[-*+]))[ ]+(.*)' % (self.tab_length - 1, formats),
re.VERBOSE
)
# Detect indented (nested) list items of any type.
self.indent_re = re.compile(
r'^[ ]{%d,%d}(?:(?:\d+%s)[).]|[-*+])[ ]+.*' % (self.tab_length, self.tab_length * 2 - 1, formats),
re.VERBOSE
)
self.startswith = "1"
def test(self, parent, block):
"""Test to see if block starts with a list."""
return bool(self.list_re.match(block))
def run(self, parent, blocks):
"""Process list items."""
sibling = self.lastChild(parent)
# Check for multiple items in one block and get the ordered list fancy type.
items, fancy_type = self.get_items(sibling, blocks.pop(0), blocks)
# Append list items that are under the sibling list if the list type matches
if (
sibling is not None and sibling.tag in self.SIBLING_TAGS and
sibling.attrib.get('__fancylist', '') == fancy_type
):
# Previous block was a list item, so set that as parent
lst = sibling
# Make sure previous item is in a `p` - if the item has text,
# then it isn't in a `p`.
if lst[-1].text:
# Since it's possible there are other children for this
# sibling, we can't just `SubElement` the `p`, we need to
# insert it as the first item.
p = etree.Element('p')
p.text = lst[-1].text
lst[-1].text = ''
lst[-1].insert(0, p)
# If the last item has a tail, then the tail needs to be put in a `p`
# likely only when a header is not followed by a blank line.
lch = self.lastChild(lst[-1])
if lch is not None and lch.tail:
p = etree.SubElement(lst[-1], 'p')
p.text = lch.tail.lstrip()
lch.tail = ''
# Parse first block differently as it gets wrapped in a `p`.
li = etree.SubElement(lst, 'li')
self.parser.state.set('looselist')
firstitem = items.pop(0)
self.parser.parseBlocks(li, [firstitem])
self.parser.state.reset()
# This catches the edge case of a multi-item indented list whose
# first item is in a blank parent-list item:
# ```
# * * subitem1
# * subitem2
# ```
# see also `ListIndentProcessor`
elif parent.tag in ['ol', 'ul']:
lst = parent
# This is a new, unique list so create parent with appropriate tag.
else:
if self.TAG == 'ol':
# Correct the metadata of a forced list to now represent the actual content
if sibling is not None and sibling.attrib.get('__fancylist', '').startswith('force'):
sibling.attrib['__fancylist'] = fancy_type
lst = sibling
else:
attrib = {'type': self.OL_TYPES[fancy_type], '__fancylist': fancy_type}
if self.inject_style:
attrib['style'] = f"list-style-type: {OL_STYLE[attrib['type']]};"
if self.inject_class:
attrib['class'] = f"fancylists-{OL_STYLE[attrib['type']]}"
lst = etree.SubElement(
parent,
self.TAG,
attrib
)
else:
lst = etree.SubElement(parent, self.TAG)
# Check if a custom start integer is set
if self.startswith != '1' and not lst.attrib.get('start', ''):
lst.attrib['start'] = self.startswith
# Set the parse set to list
self.parser.state.set('list')
# Loop through items in block, recursively parsing each with the appropriate parent.
for item in items:
# Item is indented. Parse with last item as parent
if item.startswith(' '*self.tab_length):
self.parser.parseBlocks(lst[-1], [item])
# New item. Create `li` and parse with it as parent
else:
li = etree.SubElement(lst, 'li')
self.parser.parseBlocks(li, [item])
# Reset the parse state
self.parser.state.reset()
def get_start(self, fancy_type, m):
"""Translate list convention into a logical start."""
# Generic marker
if m.group(1).startswith('#'):
return '1'
t = fancy_type.split('-')[1].lower()
if t == 'decimal':
return m.group(1)[:-1].lstrip('(')
elif t == 'roman':
return str(roman2int(m.group(1)[:-1]))
elif t == 'alpha':
return str(ord(m.group(1)[:-1].upper()) - 64)
def get_fancy_type(self, m, first, fancy_type):
"""Get the fancy type for a given list item."""
value = m.group(1)[:-1]
sep = m.group(1)[-1]
list_type = ''
# Determine list type convention: _., _), (_)
if sep == '.':
list_type += 'dot-'
elif sep == ')':
list_type += 'paren-'
else:
return list_type, fancy_type
# The first item will be forced to assume the sibling list's type
if fancy_type.startswith('force'):
ltype = fancy_type.split('-', 1)[1]
# Make sure we aren't forcing an impossible scenario.
# If everything looks sound, return the types
if value == '#' or (
(ltype.lower() == 'decimal' and value.isdigit()) or
(
ltype.lower() == 'roman' and
self.roman_enabled and
value.isalpha() and
(len(value) > 2 or value.lower() in 'ivxlcdm')
) or
(ltype.lower() == 'alpha' and self.alpha_enabled and len(value) == 1 and value.isalpha())
):
fancy_type = list_type + fancy_type.split('-', 1)[1] if list_type else list_type
return fancy_type, fancy_type
# Ignore the force as it cannot be done
fancy_type = ''
# Determine numbering: numerical, roman numerical, alphabetic, or `#` numerical placeholder.
if value == '#':
list_type += fancy_type.split('-', 1)[1] if fancy_type else 'decimal'
elif value.isdigit():
list_type += 'decimal'
elif len(value) == 1 and value.isalpha():
if value.islower():
in_roman = value in 'ivxlcdm'
if (
self.alpha_enabled and (
not self.roman_enabled or (
first and (not in_roman or ((list_type + 'roman') != fancy_type and value != 'i'))
)
)
):
list_type += 'alpha'
elif self.alpha_enabled and not first and ((list_type + 'alpha') == fancy_type or not in_roman):
list_type += 'alpha'
else:
list_type += 'roman'
elif value.isupper():
in_roman = value in 'IVXLCDM'
if (
self.alpha_enabled and (
not self.roman_enabled or (
first and (not in_roman or ((list_type + 'ROMAN') != fancy_type and value != 'I'))
)
)
):
list_type += 'ALPHA'
elif self.alpha_enabled and not first and ((list_type + 'ALPHA') == fancy_type or not in_roman):
list_type += 'ALPHA'
else:
list_type += 'ROMAN'
elif value.isupper():
list_type += 'ROMAN'
elif value.islower():
list_type += 'roman'
return list_type, fancy_type
def get_items(self, sibling, block, blocks):
"""Break a block into list items."""
# Get ordered list fancy type
fancy_type = ''
if self.TAG == 'ol':
if sibling is not None and sibling.tag in self.SIBLING_TAGS:
fancy_type = sibling.attrib.get('__fancylist', '')
fancy = fancy_type
items = []
rest = []
for line in block.split('\n'):
# We've found a list type that differs form the our current,
# so gather the rest to be processed separately.
if rest:
rest.append(line)
continue
# Child list items
m = self.child_re.match(line)
if m:
# This is a new list item check first item for the start index.
# Also check for list items that differ from the first.
fancy, fancy_type = self.get_fancy_type(m, not items, fancy)
# We found a different fancy type, so handle these separately
if items and fancy != fancy_type:
rest.append(line)
continue
# Detect the integer value of first list item.
# If we are already in a list, just grab that.
if not items and self.TAG == 'ol':
self.startswith = self.get_start(fancy, m)
fancy_type = fancy
# Append to the list
items.append(m.group(2))
# Indented, possibly nested content
elif self.indent_re.match(line):
# Previous item was indented. Append to that item.
if items[-1].startswith(' ' * self.tab_length):
items[-1] = '{}\n{}'.format(items[-1], line)
# Other indented content
else:
items.append(line)
# Append non list items to previous list item.
else:
items[-1] = '{}\n{}'.format(items[-1], line)
# Insert non-list items back into the blocks to be parsed later
if rest:
blocks.insert(0, '\n'.join(rest))
return items, fancy_type
class FancyListBlock(Block):
"""Collapse code."""
NAME = 'fancylists'
ARGUMENT = True
OL_TYPE = {
'1': 'decimal',
'a': 'alpha',
'A': 'ALPHA',
'i': 'roman',
'I': 'ROMAN'
}
def on_init(self):
"""Handle initialization."""
ordered_styles = self.config['additional_ordered_styles']
self.inject_style = self.config['inject_style']
self.inject_class = self.config['inject_class']
self.roman_enabled = 'roman' in ordered_styles
self.alpha_enabled = 'alpha' in ordered_styles
def on_validate(self, parent):
"""Handle on validate event."""
self.type = '1'
self.start = None
self.count = 0
try:
for a in self.argument.split():
name, value = [x.strip() for x in a.split('=')]
if name == 'type' and value in ['a', 'A', 'i', 'I', '1']:
if value.lower() == 'a' and not self.alpha_enabled:
raise ValueError('Alphabetical lists not enabled')
if value.lower() == 'i' and not self.roman_enabled:
raise ValueError('Alphabetical lists not enabled')
self.type = value
elif name == 'start':
self.start = max(0, int(value))
else:
raise ValueError('Not a valid option')
except Exception:
return False
return True
def on_create(self, parent):
"""Create the element."""
# Create an ordered list that will guide the first list item's type
attrib = {'type': self.type, '__fancylist': 'force-' + self.OL_TYPE[self.type]}
if self.start is not None:
attrib['start'] = str(self.start)
if self.inject_style:
attrib['style'] = f"list-style-type: {OL_STYLE[self.type]};"
if self.inject_class:
attrib['class'] = f"fancylists-{OL_STYLE[self.type]}"
self.parent = parent
self.ol = etree.SubElement(parent, 'ol', attrib)
return parent
def on_end(self, block):
"""On end."""
# Remove the ordered list if empty.
if not list(self.ol):
self.parent.remove(self.ol)
class FancyUListProcessor(FancyOListProcessor):
"""Process unordered list blocks."""
SIBLING_TAGS = ['ul']
TAG = 'ul'
def __init__(self, parser, config):
"""Initialize."""
super().__init__(parser, config)
self.list_re = re.compile(r'^[ ]{0,%d}[-+*][ ]+(.*)' % (self.tab_length - 1))
class FancyListTreeprocessor(Treeprocessor):
"""Clean up fancy list metadata."""
def run(self, root):
"""Remove intermediate fancy list type metadata."""
for ol in root.iter('ol'):
if '__fancylist' in ol.attrib:
del ol.attrib['__fancylist']
return root
class FancyListExtension(BlocksExtension):
"""HTML Blocks Extension."""
def __init__(self, *args, **kwargs):
"""Initialize."""
self.config = {
'additional_ordered_styles': [
['roman', 'alpha', 'generic'],
"Specify the ordered list formats to add in addition to decimal.",
],
'inject_style': [
False,
"Inject style attribute with the appropriate 'list-style-type'"
],
'inject_class': [
False,
"Inject a class indicating the 'list-style-type'"
]
}
super().__init__(*args, **kwargs)
def extendMarkdownBlocks(self, md, blocks):
"""Add Details to Markdown instance."""
config = self.getConfigs()
blocks.register(FancyListBlock, config)
ol = FancyOListProcessor(md.parser, config)
ul = FancyUListProcessor(md.parser, config)
md.parser.blockprocessors.register(ol, 'olist', 40)
md.parser.blockprocessors.register(ul, 'ulist', 30)
md.treeprocessors.register(FancyListTreeprocessor(md), "olist-cleanup", 10)
def makeExtension(*args, **kwargs):
"""Return extension."""
return FancyListExtension(*args, **kwargs)