Metapath expression evaluator subcommand

.lycheeignore

@@ -16,6 +16,8 @@ https://github.com/hamcrest/JavaHamcrest/hamcrest-core
 https://github.com/javaparser/.*
 https://github.com/vsch/flexmark-java/.*
 https://hc.apache.org/httpcomponents-client-5.0.x/5.1.3/httpclient5/
+http://logback.qos.ch/logback-classic
+http://logback.qos.ch/logback-core
 https://logging.apache.org/log4j/2.x/log4j/.*
 http://mojo.codehaus.org/.*
 https://pmd.github.io/latest/pmd_userdocs_cpd.html
@@ -34,7 +36,8 @@ http://www.thymeleaf.org/thymeleaf-lib/thymeleaf
 # broken license references
 https://opensource.org/licenses/Apache-2.0,https://opensource.org/licenses/EPL-2.0
 # prone to long timeouts
-http://nexus.sonatype.org/oss-repository-hosting.html/.*
 https://glassfish.dev.java.net/.*
-
-
+http://nexus.sonatype.org/oss-repository-hosting.html/.*
+https://projects.eclipse.org/projects/eclipse.jdt
+# fix later
+https://github.com/metaschema-framework/liboscal-java/

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

@@ -0,0 +1,146 @@
+/*
+ * SPDX-FileCopyrightText: none
+ * SPDX-License-Identifier: CC0-1.0
+ */
+
+package gov.nist.secauto.metaschema.core.metapath.item;
+
+import gov.nist.secauto.metaschema.core.metapath.ICollectionValue;
+import gov.nist.secauto.metaschema.core.metapath.ISequence;
+import gov.nist.secauto.metaschema.core.metapath.item.atomic.IAnyAtomicItem;
+import gov.nist.secauto.metaschema.core.metapath.item.function.IArrayItem;
+import gov.nist.secauto.metaschema.core.metapath.item.function.IMapItem;
+import gov.nist.secauto.metaschema.core.metapath.item.node.INodeItem;
+
+import java.io.PrintWriter;
+
+import edu.umd.cs.findbugs.annotations.NonNull;
+
+/**
+ * Produces a textual representation of a Metapath sequence.
+ */
+public class DefaultItemWriter implements IItemWriter {
+
+  @NonNull
+  private final PrintWriter writer;
+  @NonNull
+  private final Visitor visitor = new Visitor();
+
+  /**
+   * Construct a new item writer.
+   *
+   * @param writer
+   *          the writer to append text to
+   */
+  public DefaultItemWriter(@NonNull PrintWriter writer) {
+    this.writer = writer;
+  }
+
+  @Override
+  public void writeSequence(ISequence<?> sequence) {
+    boolean wrap = sequence.size() != 1;
+    if (wrap) {
+      writer.append('(');
+    }
+    boolean first = true;
+    for (IItem item : sequence) {
+
+      if (first) {
+        first = false;
+      } else {
+        writer.append(',');
+      }
+
+      item.accept(visitor);
+    }
+
+    if (wrap) {
+      writer.append(')');
+    }
+  }
+
+  @Override
+  public void writeArray(IArrayItem<?> array) {
+    writer.append('[');
+    boolean first = true;
+    for (ICollectionValue value : array) {
+      assert value != null;
+
+      if (first) {
+        first = false;
+      } else {
+        writer.append(',');
+      }
+
+      writeCollectionValue(value);
+    }
+    writer.append(']');
+  }
+
+  @Override
+  public void writeMap(IMapItem<?> map) {
+    writer.append("map {");
+    boolean first = true;
+    for (ICollectionValue value : map.values()) {
+      assert value != null;
+
+      if (first) {
+        first = false;
+      } else {
+        writer.append(',');
+      }
+
+      writeCollectionValue(value);
+    }
+    writer.append('}');
+  }
+
+  @Override
+  public void writeNode(INodeItem node) {
+    writer.append(node.getBaseUri().toString());
+    writer.append('#');
+    writer.append(node.getMetapath());
+  }
+
+  @Override
+  public void writeAtomicValue(IAnyAtomicItem node) {
+    writer.append(node.asString());
+  }
+
+  /**
+   * Write the provided collection value.
+   *
+   * @param value
+   *          the value to write
+   */
+  protected void writeCollectionValue(@NonNull ICollectionValue value) {
+    if (value instanceof IItem) {
+      ((IItem) value).accept(visitor);
+    } else if (value instanceof ISequence) {
+      writeSequence((ISequence<?>) value);
+    }
+  }
+
+  private final class Visitor implements IItemVisitor {
+
+    @Override
+    public void visit(IArrayItem<?> array) {
+      writeArray(array);
+    }
+
+    @Override
+    public void visit(IMapItem<?> map) {
+      writeMap(map);
+    }
+
+    @Override
+    public void visit(INodeItem node) {
+      writeNode(node);
+    }
+
+    @Override
+    public void visit(IAnyAtomicItem node) {
+      writeAtomicValue(node);
+    }
+  }
+}

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

