Conversor de Subconjunto Markdown para HTML

import re import html def markdown_to_html(markdown_text: str) -> str: """Converte um subconjunto de Markdown para HTML. Recursos suportados: - Cabeçalhos (# .. ######) - Listas não ordenadas com aninhamento de 2 espaços - Blocos de código delimitados (```) - Parágrafos - Inline: ***negrito+itálico***, **negrito**, *itálico* """ def escape(text: str) -> str: # Escapa caracteres sensíveis a HTML. return html.escape(text, quote=False) def process_inline(text: str) -> str: """Processa markdown inline. Funciona em texto já escapado, pois os marcadores *, ** e *** não contêm caracteres escapados.""" escaped = escape(text) # Ordem de precedência: ***, depois **, depois *. # Usa correspondência não gulosa e exige limites de não espaço em branco de forma flexível. # ***texto*** escaped = re.sub( r'\*\*\*(.+?)\*\*\*', r'<strong><em>\1</em></strong>', escaped, ) # **texto** escaped = re.sub( r'\*\*(.+?)\*\*', r'<strong>\1</strong>', escaped, ) # *texto* escaped = re.sub( r'\*(.+?)\*', r'<em>\1</em>', escaped, ) return escaped lines = markdown_text.split('\n') output = [] # Rastreadores de estado in_code_block = False code_buffer = [] paragraph_buffer = [] # Pilha de lista: lista de níveis de indentação (0, 1, 2, ...) atualmente abertos list_stack = [] def flush_paragraph(): if paragraph_buffer: content = ' '.join(paragraph_buffer) output.append(f'<p>{process_inline(content)}</p>') paragraph_buffer.clear() def close_lists_to(level): """Fecha listas até que restem apenas `level` listas abertas (level = número de <ul> abertos).""" while len(list_stack) > level: output.append('</li>') output.append('</ul>') list_stack.pop() if list_stack: # Após fechar uma lista aninhada, o <li> pai permanece aberto; # nós o fechamos quando o próximo irmão começa ou quando fechamos completamente. pass def close_all_lists(): while list_stack: output.append('</li>') output.append('</ul>') list_stack.pop() i = 0 while i < len(lines): line = lines[i] # Tratamento de bloco de código if in_code_block: if line.strip().startswith('```'): # Fim do bloco de código code_content = '\n'.join(code_buffer) output.append(f'<pre><code>{escape(code_content)}</code></pre>') code_buffer = [] in_code_block = False else: code_buffer.append(line) i += 1 continue # Verifica o início do bloco de código stripped = line.strip() if stripped.startswith('```'): flush_paragraph() close_all_lists() in_code_block = True i += 1 continue # Linha em branco if stripped == '': flush_paragraph() close_all_lists() i += 1 continue # Cabeçalho? header_match = re.match(r'^(#{1,6}) +(.*)$', line) if header_match: flush_paragraph() close_all_lists() level = len(header_match.group(1)) content = header_match.group(2).rstrip() output.append(f'<h{level}>{process_inline(content)}</h{level}>') i += 1 continue # Item de lista? # Corresponde a espaços iniciais (devem ser pares para aninhamento) seguidos por '- ' list_match = re.match(r'^( *)- +(.*)$', line) if list_match: flush_paragraph() indent_spaces = len(list_match.group(1)) # Trata como um nível de aninhamento válido apenas se a indentação for um múltiplo de 2 indent_level = indent_spaces // 2 content = list_match.group(2) # Ajusta a pilha de listas if not list_stack: # Começando do zero: a primeira lista deve estar no nível 0 indent_level = 0 output.append('<ul>') list_stack.append(0) output.append(f'<li>{process_inline(content)}') else: current_depth = len(list_stack) - 1 # índice superior if indent_level > current_depth: # Abre uma nova lista aninhada (avança apenas um nível de cada vez) indent_level = current_depth + 1 output.append('<ul>') list_stack.append(indent_level) output.append(f'<li>{process_inline(content)}') elif indent_level == current_depth: # Irmão no mesmo nível: fecha o <li> anterior output.append('</li>') output.append(f'<li>{process_inline(content)}') else: # Recua: fecha listas mais profundas while len(list_stack) - 1 > indent_level: output.append('</li>') output.append('</ul>') list_stack.pop() # Fecha também o <li> pai que continha esta lista aninhada output.append('</li>') # Agora no mesmo nível: adiciona o irmão output.append(f'<li>{process_inline(content)}') i += 1 continue # Caso contrário, é uma linha de parágrafo if list_stack: close_all_lists() paragraph_buffer.append(line.strip()) i += 1 # Fim da entrada: descarrega tudo if in_code_block: # Bloco de código não fechado: emite o que tivermos code_content = '\n'.join(code_buffer) output.append(f'<pre><code>{escape(code_content)}</code></pre>') flush_paragraph() close_all_lists() return '\n'.join(output) if __name__ == '__main__': sample = '''# Cabeçalho 1 Este é um parágrafo com texto **negrito** e *itálico*. Este é o mesmo parágrafo. - Item de lista um - Item de lista dois com ***negrito e itálico*** - Item de lista aninhada - De volta ao primeiro nível ```python def hello(): print("Hello, World!") ``` ''' print(markdown_to_html(sample))

