path: root/src/utils/irc.py

import dataclasses, json, string, re, typing, uuid
from . import consts

ASCII_UPPER = string.ascii_uppercase
ASCII_LOWER = string.ascii_lowercase
STRICT_RFC1459_UPPER = ASCII_UPPER+r'\[]'
STRICT_RFC1459_LOWER = ASCII_LOWER+r'|{}'
RFC1459_UPPER = STRICT_RFC1459_UPPER+"^"
RFC1459_LOWER = STRICT_RFC1459_LOWER+"~"

# case mapping lowercase/uppcase logic
def multi_replace(s: str,
        chars1: typing.Iterable[str],
        chars2: typing.Iterable[str]) -> str:
    for char1, char2 in zip(chars1, chars2):
        s = s.replace(char1, char2)
    return s
def lower(case_mapping: str, s: str) -> str:
    if case_mapping == "ascii":
        return multi_replace(s, ASCII_UPPER, ASCII_LOWER)
    elif case_mapping == "rfc1459":
        return multi_replace(s, RFC1459_UPPER, RFC1459_LOWER)
    elif case_mapping == "strict-rfc1459":
        return multi_replace(s, STRICT_RFC1459_UPPER, STRICT_RFC1459_LOWER)
    else:
        raise ValueError("unknown casemapping '%s'" % case_mapping)

# compare a string while respecting case mapping
def equals(case_mapping: str, s1: str, s2: str) -> bool:
    return lower(case_mapping, s1) == lower(case_mapping, s2)

REGEX_COLOR = re.compile("%s(?:(\d{1,2})(?:,(\d{1,2}))?)?" % consts.COLOR)

def color(s: str, foreground: consts.IRCColor,
        background: consts.IRCColor=None,
        terminate: bool=True) -> str:
    foreground_s = str(foreground.irc).zfill(2)
    background_s = ""
    if background:
        background_s = ",%s" % str(background.irc).zfill(2)

    out = f"{consts.COLOR}{foreground_s}{background_s}{s}"
    if terminate:
        out += consts.COLOR

    return out

HASH_STOP = ["_", "|", "["]
HASH_COLORS = [consts.CYAN, consts.PURPLE, consts.GREEN, consts.ORANGE,
    consts.LIGHTBLUE, consts.TRANSPARENT, consts.LIGHTCYAN, consts.PINK,
    consts.LIGHTGREEN, consts.BLUE]
def hash_colorize(s: str):
    hash = 5381
    non_stop = False
    for i, char in enumerate(s):
        if not char in HASH_STOP:
            non_stop = True
        elif non_stop:
            break
        hash ^= ((hash<<5)+(hash>>2)+ord(char))&0xFFFFFFFFFFFFFFFF

    return color(s, HASH_COLORS[hash%len(HASH_COLORS)])

def bold(s: str) -> str:
    return f"{consts.BOLD}{s}{consts.BOLD}"

def underline(s: str) -> str:
    return f"{consts.UNDERLINE}{s}{consts.UNDERLINE}"

FORMAT_TOKENS = [
    consts.BOLD,
    consts.RESET,
    consts.UNDERLINE
]
FORMAT_STRIP = [
    "\x08" # backspace
]

def _format_tokens(s: str) -> typing.List[str]:
    tokens: typing.List[str] = []

    s_copy = list(s)
    while s_copy:
        token = s_copy.pop(0)
        if token == "\x03":
            for i in range(2):
                if s_copy and s_copy[0].isdigit():
                    token += s_copy.pop(0)
            if (len(s_copy) > 1 and
                    s_copy[0] == "," and
                    s_copy[1].isdigit()):
                token += s_copy.pop(0)
                token += s_copy.pop(0)
                if s_copy and s_copy[0].isdigit():
                    token += s_copy.pop(0)

            tokens.append(token)
        elif (token in FORMAT_TOKENS or
                token in FORMAT_STRIP):
            tokens.append(token)
    return tokens

def _color_match(code: typing.Optional[str], foreground: bool) -> str:
    if not code:
        return ""
    color = consts.COLOR_CODES[int(code)]
    return color.to_ansi(not foreground)

