XPath.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using System.Xml;
using Waher.Script.Abstraction.Elements;
using Waher.Script.Exceptions;
using Waher.Script.Model;
using Waher.Script.Objects;
 
namespace Waher.Script.Persistence.Functions
{
    public class XPath : FunctionOneScalarVariable
    {
        private readonly string xpath;
        private bool extractValue;
 
        public XPath(ScriptNode XPath, int Start, int Length, Expression Expression)
            : base(XPath, Start, Length, Expression)
        {
            this.xpath = null;
            this.extractValue = false;
        }
 
        public XPath(string XPath, bool ExtractValue, int Start, int Length, Expression Expression)
            : base(new ConstantElement(new StringValue(XPath, false), Start, Length, Expression), Start, Length, Expression)
        {
            this.xpath = XPath;
            this.extractValue = ExtractValue;
        }
 
        public override string FunctionName => nameof(xpath);
 
        public string XPathExpression => this.xpath;
 
        public bool ExtractValue
        {
            get => this.extractValue;
            internal set => this.extractValue = value;
        }
 
        public override IElement Evaluate(Variables Variables)
        {
            if (string.IsNullOrEmpty(this.xpath))
                return base.Evaluate(Variables);
            else
                return this.EvaluateScalar(this.xpath, Variables);
        }
 
        public override Task<IElement> EvaluateAsync(Variables Variables)
        {
            return Task.FromResult<IElement>(this.Evaluate(Variables));
        }
 
        public override IElement EvaluateScalar(string Argument, Variables Variables)
        {
            if (!Variables.TryGetVariable("this", out Variable v))
                throw new ScriptRuntimeException("'this' variable not defined.", this);
 
            object Obj = v.ValueObject;
            XmlNodeList Result;
 
            if (Obj is null)
                return ObjectValue.Null;
            else if (Obj is XmlNode N)
            {
                XmlNamespaceManager NamespaceManager;
                XmlElement Root;
 
                if (Obj is XmlDocument Doc)
                {
                    NamespaceManager = new XmlNamespaceManager(Doc.NameTable);
                    Root = Doc.DocumentElement;
                }
                else if (N is XmlElement E && !(N.OwnerDocument is null))
                {
                    NamespaceManager = new XmlNamespaceManager(N.OwnerDocument.NameTable);
                    Root = E;
                }
                else
                {
                    NamespaceManager = null;
                    Root = null;
                }
 
                if (NamespaceManager is null)
                    Result = N.SelectNodes(Argument);
                else
                {
                    if (Argument.Contains("default:"))
                    {
                        string Namespace = null;
 
                        if (string.IsNullOrEmpty(Root.Prefix) && !string.IsNullOrEmpty(Root.NamespaceURI))
                            Namespace = Root.NamespaceURI;
                        else
                        {
                            LinkedList<XmlElement> ToProcess = new LinkedList<XmlElement>();
 
                            foreach (XmlNode N2 in Root.ChildNodes)
                            {
                                if (N2 is XmlElement E)
                                    ToProcess.AddLast(E);
                            }
 
                            while (!(ToProcess.First is null))
                            {
                                Root = ToProcess.First.Value;
                                ToProcess.RemoveFirst();
 
                                if (string.IsNullOrEmpty(Root.Prefix) && !string.IsNullOrEmpty(Root.NamespaceURI))
                                {
                                    Namespace = Root.NamespaceURI;
                                    break;
                                }
 
                                foreach (XmlNode N2 in Root.ChildNodes)
                                {
                                    if (N2 is XmlElement E)
                                        ToProcess.AddLast(E);
                                }
                            }
                        }
 
                        if (!string.IsNullOrEmpty(Namespace) && !NamespaceManager.HasNamespace(Namespace))
                            NamespaceManager.AddNamespace("default", Namespace);
                    }
 
                    Result = N.SelectNodes(Argument, NamespaceManager);
                }
            }
            else
                throw new ScriptRuntimeException("XPath expression only operate on XML.", this);
 
            int i, c = Result.Count;
 
            switch (c)
            {
                case 0:
                    return ObjectValue.Null;
 
                case 1:
                    return ToElement(Result[0], this.extractValue);
 
                default:
                    IElement[] Items = new IElement[c];
 
                    for (i = 0; i < c; i++)
                        Items[i] = ToElement(Result[i], this.extractValue);
 
                    return Operators.Vectors.VectorDefinition.Encapsulate(Items, false, this);
            }
        }
 
        public static IElement ToElement(XmlNode Node, bool ExtractValue)
        {
            if (Node is XmlText Text)
                return new StringValue(Text.Value);
            else if (Node is XmlCDataSection CData)
                return new StringValue(CData.Value);
            else if (Node is XmlAttribute Attr)
                return ToElement(Attr.Value);
            else
            {
                if (ExtractValue && Node.HasChildNodes && Node.FirstChild == Node.LastChild && Node.FirstChild is XmlText Text2)
                    return ToElement(Text2.Value);
                else
                    return new ObjectValue(Node);
            }
        }
 
        private static IElement ToElement(string s)
        {
            if (Expression.TryParse(s, out double d))
                return new DoubleNumber(d);
            else
                return new StringValue(s);
        }
 
    }
}