518 lines
15 KiB
Python
518 lines
15 KiB
Python
|
|
import re;
|
|
|
|
from itertools import product
|
|
|
|
def parse_colinfo(linesep):
|
|
column_info = [];
|
|
|
|
linesep = linesep.strip();
|
|
|
|
print(f"linesep = {linesep}");
|
|
|
|
if linesep.startswith("|"):
|
|
linesep = linesep[1:]
|
|
|
|
print(f"linesep = {linesep}");
|
|
|
|
if linesep.endswith("|"):
|
|
linesep = linesep[:-1]
|
|
|
|
print(f"linesep = {linesep}");
|
|
|
|
column_info = [];
|
|
|
|
for sep in linesep.split("|"):
|
|
sep = sep.strip()
|
|
|
|
print(f'sep = "{sep}"');
|
|
|
|
if re.match(r"^:-+$", sep):
|
|
appendme = {'align': 'left', 'default-tag': 'td'};
|
|
elif re.match(r"^-+:$", sep):
|
|
appendme = {'align': 'right', 'default-tag': 'td'};
|
|
elif re.match(r"^:-+:$", sep):
|
|
appendme = {'align': 'center', 'default-tag': 'td'};
|
|
elif re.match(r"^-+$", sep):
|
|
appendme = {'align': 'default', 'default-tag': 'td'};
|
|
elif re.match(r"^:=+$", sep):
|
|
appendme = {'align': 'left', 'default-tag': 'th'};
|
|
elif re.match(r"^=+:$", sep):
|
|
appendme = {'align': 'right', 'default-tag': 'th'};
|
|
elif re.match(r"^:=+:$", sep):
|
|
appendme = {'align': 'center', 'default-tag': 'th'};
|
|
elif re.match(r"^=+$", sep):
|
|
appendme = {'align': 'default', 'default-tag': 'th'};
|
|
else:
|
|
raise SyntaxError("bad seperator!");
|
|
|
|
print(f'appendme = {appendme}');
|
|
|
|
column_info.append(appendme);
|
|
|
|
return column_info;
|
|
|
|
class State:
|
|
def __init__(self, section_tag, default_cell_tag, column_info = []):
|
|
self.section_tag = section_tag;
|
|
|
|
self.default_cell_tag = default_cell_tag;
|
|
|
|
self.column_info = column_info;
|
|
|
|
self.already_opened_section = 0;
|
|
|
|
def do_table_line(state, line):
|
|
"""
|
|
I'm supposed to return the whole HTML.
|
|
Including the <tr> if needed.
|
|
"""
|
|
|
|
print(f'line = "{line}"');
|
|
|
|
tags = r"(?:colgroup|col|thead|tr|tbody|tfoot)"
|
|
|
|
passthrough_pattern = fr"(?:<{tags}(?:[\s]+[^>]*)?>|</{tags}>)";
|
|
|
|
start_tag_pattern = fr"<{state.section_tag}(?:[\s]+[^>]*)?>"
|
|
|
|
open_tr_pattern = r"<tr(?:[\s]+[^<>]*)?>[\s]*";
|
|
|
|
open_caption_pattern = r"<caption(?:[\s]+[^<>]*)?>";
|
|
|
|
cell_delimiter = r"(?:[|]|<(?:tr|th)(?:[\s]+[^<>]*)?>)";
|
|
|
|
caption_sentinel_pattern = "(?:" + \
|
|
'|'.join((cell_delimiter, passthrough_pattern, start_tag_pattern,
|
|
open_tr_pattern, open_caption_pattern)) + ")"
|
|
|
|
already_open_tr = 0;
|
|
|
|
out = "";
|
|
|
|
while line:
|
|
# Is it whatever our start tag is?
|
|
if (m := re.match(start_tag_pattern, line)):
|
|
# we'll pass this through, and remember that we don't need to do
|
|
# it ourselves
|
|
print("found our start tag");
|
|
|
|
out += m.group(0);
|
|
|
|
line = line[len(m.group(0)):];
|
|
|
|
print(f'line = "{line}"');
|
|
|
|
state.already_opened_section = 1;
|
|
|
|
continue;
|
|
|
|
# Is it a <tr> we should just pass through?
|
|
if (m := re.match(open_tr_pattern, line)):
|
|
|
|
# we'll also pass this through, and remember that we don't need
|
|
# to do it ourselves.
|
|
|
|
print("found our tr tag");
|
|
|
|
if not state.already_opened_section:
|
|
out += f"<{state.section_tag}>";
|
|
state.already_opened_section = 1;
|
|
|
|
out += m.group(0);
|
|
|
|
line = line[len(m.group(0)):];
|
|
|
|
print(f'line = "{line}"');
|
|
|
|
already_open_tr = 1;
|
|
|
|
continue;
|
|
|
|
# Is it the "<caption>" table part?
|
|
if (m := re.match(open_caption_pattern, line)):
|
|
|
|
print(f'found caption tag: "{m.group(0)}"');
|
|
|
|
out += m.group(0);
|
|
|
|
line = line[len(m.group(0)):];
|
|
|
|
print(f'line = "{line}"');
|
|
|
|
# For the caption, we'll need to keep eating until we see
|
|
# the caption sentinel, or end-of-line
|
|
|
|
while line:
|
|
if (m := re.match(r"</caption>", line)):
|
|
line = line[len(m.group(0)):];
|
|
|
|
print(f'line = "{line}"');
|
|
|
|
break;
|
|
|
|
if (m := re.match(caption_sentinel_pattern, line)):
|
|
break;
|
|
|
|
out += line[0];
|
|
|
|
line = line[1:];
|
|
|
|
print(f'line = "{line}"');
|
|
|
|
out += "</caption>";
|
|
|
|
continue;
|
|
|
|
# Is it some table part we should just pass through?
|
|
if (m := re.match(passthrough_pattern, line)):
|
|
print(f'found passthrough tag: "{m.group(0)}"');
|
|
|
|
out += m.group(0);
|
|
|
|
line = line[len(m.group(0)):];
|
|
|
|
print(f'line = "{line}"');
|
|
|
|
continue;
|
|
|
|
# If we made it here, it must actually be content
|
|
break;
|
|
|
|
if line:
|
|
# If there's anything to read after the table parts, it's gotta be cells
|
|
|
|
print("new table row");
|
|
|
|
column_index = 0;
|
|
|
|
if not state.already_opened_section:
|
|
out += f"<{state.section_tag}>";
|
|
state.already_opened_section = 1;
|
|
|
|
if not already_open_tr:
|
|
out += "<tr>";
|
|
|
|
while line:
|
|
print("new cell");
|
|
|
|
tag = "";
|
|
|
|
print("loading attributes");
|
|
|
|
attributes = {};
|
|
|
|
if column_index < len(state.column_info):
|
|
align = state.column_info[column_index]['align'];
|
|
|
|
if align != 'default':
|
|
attributes['align'] = align;
|
|
|
|
print(f'attributes = "{attributes}"');
|
|
|
|
print("looking for starter");
|
|
|
|
if (m := re.match(r"[|]", line)):
|
|
print("found opening vbar");
|
|
|
|
if column_index < len(state.column_info):
|
|
tag = state.column_info[column_index]['default-tag']
|
|
else:
|
|
tag = state.default_cell_tag;
|
|
|
|
print(f'tag = "{tag}"');
|
|
|
|
line = line[1:];
|
|
|
|
print(f'line = "{line}"');
|
|
elif (m := re.match(r"<([a-z]+)(?:[\s]+([^<>]*))?>", line)):
|
|
print("found opening HTML tag");
|
|
|
|
tag = m.group(1);
|
|
|
|
print(f'tag = "{tag}"');
|
|
|
|
raw_attributes = m.group(2);
|
|
|
|
while raw_attributes:
|
|
if (mm := re.match(fr'\s*([a-z0-9]+)\s*=\s*"([^"]+)"', raw_attributes)):
|
|
attribute = mm.group(1);
|
|
|
|
value = mm.group(2);
|
|
|
|
print(f'attribute = "{attribute}"');
|
|
|
|
print(f'value = "{value}"');
|
|
|
|
if attribute in attributes and attribute == "style":
|
|
attributes[attribute] += '; ' + value;
|
|
else:
|
|
attributes[attribute] = value;
|
|
|
|
print(f'attributes = "{attributes}"');
|
|
|
|
raw_attributes = raw_attributes[len(mm.group(0)):];
|
|
|
|
print(f'raw_attributes = "{raw_attributes}"');
|
|
else:
|
|
print(f'could not parse HTML attributes?! huh?! throwing! ');
|
|
|
|
raise SyntaxError("could not parse HTML attributes");
|
|
|
|
line = line[len(m.group(0)):];
|
|
|
|
print(f'line = "{line}"');
|
|
elif (m := re.match(r"<([a-z]+)", line)):
|
|
print("found HTML open, but it's incomplete? huh?! throwing!");
|
|
|
|
raise SyntaxError("could not find '>' for HTML open tag");
|
|
elif column_index < len(state.column_info):
|
|
print("found nothing, defaulting to column info");
|
|
|
|
tag = state.column_info[column_index]['default-tag']
|
|
|
|
print(f'tag = "{tag}"');
|
|
else:
|
|
print(f"found nothing, defaulting default_tag ({state.default_cell_tag})");
|
|
|
|
tag = state.default_cell_tag;
|
|
|
|
print(f'tag = "{tag}"');
|
|
|
|
print("looking for closer");
|
|
|
|
content = "";
|
|
|
|
depth = 0;
|
|
|
|
while line:
|
|
if (m := re.match("(?:\\s|\\w|[.,-])+", line)):
|
|
content += m.group(0);
|
|
line = line[len(m.group(0)):];
|
|
print(f'line = "{line}"');
|
|
elif not depth and (m := re.match("<(td|th)", line)):
|
|
print(f"found HTML open tag: {m.group(1)}");
|
|
break;
|
|
elif not depth and (m := re.match("</(td|th)>", line)):
|
|
print(f"found HTML close tag: {m.group(1)}");
|
|
line = line[len(m.group(0)):]
|
|
print(f'line = "{line}"');
|
|
break;
|
|
elif not depth and (m := re.match(r"([|]+)", line)):
|
|
print(f'found vbar ("{m.group(1)}")');
|
|
|
|
num_vbars = len(m.group(1));
|
|
|
|
if num_vbars > 1:
|
|
attributes['colspan'] = num_vbars;
|
|
|
|
line = line[len(m.group(0)):]
|
|
|
|
print(f'line = "{line}"');
|
|
break;
|
|
elif (m := re.match("<table>", line)):
|
|
content += m.group(0);
|
|
depth += 1;
|
|
line = line[len(m.group(0)):]
|
|
print(f'line = "{line}"');
|
|
print(f'depth = {depth}');
|
|
elif (m := re.match("</table>", line)):
|
|
content += m.group(0);
|
|
depth -= 1;
|
|
if depth < 0: raise SyntaxError("negative depth; bad HTML");
|
|
line = line[len(m.group(0)):]
|
|
print(f'line = "{line}"');
|
|
print(f'depth = {depth}');
|
|
# elif (m := re.match(fr"</{tags}>", line)):
|
|
# # ignore the closers for table parts, no passthrough
|
|
# line = line[len(m.group(0)):]
|
|
# print(f'line = "{line}"');
|
|
elif (m := re.match("<[a-z]+(?:\\s+[^<>]*)?>", line)):
|
|
content += m.group(0);
|
|
line = line[len(m.group(0)):]
|
|
print(f'line = "{line}"');
|
|
elif (m := re.match("</[a-z]+>", line)):
|
|
content += m.group(0);
|
|
line = line[len(m.group(0)):]
|
|
print(f'line = "{line}"');
|
|
elif (m := re.match(r"`[^`\n]+`", line)):
|
|
content += m.group(0);
|
|
line = line[len(m.group(0)):]
|
|
print(f'line = "{line}"');
|
|
else:
|
|
print(f'line = "{line}"');
|
|
|
|
assert(not "TODO");
|
|
|
|
if attributes:
|
|
attributes = " ".join(f'{key}="{value}"'
|
|
for key, value in sorted(attributes.items()));
|
|
|
|
cell = f"<{tag} {attributes}> {content} </{tag}>";
|
|
else:
|
|
cell = f"<{tag}> {content} </{tag}>";
|
|
|
|
print(f'cell = "{cell}"');
|
|
|
|
out += cell;
|
|
|
|
column_index += 1;
|
|
|
|
print(f'out = "{out}"');
|
|
|
|
return out;
|
|
|
|
def do_table(table_open_tag, header_lines, seperator_line, body_lines, optional_caption):
|
|
|
|
out = "";
|
|
|
|
# handle explicit table tag?
|
|
if table_open_tag:
|
|
out += table_open_tag + "\n";
|
|
else:
|
|
# otherwise, add a default one:
|
|
out += "<table>" + "\n";
|
|
|
|
state = State(section_tag = "thead", default_cell_tag = "th");
|
|
|
|
# Process the header lines:
|
|
for line in header_lines:
|
|
html_table_line = do_table_line(state, line);
|
|
|
|
out += html_table_line + "\n";
|
|
|
|
# Handle line seperator:
|
|
column_info = parse_colinfo(seperator_line);
|
|
|
|
# Process the body lines:
|
|
for lines in body_lines:
|
|
state = State(section_tag = "tbody", \
|
|
default_cell_tag = "td", \
|
|
column_info = column_info);
|
|
|
|
for line in lines:
|
|
html_table_line = do_table_line(state, line);
|
|
|
|
out += html_table_line + "\n";
|
|
|
|
# Consider the optional caption
|
|
if optional_caption:
|
|
out += f"<caption> {optional_caption} </caption>\n";
|
|
|
|
out += "</table>\n";
|
|
|
|
for o in out.split("\n"):
|
|
print(o);
|
|
|
|
return "\n\n" + out + "\n\n";
|
|
|
|
def handle_table(m):
|
|
print("handle_table");
|
|
|
|
matched = m.group(0);
|
|
|
|
print(f'matched = """{matched}"""');
|
|
|
|
optional_table_open = m.group(1);
|
|
|
|
one_or_more_header_lines = m.group(2);
|
|
|
|
seperator_line = m.group(3);
|
|
|
|
one_or_more_body_lines = m.group(4);
|
|
|
|
optional_caption = m.group(5);
|
|
|
|
assert(seperator_line is not None)
|
|
|
|
try:
|
|
return do_table(
|
|
optional_table_open,
|
|
one_or_more_header_lines.strip().split("\n"),
|
|
seperator_line,
|
|
[e.strip().split("\n")
|
|
for e in one_or_more_body_lines.strip().split("\n\n")],
|
|
optional_caption,
|
|
);
|
|
except SyntaxError as e:
|
|
print(f"caught syntax error: {e}");
|
|
print("moving on to next table...");
|
|
return m.group(0);
|
|
|
|
with open("test.md") as stream:
|
|
text = stream.read();
|
|
|
|
# delimiters between cells
|
|
delimiter = r"(?:[|]|<(?:tr|th)(?:[\s]+[^<>]*)?>)";
|
|
|
|
# A row is anything with at least one delimiter
|
|
row = fr"(?: .* {delimiter} .*)";
|
|
|
|
# Most table parts are simple.
|
|
table_tags = r"(?:colgroup|col|thead|tr|tbody|tfoot|caption)"
|
|
table_part = fr"(?:<{table_tags}(?:\s+[^<>]*)?>|</{table_tags}>)";
|
|
|
|
# captions eat until the next table part or delimiter
|
|
# temp = fr"(?: {table_part} | <caption>)";
|
|
# caption_table_part = fr"(?: <caption> (?! (?: {delimiter} | {temp})) .*)"
|
|
# caption_table_part = fr"(?: <caption> (?!{delimiter}) .*)"
|
|
# caption_table_part = fr"(?: <caption> [^<>]* </caption>)"
|
|
caption_table_part = fr"(?: <caption> [^<>]*)"
|
|
table_part = fr"(?: {table_part} | {caption_table_part})";
|
|
|
|
# A table line can also be all table parts
|
|
row = fr"(?:{row} | {table_part}+)";
|
|
|
|
# Between the header rows and the body rows there is a line seperator.
|
|
seperator_line = r"\s* [|]? \s* [-=:]+ \s* (?: \s* [|] \s* [-=:]* \s* )* \s*"
|
|
|
|
# Regex for whole table:
|
|
for o, c in product((1, 0), repeat=2):
|
|
table = fr"""
|
|
# two blank lines:
|
|
[\n]{{2}}
|
|
|
|
# optional or required open table tag:
|
|
(?:(<table(?:[\s]+[^<>]*)?>) \n){{{o},1}}
|
|
|
|
# zero or one or more header rows:
|
|
((?: {row} \n){{{1-o},}})
|
|
|
|
# line seperator:
|
|
({seperator_line}) [\n]
|
|
|
|
# zero or one or more body rows, with empty lines of one:
|
|
((?: {row} [\n]{{1,2}}){{{1-c},}})
|
|
|
|
# optional caption:
|
|
(?: \[ ([a-z0-9 "']+) \] \n)?
|
|
|
|
# optional or required close table tag:
|
|
(?: </table> [\n]){{{c},1}}
|
|
|
|
# two blank lines:
|
|
[\n]{{2}}
|
|
""";
|
|
|
|
text = re.sub(table, handle_table, text, flags=re.VERBOSE)
|
|
|
|
text += """
|
|
<style>
|
|
table
|
|
{
|
|
border-collapse: collapse;
|
|
margin: 1em 0;
|
|
}
|
|
|
|
th, td
|
|
{
|
|
border: thin solid grey;
|
|
padding: 0.5em;
|
|
}
|
|
</style>
|
|
|
|
""";
|
|
|
|
with open("test.html", "w") as stream:
|
|
stream.write(text);
|
|
|