@@ -11,6 +11,8 @@
 
 import java.util.stream.Stream;
 
+import edu.umd.cs.findbugs.annotations.NonNull;
+
 public interface IItem extends ICollectionValue {
 
   /**
@@ -49,4 +51,12 @@ default ISequence<?> asSequence() {
   default Stream<? extends IItem> flatten() {
     return Stream.of(this);
   }
+
+  /**
+   * A visitor callback used to visit a variety of Metapath item types.
+   *
+   * @param visitor
+   *          the visitor to call back
+   */
+  void accept(@NonNull IItemVisitor visitor);
 }

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

@@ -0,0 +1,47 @@
+/*
+ * SPDX-FileCopyrightText: none
+ * SPDX-License-Identifier: CC0-1.0
+ */
+
+package gov.nist.secauto.metaschema.core.metapath.item;
+
+import gov.nist.secauto.metaschema.core.metapath.item.atomic.IAnyAtomicItem;
+import gov.nist.secauto.metaschema.core.metapath.item.function.IArrayItem;
+import gov.nist.secauto.metaschema.core.metapath.item.function.IMapItem;
+import gov.nist.secauto.metaschema.core.metapath.item.node.INodeItem;
+
+import edu.umd.cs.findbugs.annotations.NonNull;
+
+public interface IItemVisitor {
+  /**
+   * Visit the array item instance.
+   *
+   * @param array
+   *          the instance to visit
+   */
+  void visit(@NonNull IArrayItem<?> array);
+
+  /**
+   * Visit the map item instance.
+   *
+   * @param map
+   *          the instance to visit
+   */
+  void visit(@NonNull IMapItem<?> map);
+
+  /**
+   * Visit the node item instance.
+   *
+   * @param node
+   *          the instance to visit
+   */
+  void visit(@NonNull INodeItem node);
+
+  /**
+   * Visit the atomic item instance.
+   *
+   * @param item
+   *          the instance to visit
+   */
+  void visit(@NonNull IAnyAtomicItem item);
+}

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

@@ -0,0 +1,56 @@
+/*
+ * SPDX-FileCopyrightText: none
+ * SPDX-License-Identifier: CC0-1.0
+ */
+
+package gov.nist.secauto.metaschema.core.metapath.item;
+
+import gov.nist.secauto.metaschema.core.metapath.ISequence;
+import gov.nist.secauto.metaschema.core.metapath.item.atomic.IAnyAtomicItem;
+import gov.nist.secauto.metaschema.core.metapath.item.function.IArrayItem;
+import gov.nist.secauto.metaschema.core.metapath.item.function.IMapItem;
+import gov.nist.secauto.metaschema.core.metapath.item.node.INodeItem;
+
+import edu.umd.cs.findbugs.annotations.NonNull;
+
+public interface IItemWriter {
+  /**
+   * Write the provided sequence instance.
+   *
+   * @param sequence
+   *          the instance to write
+   */
+  void writeSequence(@NonNull ISequence<?> sequence);
+
+  /**
+   * Write the provided array item instance.
+   *
+   * @param array
+   *          the instance to write
+   */
+  void writeArray(@NonNull IArrayItem<?> array);
+
+  /**
+   * Write the provided map item instance.
+   *
+   * @param map
+   *          the instance to write
+   */
+  void writeMap(@NonNull IMapItem<?> map);
+
+  /**
+   * Write the provided node item instance.
+   *
+   * @param node
+   *          the instance to write
+   */
+  void writeNode(@NonNull INodeItem node);
+
+  /**
+   * Write the provided atomic item instance.
+   *
+   * @param item
+   *          the instance to write
+   */
+  void writeAtomicValue(@NonNull IAnyAtomicItem item);
+}

