Refactor meta-constraints context handling (#400)

* Cleaned up context processing for meta-constraints. Ensuing the constraint static context is used instead of the module static context.

* Added debug hook.

* Added module QName to the module item's signature.

* Added module QName to the module item's signature.

* Ensure imported modules are also registered when an module is registered.

Author: david-waltermire

core/src/main/java/gov/nist/secauto/metaschema/core/metapath/item/node/ModuleNodeItemImpl.java

@@ -55,6 +55,6 @@ public String stringValue() {
 
   @Override
   protected String getValueSignature() {
-    return null;
+    return getModule().getLocationHint();
   }
 }

core/src/main/java/gov/nist/secauto/metaschema/core/model/constraint/ExternalConstraintsModulePostProcessor.java

@@ -5,8 +5,6 @@
 
 package gov.nist.secauto.metaschema.core.model.constraint;
 
-import gov.nist.secauto.metaschema.core.metapath.DynamicContext;
-import gov.nist.secauto.metaschema.core.metapath.StaticContext;
 import gov.nist.secauto.metaschema.core.metapath.item.node.IModuleNodeItem;
 import gov.nist.secauto.metaschema.core.metapath.item.node.INodeItemFactory;
 import gov.nist.secauto.metaschema.core.model.IModule;
@@ -61,22 +59,16 @@ public void processModule(IModule module) {
     ConstraintComposingVisitor visitor = new ConstraintComposingVisitor();
     IModuleNodeItem moduleItem = INodeItemFactory.instance().newModuleNodeItem(module);
 
-    StaticContext staticContext = StaticContext.builder()
-        .defaultModelNamespace(module.getXmlNamespace())
-        .build();
-    DynamicContext dynamicContext = new DynamicContext(staticContext);
-
     for (IConstraintSet set : getRegisteredConstraintSets()) {
       assert set != null;
-      applyConstraintsForModule(moduleItem, set, visitor, dynamicContext);
+      applyConstraintsForModule(moduleItem, set, visitor);
     }
   }
 
   private static void applyConstraintsForModule(
       @NonNull IModuleNodeItem moduleItem,
       @NonNull IConstraintSet set,
-      @NonNull ConstraintComposingVisitor visitor,
-      @NonNull DynamicContext dynamicContext) {
-    set.applyConstraintsForModule(moduleItem, dynamicContext, visitor);
+      @NonNull ConstraintComposingVisitor visitor) {
+    set.applyConstraintsForModule(moduleItem, visitor);
   }
 }

core/src/main/java/gov/nist/secauto/metaschema/core/model/constraint/IConstraintSet.java

@@ -5,7 +5,6 @@
 
 package gov.nist.secauto.metaschema.core.model.constraint;
 
-import gov.nist.secauto.metaschema.core.metapath.DynamicContext;
 import gov.nist.secauto.metaschema.core.metapath.item.node.IModuleNodeItem;
 import gov.nist.secauto.metaschema.core.model.IModelElementVisitor;
 import gov.nist.secauto.metaschema.core.model.ISource;
@@ -37,13 +36,10 @@ public interface IConstraintSet {
    *
    * @param moduleItem
    *          the module node item to apply applicable constraints to
-   * @param dynamicContext
-   *          used to resolve Metapath targeting expressions
    * @param visitor
    *          the visitor used to apply constraints to target definitions
    */
   void applyConstraintsForModule(
       @NonNull IModuleNodeItem moduleItem,
-      @NonNull DynamicContext dynamicContext,
       @NonNull IModelElementVisitor<ITargetedConstraints, Void> visitor);
 }

core/src/main/java/gov/nist/secauto/metaschema/core/model/constraint/MetaConstraintSet.java