def markdown_to_html(markdown_text: str) -> str: import re from html import escape lines = markdown_text.splitlines() out = [] paragraph_lines = [] list_stack = [] i = 0 in_code_block = False code_lines = [] def parse_inline(text: str) -> str: parts = [] i = 0 n = len(text) while i < n: if text.startswith('***', i): j = text.find('***', i + 3) if j != -1: inner = parse_inline(text[i + 3:j]) parts.append(f'<strong><em>{inner}</em></strong>') i = j + 3 continue if text.startswith('**', i): j = text.find('**', i + 2) if j != -1: inner = parse_inline(text[i + 2:j]) parts.append(f'<strong>{inner}</strong>') i = j + 2 continue if text.startswith('*', i): j = text.find('*', i + 1) if j != -1: inner = parse_inline(text[i + 1:j]) parts.append(f'<em>{inner}</em>') i = j + 1 continue parts.append(escape(text[i])) i += 1 return ''.join(parts) def flush_paragraph(): nonlocal paragraph_lines if paragraph_lines: text = ' '.join(line.strip() for line in paragraph_lines) out.append(f'<p>{parse_inline(text)}</p>') paragraph_lines = [] def close_lists_to(level: int): while len(list_stack) > level: out.append('</li>') out.append('</ul>') list_stack.pop() def handle_list_item(indent_spaces: int, content: str): level = indent_spaces // 2 if indent_spaces % 2 != 0: return False if level > len(list_stack): if level != len(list_stack) + 1: return False out.append('<ul>') list_stack.append(True) elif level < len(list_stack): close_lists_to(level) out.append('</li>') else: if list_stack: out.append('</li>') else: out.append('<ul>') list_stack.append(True) while len(list_stack) < level + 1: out.append('<ul>') list_stack.append(True) out.append(f'<li>{parse_inline(content)}') return True while i < len(lines): line = lines[i] if in_code_block: if line.startswith('```'): out.append(f'<pre><code>{escape("\n".join(code_lines))}</code></pre>') code_lines = [] in_code_block = False else: code_lines.append(line) i += 1 continue if line.startswith('```'): flush_paragraph() close_lists_to(0) in_code_block = True code_lines = [] i += 1 continue if not line.strip(): flush_paragraph() close_lists_to(0) i += 1 continue header_match = re.match(r'^(#{1,6})\s+(.*)$', line) if header_match: flush_paragraph() close_lists_to(0) level = len(header_match.group(1)) content = parse_inline(header_match.group(2).strip()) out.append(f'<h{level}>{content}</h{level}>') i += 1 continue list_match = re.match(r'^( *)(- )(.+)$', line) if list_match: flush_paragraph() indent = len(list_match.group(1)) content = list_match.group(3) if handle_list_item(indent, content): i += 1 continue if list_stack: close_lists_to(0) paragraph_lines.append(line) i += 1 if in_code_block: out.append(f'<pre><code>{escape("\n".join(code_lines))}</code></pre>') flush_paragraph() close_lists_to(0) return '\n'.join(out)