Normalize expression variables (#1146)

* Normalize archetype expression variables

ScriptCompiler:
- Use absolute context reference in variable expression
- Fix NO_OUTPUT
- Move mirror outside of Image
- Make Image public

JsonScriptWriter:
- Fix expressions duplications
- Exclude empty attributes (I.e. expressions, methods, children)

Misc:
- Update stager plugin to support incremental staging (I.e. don't fail if output files already exist)

* Add test for normalized expressions

* Fix ReflectedEngine

Author: romain-grecourt

archetype/engine-v2-json/src/main/java/io/helidon/build/archetype/v2/json/JsonScriptWriter.java

@@ -16,7 +16,7 @@
 package io.helidon.build.archetype.v2.json;
 
 import java.io.Writer;
-import java.util.HashMap;
+import java.util.LinkedHashMap;
 import java.util.Map;
 import java.util.concurrent.atomic.AtomicInteger;
 
@@ -33,7 +33,7 @@
  */
 public class JsonScriptWriter implements Script.Writer {
 
-    private final Map<Expression, String> expressions = new HashMap<>();
+    private final Map<Expression, String> expressions = new LinkedHashMap<>();
     private final JsonGenerator generator;
 
     /**
@@ -54,23 +54,40 @@ public void close() {
     @Override
     public void writeScript(Node script) {
         generator.writeStartObject();
-        generator.writeStartObject("expressions");
-        for (Node node : script.traverse()) {
-            if (node.kind() == Kind.CONDITION) {
-                writeExpression(node.expression());
-            }
+
+        // compute expression ids
+        for (Node node : script.traverse(Kind.CONDITION::equals)) {
+            expressions.computeIfAbsent(node.expression(), k -> String.valueOf(expressions.size() + 1));
         }
-        generator.writeEnd();
-        generator.writeStartObject("methods");
-        script.script().methods().forEach((k, v) -> {
-            generator.writeStartArray(k);
-            writeDirectives(v);
+
+        // write expressions
+        if (!expressions.isEmpty()) {
+            generator.writeStartObject("expressions");
+            expressions.forEach(this::writeExpression);
             generator.writeEnd();
-        });
-        generator.writeEnd();
-        generator.writeStartArray("children");
-        writeDirectives(script);
+        }
+
+        // write methods
+        Map<String, Node> methods = script.script().methods();
+        if (!methods.isEmpty()) {
+            generator.writeStartObject("methods");
+            methods.forEach(this::writeMethod);
+            generator.writeEnd();
+        }
+
+        // write children
+        if (!script.children().isEmpty()) {
+            generator.writeStartArray("children");
+            writeDirectives(script);
+            generator.writeEnd();
+        }
+
         generator.writeEnd();
+    }
+
+    private void writeMethod(String methodName, Node method) {
+        generator.writeStartArray(methodName);
+        writeDirectives(method);
         generator.writeEnd();
     }
 
@@ -140,8 +157,7 @@ private void writeValue(Node node) {
         }
     }
 
-    private void writeExpression(Expression expr) {
-        String id = expressions.computeIfAbsent(expr, k -> String.valueOf(expressions.size() + 1));
+    private void writeExpression(Expression expr, String id) {
         generator.writeStartArray(id);
         for (Expression.Token token : expr.tokens()) {
             generator.writeStartObject();

archetype/engine-v2-json/src/test/resources/writer/expressions.json

@@ -609,7 +609,6 @@
             }
         ]
     },
-    "methods": {},
     "children": [
         {
             "kind": "step",

archetype/engine-v2-json/src/test/resources/writer/inputs.json

@@ -7,8 +7,6 @@
             }
         ]
     },
-    "methods": {
-    },
     "children": [
         {
             "kind": "step",

archetype/engine-v2-json/src/test/resources/writer/methods.json

@@ -1,6 +1,4 @@
 {
-    "expressions": {
-    },
     "methods": {
         "method1": [
             {
@@ -24,7 +22,5 @@
                 ]
             }
         ]
-    },
-    "children": [
-    ]
+    }
 }

archetype/engine-v2-json/src/test/resources/writer/presets.json

@@ -1,8 +1,4 @@
 {
-    "expressions": {
-    },
-    "methods": {
-    },
     "children": [
         {
             "kind": "presets",

archetype/engine-v2-json/src/test/resources/writer/validations.json

@@ -1,8 +1,4 @@
 {
-    "expressions": {
-    },
-    "methods": {
-    },
     "children": [
         {
             "kind": "validations",

archetype/engine-v2-json/src/test/resources/writer/variables.json

@@ -1,8 +1,4 @@
 {
-    "expressions": {
-    },
-    "methods": {
-    },
     "children": [
         {
             "kind": "variables",

archetype/engine-v2/src/main/java/io/helidon/build/archetype/engine/v2/ArchetypeEngineV2.java

@@ -16,7 +16,6 @@
 
 package io.helidon.build.archetype.engine.v2;
 
-import java.nio.file.FileSystem;
 import java.nio.file.Path;
 import java.util.Map;
 import java.util.function.Function;
@@ -195,13 +194,13 @@ public Builder batch(boolean batch) {
         }
 
         /**
-         * Set the archetype file system.
+         * Set the current working directory.
          *
-         * @param fileSystem archetype file system
+         * @param cwd cwd
          * @return this builder
          */
-        public Builder fileSystem(FileSystem fileSystem) {
-            this.cwd = fileSystem.getPath("/");
+        public Builder cwd(Path cwd) {
+            this.cwd = cwd;
             return this;
         }
 

archetype/engine-v2/src/main/java/io/helidon/build/archetype/engine/v2/Expression.java

@@ -35,6 +35,7 @@
 import java.util.Stack;
 import java.util.TreeMap;
 import java.util.function.Function;
+import java.util.function.UnaryOperator;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
@@ -87,7 +88,7 @@ public final class Expression implements Comparable<Expression> {
         this(parse(expression), false);
     }
 
-    private Expression(List<Token> tokens, boolean reduced) {
+    Expression(List<Token> tokens, boolean reduced) {
         if (tokens.isEmpty()) {
             throw new IllegalArgumentException("Empty expression");
         }
@@ -170,6 +171,16 @@ public Set<String> variables() {
         return variables.get();
     }
 
+    /**
+     * Map this expression.
+     *
+     * @param mapper mapper
+     * @return Expression
+     */
+    public Expression map(UnaryOperator<Token> mapper) {
+        return new Expression(Lists.map(tokens, mapper), false);
+    }
+
     /**
      * Evaluate this expression.
      *