BadFunctionNodeTransformer.cs

Go to the documentation of this file.

using System.Collections.Generic;
using System.Linq;
 
using BadScript2.Parser.Expressions;
using BadScript2.Runtime;
using BadScript2.Runtime.Error;
using BadScript2.Runtime.Interop.Functions;
using BadScript2.Runtime.Objects;
using BadScript2.Runtime.Objects.Functions;
using BadScript2.Runtime.Objects.Types;
 
using HtmlAgilityPack;
 
namespace BadHtml.Transformer;
 
public class BadFunctionNodeTransformer : BadHtmlNodeTransformer
{
    protected override bool CanTransform(BadHtmlContext context)
    {
        return context.InputNode.Name == "bs:function";
    }
 
    private static bool IsOptional(string value)
    {
        return value.EndsWith("?") || value.EndsWith("?!");
    }
 
    private static bool IsNullChecked(string value)
    {
        return value.EndsWith("!") || value.EndsWith("!?");
    }
 
    private static bool IsRestArgs(string value)
    {
        return value.EndsWith("*");
    }
 
    private static BadExpression? GetParameterType(BadHtmlContext context, HtmlAttribute attribute)
    {
        string name = attribute.Value;
 
        while (name.EndsWith("*") || name.EndsWith("?") || name.EndsWith("!"))
        {
            name = name.Remove(name.Length - 1);
        }
 
        if (string.IsNullOrEmpty(name))
        {
            return null;
        }
 
        BadExpression[] expressions = context.Parse(name + ';', context.CreateAttributePosition(attribute));
 
        if (expressions.Length != 1)
        {
            throw BadRuntimeException.Create(
                context.ExecutionContext.Scope,
                $"Invalid parameter type expression for parameter {attribute.Name} in 'bs:function' node",
                context.CreateAttributePosition(attribute)
            );
        }
 
        return expressions[0];
    }
 
    protected override void TransformNode(BadHtmlContext context)
    {
        HtmlAttribute? nameAttribute = context.InputNode.Attributes["name"];
 
        if (nameAttribute == null)
        {
            throw BadRuntimeException.Create(
                context.ExecutionContext.Scope,
                "Missing 'name' attribute in 'bs:function' node",
                context.CreateOuterPosition()
            );
        }
 
        if (string.IsNullOrEmpty(nameAttribute.Value))
        {
            throw BadRuntimeException.Create(
                context.ExecutionContext.Scope,
                "Empty 'name' attribute in 'bs:function' node",
                context.CreateAttributePosition(nameAttribute)
            );
        }
 
        IEnumerable<HtmlAttribute> parameterAttributes =
            context.InputNode.Attributes.Where(x => x.Name.StartsWith("param:"));
 
        BadFunctionParameter[] parameters = parameterAttributes.Select(
                x => new BadFunctionParameter(
                    x.Name.Remove(0, "param:".Length),
                    IsOptional(x.Value),
                    IsNullChecked(x.Value),
                    IsRestArgs(x.Value),
                    GetParameterType(context, x)
                )
            )
            .ToArray();
 
        BadInteropFunction func = new BadInteropFunction(
            nameAttribute.Value,
            (ctx, args) => InvokeFunction(nameAttribute.Value, context, parameters, ctx, args),
            false,
            BadNativeClassBuilder.GetNative("string"),
            parameters
        );
        context.ExecutionContext.Scope.DefineVariable(
            nameAttribute.Value,
            func,
            context.ExecutionContext.Scope,
            new BadPropertyInfo(func.GetPrototype(), true)
        );
    }
 
    private BadObject InvokeFunction(
        string name,
        BadHtmlContext context,
        BadFunctionParameter[] parameters,
        BadExecutionContext caller,
        BadObject[] arguments)
    {
        using BadExecutionContext ctx = new BadExecutionContext(
            context.ExecutionContext.Scope.CreateChild(
                ToString(),
                caller.Scope,
                null,
                BadScopeFlags.Returnable | BadScopeFlags.AllowThrow | BadScopeFlags.CaptureThrow
            )
        );
 
        // ReSharper disable once UseObjectOrCollectionInitializer
        HtmlDocument outputDocument = new HtmlDocument();
        outputDocument.OptionUseIdAttribute = true;
        outputDocument.LoadHtml("");
        BadFunction.ApplyParameters(
            BadFunction.GetHeader(name, BadNativeClassBuilder.GetNative("string"), parameters),
            parameters,
            ctx,
            arguments,
            context.CreateOuterPosition()
        );
 
        foreach (HtmlNode? child in context.InputNode.ChildNodes)
        {
            BadHtmlContext childContext = new BadHtmlContext(
                child,
                outputDocument.DocumentNode,
                ctx,
                context.FilePath,
                context.Source,
                context.Options,
                context.FileSystem
            );
            Transform(childContext);
        }
 
        return outputDocument.DocumentNode.InnerHtml;
    }
}