You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1179 lines
36 KiB
1179 lines
36 KiB
# -*- coding: utf-8 -*-
|
|
|
|
# Copyright © 2008 Nicholas Marriott <nicholas.marriott@gmail.com>
|
|
# Copyright © 2016 Avi Halachmi <avihpit@yahoo.com>
|
|
# Copyright © 2018, 2019 Damir Jelić <poljar@termina.org.uk>
|
|
# Copyright © 2018, 2019 Denis Kasak <dkasak@termina.org.uk>
|
|
#
|
|
# Permission to use, copy, modify, and/or distribute this software for
|
|
# any purpose with or without fee is hereby granted, provided that the
|
|
# above copyright notice and this permission notice appear in all copies.
|
|
#
|
|
# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
|
# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
|
# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
|
|
# SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
|
|
# RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
|
|
# CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
|
|
# CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
|
|
|
from __future__ import unicode_literals
|
|
|
|
import html
|
|
import re
|
|
import textwrap
|
|
|
|
# pylint: disable=redefined-builtin
|
|
from builtins import str
|
|
from collections import namedtuple
|
|
from typing import List
|
|
|
|
import webcolors
|
|
from pygments import highlight
|
|
from pygments.formatter import Formatter, get_style_by_name
|
|
from pygments.lexers import get_lexer_by_name
|
|
from pygments.util import ClassNotFound
|
|
|
|
from . import globals as G
|
|
from .globals import W
|
|
from .utils import (string_strikethrough,
|
|
string_color_and_reset,
|
|
color_pair,
|
|
text_block,
|
|
colored_text_block)
|
|
|
|
try:
|
|
from HTMLParser import HTMLParser
|
|
except ImportError:
|
|
from html.parser import HTMLParser
|
|
|
|
|
|
class FormattedString:
|
|
__slots__ = ("text", "attributes")
|
|
|
|
def __init__(self, text, attributes):
|
|
self.attributes = DEFAULT_ATTRIBUTES.copy()
|
|
self.attributes.update(attributes)
|
|
self.text = text
|
|
|
|
|
|
class Formatted(object):
|
|
def __init__(self, substrings):
|
|
# type: (List[FormattedString]) -> None
|
|
self.substrings = substrings
|
|
|
|
@property
|
|
def textwrapper(self):
|
|
quote_pair = color_pair(G.CONFIG.color.quote_fg,
|
|
G.CONFIG.color.quote_bg)
|
|
return textwrap.TextWrapper(
|
|
width=67,
|
|
initial_indent="{}> ".format(W.color(quote_pair)),
|
|
subsequent_indent="{}> ".format(W.color(quote_pair)),
|
|
)
|
|
|
|
def is_formatted(self):
|
|
# type: (Formatted) -> bool
|
|
for string in self.substrings:
|
|
if string.attributes != DEFAULT_ATTRIBUTES:
|
|
return True
|
|
return False
|
|
|
|
# TODO reverse video
|
|
@classmethod
|
|
def from_input_line(cls, line):
|
|
# type: (str) -> Formatted
|
|
"""Parses the weechat input line and produces formatted strings that
|
|
can be later converted to HTML or to a string for weechat's print
|
|
functions
|
|
"""
|
|
text = "" # type: str
|
|
substrings = [] # type: List[FormattedString]
|
|
attributes = DEFAULT_ATTRIBUTES.copy()
|
|
|
|
i = 0
|
|
while i < len(line):
|
|
# Bold
|
|
if line[i] == "\x02" and not attributes["code"]:
|
|
if text:
|
|
substrings.append(FormattedString(text, attributes.copy()))
|
|
text = ""
|
|
attributes["bold"] = not attributes["bold"]
|
|
i = i + 1
|
|
|
|
# Markdown inline code
|
|
elif line[i] == "`":
|
|
if text:
|
|
# strip leading and trailing spaces and compress consecutive
|
|
# spaces in inline code blocks
|
|
if attributes["code"]:
|
|
text = text.strip()
|
|
text = re.sub(r"\s+", " ", text)
|
|
|
|
substrings.append(
|
|
FormattedString(text, attributes.copy())
|
|
)
|
|
text = ""
|
|
attributes["code"] = not attributes["code"]
|
|
i = i + 1
|
|
|
|
# Markdown emphasis
|
|
elif line[i] == "*" and not attributes["code"]:
|
|
if attributes["italic"] and not line[i - 1].isspace():
|
|
if text:
|
|
substrings.append(
|
|
FormattedString(text, attributes.copy())
|
|
)
|
|
text = ""
|
|
attributes["italic"] = not attributes["italic"]
|
|
i = i + 1
|
|
continue
|
|
|
|
elif attributes["italic"] and line[i - 1].isspace():
|
|
text = text + line[i]
|
|
i = i + 1
|
|
continue
|
|
|
|
elif i + 1 < len(line) and line[i + 1].isspace():
|
|
text = text + line[i]
|
|
i = i + 1
|
|
continue
|
|
|
|
elif i == len(line) - 1:
|
|
text = text + line[i]
|
|
i = i + 1
|
|
continue
|
|
|
|
if text:
|
|
substrings.append(FormattedString(text, attributes.copy()))
|
|
text = ""
|
|
attributes["italic"] = not attributes["italic"]
|
|
i = i + 1
|
|
|
|
# Color
|
|
elif line[i] == "\x03" and not attributes["code"]:
|
|
if text:
|
|
substrings.append(FormattedString(text, attributes.copy()))
|
|
text = ""
|
|
i = i + 1
|
|
|
|
# check if it's a valid color, add it to the attributes
|
|
if line[i].isdigit():
|
|
color_string = line[i]
|
|
i = i + 1
|
|
|
|
if line[i].isdigit():
|
|
if color_string == "0":
|
|
color_string = line[i]
|
|
else:
|
|
color_string = color_string + line[i]
|
|
i = i + 1
|
|
|
|
attributes["fgcolor"] = color_line_to_weechat(color_string)
|
|
else:
|
|
attributes["fgcolor"] = None
|
|
|
|
# check if we have a background color
|
|
if line[i] == "," and line[i + 1].isdigit():
|
|
color_string = line[i + 1]
|
|
i = i + 2
|
|
|
|
if line[i].isdigit():
|
|
if color_string == "0":
|
|
color_string = line[i]
|
|
else:
|
|
color_string = color_string + line[i]
|
|
i = i + 1
|
|
|
|
attributes["bgcolor"] = color_line_to_weechat(color_string)
|
|
else:
|
|
attributes["bgcolor"] = None
|
|
# Reset
|
|
elif line[i] == "\x0F" and not attributes["code"]:
|
|
if text:
|
|
substrings.append(FormattedString(text, attributes.copy()))
|
|
text = ""
|
|
# Reset all the attributes
|
|
attributes = DEFAULT_ATTRIBUTES.copy()
|
|
i = i + 1
|
|
|
|
# Italic
|
|
elif line[i] == "\x1D" and not attributes["code"]:
|
|
if text:
|
|
substrings.append(FormattedString(text, attributes.copy()))
|
|
text = ""
|
|
attributes["italic"] = not attributes["italic"]
|
|
i = i + 1
|
|
|
|
# Underline
|
|
elif line[i] == "\x1F" and not attributes["code"]:
|
|
if text:
|
|
substrings.append(FormattedString(text, attributes.copy()))
|
|
text = ""
|
|
attributes["underline"] = not attributes["underline"]
|
|
i = i + 1
|
|
|
|
# Normal text
|
|
else:
|
|
text = text + line[i]
|
|
i = i + 1
|
|
|
|
substrings.append(FormattedString(text, attributes))
|
|
return cls(substrings)
|
|
|
|
@classmethod
|
|
def from_html(cls, html):
|
|
# type: (str) -> Formatted
|
|
parser = MatrixHtmlParser()
|
|
parser.feed(html)
|
|
return cls(parser.get_substrings())
|
|
|
|
def to_html(self):
|
|
def add_attribute(string, name, value):
|
|
if name == "bold" and value:
|
|
return "{bold_on}{text}{bold_off}".format(
|
|
bold_on="<strong>", text=string, bold_off="</strong>"
|
|
)
|
|
if name == "italic" and value:
|
|
return "{italic_on}{text}{italic_off}".format(
|
|
italic_on="<em>", text=string, italic_off="</em>"
|
|
)
|
|
if name == "underline" and value:
|
|
return "{underline_on}{text}{underline_off}".format(
|
|
underline_on="<u>", text=string, underline_off="</u>"
|
|
)
|
|
if name == "strikethrough" and value:
|
|
return "{strike_on}{text}{strike_off}".format(
|
|
strike_on="<del>", text=string, strike_off="</del>"
|
|
)
|
|
if name == "quote" and value:
|
|
return "{quote_on}{text}{quote_off}".format(
|
|
quote_on="<blockquote>",
|
|
text=string,
|
|
quote_off="</blockquote>",
|
|
)
|
|
if name == "code" and value:
|
|
return "{code_on}{text}{code_off}".format(
|
|
code_on="<code>", text=string, code_off="</code>"
|
|
)
|
|
|
|
return string
|
|
|
|
def add_color(string, fgcolor, bgcolor):
|
|
fgcolor_string = ""
|
|
bgcolor_string = ""
|
|
|
|
if fgcolor:
|
|
fgcolor_string = " data-mx-color={}".format(
|
|
color_weechat_to_html(fgcolor)
|
|
)
|
|
|
|
if bgcolor:
|
|
bgcolor_string = " data-mx-bg-color={}".format(
|
|
color_weechat_to_html(bgcolor)
|
|
)
|
|
|
|
return "{color_on}{text}{color_off}".format(
|
|
color_on="<font{fg}{bg}>".format(
|
|
fg=fgcolor_string,
|
|
bg=bgcolor_string
|
|
),
|
|
text=string,
|
|
color_off="</font>",
|
|
)
|
|
|
|
def format_string(formatted_string):
|
|
text = formatted_string.text
|
|
attributes = formatted_string.attributes.copy()
|
|
|
|
if attributes["code"]:
|
|
if attributes["preformatted"]:
|
|
# XXX: This can't really happen since there's no way of
|
|
# creating preformatted code blocks in weechat (because
|
|
# there is not multiline input), but I'm creating this
|
|
# branch as a note that it should be handled once we do
|
|
# implement them.
|
|
pass
|
|
else:
|
|
text = add_attribute(text, "code", True)
|
|
attributes.pop("code")
|
|
|
|
elif attributes["fgcolor"] or attributes["bgcolor"]:
|
|
text = add_color(
|
|
text,
|
|
attributes["fgcolor"],
|
|
attributes["bgcolor"]
|
|
)
|
|
else:
|
|
for key, value in attributes.items():
|
|
text = add_attribute(text, key, value)
|
|
|
|
return text
|
|
|
|
html_string = map(format_string, self.substrings)
|
|
return "".join(html_string)
|
|
|
|
# TODO do we want at least some formatting using unicode
|
|
# (strikethrough, quotes)?
|
|
def to_plain(self):
|
|
# type: () -> str
|
|
def strip_atribute(string, _, __):
|
|
return string
|
|
|
|
def format_string(formatted_string):
|
|
text = formatted_string.text
|
|
attributes = formatted_string.attributes
|
|
|
|
for key, value in attributes.items():
|
|
text = strip_atribute(text, key, value)
|
|
return text
|
|
|
|
plain_string = map(format_string, self.substrings)
|
|
return "".join(plain_string)
|
|
|
|
def to_weechat(self):
|
|
def add_attribute(string, name, value, attributes):
|
|
if not value:
|
|
return string
|
|
elif name == "bold":
|
|
return "{bold_on}{text}{bold_off}".format(
|
|
bold_on=W.color("bold"),
|
|
text=string,
|
|
bold_off=W.color("-bold"),
|
|
)
|
|
elif name == "italic":
|
|
return "{italic_on}{text}{italic_off}".format(
|
|
italic_on=W.color("italic"),
|
|
text=string,
|
|
italic_off=W.color("-italic"),
|
|
)
|
|
elif name == "underline":
|
|
return "{underline_on}{text}{underline_off}".format(
|
|
underline_on=W.color("underline"),
|
|
text=string,
|
|
underline_off=W.color("-underline"),
|
|
)
|
|
elif name == "strikethrough":
|
|
return string_strikethrough(string)
|
|
elif name == "quote":
|
|
return self.textwrapper.fill(
|
|
W.string_remove_color(string.replace("\n", ""), "")
|
|
)
|
|
elif name == "code":
|
|
code_color_pair = color_pair(
|
|
G.CONFIG.color.untagged_code_fg,
|
|
G.CONFIG.color.untagged_code_bg
|
|
)
|
|
|
|
margin = G.CONFIG.look.code_block_margin
|
|
|
|
if attributes["preformatted"]:
|
|
# code block
|
|
|
|
try:
|
|
lexer = get_lexer_by_name(value)
|
|
except ClassNotFound:
|
|
if G.CONFIG.look.code_blocks:
|
|
return colored_text_block(
|
|
string,
|
|
margin=margin,
|
|
color_pair=code_color_pair)
|
|
else:
|
|
return string_color_and_reset(string,
|
|
code_color_pair)
|
|
|
|
try:
|
|
style = get_style_by_name(G.CONFIG.look.pygments_style)
|
|
except ClassNotFound:
|
|
style = "native"
|
|
|
|
if G.CONFIG.look.code_blocks:
|
|
code_block = text_block(string, margin=margin)
|
|
else:
|
|
code_block = string
|
|
|
|
# highlight adds a newline to the end of the string, remove
|
|
# it from the output
|
|
highlighted_code = highlight(
|
|
code_block,
|
|
lexer,
|
|
WeechatFormatter(style=style)
|
|
).rstrip()
|
|
|
|
return highlighted_code
|
|
else:
|
|
return string_color_and_reset(string, code_color_pair)
|
|
elif name == "fgcolor":
|
|
return "{color_on}{text}{color_off}".format(
|
|
color_on=W.color(value),
|
|
text=string,
|
|
color_off=W.color("resetcolor"),
|
|
)
|
|
elif name == "bgcolor":
|
|
return "{color_on}{text}{color_off}".format(
|
|
color_on=W.color("," + value),
|
|
text=string,
|
|
color_off=W.color("resetcolor"),
|
|
)
|
|
else:
|
|
return string
|
|
|
|
def format_string(formatted_string):
|
|
text = formatted_string.text
|
|
attributes = formatted_string.attributes
|
|
|
|
# We need to handle strikethrough first, since doing
|
|
# a strikethrough followed by other attributes succeeds in the
|
|
# terminal, but doing it the other way around results in garbage.
|
|
if "strikethrough" in attributes:
|
|
text = add_attribute(
|
|
text,
|
|
"strikethrough",
|
|
attributes["strikethrough"],
|
|
attributes
|
|
)
|
|
attributes.pop("strikethrough")
|
|
|
|
def indent(text, prefix):
|
|
return prefix + text.replace("\n", "\n{}".format(prefix))
|
|
|
|
for key, value in attributes.items():
|
|
if not value:
|
|
continue
|
|
|
|
# Don't use textwrap to quote the code
|
|
if key == "quote" and attributes["code"]:
|
|
continue
|
|
|
|
# Reflow inline code blocks
|
|
if key == "code" and not attributes["preformatted"]:
|
|
text = text.strip().replace('\n', ' ')
|
|
|
|
text = add_attribute(text, key, value, attributes)
|
|
|
|
# If we're quoted code add quotation marks now.
|
|
if key == "code" and attributes["quote"]:
|
|
fg = G.CONFIG.color.quote_fg
|
|
bg = G.CONFIG.color.quote_bg
|
|
text = indent(
|
|
text,
|
|
string_color_and_reset(">", color_pair(fg, bg)) + " ",
|
|
)
|
|
|
|
# If we're code don't remove multiple newlines blindly
|
|
if attributes["code"]:
|
|
return text
|
|
return re.sub(r"\n+", "\n", text)
|
|
|
|
weechat_strings = map(format_string, self.substrings)
|
|
|
|
# Remove duplicate \n elements from the list
|
|
strings = []
|
|
for string in weechat_strings:
|
|
if len(strings) == 0 or string != "\n" or string != strings[-1]:
|
|
strings.append(string)
|
|
|
|
return "".join(strings).strip()
|
|
|
|
|
|
# TODO this should be a typed dict.
|
|
DEFAULT_ATTRIBUTES = {
|
|
"bold": False,
|
|
"italic": False,
|
|
"underline": False,
|
|
"strikethrough": False,
|
|
"preformatted": False,
|
|
"quote": False,
|
|
"code": None,
|
|
"fgcolor": None,
|
|
"bgcolor": None,
|
|
}
|
|
|
|
|
|
class MatrixHtmlParser(HTMLParser):
|
|
# TODO bullets
|
|
def __init__(self):
|
|
HTMLParser.__init__(self)
|
|
self.text = "" # type: str
|
|
self.substrings = [] # type: List[FormattedString]
|
|
self.attributes = DEFAULT_ATTRIBUTES.copy()
|
|
|
|
def unescape(self, text):
|
|
"""Shim to unescape HTML in both Python 2 and 3.
|
|
|
|
The instance method was deprecated in Python 3 and html.unescape
|
|
doesn't exist in Python 2 so this is needed.
|
|
"""
|
|
try:
|
|
return html.unescape(text)
|
|
except AttributeError:
|
|
return HTMLParser.unescape(self, text)
|
|
|
|
def add_substring(self, text, attrs):
|
|
fmt_string = FormattedString(text, attrs)
|
|
self.substrings.append(fmt_string)
|
|
|
|
def _toggle_attribute(self, attribute):
|
|
if self.text:
|
|
self.add_substring(self.text, self.attributes.copy())
|
|
self.text = ""
|
|
self.attributes[attribute] = not self.attributes[attribute]
|
|
|
|
def handle_starttag(self, tag, attrs):
|
|
if tag == "strong":
|
|
self._toggle_attribute("bold")
|
|
elif tag == "em":
|
|
self._toggle_attribute("italic")
|
|
elif tag == "u":
|
|
self._toggle_attribute("underline")
|
|
elif tag == "del":
|
|
self._toggle_attribute("strikethrough")
|
|
elif tag == "blockquote":
|
|
self._toggle_attribute("quote")
|
|
elif tag == "pre":
|
|
self._toggle_attribute("preformatted")
|
|
elif tag == "code":
|
|
lang = None
|
|
|
|
for key, value in attrs:
|
|
if key == "class":
|
|
if value.startswith("language-"):
|
|
lang = value.split("-", 1)[1]
|
|
|
|
lang = lang or "unknown"
|
|
|
|
if self.text:
|
|
self.add_substring(self.text, self.attributes.copy())
|
|
self.text = ""
|
|
self.attributes["code"] = lang
|
|
elif tag == "p":
|
|
if self.text:
|
|
self.add_substring(self.text, self.attributes.copy())
|
|
self.text = "\n"
|
|
self.add_substring(self.text, DEFAULT_ATTRIBUTES.copy())
|
|
self.text = ""
|
|
elif tag == "br":
|
|
if self.text:
|
|
self.add_substring(self.text, self.attributes.copy())
|
|
self.text = "\n"
|
|
self.add_substring(self.text, DEFAULT_ATTRIBUTES.copy())
|
|
self.text = ""
|
|
elif tag == "font":
|
|
for key, value in attrs:
|
|
if key in ["data-mx-color", "color"]:
|
|
color = color_html_to_weechat(value)
|
|
|
|
if not color:
|
|
continue
|
|
|
|
if self.text:
|
|
self.add_substring(self.text, self.attributes.copy())
|
|
self.text = ""
|
|
self.attributes["fgcolor"] = color
|
|
|
|
elif key in ["data-mx-bg-color"]:
|
|
color = color_html_to_weechat(value)
|
|
if not color:
|
|
continue
|
|
|
|
if self.text:
|
|
self.add_substring(self.text, self.attributes.copy())
|
|
self.text = ""
|
|
self.attributes["bgcolor"] = color
|
|
|
|
else:
|
|
pass
|
|
|
|
def handle_endtag(self, tag):
|
|
if tag == "strong":
|
|
self._toggle_attribute("bold")
|
|
elif tag == "em":
|
|
self._toggle_attribute("italic")
|
|
elif tag == "u":
|
|
self._toggle_attribute("underline")
|
|
elif tag == "del":
|
|
self._toggle_attribute("strikethrough")
|
|
elif tag == "pre":
|
|
self._toggle_attribute("preformatted")
|
|
elif tag == "code":
|
|
if self.text:
|
|
self.add_substring(self.text, self.attributes.copy())
|
|
self.text = ""
|
|
self.attributes["code"] = None
|
|
elif tag == "blockquote":
|
|
self._toggle_attribute("quote")
|
|
self.text = "\n"
|
|
self.add_substring(self.text, DEFAULT_ATTRIBUTES.copy())
|
|
self.text = ""
|
|
elif tag == "font":
|
|
if self.text:
|
|
self.add_substring(self.text, self.attributes.copy())
|
|
self.text = ""
|
|
self.attributes["fgcolor"] = None
|
|
else:
|
|
pass
|
|
|
|
def handle_data(self, data):
|
|
self.text += data
|
|
|
|
def handle_entityref(self, name):
|
|
self.text += self.unescape("&{};".format(name))
|
|
|
|
def handle_charref(self, name):
|
|
self.text += self.unescape("&#{};".format(name))
|
|
|
|
def get_substrings(self):
|
|
if self.text:
|
|
self.add_substring(self.text, self.attributes.copy())
|
|
|
|
return self.substrings
|
|
|
|
|
|
def color_line_to_weechat(color_string):
|
|
# type: (str) -> str
|
|
line_colors = {
|
|
"0": "white",
|
|
"1": "black",
|
|
"2": "blue",
|
|
"3": "green",
|
|
"4": "lightred",
|
|
"5": "red",
|
|
"6": "magenta",
|
|
"7": "brown",
|
|
"8": "yellow",
|
|
"9": "lightgreen",
|
|
"10": "cyan",
|
|
"11": "lightcyan",
|
|
"12": "lightblue",
|
|
"13": "lightmagenta",
|
|
"14": "darkgray",
|
|
"15": "gray",
|
|
"16": "52",
|
|
"17": "94",
|
|
"18": "100",
|
|
"19": "58",
|
|
"20": "22",
|
|
"21": "29",
|
|
"22": "23",
|
|
"23": "24",
|
|
"24": "17",
|
|
"25": "54",
|
|
"26": "53",
|
|
"27": "89",
|
|
"28": "88",
|
|
"29": "130",
|
|
"30": "142",
|
|
"31": "64",
|
|
"32": "28",
|
|
"33": "35",
|
|
"34": "30",
|
|
"35": "25",
|
|
"36": "18",
|
|
"37": "91",
|
|
"38": "90",
|
|
"39": "125",
|
|
"40": "124",
|
|
"41": "166",
|
|
"42": "184",
|
|
"43": "106",
|
|
"44": "34",
|
|
"45": "49",
|
|
"46": "37",
|
|
"47": "33",
|
|
"48": "19",
|
|
"49": "129",
|
|
"50": "127",
|
|
"51": "161",
|
|
"52": "196",
|
|
"53": "208",
|
|
"54": "226",
|
|
"55": "154",
|
|
"56": "46",
|
|
"57": "86",
|
|
"58": "51",
|
|
"59": "75",
|
|
"60": "21",
|
|
"61": "171",
|
|
"62": "201",
|
|
"63": "198",
|
|
"64": "203",
|
|
"65": "215",
|
|
"66": "227",
|
|
"67": "191",
|
|
"68": "83",
|
|
"69": "122",
|
|
"70": "87",
|
|
"71": "111",
|
|
"72": "63",
|
|
"73": "177",
|
|
"74": "207",
|
|
"75": "205",
|
|
"76": "217",
|
|
"77": "223",
|
|
"78": "229",
|
|
"79": "193",
|
|
"80": "157",
|
|
"81": "158",
|
|
"82": "159",
|
|
"83": "153",
|
|
"84": "147",
|
|
"85": "183",
|
|
"86": "219",
|
|
"87": "212",
|
|
"88": "16",
|
|
"89": "233",
|
|
"90": "235",
|
|
"91": "237",
|
|
"92": "239",
|
|
"93": "241",
|
|
"94": "244",
|
|
"95": "247",
|
|
"96": "250",
|
|
"97": "254",
|
|
"98": "231",
|
|
"99": "default",
|
|
}
|
|
|
|
assert color_string in line_colors
|
|
|
|
return line_colors[color_string]
|
|
|
|
|
|
# The functions color_dist_sq(), color_to_6cube(), and color_find_rgb
|
|
# are python ports of the same named functions from the tmux
|
|
# source, they are under the copyright of Nicholas Marriott, and Avi Halachmi
|
|
# under the ISC license.
|
|
# More info: https://github.com/tmux/tmux/blob/master/colour.c
|
|
|
|
|
|
def color_dist_sq(R, G, B, r, g, b):
|
|
# pylint: disable=invalid-name,too-many-arguments
|
|
# type: (int, int, int, int, int, int) -> int
|
|
return (R - r) * (R - r) + (G - g) * (G - g) + (B - b) * (B - b)
|
|
|
|
|
|
def color_to_6cube(v):
|
|
# pylint: disable=invalid-name
|
|
# type: (int) -> int
|
|
if v < 48:
|
|
return 0
|
|
if v < 114:
|
|
return 1
|
|
return (v - 35) // 40
|
|
|
|
|
|
def color_find_rgb(r, g, b):
|
|
# type: (int, int, int) -> int
|
|
"""Convert an RGB triplet to the xterm(1) 256 color palette.
|
|
|
|
xterm provides a 6x6x6 color cube (16 - 231) and 24 greys (232 - 255).
|
|
We map our RGB color to the closest in the cube, also work out the
|
|
closest grey, and use the nearest of the two.
|
|
|
|
Note that the xterm has much lower resolution for darker colors (they
|
|
are not evenly spread out), so our 6 levels are not evenly spread: 0x0,
|
|
0x5f (95), 0x87 (135), 0xaf (175), 0xd7 (215) and 0xff (255). Greys are
|
|
more evenly spread (8, 18, 28 ... 238).
|
|
"""
|
|
# pylint: disable=invalid-name
|
|
q2c = [0x00, 0x5f, 0x87, 0xaf, 0xd7, 0xff]
|
|
|
|
# Map RGB to 6x6x6 cube.
|
|
qr = color_to_6cube(r)
|
|
qg = color_to_6cube(g)
|
|
qb = color_to_6cube(b)
|
|
|
|
cr = q2c[qr]
|
|
cg = q2c[qg]
|
|
cb = q2c[qb]
|
|
|
|
# If we have hit the color exactly, return early.
|
|
if cr == r and cg == g and cb == b:
|
|
return 16 + (36 * qr) + (6 * qg) + qb
|
|
|
|
# Work out the closest grey (average of RGB).
|
|
grey_avg = (r + g + b) // 3
|
|
|
|
if grey_avg > 238:
|
|
grey_idx = 23
|
|
else:
|
|
grey_idx = (grey_avg - 3) // 10
|
|
|
|
grey = 8 + (10 * grey_idx)
|
|
|
|
# Is grey or 6x6x6 color closest?
|
|
d = color_dist_sq(cr, cg, cb, r, g, b)
|
|
|
|
if color_dist_sq(grey, grey, grey, r, g, b) < d:
|
|
idx = 232 + grey_idx
|
|
else:
|
|
idx = 16 + (36 * qr) + (6 * qg) + qb
|
|
|
|
return idx
|
|
|
|
|
|
def color_html_to_weechat(color):
|
|
# type: (str) -> str
|
|
# yapf: disable
|
|
weechat_basic_colors = {
|
|
(0, 0, 0): "black", # 0
|
|
(128, 0, 0): "red", # 1
|
|
(0, 128, 0): "green", # 2
|
|
(128, 128, 0): "brown", # 3
|
|
(0, 0, 128): "blue", # 4
|
|
(128, 0, 128): "magenta", # 5
|
|
(0, 128, 128): "cyan", # 6
|
|
(192, 192, 192): "default", # 7
|
|
(128, 128, 128): "gray", # 8
|
|
(255, 0, 0): "lightred", # 9
|
|
(0, 255, 0): "lightgreen", # 10
|
|
(255, 255, 0): "yellow", # 11
|
|
(0, 0, 255): "lightblue", # 12
|
|
(255, 0, 255): "lightmagenta", # 13
|
|
(0, 255, 255): "lightcyan", # 14
|
|
(255, 255, 255): "white", # 15
|
|
}
|
|
# yapf: enable
|
|
|
|
try:
|
|
rgb_color = webcolors.html5_parse_legacy_color(color)
|
|
except ValueError:
|
|
return ""
|
|
|
|
if rgb_color in weechat_basic_colors:
|
|
return weechat_basic_colors[rgb_color]
|
|
|
|
return str(color_find_rgb(*rgb_color))
|
|
|
|
|
|
def color_weechat_to_html(color):
|
|
# type: (str) -> str
|
|
# yapf: disable
|
|
weechat_basic_colors = {
|
|
"black": "0",
|
|
"red": "1",
|
|
"green": "2",
|
|
"brown": "3",
|
|
"blue": "4",
|
|
"magenta": "5",
|
|
"cyan": "6",
|
|
"default": "7",
|
|
"gray": "8",
|
|
"lightred": "9",
|
|
"lightgreen": "10",
|
|
"yellow": "11",
|
|
"lightblue": "12",
|
|
"lightmagenta": "13",
|
|
"lightcyan": "14",
|
|
"white": "15",
|
|
}
|
|
hex_colors = {
|
|
"0": "#000000",
|
|
"1": "#800000",
|
|
"2": "#008000",
|
|
"3": "#808000",
|
|
"4": "#000080",
|
|
"5": "#800080",
|
|
"6": "#008080",
|
|
"7": "#c0c0c0",
|
|
"8": "#808080",
|
|
"9": "#ff0000",
|
|
"10": "#00ff00",
|
|
"11": "#ffff00",
|
|
"12": "#0000ff",
|
|
"13": "#ff00ff",
|
|
"14": "#00ffff",
|
|
"15": "#ffffff",
|
|
"16": "#000000",
|
|
"17": "#00005f",
|
|
"18": "#000087",
|
|
"19": "#0000af",
|
|
"20": "#0000d7",
|
|
"21": "#0000ff",
|
|
"22": "#005f00",
|
|
"23": "#005f5f",
|
|
"24": "#005f87",
|
|
"25": "#005faf",
|
|
"26": "#005fd7",
|
|
"27": "#005fff",
|
|
"28": "#008700",
|
|
"29": "#00875f",
|
|
"30": "#008787",
|
|
"31": "#0087af",
|
|
"32": "#0087d7",
|
|
"33": "#0087ff",
|
|
"34": "#00af00",
|
|
"35": "#00af5f",
|
|
"36": "#00af87",
|
|
"37": "#00afaf",
|
|
"38": "#00afd7",
|
|
"39": "#00afff",
|
|
"40": "#00d700",
|
|
"41": "#00d75f",
|
|
"42": "#00d787",
|
|
"43": "#00d7af",
|
|
"44": "#00d7d7",
|
|
"45": "#00d7ff",
|
|
"46": "#00ff00",
|
|
"47": "#00ff5f",
|
|
"48": "#00ff87",
|
|
"49": "#00ffaf",
|
|
"50": "#00ffd7",
|
|
"51": "#00ffff",
|
|
"52": "#5f0000",
|
|
"53": "#5f005f",
|
|
"54": "#5f0087",
|
|
"55": "#5f00af",
|
|
"56": "#5f00d7",
|
|
"57": "#5f00ff",
|
|
"58": "#5f5f00",
|
|
"59": "#5f5f5f",
|
|
"60": "#5f5f87",
|
|
"61": "#5f5faf",
|
|
"62": "#5f5fd7",
|
|
"63": "#5f5fff",
|
|
"64": "#5f8700",
|
|
"65": "#5f875f",
|
|
"66": "#5f8787",
|
|
"67": "#5f87af",
|
|
"68": "#5f87d7",
|
|
"69": "#5f87ff",
|
|
"70": "#5faf00",
|
|
"71": "#5faf5f",
|
|
"72": "#5faf87",
|
|
"73": "#5fafaf",
|
|
"74": "#5fafd7",
|
|
"75": "#5fafff",
|
|
"76": "#5fd700",
|
|
"77": "#5fd75f",
|
|
"78": "#5fd787",
|
|
"79": "#5fd7af",
|
|
"80": "#5fd7d7",
|
|
"81": "#5fd7ff",
|
|
"82": "#5fff00",
|
|
"83": "#5fff5f",
|
|
"84": "#5fff87",
|
|
"85": "#5fffaf",
|
|
"86": "#5fffd7",
|
|
"87": "#5fffff",
|
|
"88": "#870000",
|
|
"89": "#87005f",
|
|
"90": "#870087",
|
|
"91": "#8700af",
|
|
"92": "#8700d7",
|
|
"93": "#8700ff",
|
|
"94": "#875f00",
|
|
"95": "#875f5f",
|
|
"96": "#875f87",
|
|
"97": "#875faf",
|
|
"98": "#875fd7",
|
|
"99": "#875fff",
|
|
"100": "#878700",
|
|
"101": "#87875f",
|
|
"102": "#878787",
|
|
"103": "#8787af",
|
|
"104": "#8787d7",
|
|
"105": "#8787ff",
|
|
"106": "#87af00",
|
|
"107": "#87af5f",
|
|
"108": "#87af87",
|
|
"109": "#87afaf",
|
|
"110": "#87afd7",
|
|
"111": "#87afff",
|
|
"112": "#87d700",
|
|
"113": "#87d75f",
|
|
"114": "#87d787",
|
|
"115": "#87d7af",
|
|
"116": "#87d7d7",
|
|
"117": "#87d7ff",
|
|
"118": "#87ff00",
|
|
"119": "#87ff5f",
|
|
"120": "#87ff87",
|
|
"121": "#87ffaf",
|
|
"122": "#87ffd7",
|
|
"123": "#87ffff",
|
|
"124": "#af0000",
|
|
"125": "#af005f",
|
|
"126": "#af0087",
|
|
"127": "#af00af",
|
|
"128": "#af00d7",
|
|
"129": "#af00ff",
|
|
"130": "#af5f00",
|
|
"131": "#af5f5f",
|
|
"132": "#af5f87",
|
|
"133": "#af5faf",
|
|
"134": "#af5fd7",
|
|
"135": "#af5fff",
|
|
"136": "#af8700",
|
|
"137": "#af875f",
|
|
"138": "#af8787",
|
|
"139": "#af87af",
|
|
"140": "#af87d7",
|
|
"141": "#af87ff",
|
|
"142": "#afaf00",
|
|
"143": "#afaf5f",
|
|
"144": "#afaf87",
|
|
"145": "#afafaf",
|
|
"146": "#afafd7",
|
|
"147": "#afafff",
|
|
"148": "#afd700",
|
|
"149": "#afd75f",
|
|
"150": "#afd787",
|
|
"151": "#afd7af",
|
|
"152": "#afd7d7",
|
|
"153": "#afd7ff",
|
|
"154": "#afff00",
|
|
"155": "#afff5f",
|
|
"156": "#afff87",
|
|
"157": "#afffaf",
|
|
"158": "#afffd7",
|
|
"159": "#afffff",
|
|
"160": "#d70000",
|
|
"161": "#d7005f",
|
|
"162": "#d70087",
|
|
"163": "#d700af",
|
|
"164": "#d700d7",
|
|
"165": "#d700ff",
|
|
"166": "#d75f00",
|
|
"167": "#d75f5f",
|
|
"168": "#d75f87",
|
|
"169": "#d75faf",
|
|
"170": "#d75fd7",
|
|
"171": "#d75fff",
|
|
"172": "#d78700",
|
|
"173": "#d7875f",
|
|
"174": "#d78787",
|
|
"175": "#d787af",
|
|
"176": "#d787d7",
|
|
"177": "#d787ff",
|
|
"178": "#d7af00",
|
|
"179": "#d7af5f",
|
|
"180": "#d7af87",
|
|
"181": "#d7afaf",
|
|
"182": "#d7afd7",
|
|
"183": "#d7afff",
|
|
"184": "#d7d700",
|
|
"185": "#d7d75f",
|
|
"186": "#d7d787",
|
|
"187": "#d7d7af",
|
|
"188": "#d7d7d7",
|
|
"189": "#d7d7ff",
|
|
"190": "#d7ff00",
|
|
"191": "#d7ff5f",
|
|
"192": "#d7ff87",
|
|
"193": "#d7ffaf",
|
|
"194": "#d7ffd7",
|
|
"195": "#d7ffff",
|
|
"196": "#ff0000",
|
|
"197": "#ff005f",
|
|
"198": "#ff0087",
|
|
"199": "#ff00af",
|
|
"200": "#ff00d7",
|
|
"201": "#ff00ff",
|
|
"202": "#ff5f00",
|
|
"203": "#ff5f5f",
|
|
"204": "#ff5f87",
|
|
"205": "#ff5faf",
|
|
"206": "#ff5fd7",
|
|
"207": "#ff5fff",
|
|
"208": "#ff8700",
|
|
"209": "#ff875f",
|
|
"210": "#ff8787",
|
|
"211": "#ff87af",
|
|
"212": "#ff87d7",
|
|
"213": "#ff87ff",
|
|
"214": "#ffaf00",
|
|
"215": "#ffaf5f",
|
|
"216": "#ffaf87",
|
|
"217": "#ffafaf",
|
|
"218": "#ffafd7",
|
|
"219": "#ffafff",
|
|
"220": "#ffd700",
|
|
"221": "#ffd75f",
|
|
"222": "#ffd787",
|
|
"223": "#ffd7af",
|
|
"224": "#ffd7d7",
|
|
"225": "#ffd7ff",
|
|
"226": "#ffff00",
|
|
"227": "#ffff5f",
|
|
"228": "#ffff87",
|
|
"229": "#ffffaf",
|
|
"230": "#ffffd7",
|
|
"231": "#ffffff",
|
|
"232": "#080808",
|
|
"233": "#121212",
|
|
"234": "#1c1c1c",
|
|
"235": "#262626",
|
|
"236": "#303030",
|
|
"237": "#3a3a3a",
|
|
"238": "#444444",
|
|
"239": "#4e4e4e",
|
|
"240": "#585858",
|
|
"241": "#626262",
|
|
"242": "#6c6c6c",
|
|
"243": "#767676",
|
|
"244": "#808080",
|
|
"245": "#8a8a8a",
|
|
"246": "#949494",
|
|
"247": "#9e9e9e",
|
|
"248": "#a8a8a8",
|
|
"249": "#b2b2b2",
|
|
"250": "#bcbcbc",
|
|
"251": "#c6c6c6",
|
|
"252": "#d0d0d0",
|
|
"253": "#dadada",
|
|
"254": "#e4e4e4",
|
|
"255": "#eeeeee"
|
|
}
|
|
|
|
# yapf: enable
|
|
if color in weechat_basic_colors:
|
|
return hex_colors[weechat_basic_colors[color]]
|
|
return hex_colors[color]
|
|
|
|
|
|
class WeechatFormatter(Formatter):
|
|
def __init__(self, **options):
|
|
Formatter.__init__(self, **options)
|
|
self.styles = {}
|
|
|
|
for token, style in self.style:
|
|
start = end = ""
|
|
if style["color"]:
|
|
start += "{}".format(
|
|
W.color(color_html_to_weechat(str(style["color"])))
|
|
)
|
|
end = "{}".format(W.color("resetcolor")) + end
|
|
if style["bold"]:
|
|
start += W.color("bold")
|
|
end = W.color("-bold") + end
|
|
if style["italic"]:
|
|
start += W.color("italic")
|
|
end = W.color("-italic") + end
|
|
if style["underline"]:
|
|
start += W.color("underline")
|
|
end = W.color("-underline") + end
|
|
self.styles[token] = (start, end)
|
|
|
|
def format(self, tokensource, outfile):
|
|
lastval = ""
|
|
lasttype = None
|
|
|
|
for ttype, value in tokensource:
|
|
while ttype not in self.styles:
|
|
ttype = ttype.parent
|
|
|
|
if ttype == lasttype:
|
|
lastval += value
|
|
else:
|
|
if lastval:
|
|
stylebegin, styleend = self.styles[lasttype]
|
|
outfile.write(stylebegin + lastval + styleend)
|
|
# set lastval/lasttype to current values
|
|
lastval = value
|
|
lasttype = ttype
|
|
|
|
if lastval:
|
|
stylebegin, styleend = self.styles[lasttype]
|
|
outfile.write(stylebegin + lastval + styleend)
|