feat(common): add utility functions for xmlns attributes

packages/ast/lib/build-ast.js

@@ -10,7 +10,11 @@ const {
   isArray,
   assign
 } = require("lodash");
-const { findNextTextualToken } = require("@xml-tools/common");
+const {
+  findNextTextualToken,
+  isXMLNamespaceKey,
+  getXMLNamespaceKeyPrefix
+} = require("@xml-tools/common");
 
 const { getAstChildrenReflective } = require("./utils");
 const { DEFAULT_NS } = require("./constants");
@@ -256,13 +260,12 @@ function updateNamespaces(element, prevNamespaces = []) {
     (result, attrib) => {
       /* istanbul ignore else - Defensive Coding, not actually possible branch */
       if (attrib.key !== invalidSyntax) {
-        const nsMatch = /^xmlns(?::([^:]+))?$/.exec(attrib.key);
-        if (nsMatch !== null) {
-          const prefix = nsMatch[1];
+        if (isXMLNamespaceKey(attrib.key, false) === true) {
+          const prefix = getXMLNamespaceKeyPrefix(attrib.key);
           // TODO: Support un-defining namespaces (including the default one)
           if (attrib.value) {
             const uri = attrib.value;
-            if (prefix !== undefined) {
+            if (prefix !== "") {
               result[prefix] = uri;
             } else {
               // default namespace

packages/common/api.d.ts

@@ -10,3 +10,20 @@ export function findNextTextualToken(
   tokenVector: IToken[],
   prevTokEndOffset: number
 ): IToken | null;
+
+/**
+ * Check if an xml attribute key is an xmlns key.
+ * @param key - the attribute key
+ * @param includeEmptyPrefix - should true be returned when there is no prefix (key === "xmlns:")
+ */
+export function isXMLNamespaceKey(
+  key: string,
+  includeEmptyPrefix: boolean
+): boolean;
+
+/**
+ * Get the attribute name, without its "xmlns:" prefix, from an xmlns attribute key.
+ * If the attribute key is not an xmlns key, undefined is returned.
+ * @param key - the attribute key
+ */
+export function getXMLNamespaceKeyPrefix(key: string): string | undefined;

packages/common/lib/api.js

@@ -1,5 +1,11 @@
 const { findNextTextualToken } = require("./find-next-textual-token");
+const {
+  isXMLNamespaceKey,
+  getXMLNamespaceKeyPrefix
+} = require("./xml-ns-key.js");
 
 module.exports = {
-  findNextTextualToken: findNextTextualToken
+  findNextTextualToken: findNextTextualToken,
+  isXMLNamespaceKey: isXMLNamespaceKey,
+  getXMLNamespaceKeyPrefix: getXMLNamespaceKeyPrefix
 };

packages/common/lib/xml-ns-key.js

@@ -0,0 +1,38 @@
+// The xml parser takes care of validating the attribute name.
+// If the user started the attribute name with "xmlns:" we can assume that
+// they meant for it to be an xml namespace attribute.
+// xmlns attributes explicitly can't contain ":" after the "xmlns:" part.
+const namespaceRegex = /^xmlns(?<prefixWithColon>:(?<prefix>[^:]*))?$/;
+
+function isXMLNamespaceKey(key, includeEmptyPrefix) {
+  if (typeof key !== "string") {
+    return false;
+  }
+  const matchArr = key.match(namespaceRegex);
+  if (matchArr === null) {
+    return false;
+  }
+  if (includeEmptyPrefix === true) {
+    return true;
+  }
+  /* istanbul ignore next - defensive coding */
+  const groups = matchArr.groups || {};
+  // In the case where key === "xmlns:", prefix will be empty and prefixWithColon will not be empty
+  return !(groups.prefixWithColon && !groups.prefix);
+}
+
+function getXMLNamespaceKeyPrefix(key) {
+  if (typeof key !== "string") {
+    return undefined;
+  }
+  const matchArr = key.match(namespaceRegex);
+  if (matchArr === null) {
+    return undefined;
+  }
+  return (matchArr.groups && matchArr.groups.prefix) || "";
+}
+
+module.exports = {
+  isXMLNamespaceKey: isXMLNamespaceKey,
+  getXMLNamespaceKeyPrefix: getXMLNamespaceKeyPrefix
+};

packages/common/test/xml-ns-key-spec.js

@@ -0,0 +1,84 @@
+const { expect } = require("chai");
+const { isXMLNamespaceKey, getXMLNamespaceKeyPrefix } = require("../");
+
+describe("The XML-Tools Common Utils", () => {
+  context("isXMLNamespaceKey", () => {
+    it("will return true for attribute name starting with xmlns:", () => {
+      expect(isXMLNamespaceKey("xmlns:a", true)).to.be.true;
+      expect(isXMLNamespaceKey("xmlns:a", false)).to.be.true;
+    });
+
+    it("will return true for attribute name starting with xmlns: that contains dots", () => {
+      expect(isXMLNamespaceKey("xmlns:a.b.c", true)).to.be.true;
+      expect(isXMLNamespaceKey("xmlns:a.b.c", false)).to.be.true;
+    });
+
+    it("will return true for the default namespace attribute", () => {
+      expect(isXMLNamespaceKey("xmlns", true)).to.be.true;
+      expect(isXMLNamespaceKey("xmlns", false)).to.be.true;
+    });
+
+    it("will return true for xmlns attribute without a name when includeEmptyPrefix is true", () => {
+      expect(isXMLNamespaceKey("xmlns:", true)).to.be.true;
+    });
+
+    it("will return false for xmlns attribute without a name when includeEmptyPrefix is false", () => {
+      expect(isXMLNamespaceKey("xmlns:", false)).to.be.false;
+    });
+
+    it("will return false for the non-xmlns attribute", () => {
+      expect(isXMLNamespaceKey("abc", true)).to.be.false;
+      expect(isXMLNamespaceKey("abc", false)).to.be.false;
+    });
+
+    it("will return false for non-xmlns attribute that starts with xmlns", () => {
+      expect(isXMLNamespaceKey("xmlnst", true)).to.be.false;
+      expect(isXMLNamespaceKey("xmlnst", false)).to.be.false;
+    });
+
+    it("will return false for attribute name starting with xmlns: that contains additional colons", () => {
+      expect(isXMLNamespaceKey("xmlns:a.b:c", true)).to.be.false;
+      expect(isXMLNamespaceKey("xmlns:a.b:c", false)).to.be.false;
+    });
+
+    it("will return false for undefined", () => {
+      expect(isXMLNamespaceKey(undefined, true)).to.be.false;
+      expect(isXMLNamespaceKey(undefined, false)).to.be.false;
+    });
+
+    it("will return false for null", () => {
+      expect(isXMLNamespaceKey(null, true)).to.be.false;
+      expect(isXMLNamespaceKey(null, false)).to.be.false;
+    });
+  });
+
+  context("getNamespaceKeyPrefix", () => {
+    it("will return the name without xmlns prefix for xmlns attribute with name", () => {
+      expect(getXMLNamespaceKeyPrefix("xmlns:abc")).to.eql("abc");
+    });
+
+    it("will return the name without xmlns prefix for xmlns attribute with name that contains dots", () => {
+      expect(getXMLNamespaceKeyPrefix("xmlns:abc.efg")).to.eql("abc.efg");
+    });
+
+    it("will return empty string when prefix is empty", () => {
+      expect(getXMLNamespaceKeyPrefix("xmlns:")).to.be.empty;
+    });
+
+    it("will return undefined when key does not start with xmlns", () => {
+      expect(getXMLNamespaceKeyPrefix("abc")).to.be.undefined;
+    });
+
+    it("will return undefined when key starts with xmlns but is not an xmlns key", () => {
+      expect(getXMLNamespaceKeyPrefix("xmlns*")).to.be.undefined;
+    });
+
+    it("will return undefined for undefined", () => {
+      expect(getXMLNamespaceKeyPrefix(undefined)).to.be.undefined;
+    });
+
+    it("will return undefined for null", () => {
+      expect(getXMLNamespaceKeyPrefix(null)).to.be.undefined;
+    });
+  });
+});

packages/simple-schema/lib/validators/unknown-attributes.js

@@ -1,7 +1,7 @@
 const { map, includes, forEach } = require("lodash");
+const { isXMLNamespaceKey } = require("@xml-tools/common");
 const { tokenToOffsetPosition } = require("./utils");
 
-const NAMESPACE_ATTRRIBUTE_PATTERN = /^xmlns(:[^=]*)?$/;
 /**
  * @param {XMLElement} elem
  * @param {XSSElement} schema
@@ -23,7 +23,7 @@ function validateUnknownAttributes(elem, schema) {
     if (attrib.key !== null) {
       if (
         includes(allowedAttribNames, attrib.key) === false &&
-        NAMESPACE_ATTRRIBUTE_PATTERN.test(attrib.key) === false
+        isXMLNamespaceKey(attrib.key, true) === false
       ) {
         issues.push({
           msg: `Unknown Attribute: <${