path: root/muppet/puppet/format/html.py

"""
Reserilaize AST as HTML.

This is mostly an extension of the text formatter, but with some HTML
tags inserted. This is also why the text module is imported.

.. code-block:: html

    <span class="{TYPE}">{BODY}</span>
"""

import re
import logging
from .base import Serializer
from muppet.puppet.ast import (
    PuppetLiteral, PuppetAccess, PuppetBinaryOperator,
    PuppetUnaryOperator, PuppetArray, PuppetCallMethod,
    PuppetCase, PuppetDeclarationParameter,
    PuppetInstanciationParameter, PuppetClass, PuppetConcat,
    PuppetCollect, PuppetIf, PuppetUnless, PuppetKeyword,
    PuppetExportedQuery, PuppetVirtualQuery, PuppetFunction,
    PuppetHash, PuppetHeredoc, PuppetLiteralHeredoc, PuppetVar,
    PuppetLambda,  PuppetQn, PuppetQr, PuppetRegex,
    PuppetResource, PuppetDefine, PuppetString,
    PuppetNumber, PuppetInvoke, PuppetResourceDefaults,
    PuppetResourceOverride, PuppetDeclaration, PuppetSelector,
    PuppetBlock, PuppetNode,
    PuppetCall, PuppetParenthesis, PuppetNop,

    HashEntry,
    # PuppetParseError,
)
import html
from .text import (
    override,
    find_heredoc_delimiter,
    ind,
    string_width,
)


logger = logging.getLogger(__name__)


def span(cls: str, content: str) -> str:
    """Wrap content in a span, and escape content."""
    return f'<span class="{cls}">{html.escape(content)}</span>'


def literal(x: str) -> str:
    """Tag string as a literal."""
    return span("literal", x)


def op(x: str) -> str:
    """Tag string as an operator."""
    return span("op", x)


def keyword(x: str) -> str:
    """Tag string as a keyword."""
    return span("keyword", x)


def var(x: str) -> str:
    """Tag string as a variable."""
    return span("var", x)


def string(x: str) -> str:
    """Tag strings as a string literal."""
    return span("string", x)


def number(x: str) -> str:
    """Tag string as a number literal."""
    return span("number", x)


