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(null);
        }
        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(null);
        }
        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);
    }
}