@@ -57,12 +57,14 @@ public Collection<? extends IConstraintSet> getImportedConstraintSets() {
   @Override
   public void applyConstraintsForModule(
       IModuleNodeItem moduleItem,
-      DynamicContext dynamicContext,
       IModelElementVisitor<ITargetedConstraints, Void> visitor) {
+
     for (IConstraintSet imported : imports) {
-      imported.applyConstraintsForModule(moduleItem, dynamicContext, visitor);
+      imported.applyConstraintsForModule(moduleItem, visitor);
     }
 
+    // generate a dynamic context using the external constraint set's static context
+    DynamicContext dynamicContext = new DynamicContext(getSource().getStaticContext());
     for (Context context : contexts) {
       context.applyConstraintsForModule(moduleItem, dynamicContext, visitor, ISequence.of(moduleItem));
     }
@@ -142,26 +144,25 @@ void applyConstraintsForModule(
         @NonNull DynamicContext dynamicContext,
         @NonNull IModelElementVisitor<ITargetedConstraints, Void> visitor,
         @NonNull ISequence<? extends INodeItem> targetedItems) {
-      Set<IDefinition> definitionConstraints = new HashSet<>();
+      Set<IDefinition> targetedDefinitions = new HashSet<>();
 
       for (INodeItem nodeItem : targetedItems) {
         for (IMetapathExpression metapath : metapaths) {
           ISequence<? extends IDefinitionNodeItem<?, ?>> items = ISequence.of(ObjectUtils.notNull(
-              metapath.evaluate(nodeItem, dynamicContext).stream()
+              evaluateItem(metapath, nodeItem, dynamicContext).stream()
                   .filter(item -> filterNonDefinitionItem(item, metapath))
                   .map(item -> (IDefinitionNodeItem<?, ?>) item)))
               .reusable();
           assert items != null;
           if (!items.isEmpty()) {
             // build a map to ensure the constraint is only applied once to each
             // underlying definition
-            Set<IDefinition> targetedDefinitions = items.stream()
+            items.stream()
                 .map(IDefinitionNodeItem::getDefinition)
                 // ensure the definition only gets processed if the module being processed is
                 // the containing module
                 .filter(definition -> definition.getContainingModule().equals(moduleItem.getModule()))
-                .collect(Collectors.toUnmodifiableSet());
-            definitionConstraints.addAll(targetedDefinitions);
+                .forEach(definition -> targetedDefinitions.add(definition));
 
             // process child contexts, which will be applied depth first
             for (Context context : childContexts) {
@@ -172,13 +173,20 @@ void applyConstraintsForModule(
       }
 
       // apply the constraints for this context
-      definitionConstraints.forEach(definition -> {
+      targetedDefinitions.forEach(definition -> {
         getTargetedConstraints().forEach(constraints -> {
           definition.accept(visitor, constraints);
         });
       });
     }
 
+    private ISequence<?> evaluateItem(
+        @NonNull IMetapathExpression metapath,
+        @NonNull INodeItem nodeItem,
+        @NonNull DynamicContext dynamicContext) {
+      return metapath.evaluate(nodeItem, dynamicContext).reusable();
+    }
+
     private static boolean filterNonDefinitionItem(IItem item, @NonNull IMetapathExpression metapath) {
       boolean retval = item instanceof IDefinitionNodeItem;
       if (!retval) {

core/src/main/java/gov/nist/secauto/metaschema/core/model/constraint/ScopedConstraintSet.java

@@ -101,13 +101,14 @@ public Set<IConstraintSet> getImportedConstraintSets() {
   @Override
   public void applyConstraintsForModule(
       IModuleNodeItem moduleItem,
-      DynamicContext dynamicContext,
       IModelElementVisitor<ITargetedConstraints, Void> visitor) {
     IEnhancedQName qname = moduleItem.getModule().getQName();
     List<IScopedContraints> scopes = getScopedContraints().getOrDefault(qname, CollectionUtil.emptyList());
 
     Map<IDefinition, Set<ITargetedConstraints>> definitionConstraints = new HashMap<>();
 
+    DynamicContext dynamicContext = new DynamicContext(getSource().getStaticContext());
+
     for (IScopedContraints scoped : scopes) {
       for (ITargetedConstraints targeted : scoped.getTargetedContraints()) {
         for (IMetapathExpression metapath : targeted.getTargets()) {

databind/src/main/java/gov/nist/secauto/metaschema/databind/DefaultBindingContext.java

@@ -117,9 +117,19 @@ public IBindingModuleLoader newModuleLoader() {
   public final IBoundModule registerModule(@NonNull Class<? extends IBoundModule> clazz) {
     IModuleLoaderStrategy strategy = getModuleLoaderStrategy();
     IBoundModule module = strategy.loadModule(clazz, this);
+    registerImportedModules(module);
     return strategy.registerModule(module, this);
   }
 
+  private void registerImportedModules(@NonNull IBoundModule module) {
+    IModuleLoaderStrategy strategy = getModuleLoaderStrategy();
+    module.getImportedModules().stream()
+        .forEachOrdered(parentModule -> {
+          registerImportedModules(ObjectUtils.notNull(parentModule));
+          strategy.registerModule(ObjectUtils.notNull(parentModule), this);
+        });
+  }
+
   /**
    * Get the binding matchers that are associated with this class.
    *