458 lines
16 KiB
Python
458 lines
16 KiB
Python
"""
|
|
richtext
|
|
"""
|
|
from typing import List, Tuple
|
|
import re
|
|
import urwid
|
|
import unicodedata
|
|
from .constants import PALETTE
|
|
from bs4 import BeautifulSoup
|
|
from bs4.element import NavigableString, Tag
|
|
from .stubs.urwidgets import TextEmbed, Hyperlink, parse_text, has_urwidgets
|
|
from urwid.util import decompose_tagmarkup
|
|
from toot.utils import urlencode_url
|
|
|
|
|
|
class ContentParser:
|
|
def __init__(self):
|
|
self.palette_names = []
|
|
for p in PALETTE:
|
|
self.palette_names.append(p[0])
|
|
|
|
"""Parse a limited subset of HTML and create urwid widgets."""
|
|
|
|
def html_to_widgets(self, html, recovery_attempt=False) -> List[urwid.Widget]:
|
|
"""Convert html to urwid widgets"""
|
|
widgets: List[urwid.Widget] = []
|
|
html = unicodedata.normalize("NFKC", html)
|
|
soup = BeautifulSoup(html.replace("'", "'"), "html.parser")
|
|
first_tag = True
|
|
for e in soup.body or soup:
|
|
if isinstance(e, NavigableString):
|
|
if first_tag and not recovery_attempt:
|
|
# if our first "tag" is a navigable string
|
|
# the HTML is out of spec, doesn't start with a tag,
|
|
# we see this in content from Pixelfed servers.
|
|
# attempt a fix by wrapping the HTML with <p></p>
|
|
return self.html_to_widgets(f"<p>{html}</p>", recovery_attempt=True)
|
|
else:
|
|
continue
|
|
else:
|
|
name = e.name
|
|
# if our HTML starts with a tag, but not a block tag
|
|
# the HTML is out of spec. Attempt a fix by wrapping the
|
|
# HTML with <p></p>
|
|
if (
|
|
first_tag
|
|
and not recovery_attempt
|
|
and name
|
|
not in (
|
|
"p",
|
|
"pre",
|
|
"li",
|
|
"blockquote",
|
|
"h1",
|
|
"h2",
|
|
"h3",
|
|
"h4",
|
|
"h5",
|
|
"h6",
|
|
) # NOTE: update this list if Mastodon starts supporting more block tags
|
|
):
|
|
return self.html_to_widgets(f"<p>{html}</p>", recovery_attempt=True)
|
|
|
|
# First, look for a custom tag handler method in this class
|
|
# If that fails, fall back to inline_tag_to_text handler
|
|
method = getattr(self, "_" + name, self.inline_tag_to_text)
|
|
markup = method(e) # either returns a Widget, or plain text
|
|
first_tag = False
|
|
|
|
if not isinstance(markup, urwid.Widget):
|
|
# plaintext, so create a padded text widget
|
|
txt = self.text_to_widget("", markup)
|
|
markup = urwid.Padding(
|
|
txt,
|
|
align="left",
|
|
width=("relative", 100),
|
|
min_width=None,
|
|
)
|
|
widgets.append(markup)
|
|
# separate top level widgets with a blank line
|
|
widgets.append(urwid.Divider(" "))
|
|
return widgets[:-1] # but suppress the last blank line
|
|
|
|
def inline_tag_to_text(self, tag) -> Tuple:
|
|
"""Convert html tag to plain text with tag as attributes recursively"""
|
|
markups = self.process_inline_tag_children(tag)
|
|
if not markups:
|
|
return (tag.name, "")
|
|
return (tag.name, markups)
|
|
|
|
def process_inline_tag_children(self, tag) -> List:
|
|
"""Recursively retrieve all children
|
|
and convert to a list of markup text"""
|
|
markups = []
|
|
for child in tag.children:
|
|
if isinstance(child, Tag):
|
|
method = getattr(self, "_" + child.name, self.inline_tag_to_text)
|
|
markup = method(child)
|
|
markups.append(markup)
|
|
else:
|
|
markups.append(child)
|
|
return markups
|
|
|
|
def text_to_widget(self, attr, markup) -> urwid.Widget:
|
|
if not has_urwidgets:
|
|
return urwid.Text((attr, markup))
|
|
|
|
TRANSFORM = {
|
|
# convert http[s] URLs to Hyperlink widgets for nesting in a TextEmbed widget
|
|
re.compile(r"(^.+)\x03(.+$)"): lambda g: (
|
|
len(g[1]),
|
|
urwid.Filler(Hyperlink(g[2], anchor_attr, g[1])),
|
|
),
|
|
}
|
|
markup_list = []
|
|
|
|
for run in markup:
|
|
if isinstance(run, tuple):
|
|
txt, attr_list = decompose_tagmarkup(run)
|
|
# find anchor titles with an ETX separator followed by href
|
|
m = re.match(r"(^.+)\x03(.+$)", txt)
|
|
if m:
|
|
anchor_attr = self.get_best_anchor_attr(attr_list)
|
|
markup_list.append(
|
|
parse_text(
|
|
txt,
|
|
TRANSFORM,
|
|
lambda pattern, groups, span: TRANSFORM[pattern](groups),
|
|
)
|
|
)
|
|
else:
|
|
markup_list.append(run)
|
|
else:
|
|
markup_list.append(run)
|
|
|
|
return TextEmbed(markup_list)
|
|
|
|
def process_block_tag_children(self, tag) -> List[urwid.Widget]:
|
|
"""Recursively retrieve all children
|
|
and convert to a list of widgets
|
|
any inline tags containing text will be
|
|
converted to Text widgets"""
|
|
|
|
pre_widget_markups = []
|
|
post_widget_markups = []
|
|
child_widgets = []
|
|
found_nested_widget = False
|
|
|
|
for child in tag.children:
|
|
if isinstance(child, Tag):
|
|
# child is a nested tag; process using custom method
|
|
# or default to inline_tag_to_text
|
|
method = getattr(self, "_" + child.name, self.inline_tag_to_text)
|
|
result = method(child)
|
|
if isinstance(result, urwid.Widget):
|
|
found_nested_widget = True
|
|
child_widgets.append(result)
|
|
else:
|
|
if not found_nested_widget:
|
|
pre_widget_markups.append(result)
|
|
else:
|
|
post_widget_markups.append(result)
|
|
else:
|
|
# child is text; append to the appropriate markup list
|
|
if not found_nested_widget:
|
|
pre_widget_markups.append(child)
|
|
else:
|
|
post_widget_markups.append(child)
|
|
|
|
widget_list = []
|
|
if len(pre_widget_markups):
|
|
widget_list.append(self.text_to_widget(tag.name, pre_widget_markups))
|
|
|
|
if len(child_widgets):
|
|
widget_list += child_widgets
|
|
|
|
if len(post_widget_markups):
|
|
widget_list.append(self.text_to_widget(tag.name, post_widget_markups))
|
|
|
|
return widget_list
|
|
|
|
def get_urwid_attr_name(self, tag) -> str:
|
|
"""Get the class name and translate to a
|
|
name suitable for use as an urwid
|
|
text attribute name"""
|
|
|
|
if "class" in tag.attrs:
|
|
clss = tag.attrs["class"]
|
|
if len(clss) > 0:
|
|
style_name = "class_" + "_".join(clss)
|
|
# return the class name, only if we
|
|
# find it as a defined palette name
|
|
if style_name in self.palette_names:
|
|
return style_name
|
|
|
|
# fallback to returning the tag name
|
|
return tag.name
|
|
|
|
# Tag handlers start here.
|
|
# Tags not explicitly listed are "supported" by
|
|
# rendering as text.
|
|
# Inline tags return a list of marked up text for urwid.Text
|
|
# Block tags return urwid.Widget
|
|
|
|
def basic_block_tag_handler(self, tag) -> urwid.Widget:
|
|
"""default for block tags that need no special treatment"""
|
|
return urwid.Pile(self.process_block_tag_children(tag))
|
|
|
|
def get_best_anchor_attr(self, attrib_list) -> str:
|
|
if not attrib_list:
|
|
return ""
|
|
flat_al = list(flatten(attrib_list))
|
|
|
|
for a in flat_al[0]:
|
|
# ref: https://docs.joinmastodon.org/spec/activitypub/
|
|
# these are the class names (translated to attrib names)
|
|
# that we can support for display
|
|
|
|
try:
|
|
if a[0] in ["class_hashtag", "class_mention_hashtag", "class_mention"]:
|
|
return a[0]
|
|
except KeyError:
|
|
continue
|
|
|
|
return "a"
|
|
|
|
def _a(self, tag) -> Tuple:
|
|
"""anchor tag handler"""
|
|
|
|
markups = self.process_inline_tag_children(tag)
|
|
if not markups:
|
|
return (tag.name, "")
|
|
|
|
href = tag.attrs["href"]
|
|
title, attrib_list = decompose_tagmarkup(markups)
|
|
if not attrib_list:
|
|
attrib_list = [tag]
|
|
if href and has_urwidgets:
|
|
# only if we have urwidgets loaded for OCS 8 hyperlinks:
|
|
# urlencode the path and query portions of the URL
|
|
href = urlencode_url(href)
|
|
# use ASCII ETX (end of record) as a
|
|
# delimiter between the title and the HREF
|
|
title += f"\x03{href}"
|
|
|
|
attr = self.get_best_anchor_attr(attrib_list)
|
|
|
|
if attr == "a":
|
|
# didn't find an attribute to use
|
|
# in the child markup, so let's
|
|
# try the anchor tag's own attributes
|
|
|
|
attr = self.get_urwid_attr_name(tag)
|
|
|
|
# hashtag anchors have a class of "mention hashtag"
|
|
# or "hashtag"
|
|
# we'll return style "class_mention_hashtag"
|
|
# or "class_hashtag"
|
|
# in that case; see corresponding palette entry
|
|
# in constants.py controlling hashtag highlighting
|
|
|
|
return (attr, title)
|
|
|
|
def _blockquote(self, tag) -> urwid.Widget:
|
|
widget_list = self.process_block_tag_children(tag)
|
|
blockquote_widget = urwid.LineBox(
|
|
urwid.Padding(
|
|
urwid.Pile(widget_list),
|
|
align="left",
|
|
width=("relative", 100),
|
|
min_width=None,
|
|
left=1,
|
|
right=1,
|
|
),
|
|
tlcorner="",
|
|
tline="",
|
|
lline="│",
|
|
trcorner="",
|
|
blcorner="",
|
|
rline="",
|
|
bline="",
|
|
brcorner="",
|
|
)
|
|
return urwid.Pile([urwid.AttrMap(blockquote_widget, "blockquote")])
|
|
|
|
def _br(self, tag) -> Tuple:
|
|
return ("br", "\n")
|
|
|
|
def _em(self, tag) -> Tuple:
|
|
# to simplify the number of palette entries
|
|
# translate EM to I (italic)
|
|
markups = self.process_inline_tag_children(tag)
|
|
if not markups:
|
|
return ("i", "")
|
|
|
|
# special case processing for bold and italic
|
|
for parent in tag.parents:
|
|
if parent.name == "b" or parent.name == "strong":
|
|
return ("bi", markups)
|
|
|
|
return ("i", markups)
|
|
|
|
def _ol(self, tag) -> urwid.Widget:
|
|
"""ordered list tag handler"""
|
|
|
|
widgets = []
|
|
list_item_num = 1
|
|
increment = -1 if tag.has_attr("reversed") else 1
|
|
|
|
# get ol start= attribute if present
|
|
if tag.has_attr("start") and len(tag.attrs["start"]) > 0:
|
|
try:
|
|
list_item_num = int(tag.attrs["start"])
|
|
except ValueError:
|
|
pass
|
|
|
|
for li in tag.find_all("li", recursive=False):
|
|
method = getattr(self, "_li", self.inline_tag_to_text)
|
|
markup = method(li)
|
|
|
|
# li value= attribute will change the item number
|
|
# it also overrides any ol start= attribute
|
|
|
|
if li.has_attr("value") and len(li.attrs["value"]) > 0:
|
|
try:
|
|
list_item_num = int(li.attrs["value"])
|
|
except ValueError:
|
|
pass
|
|
|
|
if not isinstance(markup, urwid.Widget):
|
|
txt = self.text_to_widget("li", [str(list_item_num), ". ", markup])
|
|
# 1. foo, 2. bar, etc.
|
|
widgets.append(txt)
|
|
else:
|
|
txt = self.text_to_widget("li", [str(list_item_num), ". "])
|
|
columns = urwid.Columns(
|
|
[txt, ("weight", 9999, markup)], dividechars=1, min_width=3
|
|
)
|
|
widgets.append(columns)
|
|
|
|
list_item_num += increment
|
|
|
|
return urwid.Pile(widgets)
|
|
|
|
def _pre(self, tag) -> urwid.Widget:
|
|
# <PRE> tag spec says that text should not wrap,
|
|
# but horizontal screen space is at a premium
|
|
# and we have no horizontal scroll bar, so allow
|
|
# wrapping.
|
|
|
|
widget_list = [urwid.Divider(" ")]
|
|
widget_list += self.process_block_tag_children(tag)
|
|
|
|
pre_widget = urwid.Padding(
|
|
urwid.Pile(widget_list),
|
|
align="left",
|
|
width=("relative", 100),
|
|
min_width=None,
|
|
left=1,
|
|
right=1,
|
|
)
|
|
return urwid.Pile([urwid.AttrMap(pre_widget, "pre")])
|
|
|
|
def _span(self, tag) -> Tuple:
|
|
markups = self.process_inline_tag_children(tag)
|
|
|
|
if not markups:
|
|
return (tag.name, "")
|
|
|
|
# span inherits its parent's class definition
|
|
# unless it has a specific class definition
|
|
# of its own
|
|
|
|
if "class" in tag.attrs:
|
|
# uncomment the following code to hide all HTML marked
|
|
# invisible (generally, the http:// prefix of URLs)
|
|
# could be a user preference, it's only advisable if
|
|
# the terminal supports OCS 8 hyperlinks (and that's not
|
|
# automatically detectable)
|
|
|
|
# if "invisible" in tag.attrs["class"]:
|
|
# return (tag.name, "")
|
|
|
|
style_name = self.get_urwid_attr_name(tag)
|
|
|
|
if style_name != "span":
|
|
# unique class name matches an entry in our palette
|
|
return (style_name, markups)
|
|
|
|
if tag.parent:
|
|
return (self.get_urwid_attr_name(tag.parent), markups)
|
|
else:
|
|
# fallback
|
|
return ("span", markups)
|
|
|
|
def _strong(self, tag) -> Tuple:
|
|
# to simplify the number of palette entries
|
|
# translate STRONG to B (bold)
|
|
markups = self.process_inline_tag_children(tag)
|
|
if not markups:
|
|
return ("b", "")
|
|
|
|
# special case processing for bold and italic
|
|
for parent in tag.parents:
|
|
if parent.name == "i" or parent.name == "em":
|
|
return ("bi", markups)
|
|
|
|
return ("b", markups)
|
|
|
|
def _ul(self, tag) -> urwid.Widget:
|
|
"""unordered list tag handler"""
|
|
|
|
widgets = []
|
|
|
|
for li in tag.find_all("li", recursive=False):
|
|
method = getattr(self, "_li", self.inline_tag_to_text)
|
|
markup = method(li)
|
|
|
|
if not isinstance(markup, urwid.Widget):
|
|
txt = self.text_to_widget("li", ["\N{bullet} ", markup])
|
|
# * foo, * bar, etc.
|
|
widgets.append(txt)
|
|
else:
|
|
txt = self.text_to_widget("li", ["\N{bullet} "])
|
|
columns = urwid.Columns(
|
|
[txt, ("weight", 9999, markup)], dividechars=1, min_width=3
|
|
)
|
|
widgets.append(columns)
|
|
|
|
return urwid.Pile(widgets)
|
|
|
|
# These tags are handled identically to others
|
|
# the only difference being the tag name used for
|
|
# urwid attribute mapping
|
|
|
|
_b = _strong
|
|
|
|
_div = basic_block_tag_handler
|
|
|
|
_i = _em
|
|
|
|
_li = basic_block_tag_handler
|
|
|
|
# Glitch-soc and Pleroma allow <H1>...<H6> in content
|
|
# Mastodon (PR #23913) does not; header tags are converted to <P><STRONG></STRONG></P>
|
|
|
|
_h1 = _h2 = _h3 = _h4 = _h5 = _h6 = basic_block_tag_handler
|
|
|
|
_p = basic_block_tag_handler
|
|
|
|
|
|
def flatten(data):
|
|
if isinstance(data, tuple):
|
|
for x in data:
|
|
yield from flatten(x)
|
|
else:
|
|
yield data
|