def parse_format(s: str) -> str:
    has_foreground = False
    has_background = False
    bold = False
    underline = False

    for token in _format_tokens(s):
        replace = ""
        type = token[0]

        if type == consts.COLOR:
            match = REGEX_COLOR.match(token)

            if match and (match.group(1) or match.group(2)):
                foreground = _color_match(match.group(1), True)
                background = _color_match(match.group(2), False)

                if foreground:
                    replace += foreground
                    has_foreground = True
                if background:
                    replace += background
                    has_background = True
            else:
                if has_foreground:
                    has_foreground = False
                    replace += consts.ANSI_FOREGROUND_RESET
                if has_background:
                    has_background = False
                    replace += consts.ANSI_BACKGROUND_RESET
        elif type == consts.BOLD:
            if bold:
                replace += consts.ANSI_BOLD_RESET
            else:
                replace += consts.ANSI_BOLD
            bold = not bold
        elif type == consts.RESET:
            replace += consts.ANSI_RESET
        elif type == consts.UNDERLINE:
            if underline:
                replace += consts.ANSI_UNDERLINE_RESET
            else:
                replace += consts.ANSI_UNDERLINE
            underline = not underline
        elif type in FORMAT_STRIP:
            replace = ""

        s = s.replace(token, replace, 1)

    s += consts.ANSI_RESET
    return s

def strip_font(s: str) -> str:
    for token in _format_tokens(s):
        s = s.replace(token, "", 1)
    return s

OPT_STR = typing.Optional[str]
class IRCConnectionParameters(object):
    def __init__(self, id: int, alias: str, hostname: str, port: int,
            password: OPT_STR, tls: bool, bindhost: OPT_STR, nickname: str,
            username: OPT_STR, realname: OPT_STR,
            args: typing.Dict[str, str]={}):
        self.id = id
        self.alias = alias
        self.hostname = hostname
        self.port = port
        self.tls = tls
        self.bindhost = bindhost
        self.password = password
        self.nickname = nickname
        self.username = username
        self.realname = realname
        self.args = args

class CTCPMessage(object):
    def __init__(self, command: str, message: str):
        self.command = command
        self.message = message
def parse_ctcp(s: str) -> typing.Optional[CTCPMessage]:
    ctcp = s.startswith("\x01")
    if s.startswith("\x01"):
        ctcp_command, sep, ctcp_message = s[1:].partition(" ")
        if ctcp_command.endswith("\x01"):
            ctcp_command = ctcp_command[:-1]
        if ctcp_message.endswith("\x01"):
            ctcp_message = ctcp_message[:-1]
        return CTCPMessage(ctcp_command, ctcp_message)

    return None

class Capability(object):
    def __init__(self, ratified_name: typing.Optional[str],
            draft_name: str=None, alias: str=None,
            depends_on: typing.List[str]=None):
        self.alias = alias or ratified_name
        self._caps = set([ratified_name, draft_name])
        self.depends_on = depends_on or []
        self._on_ack_callbacks = [
            ] # type: typing.List[typing.Callable[[], None]]

    def available(self, capabilities: typing.Iterable[str]
            ) -> typing.Optional[str]:
        match = list(set(capabilities)&self._caps)
        return match[0] if match else None

    def match(self, capability: str) -> typing.Optional[str]:
        cap = list(set([capability])&self._caps)
        return cap[0] if cap else None

    def copy(self):
        return Capability(*self._caps, alias=self.alias,
            depends_on=self.depends_on[:])

    def on_ack(self, callback: typing.Callable[[], None]):
        self._on_ack_callbacks.append(callback)
    def ack(self):
        for callback in self._on_ack_callbacks:
            callback()
    def nak(self):
        pass

class MessageTag(object):
    def __init__(self, name: typing.Optional[str], draft_name: str=None):
        self._names = set([name, draft_name])
    def get_value(self, tags: typing.Dict[str, str]) -> typing.Optional[str]:
        key = list(set(tags.keys())&self._names)
        return tags[key[0]] if key else None
    def present(self, tags: typing.Dict[str, str]) -> bool:
        return bool(set(tags.keys())&self._names)
    def match(self, tag: str) -> typing.Optional[str]:
        key = list(set([tag])&self._names)
        return key[0] if key else None

class BatchType(object):
    def __init__(self, name: typing.Optional[str], draft_name: str=None):
        self._names = set([name, draft_name])
    def match(self, type: str) -> typing.Optional[str]:
        t = list(set([type])&self._names)
        return t[0] if t else None

@dataclasses.dataclass
class HostmaskPattern(object):
    original: str
    pattern: typing.Pattern

    def match(self, hostmask: str):
        return bool(self.pattern.fullmatch(hostmask))
def hostmask_parse(hostmask: str):
    part1_out = []
    for part1 in hostmask.split("?"):
        part2_out = []
        for part2 in part1.split("*"):
            part2_out.append(re.escape(part2))
        part1_out.append(".*".join(part2_out))
    return HostmaskPattern(hostmask, re.compile(".".join(part1_out)))

def hostmask_match_many(hostmasks: typing.List[str], pattern: HostmaskPattern,
        ) -> typing.Generator[str, None, None]:
    for hostmask in hostmasks:
        if pattern.match(hostmask):
            yield hostmask
    return None

def hostmask_match(hostmask: str, pattern: HostmaskPattern) -> bool:
    return any(hostmask_match_many([hostmask], pattern))