parse isOptional from both optional attribute and conformance

Author: ethanzhouyc

docs/api.md

@@ -20032,6 +20032,7 @@ This module provides utilities for evaluating conformance expressions.
         * [~evaluateBooleanExpression(expr)](#module_Validation API_ Evaluate conformance expressions..evaluateConformanceExpression..evaluateBooleanExpression)
         * [~evaluateWithParentheses(expr)](#module_Validation API_ Evaluate conformance expressions..evaluateConformanceExpression..evaluateWithParentheses)
     * [~checkMissingTerms(expression, elementMap)](#module_Validation API_ Evaluate conformance expressions..checkMissingTerms) ⇒
+    * [~checkIfExpressionHasTerm(expression, term)](#module_Validation API_ Evaluate conformance expressions..checkIfExpressionHasTerm) ⇒
 
 <a name="module_Validation API_ Evaluate conformance expressions..evaluateConformanceExpression"></a>
 
@@ -20092,6 +20093,19 @@ If so, it means the conformance depends on terms with unknown values and changes
 | expression | <code>\*</code> | 
 | elementMap | <code>\*</code> | 
 
+<a name="module_Validation API_ Evaluate conformance expressions..checkIfExpressionHasTerm"></a>
+
+### Validation API: Evaluate conformance expressions~checkIfExpressionHasTerm(expression, term) ⇒
+Check if the expression contains a given term.
+
+**Kind**: inner method of [<code>Validation API: Evaluate conformance expressions</code>](#module_Validation API_ Evaluate conformance expressions)  
+**Returns**: true if the expression contains the term, false otherwise  
+
+| Param |
+| --- |
+| expression | 
+| term | 
+
 <a name="module_Validation API_ Parse conformance data from XML"></a>
 
 ## Validation API: Parse conformance data from XML
@@ -20101,6 +20115,7 @@ This module provides utilities for parsing conformance data from XML into expres
 * [Validation API: Parse conformance data from XML](#module_Validation API_ Parse conformance data from XML)
     * [~parseConformanceFromXML(operand)](#module_Validation API_ Parse conformance data from XML..parseConformanceFromXML) ⇒
     * [~parseConformanceRecursively(operand, depth, parentJoinChar)](#module_Validation API_ Parse conformance data from XML..parseConformanceRecursively) ⇒
+    * [~getOptionalAttributeFromXML(element)](#module_Validation API_ Parse conformance data from XML..getOptionalAttributeFromXML) ⇒
 
 <a name="module_Validation API_ Parse conformance data from XML..parseConformanceFromXML"></a>
 
@@ -20162,6 +20177,21 @@ When they appear, stop recursing and return the name inside directly
 | depth | <code>\*</code> | <code>0</code> | 
 | parentJoinChar | <code>\*</code> |  | 
 
+<a name="module_Validation API_ Parse conformance data from XML..getOptionalAttributeFromXML"></a>
+
+### Validation API: Parse conformance data from XML~getOptionalAttributeFromXML(element) ⇒
+if optional attribute is defined, return its value
+if optional attribute is undefined, check if the element conformance is mandatory
+if both optional attribute and conformance are undefined, return false
+Optional attribute takes precedence over conformance for backward compatibility on certain elements
+
+**Kind**: inner method of [<code>Validation API: Parse conformance data from XML</code>](#module_Validation API_ Parse conformance data from XML)  
+**Returns**: true if the element is optional, false if the element is mandatory  
+
+| Param | Type |
+| --- | --- |
+| element | <code>\*</code> | 
+
 <a name="module_Validation API_ Validation APIs"></a>
 
 ## Validation API: Validation APIs

src-electron/validation/conformance-expression-evaluator.js

@@ -132,5 +132,18 @@ function checkMissingTerms(expression, elementMap) {
   return missingTerms
 }
 
+/**
+ * Check if the expression contains a given term.
+ *
+ * @param expression
+ * @param term
+ * @returns true if the expression contains the term, false otherwise
+ */
+function checkIfExpressionHasTerm(expression, term) {
+  let terms = expression.match(/[A-Za-z][A-Za-z0-9_]*/g)
+  return terms && terms.includes(term)
+}
+
 exports.evaluateConformanceExpression = evaluateConformanceExpression
 exports.checkMissingTerms = checkMissingTerms
+exports.checkIfExpressionHasTerm = checkIfExpressionHasTerm

src-electron/validation/conformance-xml-parser.js

@@ -21,6 +21,9 @@
  * @module Validation API: Parse conformance data from XML
  */
 
+const dbEnum = require('../../src-shared/db-enum')
+const conformEvaluator = require('./conformance-expression-evaluator')
+
 /**
  * Parses conformance from XML data.
  * The conformance could come from features, attributes, commands, or events
@@ -155,4 +158,30 @@ function parseConformanceRecursively(operand, depth = 0, parentJoinChar = '') {
   }
 }
 
+/**
+ * if optional attribute is defined, return its value
+ * if optional attribute is undefined, check if the element conformance is mandatory
+ * if both optional attribute and conformance are undefined, return false
+ * Optional attribute takes precedence over conformance for backward compatibility on certain elements
+ *
+ * @param {*} element
+ * @returns true if the element is optional, false if the element is mandatory
+ */
+function getOptionalAttributeFromXML(element) {
+  if (element.$.optional) {
+    return element.$.optional == 'true'
+  } else {
+    let conformance = parseConformanceFromXML(element)
+    if (conformance) {
+      return !conformEvaluator.checkIfExpressionHasTerm(
+        conformance,
+        dbEnum.conformance.mandatory
+      )
+    } else {
+      return false
+    }
+  }
+}
+
 exports.parseConformanceFromXML = parseConformanceFromXML
+exports.getOptionalAttributeFromXML = getOptionalAttributeFromXML

src-electron/zcl/zcl-loader-silabs.js

@@ -506,7 +506,7 @@ function prepareCluster(cluster, context, isExtension = false) {
         name: command.$.name,
         description: command.description ? command.description[0].trim() : '',
         source: command.$.source,
-        isOptional: command.$.optional == 'true' ? true : false,
+        isOptional: conformParser.getOptionalAttributeFromXML(command),
         conformance: conformParser.parseConformanceFromXML(command),
         mustUseTimedInvoke: command.$.mustUseTimedInvoke == 'true',
         introducedIn: command.$.introducedIn,
@@ -567,7 +567,7 @@ function prepareCluster(cluster, context, isExtension = false) {
         conformance: conformParser.parseConformanceFromXML(event),
         priority: event.$.priority,
         description: event.description ? event.description[0].trim() : '',
-        isOptional: event.$.optional == 'true',
+        isOptional: conformParser.getOptionalAttributeFromXML(event),
         isFabricSensitive: event.$.isFabricSensitive == 'true'
       }
       ev.access = extractAccessIntoArray(event)
@@ -685,7 +685,7 @@ function prepareCluster(cluster, context, isExtension = false) {
           : null,
         isWritable: attribute.$.writable == 'true',
         defaultValue: attribute.$.default,
-        isOptional: attribute.$.optional == 'true',
+        isOptional: conformParser.getOptionalAttributeFromXML(attribute),
         reportingPolicy: reportingPolicy,
         storagePolicy: storagePolicy,
         isSceneRequired:

src-shared/db-enum.js

@@ -247,3 +247,12 @@ exports.featureMapAttribute = {
   name: 'FeatureMap',
   code: 65532
 }
+
+exports.conformance = {
+  mandatory: 'M',
+  optional: 'O',
+  disallowed: 'X',
+  deprecated: 'D',
+  provisional: 'P',
+  desc: 'desc'
+}

test/test-query.js

@@ -255,6 +255,17 @@ WHERE
     .then((rows) => rows.map(dbMapping.map.cluster))
 }
 
+/**
+ *
+ * @param {*} elements
+ * @param {*} name
+ * @returns true if the element is optional, false if the element is mandatory
+ */
+function checkIfElementIsOptional(elements, name) {
+  let element = elements.find((element) => element.name == name)
+  return element ? element.isOptional : false
+}
+
 exports.getAllEndpointTypeClusterState = getAllEndpointTypeClusterState
 exports.selectCountFrom = selectCountFrom
 exports.getEndpointTypeAttributes = getEndpointTypeAttributes
@@ -263,3 +274,4 @@ exports.createSession = createSession
 exports.getAllSessionNotifications = getAllSessionNotifications
 exports.getAllNotificationMessages = getAllNotificationMessages
 exports.getAllSessionClusters = getAllSessionClusters
+exports.checkIfElementIsOptional = checkIfElementIsOptional

test/zcl-loader.test.js

@@ -23,6 +23,7 @@ const dbEnum = require('../src-shared/db-enum')
 const queryZcl = require('../src-electron/db/query-zcl')
 const queryDeviceType = require('../src-electron/db/query-device-type')
 const queryCommand = require('../src-electron/db/query-command')
+const queryEvent = require('../src-electron/db/query-event')
 const queryPackage = require('../src-electron/db/query-package')
 const queryPackageNotification = require('../src-electron/db/query-package-notification')
 const zclLoader = require('../src-electron/zcl/zcl-loader')
@@ -594,14 +595,14 @@ test(
       let ctx = await zclLoader.loadZcl(db, env.builtinMatterZclMetafile())
       let packageId = ctx.packageId
 
-      let zclCluster = await queryZcl.selectClusterByCode(db, packageId, 0x001f)
+      let aclCluster = await queryZcl.selectClusterByCode(db, packageId, 0x001f)
 
       /* Verify that the ACL attribute, defined using the list type format `array="true" type="X"` in XML,
         is correctly parsed and stored in the database as an array of AccessControlEntryStruct. */
       let attributes = await dbApi.dbAll(
         db,
         "SELECT * FROM ATTRIBUTE WHERE CLUSTER_REF = ? AND CODE = 0x0000 AND NAME = 'ACL'",
-        [zclCluster.id]
+        [aclCluster.id]
       )
       expect(attributes.length).toBe(1)
       let aclAttribute = attributes[0]
@@ -623,3 +624,107 @@ test(
   },
   testUtil.timeout.long()
 )
+
+test(
+  'test loading IS_OPTIONAL column for Matter attributes, commands, and events',
+  async () => {
+    let db = await dbApi.initRamDatabase()
+    try {
+      await dbApi.loadSchema(db, env.schemaFile(), env.zapVersion())
+      let ctx = await zclLoader.loadZcl(db, env.builtinMatterZclMetafile())
+      let packageId = ctx.packageId
+
+      let doorLockCluster = await queryZcl.selectClusterByCode(
+        db,
+        packageId,
+        0x0101
+      )
+      let doorLockClusterId = doorLockCluster.id
+
+      let attributes =
+        await queryZcl.selectAttributesByClusterIdIncludingGlobal(
+          db,
+          doorLockClusterId,
+          [packageId]
+        )
+      // optional attribute undefined, conformance undefined -> mandatory
+      expect(
+        testQuery.checkIfElementIsOptional(attributes, 'ActuatorEnabled')
+      ).toBeFalsy()
+      // optional="true", conformance undefined -> optional
+      expect(
+        testQuery.checkIfElementIsOptional(attributes, 'DoorClosedEvents')
+      ).toBeTruthy()
+      // optional="false", conformance undefined -> mandatory
+      expect(
+        testQuery.checkIfElementIsOptional(attributes, 'LockType')
+      ).toBeFalsy()
+      // mandatory conformance, optional attribute undefined -> mandatory
+      expect(
+        testQuery.checkIfElementIsOptional(attributes, 'OperatingMode')
+      ).toBeFalsy()
+      // optionalConform to feature DPS, optional="true" -> optional
+      expect(
+        testQuery.checkIfElementIsOptional(attributes, 'DoorOpenEvents')
+      ).toBeTruthy()
+      // mandatory conformance, optional="true" -> optional as optional="true" takes precedence
+      expect(
+        testQuery.checkIfElementIsOptional(attributes, 'LockState')
+      ).toBeTruthy()
+      // mandatoryConform to feature DPS, optional="false" -> mandatory as optional="false" takes precedence
+      expect(
+        testQuery.checkIfElementIsOptional(attributes, 'DoorState')
+      ).toBeFalsy()
+
+      let commands = await queryCommand.selectCommandsByClusterId(
+        db,
+        doorLockClusterId,
+        [packageId]
+      )
+      // optional attribute undefined, conformance undefined -> mandatory
+      expect(
+        testQuery.checkIfElementIsOptional(commands, 'LockDoor')
+      ).toBeFalsy()
+      // optional="true", conformance undefined -> optional
+      expect(
+        testQuery.checkIfElementIsOptional(commands, 'GetWeekDaySchedule')
+      ).toBeTruthy()
+      // optional conformance, optional="true" -> optional
+      expect(
+        testQuery.checkIfElementIsOptional(commands, 'UnlockWithTimeout')
+      ).toBeTruthy()
+      // mandatoryConform to feature WDSCH, optional="true" -> optional
+      expect(
+        testQuery.checkIfElementIsOptional(commands, 'SetWeekDaySchedule')
+      ).toBeTruthy()
+      // mandatory conformance, optional="true" -> optional as optional="true" takes precedence
+      expect(
+        testQuery.checkIfElementIsOptional(commands, 'UnlockDoor')
+      ).toBeTruthy()
+
+      let events = await queryEvent.selectEventsByClusterId(
+        db,
+        doorLockClusterId
+      )
+      // optional attribute undefined, conformance undefined -> mandatory
+      expect(
+        testQuery.checkIfElementIsOptional(events, 'LockUserChange')
+      ).toBeFalsy()
+      // optional="true", conformance undefined -> optional
+      expect(
+        testQuery.checkIfElementIsOptional(events, 'LockOperation')
+      ).toBeTruthy()
+      // mandatoryConform to feature DPS, optional="true" -> optional
+      expect(
+        testQuery.checkIfElementIsOptional(events, 'DoorStateChange')
+      ).toBeTruthy()
+      // mandatory conformance, optional="true" -> optional as optional="true" takes precedence
+      expect(
+        testQuery.checkIfElementIsOptional(events, 'DoorLockAlarm')
+      ).toBeTruthy()
+    } finally {
+      await dbApi.closeDatabase(db)
+    }
+  },
+  testUtil.timeout.long()
+)