class HTMLFormatter(Serializer[str]):
    """AST formatter returning source code."""

    @classmethod
    def format_declaration_parameter(
            cls,
            param: PuppetDeclarationParameter,
            indent: int) -> str:
        """Format a single declaration parameter."""
        out: str = ''
        if param.type:
            out += f'{cls.serialize(param.type, indent + 1)} '
        out += var(f'${param.k}')
        if param.v:
            out += f' = {cls.serialize(param.v, indent + 1)}'
        return out

    @classmethod
    def format_declaration_parameters(
            cls,
            lst: list[PuppetDeclarationParameter],
            indent: int) -> str:
        """
        Print declaration parameters.

        This formats the parameters for class, resoruce, and function declarations.
        """
        if not lst:
            return ''

        out = ' (\n'
        for param in lst:
            out += ind(indent + 1) + cls.format_declaration_parameter(param, indent + 1) + ',\n'
        out += ind(indent) + ')'
        return out

    @classmethod
    def serialize_hash_entry(
            cls,
            entry: HashEntry,
            indent: int) -> str:
        """Return a hash entry as a string."""
        return f'{cls.serialize(entry.k, indent + 1)} => {cls.serialize(entry.v, indent + 2)}'

    @override
    @classmethod
    def _puppet_literal(cls, it: PuppetLiteral, indent: int) -> str:
        return literal(it.literal)

    @override
    @classmethod
    def _puppet_access(cls, it: PuppetAccess, indent: int) -> str:
        args = ', '.join(cls.serialize(x, indent) for x in it.args)

        return f'{cls.serialize(it.how, indent)}[{args}]'

    @override
    @classmethod
    def _puppet_binary_operator(cls, it: PuppetBinaryOperator, indent: int) -> str:
        out = cls.serialize(it.lhs, indent)
        out += f' {op(it.op)} '
        out += cls.serialize(it.rhs, indent)
        return out

    @override
    @classmethod
    def _puppet_unary_operator(cls, it: PuppetUnaryOperator, indent: int) -> str:
        return f'{op(it.op)} {cls.serialize(it.x, indent)}'

    @override
    @classmethod
    def _puppet_array(cls, it: PuppetArray, indent: int) -> str:
        if not it.items:
            return '[]'
        else:
            out = '[\n'
            for item in it.items:
                out += ind(indent + 1) + cls.serialize(item, indent + 2) + ',\n'
            out += ind(indent) + ']'
            return out

    @override
    @classmethod
    def _puppet_call(cls, it: PuppetCall, indent: int) -> str:
        args = ', '.join(cls.serialize(x, indent) for x in it.args)
        return f'{cls.serialize(it.func, indent)}({args})'

    @override
    @classmethod
    def _puppet_call_method(cls, it: PuppetCallMethod, indent: int) -> str:
        out: str = cls.serialize(it.func, indent)

        if it.args:
            args = ', '.join(cls.serialize(x, indent) for x in it.args)
            out += f' ({args})'

        if it.block:
            out += cls.serialize(it.block, indent)

        return out

    @override
    @classmethod
    def _puppet_case(cls, it: PuppetCase, indent: int) -> str:
        out: str = f'{keyword("case")} {cls.serialize(it.test, indent)} {{\n'
        for (when, body) in it.cases:
            out += ind(indent + 1)
            out += ', '.join(cls.serialize(x, indent + 1) for x in when)
            out += ': {\n'
            for item in body:
                out += ind(indent + 2) + cls.serialize(item, indent + 2) + '\n'
            out += ind(indent + 1) + '}\n'
        out += ind(indent) + '}'
        return out

    @override
    @classmethod
    def _puppet_declaration_parameter(cls, it: PuppetDeclarationParameter, indent: int) -> str:
        out: str = ''
        if it.type:
            out += f'{cls.serialize(it.type, indent + 1)} '
        out += var(f'${it.k}')
        if it.v:
            out += f' = {cls.serialize(it.v, indent + 1)}'
        return out

    @override
    @classmethod
    def _puppet_instanciation_parameter(cls, it: PuppetInstanciationParameter, indent: int) -> str:
        return f'{it.k} {it.arrow} {cls.serialize(it.v, indent)}'

    @override
    @classmethod
    def _puppet_class(cls, it: PuppetClass, indent: int) -> str:
        out: str = f'{keyword("class")} {it.name}'
        if it.params:
            out += cls.format_declaration_parameters(it.params, indent)

        out += ' {\n'
        for form in it.body:
            out += ind(indent+1) + cls.serialize(form, indent+1) + '\n'
        out += ind(indent) + '}'
        return out

    @override
    @classmethod
    def _puppet_concat(cls, it: PuppetConcat, indent: int) -> str:
        out = '"'
        for item in it.fragments:
            match item:
                case PuppetString(s):
                    out += s
                case PuppetVar(x):
                    out += var(f"${{{x}}}")
                case puppet:
                    out += f"${{{cls.serialize(puppet, indent)}}}"
        out += '"'
        # Don't escape `out`, since it contains sub-expressions
        return f'<span class="string">{out}</span>'

    @override
    @classmethod
    def _puppet_collect(cls, it: PuppetCollect, indent: int) -> str:
        return f'{cls.serialize(it.type, indent)} {cls.serialize(it.query, indent + 1)}'

    @override
    @classmethod
    def _puppet_if(cls, it: PuppetIf, indent: int) -> str:
        out: str = f'{keyword("if")} {cls.serialize(it.condition, indent)} {{\n'
        for item in it.consequent:
            out += ind(indent+1) + cls.serialize(item, indent+1) + '\n'
        out += ind(indent) + '}'
        if alts := it.alternative:
            # TODO elsif
            out += f' {keyword("else")} {{\n'
            for item in alts:
                out += ind(indent+1) + cls.serialize(item, indent+1) + '\n'
            out += ind(indent) + '}'
        return out

    @override
    @classmethod
    def _puppet_unless(cls, it: PuppetUnless, indent: int) -> str:
        out: str = f'{keyword("unless")} {cls.serialize(it.condition, indent)} {{\n'
        for item in it.consequent:
            out += ind(indent+1) + cls.serialize(item, indent+1) + '\n'
        out += ind(indent) + '}'
        return out

    @override
    @classmethod
    def _puppet_keyword(cls, it: PuppetKeyword, indent: int) -> str:
        return it.name

    @override
    @classmethod
    def _puppet_exported_query(cls, it: PuppetExportedQuery, indent: int) -> str:
        out: str = op('<<|')
        if f := it.filter:
            out += ' ' + cls.serialize(f, indent)
        out += ' ' + op('|>>')
        return out

    @override
    @classmethod
    def _puppet_virtual_query(cls, it: PuppetVirtualQuery, indent: int) -> str:
        out: str = op('<|')
        if f := it.q:
            out += ' ' + cls.serialize(f, indent)
        out += ' ' + op('|>')
        return out

    @override
    @classmethod
    def _puppet_function(cls, it: PuppetFunction, indent: int) -> str:
        out: str = f'{keyword("function")} {it.name}'
        if it.params:
            out += cls.format_declaration_parameters(it.params, indent)

        if ret := it.returns:
            out += f' {op(">>")} {cls.serialize(ret, indent + 1)}'

        out += ' {\n'
        for item in it.body:
            out += ind(indent + 1) + cls.serialize(item, indent + 1) + '\n'
        out += ind(indent) + '}'

        return out

    @override
    @classmethod
    def _puppet_hash(cls, it: PuppetHash, indent: int) -> str:
        if not it.entries:
            return '{}'
        else:
            out: str = '{\n'
            for item in it.entries:
                out += ind(indent + 1)
                out += cls.serialize_hash_entry(item, indent + 1)
                out += ',\n'
            out += ind(indent) + '}'
            return out

    @override
    @classmethod
    def _puppet_heredoc(cls, it: PuppetHeredoc, indent: int) -> str:
        """
        Serialize heredoc with interpolation.

        The esacpes $, r, and t are always added and un-escaped,
        while the rest are left as is, since they work fine in the literal.
        """
        syntax: str = ''
        if it.syntax:
            syntax = f':{it.syntax}'

        # TODO find delimiter
        body = ''
        for frag in it.fragments:
            match frag:
                case PuppetString(s):
                    # \r, \t, \, $
                    e = re.sub('[\r\t\\\\$]', lambda m: {
                        '\r': r'\r',
                        '\t': r'\t',
                        }.get(m[0], '\\' + m[0]), s)
                    body += e
                case PuppetVar(x):
                    body += f'${{{x}}}'
                case p:
                    body += cls.serialize(p, indent + 2)

        # Check if string ends with a newline
        match it.fragments[-1]:
            case PuppetString(s) if s.endswith('\n'):
                eol_marker = ''
                body = body[:-1]
            case _:
                eol_marker = '-'

        # Aligning this to the left column is ugly, but saves us from
        # parsing newlines in the actual string
        return f'@("EOF"{syntax}/$rt)\n{body}\n|{eol_marker} EOF'

    @override
    @classmethod
    def _puppet_literal_heredoc(cls, it: PuppetLiteralHeredoc, indent: int) -> str:
        syntax: str = ''
        if it.syntax:
            syntax = f':{it.syntax}'

        out: str = ''
        if not it.content:
            out += f'@(EOF{syntax})\n'
            out += ind(indent) + '|- EOF'
            return out

        delimiter = find_heredoc_delimiter(it.content)

        out += f'@({delimiter}{syntax})\n'

        lines = it.content.split('\n')
        eol: bool = False
        if lines[-1] == '':
            lines = lines[:-1]  # Remove last
            eol = True

        for line in lines:
            out += ind(indent + 1) + line + '\n'

        out += ind(indent + 1) + '|'

        if not eol:
            out += '-'

        out += ' ' + delimiter

        return out

    @override
    @classmethod
    def _puppet_var(cls, it: PuppetVar, indent: int) -> str:
        return var(f'${it.name}')

    @override
    @classmethod
    def _puppet_lambda(cls, it: PuppetLambda, indent: int) -> str:
        out: str = '|'
        for item in it.params:
            out += 'TODO'
        out += '| {'
        for form in it.body:
            out += ind(indent + 1) + cls.serialize(form, indent + 1)
        out += ind(indent) + '}'
        return out

    @override
    @classmethod
    def _puppet_qn(cls, it: PuppetQn, indent: int) -> str:
        return span('qn', it.name)

    @override
    @classmethod
    def _puppet_qr(cls, it: PuppetQr, indent: int) -> str:
        return span('qn', it.name)

    @override
    @classmethod
    def _puppet_regex(cls, it: PuppetRegex, indent: int) -> str:
        return span('regex', f'/{it.s}/')

    @override
    @classmethod
    def _puppet_resource(cls, it: PuppetResource, indent: int) -> str:
        out = f'{cls.serialize(it.type, indent + 1)} {{'
        match it.bodies:
            case [(name, values)]:
                out += f' {cls.serialize(name, indent + 1)}:\n'
                for v in values:
                    out += ind(indent + 1) + cls.serialize(v, indent + 2) + ',\n'
            case bodies:
                out += '\n'
                for (name, values) in bodies:
                    out += f'{ind(indent + 1)}{cls.serialize(name, indent + 1)}:\n'
                    for v in values:
                        out += ind(indent + 2) + cls.serialize(v, indent + 3) + ',\n'
                    out += ind(indent + 2) + ';\n'
        out += ind(indent) + '}'
        return out

    @override
    @classmethod
    def _puppet_define(cls, it: PuppetDefine, indent: int) -> str:
        out: str = f'{keyword("define")} {it.name}'
        if params := it.params:
            out += cls.format_declaration_parameters(params, indent)

        out += ' {\n'
        for form in it.body:
            out += ind(indent + 1) + cls.serialize(form, indent + 1) + '\n'
        out += ind(indent) + '}'
        return out

    @override
    @classmethod
    def _puppet_string(cls, it: PuppetString, indent: int) -> str:
        # TODO escaping
        return string(f"'{it.s}'")

    @override
    @classmethod
    def _puppet_number(cls, it: PuppetNumber, indent: int) -> str:
        return number(str(it.x))

    @override
    @classmethod
    def _puppet_invoke(cls, it: PuppetInvoke, indent: int) -> str:
        invoker = f'{cls.serialize(it.func, indent)}'
        out: str = invoker
        template: str
        if invoker == keyword('include'):
            template = ' {}'
        else:
            template = '({})'
        out += template.format(', '.join(cls.serialize(x, indent + 1) for x in it.args))
        return out

    @override
    @classmethod
    def _puppet_resource_defaults(cls, it: PuppetResourceDefaults, indent: int) -> str:
        out: str = f'{cls.serialize(it.type, indent)} {{\n'
        for op in it.ops:
            out += ind(indent + 1) + cls.serialize(op, indent + 1) + ',\n'
        out += ind(indent) + '}'
        return out

    @override
    @classmethod
    def _puppet_resource_override(cls, it: PuppetResourceOverride, indent: int) -> str:
        out: str = f'{cls.serialize(it.resource, indent)} {{\n'
        for op in it.ops:
            out += ind(indent + 1) + cls.serialize(op, indent + 1) + ',\n'
        out += ind(indent) + '}'
        return out

    @override
    @classmethod
    def _puppet_declaration(cls, it: PuppetDeclaration, indent: int) -> str:
        return f'{cls.serialize(it.k, indent)} = {cls.serialize(it.v, indent)}'

    @override
    @classmethod
    def _puppet_selector(cls, it: PuppetSelector, indent: int) -> str:
        out: str = f'{cls.serialize(it.resource, indent)} ? {{\n'
        rendered_cases = [(cls.serialize(test, indent + 1),
                           cls.serialize(body, indent + 2))
                          for (test, body) in it.cases]
        case_width = max(string_width(c[0], indent + 1) for c in rendered_cases)
        for (test, body) in rendered_cases:
            out += ind(indent + 1) + test
            out += ' ' * (case_width - string_width(test, indent + 1))
            out += f' => {body},\n'
        out += ind(indent) + '}'
        return out

    @override
    @classmethod
    def _puppet_block(cls, it: PuppetBlock, indent: int) -> str:
        return '\n'.join(cls.serialize(x, indent) for x in it.entries)

    @override
    @classmethod
    def _puppet_node(cls, it: PuppetNode, indent: int) -> str:
        out: str = keyword('node') + ' '
        out += ', '.join(cls.serialize(x, indent) for x in it.matches)
        out += ' {\n'
        for item in it.body:
            out += ind(indent + 1) + cls.serialize(item, indent + 1) + '\n'
        out += ind(indent) + '}'
        return out

    @override
    @classmethod
    def _puppet_parenthesis(cls, it: PuppetParenthesis, indent: int) -> str:
        return f'({cls.serialize(it.form, indent)})'

    @override
    @classmethod
    def _puppet_nop(cls, it: PuppetNop, indent: int) -> str:
        return ''