Adding support for RoXMLElement

src/brsTypes/components/BrsObjects.ts

@@ -5,6 +5,7 @@ import { RoDateTime } from "./RoDateTime";
 import { Timespan } from "./Timespan";
 import { createNodeByType } from "./RoSGNode";
 import { RoRegex } from "./RoRegex";
+import { RoXMLElement } from "./RoXMLElement";
 import { BrsString, BrsBoolean } from "../BrsType";
 import { RoString } from "./RoString";
 import { roBoolean } from "./RoBoolean";
@@ -32,6 +33,7 @@ export const BrsObjects = new Map<string, Function>([
         "roregex",
         (_: Interpreter, expression: BrsString, flags: BrsString) => new RoRegex(expression, flags),
     ],
+    ["roxmlelement", (_: Interpreter) => new RoXMLElement()],
     ["rostring", (_: Interpreter) => new RoString()],
     ["roboolean", (_: Interpreter, literal: BrsBoolean) => new roBoolean(literal)],
     ["rodouble", (_: Interpreter, literal: Double) => new roDouble(literal)],

src/brsTypes/components/RoXMLElement.ts

@@ -0,0 +1,98 @@
+import { RoAssociativeArray } from "./RoAssociativeArray";
+import { RoArray } from "./RoArray";
+import { BrsComponent } from "./BrsComponent";
+import { BrsBoolean, BrsString, BrsValue, ValueKind } from "../BrsType";
+import { BrsType } from "..";
+import { Callable, StdlibArgument } from "../Callable";
+import { Interpreter } from "../../interpreter";
+import { XmlDocument, XmlElement } from "xmldoc";
+
+export class RoXMLElement extends BrsComponent implements BrsValue {
+    readonly kind = ValueKind.Object;
+    private xmlNode?: any;
+
+    constructor() {
+        super("roXMLElement");
+
+        this.registerMethods({
+            ifXMLEelement: [this.parse, this.getName, this.getNamedElementsCi, this.getAttributes],
+        });
+    }
+
+    public setXMLElem(xmlElem: XmlElement) {
+        this.xmlNode = xmlElem;
+        return this;
+    }
+
+    toString(parent?: BrsType) {
+        return "<Component: roXMLElement>";
+    }
+
+    equalTo(other: BrsType) {
+        return BrsBoolean.False;
+    }
+
+    private parse = new Callable("parse", {
+        signature: {
+            args: [new StdlibArgument("str", ValueKind.String)],
+            returns: ValueKind.Boolean,
+        },
+        impl: (interpreter: Interpreter, str: BrsString) => {
+            try {
+                this.xmlNode = new XmlDocument(str.value);
+                return BrsBoolean.from(true);
+            } catch (err) {
+                this.xmlNode = undefined;
+                return BrsBoolean.from(false);
+            }
+        },
+    });
+
+    private getName = new Callable("getName", {
+        signature: {
+            args: [],
+            returns: ValueKind.String,
+        },
+        impl: (interpreter: Interpreter, str: BrsString) => {
+            return new BrsString(this.xmlNode?.name ?? "");
+        },
+    });
+
+    private getNamedElementsCi = new Callable("getNamedElementsCi", {
+        signature: {
+            args: [new StdlibArgument("str", ValueKind.String)],
+            returns: ValueKind.Object,
+        },
+        impl: (interpreter: Interpreter, str: BrsString) => {
+            let neededKey = str.value.toLowerCase();
+            let arr = [];
+            for (let item of this.xmlNode?.children ?? []) {
+                if (item.name?.toLowerCase() === neededKey) {
+                    arr.push(new RoXMLElement().setXMLElem(item));
+                }
+            }
+            return new RoArray(arr);
+        },
+    });
+
+    private getAttributes = new Callable("getAttributes", {
+        signature: {
+            args: [],
+            returns: ValueKind.Object,
+        },
+        impl: (interpreter: Interpreter, str: BrsString) => {
+            return this.convertObjectToBrsAA(this.xmlNode?.attr ?? {});
+        },
+    });
+
+    private convertObjectToBrsAA(object_: any) {
+        let array = [];
+        for (let key in object_) {
+            array.push({
+                name: new BrsString(key),
+                value: new BrsString(object_[key]),
+            });
+        }
+        return new RoAssociativeArray(array);
+    }
+}

src/brsTypes/index.ts

@@ -40,6 +40,7 @@ export * from "./components/RoAssociativeArray";
 export * from "./components/Timespan";
 export * from "./components/BrsObjects";
 export * from "./components/RoRegex";
+export * from "./components/RoXMLElement";
 export * from "./components/RoString";
 export * from "./components/RoBoolean";
 export * from "./components/RoDouble";

test/brsTypes/components/RoXMLElement.test.js

@@ -0,0 +1,93 @@
+const brs = require("brs");
+const { BrsString, RoXMLElement } = brs.types;
+const { Interpreter } = require("../../../lib/interpreter");
+
+describe("RoXMLElement", () => {
+    let xmlParser;
+    let interpreter;
+
+    describe("test methods for object with successful parsing", () => {
+        beforeEach(() => {
+            xmlParser = new RoXMLElement();
+            interpreter = new Interpreter();
+            let parse = xmlParser.getMethod("parse");
+            parse.call(interpreter, new BrsString(getXmlString()));
+        });
+
+        it("getName", () => {
+            let getName = xmlParser.getMethod("getName");
+            expect(getName.call(interpreter)).toEqual(new BrsString("tag1"));
+        });
+
+        it("getNamedElementsCi", () => {
+            let getNamedElementsCi = xmlParser.getMethod("getNamedElementsCi");
+            expect(getNamedElementsCi.call(interpreter, new BrsString("any")).elements).toEqual([]);
+
+            let children = getNamedElementsCi.call(interpreter, new BrsString("CHiLd1"));
+            expect(children.elements).not.toEqual([]);
+            expect(children.elements.length).toEqual(2);
+
+            let getName = children.elements[0].getMethod("getName");
+            expect(getName.call(interpreter)).toEqual(new BrsString("Child1"));
+
+            getName = children.elements[1].getMethod("getName");
+            expect(getName.call(interpreter)).toEqual(new BrsString("CHILD1"));
+        });
+
+        it("getAttributes", () => {
+            let getAttributes = xmlParser.getMethod("getAttributes");
+            expect(getAttributes.call(interpreter).elements).not.toEqual(new Map());
+            expect(getAttributes.call(interpreter).elements).not.toEqual(
+                new Map([
+                    ["id", "someId"],
+                    ["someAtr", "0"],
+                ])
+            );
+        });
+    });
+
+    describe.each([
+        ["test methods for default object", () => {}],
+        [
+            "test methods for object with failed parsing",
+            () => {
+                let parse = xmlParser.getMethod("parse");
+                parse.call(interpreter, new BrsString('>bad_tag id="12" <  some text >/bad_tag<'));
+            },
+        ],
+    ])("%s", (name, tryParse) => {
+        xmlParser = new RoXMLElement();
+        interpreter = new Interpreter();
+        tryParse();
+
+        let getName = xmlParser.getMethod("getName");
+        expect(getName).toBeTruthy();
+        expect(getName.call(interpreter)).toEqual(new BrsString(""));
+
+        let getNamedElementsCi = xmlParser.getMethod("getNamedElementsCi");
+        expect(getNamedElementsCi).toBeTruthy();
+        expect(getNamedElementsCi.call(interpreter, new BrsString("any")).elements).toEqual([]);
+
+        let getAttributes = xmlParser.getMethod("getAttributes");
+        expect(getAttributes).toBeTruthy();
+        expect(getAttributes.call(interpreter).elements).toEqual(new Map());
+    });
+
+    describe.each([
+        ["<tag>some text<tag>", true],
+        ["<tag>some text <child1> child's text </child1> </tag>", true],
+        [getXmlString(), true],
+        ['>bad_tag id="12" <  some text >/bad_tag<', false],
+        ["", false],
+    ])("test parse with string %s", (xmlString, expected) => {
+        xmlParser = new RoXMLElement();
+        interpreter = new Interpreter();
+
+        let parse = xmlParser.getMethod("parse");
+        expect(parse.call(interpreter, new BrsString(xmlString)).value).toBe(expected);
+    });
+});
+
+function getXmlString() {
+    return '<tag1 id="someId" someAtr="0"> <Child1 id="id1"></Child1> <CHILD1 id="id2"></CHILD1> </tag1>';
+}