Fix listing of required properties for neurodata types. (#688)

* Create functions for detecting property attributes

* Update fillClass to correctly enumerate required properties in docstring

* Move and fix function for getting required property names for class

* Update getRequiredPropsForClass.m

Resolve property attributes across the whole class hierarchy, and add some comments

* Regenerate types

* Update MetaClass to use updated function for retrieving required properties

* Add option for providing a namespace to the getRequiredPropsForClass function

* Minor adjustments to file.internal.isPropertyRequired

* Add test that would fail before

* Added some comments to test for more clarity

* Update check in +types/+util/+dynamictable/checkConfig.m

Check for existence of file instead of existence of class (class might be present in memory even if the file is removed due to generating a newer NWB version)

* Create HasQuantity.m

* Add HasQuantity as superclass to Group, Dataset and Link

* Add schema and test class

* Refactor specs and tests to not use scratch

* Remove extra blank lines

* Add specification and test to test that specification quantities are correctly parsed

* Fix bug in HasQuantity

* Update MetaClass.m

Expose getRequiredMethods publicly (but keep hidden)

* Add tests for invalid quantity specifications

* Remove debug statement

* Fix merge mistake for types.untyped.MetaClass

Author: ehennestad

+file/+internal/getRequiredPropertyNames.m

@@ -0,0 +1,15 @@
+function result = isPropertyHidden(propertyInfo, className, namespace)
+% isPropertyHidden - Determine if a property is hidden
+
+    if isa(propertyInfo, 'file.Attribute') || isa(propertyInfo, 'file.Dataset') 
+        if strcmp(namespace.name, 'hdmf_common') ...
+            && strcmp(className, 'VectorData') ...
+            && any(strcmp(propertyInfo.name, {'unit', 'sampling_rate', 'resolution'}))
+            result = true;
+        else
+            result = false;
+        end
+    else
+        result = false;
+    end
+end

+file/+internal/isPropertyHidden.m

@@ -0,0 +1,8 @@
+function result = isPropertyReadonly(propertyInfo)
+% isPropertyReadonly - Determine if a property is read-only
+    if isa(propertyInfo, 'file.Attribute') || isa(propertyInfo, 'file.Dataset') 
+        result = propertyInfo.readonly;
+    else
+        result = false;
+    end
+end

+file/+internal/isPropertyReadonly.m

@@ -0,0 +1,37 @@
+function result = isPropertyRequired(propInfo, fullPropertyName, allClassprops)
+% isPropertyRequired - Determine if a property is required
+
+    if ischar(propInfo) || isa(propInfo, 'containers.Map') || isstruct(propInfo)
+        result = true;
+    elseif isa(propInfo, 'file.interface.HasProps')
+        isSubPropertyRequired = false(size(propInfo));
+        for iSubProp = 1:length(propInfo)
+            p = propInfo(iSubProp);
+            isSubPropertyRequired(iSubProp) = p.required;
+        end
+        result = all(isSubPropertyRequired);
+    elseif isa(propInfo, 'file.Attribute')
+        if isempty(propInfo.dependent)
+            result = propInfo.required;
+        else
+            result = resolveRequiredForDependentProp(propInfo, fullPropertyName, allClassprops);
+        end
+    elseif isa(propInfo, 'file.Link')
+        result = propInfo.required;
+    else
+        result = false;
+    end
+end
+
+function tf = resolveRequiredForDependentProp(propInfo, propertyName, allProps)
+% resolveRequiredForDependentProp - If a dependent property is required,
+% whether it is required on object level also depends on whether it's parent 
+% property is required.
+    if ~propInfo.required 
+        tf = false;
+    else % Check if parent is required
+        parentName = strrep(propertyName, ['_' propInfo.name], '');
+        parentInfo = allProps(parentName);
+        tf = parentInfo.required;
+    end
+end

+file/+internal/isPropertyRequired.m

@@ -97,8 +97,8 @@
         'classdef ' name ' < ' depnm ' & ' classTag newline... %header, dependencies
         '% ' upper(name) ' - ' class.doc]; %name, docstr
 