core/src/main/java/gov/nist/secauto/metaschema/core/metapath/item/atomic/IAnyAtomicItem.java

@@ -7,6 +7,7 @@
 
 import gov.nist.secauto.metaschema.core.datatype.IDataTypeAdapter;
 import gov.nist.secauto.metaschema.core.metapath.IPrintable;
+import gov.nist.secauto.metaschema.core.metapath.item.IItemVisitor;
 import gov.nist.secauto.metaschema.core.metapath.item.function.IMapItem;
 import gov.nist.secauto.metaschema.core.metapath.item.function.IMapKey;
 import gov.nist.secauto.metaschema.core.util.ObjectUtils;
@@ -103,4 +104,9 @@ default IStringItem asStringItem() {
    *         than, equal to, or greater than the {@code item}.
    */
   int compareTo(@NonNull IAnyAtomicItem other);
+
+  @Override
+  default void accept(IItemVisitor visitor) {
+    visitor.visit(this);
+  }
 }

core/src/main/java/gov/nist/secauto/metaschema/core/metapath/item/function/IArrayItem.java

@@ -15,6 +15,7 @@
 import gov.nist.secauto.metaschema.core.metapath.impl.AbstractArrayItem;
 import gov.nist.secauto.metaschema.core.metapath.impl.ArrayItemN;
 import gov.nist.secauto.metaschema.core.metapath.item.IItem;
+import gov.nist.secauto.metaschema.core.metapath.item.IItemVisitor;
 import gov.nist.secauto.metaschema.core.util.ObjectUtils;
 
 import java.util.ArrayList;
@@ -570,4 +571,9 @@ static <T extends ICollectionValue> IArrayItem<T> copyOf(@NonNull Collection<? e
             ? empty()
             : new ArrayItemN<>(new ArrayList<>(collection));
   }
+
+  @Override
+  default void accept(IItemVisitor visitor) {
+    visitor.visit(this);
+  }
 }

core/src/main/java/gov/nist/secauto/metaschema/core/metapath/item/function/IMapItem.java

@@ -16,6 +16,7 @@
 import gov.nist.secauto.metaschema.core.metapath.impl.AbstractMapItem;
 import gov.nist.secauto.metaschema.core.metapath.impl.MapItemN;
 import gov.nist.secauto.metaschema.core.metapath.item.IItem;
+import gov.nist.secauto.metaschema.core.metapath.item.IItemVisitor;
 import gov.nist.secauto.metaschema.core.metapath.item.atomic.IAnyAtomicItem;
 
 import java.util.LinkedHashMap;
@@ -782,4 +783,9 @@ IMapItem<V> copyOf(Map<? extends IMapKey, ? extends V> map) {
             ? empty()
             : new MapItemN<>(new LinkedHashMap<>(map));
   }
+
+  @Override
+  default void accept(IItemVisitor visitor) {
+    visitor.visit(this);
+  }
 }

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

@@ -11,38 +11,11 @@
  * A {@link INodeItem} supported by a {@link IFlagInstance}.
  */
 abstract class AbstractFlagInstanceNodeItem
+    extends AbstractInstanceNodeItem<IFlagDefinition, IFlagInstance, IModelNodeItem<?, ?>>
     implements IFlagNodeItem {
-  @NonNull
-  private final IFlagInstance instance;
-  @NonNull
-  private final IModelNodeItem<?, ?> parent;
 
   public AbstractFlagInstanceNodeItem(@NonNull IFlagInstance instance, @NonNull IModelNodeItem<?, ?> parent) {
-    this.instance = instance;
-    this.parent = parent;
-  }
-
-  @Override
-  public IFlagDefinition getDefinition() {
-    return getInstance().getDefinition();
-  }
-
-  @Override
-  @NonNull
-  public IFlagInstance getInstance() {
-    return instance;
-  }
-
-  @Override
-  @NonNull
-  public IModelNodeItem<?, ?> getParentContentNodeItem() {
-    return getParentNodeItem();
-  }
-
-  @Override
-  @NonNull
-  public IModelNodeItem<?, ?> getParentNodeItem() {
-    return parent;
+    super(instance, parent);
   }
 
   @Override