feat: add validation for unknown namespace name in xmlns attribute value (#103)

Author: tal-sapan

packages/language-server/src/xml-view-diagnostics.ts

@@ -49,6 +49,7 @@ function validationIssuesToLspDiagnostics(
     const issueKind = currIssue.kind;
     switch (issueKind) {
       case "UnknownEnumValue":
+      case "UnknownNamespaceInXmlnsAttributeValue":
         return {
           ...commonDiagnosticPros,
         };

packages/language-server/test/snapshots/xml-view-diagnostics/unknown-xmlns-namespace/input.xml

@@ -0,0 +1,5 @@
+<mvc:View
+        xmlns:mvc="sap.ui.core.mvc"
+        xmlns=🢂"sap.m.abcde"🢀>
+    </List>
+</mvc:View>

packages/language-server/test/snapshots/xml-view-diagnostics/unknown-xmlns-namespace/output-lsp-response.json

@@ -0,0 +1,11 @@
+[
+  {
+    "range": {
+      "start": { "line": 2, "character": 14 },
+      "end": { "line": 2, "character": 27 }
+    },
+    "severity": 2,
+    "source": "UI5 Language Assistant",
+    "message": "Unknown namespace: \"sap.m.abcde\""
+  }
+]

packages/logic-utils/api.d.ts

@@ -83,3 +83,15 @@ export function getRootSymbolParent(node: BaseUI5Node): BaseUI5Node | undefined;
  * Return a human-readable string representation of a UI5 type
  */
 export function typeToString(type: UI5Type | undefined): string;
+
+/**
+ * Check if an xml attribute key is an xmlns key
+ * @param key
+ */
+export function isXMLNamespaceKey(key: string): boolean;
+
+/**
+ * Get the attribute name, without its "xmlns:" prefix, from an xmlns attribute key
+ * @param key
+ */
+export function getXMLNamespaceKeyPrefix(key: string): string;

packages/logic-utils/src/api.ts

@@ -11,3 +11,7 @@ export {
 export { findClassesMatchingType } from "./utils/find-classes-matching-type";
 export { isRootSymbol, getRootSymbolParent } from "./utils/root-symbols";
 export { typeToString } from "./utils/type-to-string";
+export {
+  getXMLNamespaceKeyPrefix,
+  isXMLNamespaceKey,
+} from "./utils/xml-ns-key";

packages/logic-utils/src/utils/xml-ns-key.ts

@@ -0,0 +1,14 @@
+// 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(:(?<prefix>[^:=]*))?$/;
+
+export function isXMLNamespaceKey(key: string): boolean {
+  return key.match(namespaceRegex) !== null;
+}
+
+export function getXMLNamespaceKeyPrefix(key: string): string {
+  const matchArr = key.match(namespaceRegex);
+  return matchArr?.groups?.prefix ?? "";
+}

packages/logic-utils/test/utils/xml-ns-key-spec.ts

@@ -0,0 +1,51 @@
+import { expect } from "chai";
+import { isXMLNamespaceKey, getXMLNamespaceKeyPrefix } from "../../src/api";
+
+describe("The @ui5-language-assistant/logic-utils <isXMLNamespaceKey> function", () => {
+  it("will return true for attribute name starting with xmlns:", () => {
+    expect(isXMLNamespaceKey("xmlns:a")).to.be.true;
+  });
+
+  it("will return true for attribute name starting with xmlns: that contains dots", () => {
+    expect(isXMLNamespaceKey("xmlns:a.b.c")).to.be.true;
+  });
+
+  it("will return true for the default namespace attribute", () => {
+    expect(isXMLNamespaceKey("xmlns")).to.be.true;
+  });
+
+  it("will return true for xmlns attribute without a name", () => {
+    // Note: this is supported for the case of code completion
+    expect(isXMLNamespaceKey("xmlns:")).to.be.true;
+  });
+
+  it("will return false for the non-xmlns attribute", () => {
+    expect(isXMLNamespaceKey("abc")).to.be.false;
+  });
+
+  it("will return false for the non-xmlns attribute that starts with xmlns", () => {
+    expect(isXMLNamespaceKey("xmlnst")).to.be.false;
+  });
+});
+
+describe("The @ui5-language-assistant/logic-utils <getNamespaceKeyPrefix> function", () => {
+  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 key does not start with xmlns", () => {
+    expect(getXMLNamespaceKeyPrefix("abc")).to.be.empty;
+  });
+
+  it("will return empty string when symbol '*' goes after xmlns", () => {
+    expect(getXMLNamespaceKeyPrefix("xmlns*")).to.be.empty;
+  });
+
+  it("will return empty string when prefix is undefined", () => {
+    expect(getXMLNamespaceKeyPrefix("xmlns:")).to.be.empty;
+  });
+});

packages/semantic-model-types/api.d.ts

@@ -1,5 +1,6 @@
 export interface UI5SemanticModel {
   version?: string;
+  includedLibraries: string[];
   classes: Record<string, UI5Class>;
   enums: Record<string, UI5Enum>;
   namespaces: Record<string, UI5Namespace>;

packages/semantic-model/api.d.ts

@@ -32,3 +32,13 @@ export function forEachSymbol(
   model: UI5SemanticModel,
   iteratee: (symbol: BaseUI5Node, fqn: string) => boolean | void
 ): void;
+
+/**
+ * Return a root symbol according to its fully qualified name, or undefined if not found
+ * @param model
+ * @param fqn
+ */
+export function findSymbol(
+  model: UI5SemanticModel,
+  fqn: string
+): BaseUI5Node | undefined;

packages/semantic-model/src/api.ts

@@ -38,4 +38,4 @@ export function generate({
   return deepFreezeStrict(model);
 }
 
-export { forEachSymbol } from "./utils";
+export { forEachSymbol, findSymbol } from "./utils";

packages/semantic-model/src/convert.ts

@@ -23,6 +23,7 @@ export function convertToSemanticModel(
 ): model.UI5SemanticModel {
   const model: model.UI5SemanticModel = {
     version: "",
+    includedLibraries: [],
     classes: newMap(),
     enums: newMap(),
     functions: newMap(),
@@ -37,6 +38,7 @@ export function convertToSemanticModel(
     fileContent,
   }));
   const sortedLibs = sortBy(libsArray, "libraryName");
+  model.includedLibraries = map(sortedLibs, (_) => _.libraryName);
 
   reduce(
     sortedLibs,
@@ -77,6 +79,7 @@ function convertLibraryToSemanticModel(
 ): model.UI5SemanticModel {
   const model: model.UI5SemanticModel = {
     version: lib.version,
+    includedLibraries: [],
     classes: newMap(),
     interfaces: newMap(),
     enums: newMap(),

packages/semantic-model/test/unit-spec.ts

@@ -253,4 +253,69 @@ context("The ui5-language-assistant semantic model package unit tests", () => {
       });
     });
   });
+
+  context("includedLibraries", () => {
+    function generateFromLibraries(
+      libraries: Record<string, unknown>
+    ): UI5SemanticModel {
+      const result = generate({
+        version: "1.74.0",
+        strict: false,
+        typeNameFix: {},
+        libraries: libraries,
+        printValidationErrors: false,
+      });
+      return result;
+    }
+
+    const libWithSymbol = {
+      "$schema-ref": "http://schemas.sap.com/sapui5/designtime/api.json/1.0",
+      symbols: [
+        {
+          kind: "class",
+          basename: "rootSymbol",
+          name: "rootSymbol",
+        },
+      ],
+    };
+
+    it("contains a valid library", () => {
+      const result = generateFromLibraries({
+        testLib: libWithSymbol,
+      });
+      expect(result.includedLibraries, "includedLibraries").to.deep.equal([
+        "testLib",
+      ]);
+    });
+
+    it("contains an invalid library object", () => {
+      const result = generateFromLibraries({
+        testLib: {},
+      });
+      expect(result.includedLibraries, "includedLibraries").to.deep.equal([
+        "testLib",
+      ]);
+    });
+
+    it("contains an empty library", () => {
+      const result = generateFromLibraries({
+        testLib: "",
+      });
+      expect(result.includedLibraries, "includedLibraries").to.deep.equal([
+        "testLib",
+      ]);
+    });
+
+    it("contains all sent libraries", () => {
+      const result = generateFromLibraries({
+        testLib: libWithSymbol,
+        lib2: libWithSymbol,
+        emptyLib: {},
+      });
+      expect(
+        result.includedLibraries,
+        "includedLibraries"
+      ).to.deep.equalInAnyOrder(["testLib", "lib2", "emptyLib"]);
+    });
+  });
 });

packages/xml-views-completion/src/providers/attributeName/namespace.ts

@@ -3,14 +3,12 @@ import { UI5Namespace } from "@ui5-language-assistant/semantic-model-types";
 import {
   isElementSubClass,
   ui5NodeToFQN,
+  getXMLNamespaceKeyPrefix,
+  isXMLNamespaceKey,
 } from "@ui5-language-assistant/logic-utils";
 import { XMLAttribute } from "@xml-tools/ast";
 import { UI5AttributeNameCompletionOptions } from "./index";
 import { UI5NamespacesInXMLAttributeKeyCompletion } from "../../../api";
-import {
-  getXMLNamespaceKeyPrefix,
-  isXMLNamespaceKey,
-} from "../utils/xml-ns-key";
 
 /**
  * Suggests Namespaces inside Element

packages/xml-views-completion/src/providers/attributeValue/namespace.ts

@@ -3,13 +3,11 @@ import { XMLAttribute } from "@xml-tools/ast";
 import {
   isElementSubClass,
   ui5NodeToFQN,
+  getXMLNamespaceKeyPrefix,
+  isXMLNamespaceKey,
 } from "@ui5-language-assistant/logic-utils";
 import { UI5AttributeValueCompletionOptions } from "./index";
 import { UI5NamespacesInXMLAttributeValueCompletion } from "../../../api";
-import {
-  getXMLNamespaceKeyPrefix,
-  isXMLNamespaceKey,
-} from "../utils/xml-ns-key";
 
 /**
  * Suggests namespace value for namespace attribute

packages/xml-views-completion/src/providers/utils/xml-ns-key.ts

@@ -22,7 +22,6 @@ import {
   namespaceKeysSuggestions,
 } from "../../../src/providers/attributeName/namespace";
 import { ui5NodeToFQN } from "@ui5-language-assistant/logic-utils";
-import { getXMLNamespaceKeyPrefix } from "../../../src/providers/utils/xml-ns-key";
 import { UI5NamespacesInXMLAttributeKeyCompletion } from "../../../api";
 
 const allExpectedNamespaces = [
@@ -300,20 +299,6 @@ describe("The ui5-language-assistant xml-views-completion", () => {
     });
 
     context("not reproducible scenario", () => {
-      context("getNamespaceKeyPrefix", () => {
-        it("no match is found, because key does not start with xmlns", () => {
-          expect(getXMLNamespaceKeyPrefix("abc")).to.be.empty;
-        });
-
-        it("no match is found because symbol '*' goes after xmlns", () => {
-          expect(getXMLNamespaceKeyPrefix("xmlns*")).to.be.empty;
-        });
-
-        it("prefix is undefined, empty string returns", () => {
-          expect(getXMLNamespaceKeyPrefix("xmlns:")).to.be.empty;
-        });
-      });
-
       //TODO check with Shachar if this case can be received from xml
       context("isExistingNamespaceAttribute", () => {
         it("invalid attribute key", () => {

packages/xml-views-completion/test/providers/attributeName/namespace-spec.ts

@@ -20,7 +20,10 @@ export interface OffsetRange {
   end: number;
 }
 
-export type UI5XMLViewIssue = UnknownEnumValueIssue | UseOfDeprecatedClassIssue;
+export type UI5XMLViewIssue =
+  | UnknownEnumValueIssue
+  | UseOfDeprecatedClassIssue
+  | UnknownNamespaceInXmlnsAttributeValueIssue;
 
 // A sub-interface per issue type may seem redundant, but this allows
 // a sub-issue type to have additional properties (if needed) in the future.
@@ -31,3 +34,8 @@ export interface UnknownEnumValueIssue extends BaseUI5XMLViewIssue {
 export interface UseOfDeprecatedClassIssue extends BaseUI5XMLViewIssue {
   kind: "UseOfDeprecatedClass";
 }
+
+export interface UnknownNamespaceInXmlnsAttributeValueIssue
+  extends BaseUI5XMLViewIssue {
+  kind: "UnknownNamespaceInXmlnsAttributeValue";
+}

packages/xml-views-validation/api.d.ts

@@ -0,0 +1,55 @@
+import { XMLAttribute } from "@xml-tools/ast";
+import { UI5SemanticModel } from "@ui5-language-assistant/semantic-model-types";
+import { findSymbol } from "@ui5-language-assistant/semantic-model";
+import { isXMLNamespaceKey } from "@ui5-language-assistant/logic-utils";
+import { UnknownNamespaceInXmlnsAttributeValueIssue } from "../../../api";
+import { find } from "lodash";
+
+export function validateUnknownXmlnsNamespace(
+  attribute: XMLAttribute,
+  model: UI5SemanticModel
+): UnknownNamespaceInXmlnsAttributeValueIssue[] {
+  const attributeName = attribute.key;
+  if (attributeName === null || !isXMLNamespaceKey(attributeName)) {
+    return [];
+  }
+
+  const attributeValue = attribute.value;
+  const attributeValueToken = attribute.syntax.value;
+
+  // TODO empty namespaces aren't valid but this should be handled in xml-tools because it's a general xml issue.
+  if (attributeValueToken === undefined || attributeValue === null) {
+    return [];
+  }
+
+  // Only check namespaces from libraries.
+  // There are valid namespaces like some that start with "http" that should not return an error.
+  // Additionally, customers can develop in custom namespaces, even those that start with "sap", and we don't want to give false positives.
+  // But sap library namespaces can be considered reserved.
+  if (
+    find(
+      model.includedLibraries,
+      (_) => attributeValue === _ || attributeValue.startsWith(_ + ".")
+    ) === undefined
+  ) {
+    return [];
+  }
+
+  // Find the namespace. In most cases it would actually be a namespace but some classes are defined inside other things
+  // (e.g. sap.gantt.legend which is an Enum in 1.71.*)
+  if (findSymbol(model, attributeValue) === undefined) {
+    return [
+      {
+        kind: "UnknownNamespaceInXmlnsAttributeValue",
+        message: `Unknown namespace: ${attributeValueToken.image}`,
+        offsetRange: {
+          start: attributeValueToken.startOffset,
+          end: attributeValueToken.endOffset,
+        },
+        severity: "warn",
+      },
+    ];
+  }
+
+  return [];
+}