-    allClassProps = file.internal.mergeProps(classprops, superClassProps);
-    allRequiredPropertyNames = file.internal.getRequiredPropertyNames(allClassProps);
+    fullClassName = strjoin({'types', misc.str2validName(namespace.name), name}, '.');
+    allRequiredPropertyNames = schemes.internal.getRequiredPropsForClass(fullClassName, namespace);
     if isempty(allRequiredPropertyNames)
         allRequiredPropertyNames = {'None'};
     end

+file/fillClass.m

@@ -0,0 +1,51 @@
+function requiredPropertyNames = getRequiredPropsForClass(fullClassName, namespace)
+% getRequiredPropsForClass - List required properties for a neurodata type / class
+
+    arguments
+        fullClassName (1,1) string % E.g types.core.TimeSeries
+        namespace schemes.Namespace = schemes.Namespace.empty
+    end
+
+    % For the NwbFile class, we need to replace it with the generated
+    % NWBFile superclass in order to retrieve schema information correctly
+    if strcmp(fullClassName, 'NwbFile')
+        superclassNames = string(superclasses(fullClassName));
+        fullClassName = superclassNames(endsWith(superclassNames, 'NWBFile'));
+    end
+
+    % Load cached namespace specifications
+    classNameSplit = strsplit(fullClassName, '.');
+    className = classNameSplit(end);
+    if isempty(namespace)
+        namespaceName = classNameSplit(find(strcmp(classNameSplit, 'types'))+1);
+        namespaceName = strrep(namespaceName, '_', '-');
+        namespace = schemes.loadNamespace(namespaceName);
+    end
+   
+    % Process/parse the namespace specifications to retrieve attributes for
+    % the class properties.
+    processedTypeMap = containers.Map;
+    [processed, classprops, ~] = file.processClass(className, namespace, processedTypeMap);
+    if ~isempty(processed)
+        superClassProps = cell(1, numel(processed)-1);
+        for iSuper = 2:numel(processed)
+            [~, superClassProps{iSuper-1}, ~] =  file.processClass(processed(iSuper).type, namespace, processedTypeMap);
+        end
+        classprops = file.internal.mergeProps(classprops, superClassProps);
+    end
+    
+    % Resolve the required properties. For the final list of required properties,
+    % we ignore both hidden and read-only properties.
+    allPropertieNames = keys(classprops);
+    [isRequired, isReadOnly, isHidden] = deal( false(1, classprops.Count) );
+    
+    for iProp = 1:length(allPropertieNames)
+        propertyName = allPropertieNames{iProp};
+        prop = classprops(propertyName);
+        isRequired(iProp) = file.internal.isPropertyRequired(prop, propertyName, classprops);
+        isReadOnly(iProp) = file.internal.isPropertyReadonly(prop);
+        isHidden(iProp) = file.internal.isPropertyHidden(prop, className, namespace);
+    end
+
+    requiredPropertyNames = allPropertieNames(isRequired & ~isReadOnly & ~isHidden);
+end

+schemes/+internal/getRequiredPropsForClass.m

@@ -0,0 +1,29 @@
+function electrodeTable = ElectrodeTable(nwbFile)
+% ElectrodeRegion - Create electrode region
+    
+    arguments
+        nwbFile (1,1) NwbFile % A device is required
+    end
+
+    device = types.core.Device;
+    nwbFile.general_devices.set('testDevice', device);
+
+    electrodeTable = types.hdmf_common.DynamicTable(...
+        'colnames', {'location', 'group', 'group_name', 'label'}, ...
+        'description', 'all electrodes');
+    nwbFile.general_extracellular_ephys_electrodes = electrodeTable;
+
+    electrodeGroup = types.core.ElectrodeGroup( ...
+        'description', sprintf('electrode group'), ...
+        'location', 'brain area', ...
+        'device', types.untyped.SoftLink(device) ...
+    );
+    
+    nwbFile.general_extracellular_ephys.set('ElectrodeGroup', electrodeGroup);
+    
+    electrodeTable.addRow( ...
+        'location', 'unknown', ...
+        'group', types.untyped.ObjectView(electrodeGroup), ...
+        'group_name', 'test electrode group', ...
+        'label', 'test electrode');
+end