BadHtmlContext.cs

Go to the documentation of this file.

using System.Collections.Generic;
using System.Linq;
 
using BadScript2.Common;
using BadScript2.IO;
using BadScript2.Parser;
using BadScript2.Parser.Expressions;
using BadScript2.Reader;
using BadScript2.Runtime;
using BadScript2.Runtime.Error;
using BadScript2.Runtime.Objects;
 
using HtmlAgilityPack;
 
// ReSharper disable once InvalidXmlDocComment
namespace BadHtml;
 
public class BadHtmlContext
{
    public readonly BadExecutionContext ExecutionContext;
 
    public readonly string FilePath;
 
    public readonly HtmlNode InputNode;
 
    public readonly BadHtmlTemplateOptions Options;
 
    public readonly HtmlNode OutputNode;
 
    public readonly string Source;
 
    public BadHtmlContext(
        HtmlNode inputNode,
        HtmlNode outputNode,
        BadExecutionContext executionContext,
        string filePath,
        string source,
        BadHtmlTemplateOptions options,
        IFileSystem fileSystem)
    {
        InputNode = inputNode;
        OutputNode = outputNode;
        ExecutionContext = executionContext;
        FilePath = filePath;
        Source = source;
        Options = options;
        FileSystem = fileSystem;
    }
 
    public IFileSystem FileSystem { get; }
 
    public HtmlDocument InputDocument => InputNode.OwnerDocument;
 
    public HtmlDocument OutputDocument => OutputNode.OwnerDocument;
 
    public BadHtmlContext CreateChild(
        HtmlNode inputNode,
        HtmlNode outputNode,
        BadExecutionContext? executionContext = null)
    {
        return new BadHtmlContext(
            inputNode,
            outputNode,
            executionContext ?? ExecutionContext,
            FilePath,
            Source,
            Options,
            FileSystem
        );
    }
 
    public BadSourcePosition CreateAttributePosition(HtmlAttribute attribute)
    {
        return new BadSourcePosition(FilePath, Source, attribute.ValueStartIndex, attribute.Value.Length);
    }
 
    public BadSourcePosition CreateInnerPosition()
    {
        return new BadSourcePosition(FilePath, Source, InputNode.InnerStartIndex, InputNode.InnerLength);
    }
 
    public BadSourcePosition CreateOuterPosition()
    {
        return new BadSourcePosition(FilePath, Source, InputNode.InnerStartIndex, InputNode.InnerLength);
    }
 
    private static IEnumerable<BadExpression> VisitAll(IEnumerable<BadExpression> expressions)
    {
        return expressions.SelectMany(expression => expression.GetDescendantsAndSelf());
    }
 
    public BadExpression ParseSingle(string code, BadSourcePosition pos)
    {
        try
        {
            BadSourceParser parser = BadSourceParser.Create(FilePath, code);
            BadExpression expression = parser.ParseExpression();
 
            foreach (BadExpression expr in expression.GetDescendantsAndSelf())
            {
                BadSourcePosition newPosition = BadSourcePosition.Create(
                    FilePath,
                    Source,
                    pos.Index + expr.Position.Index,
                    expr.Position.Length
                );
                expr.SetPosition(newPosition);
            }
 
            return expression;
        }
        catch (BadSourceReaderException e)
        {
            if (e.Position == null)
            {
                throw new BadSourceReaderException(e.OriginalMessage, pos);
            }
 
            throw new BadSourceReaderException(
                e.OriginalMessage,
                BadSourcePosition.Create(FilePath, Source, e.Position.Index + pos.Index, e.Position.Length)
            );
        }
    }
 
    public BadExpression[] Parse(string code, BadSourcePosition pos)
    {
        try
        {
            BadExpression[] expressions = BadSourceParser.Parse(FilePath, code).ToArray();
 
            foreach (BadExpression expression in VisitAll(expressions))
            {
                BadSourcePosition newPosition = BadSourcePosition.Create(
                    FilePath,
                    Source,
                    pos.Index + expression.Position.Index,
                    expression.Position.Length
                );
                expression.SetPosition(newPosition);
            }
 
            return expressions;
        }
        catch (BadSourceReaderException e)
        {
            if (e.Position == null)
            {
                throw new BadSourceReaderException(e.OriginalMessage, pos);
            }
 
            throw new BadSourceReaderException(
                e.OriginalMessage,
                BadSourcePosition.Create(FilePath, Source, e.Position.Index + pos.Index, e.Position.Length)
            );
        }
    }
 
    public BadObject Execute(IEnumerable<BadExpression> expressions, BadSourcePosition position)
    {
        try
        {
            BadObject result = ExecutionContext.ExecuteScript(expressions);
 
            return result.Dereference();
        }
        catch (BadRuntimeException e)
        {
            throw new BadRuntimeException(e.Message, position);
        }
    }
 
    public BadObject Execute(BadExpression expression, BadSourcePosition position)
    {
        try
        {
            BadObject result = ExecutionContext.ExecuteScript(expression);
 
            // if (ExecutionContext.Scope.IsError)
            // {
            //     throw new BadRuntimeErrorException(ExecutionContext.Scope.Error);
            // }
 
            return result.Dereference();
        }
        catch (BadRuntimeException e)
        {
            throw new BadRuntimeException(e.Message, position);
        }
    }
 
    public BadObject ParseAndExecute(string code, BadSourcePosition pos)
    {
        BadExpression[] expressions = Parse(code, pos);
 
        return Execute(expressions, pos);
    }
 
    public BadObject ParseAndExecuteSingle(string code, BadSourcePosition pos)
    {
        BadExpression expression = ParseSingle(code, pos);
 
        return Execute(expression, pos);
    }
}