Using different identifier for fields and variables

vepo · vepo · commit 1ea635f7ca7b · 2025-03-17T00:37:14.000-03:00
diff --git a/src/main/antlr4/dev/vepo/jsonata/functions/generated/JSONataGrammar.g4 b/src/main/antlr4/dev/vepo/jsonata/functions/generated/JSONataGrammar.g4
@@ -8,8 +8,8 @@ object: OBJ_OPEN fieldList OBJ_CLOSE                                          #
 expression:
     functionStatement                                                         # functionCall 
     | ROOT                                                                    # rootPath
-    | DOLLAR IDENTIFIER                                                       # variableUsage
     | IDENTIFIER                                                              # identifier 
+    | FV_NAME                                                                 # variableUsage
     | '*'                                                                     # fieldValues
     | DESCEND                                                                 # allDescendantSearch
     | DOLLAR                                                                  # contextReferece
@@ -28,18 +28,18 @@ expression:
     | expression '&' expression                                               # concatValues
     | '(' expression ')'                                                      # contextValue
     | '(' expression ';' (expression ';')+ ')'                                # blockExpression
-    | IDENTIFIER VAR_ASSIGN (expression|functionDeclaration)                  # variableAssignment
+    | FV_NAME VAR_ASSIGN (expression|functionDeclaration)                     # variableAssignment
     | STRING                                                                  # stringValue
     | NUMBER                                                                  # numberValue
     | FLOAT                                                                   # floatValue
     | EXP_NUMBER                                                              # expNumberValue
     | BOOLEAN                                                                 # booleanValue    
     ;
 
-functionStatement: IDENTIFIER '(' parameterStatement (',' parameterStatement)*  ')' ;
+functionStatement: FV_NAME '(' parameterStatement (',' parameterStatement)*  ')' ;
 parameterStatement: expression | functionDeclaration;
 functionDeclaration: 
-    'function' '(' IDENTIFIER (',' IDENTIFIER)* ')' '{' expression+ '}' # functionDeclarationBuilder
+    'function' '(' FV_NAME (',' FV_NAME)* ')' '{' expression+ '}' # functionDeclarationBuilder
     ;
 expressionList: expression (',' expression)*;
 fieldList: expression ':' uniqueObj expOrObject  (',' expression ':' uniqueObj expOrObject)*;
@@ -57,7 +57,9 @@ OBJ_CLOSE: '}';
 VAR_ASSIGN : ':=' ;
 uniqueObj: (DOLLAR DOT)?;
 
-IDENTIFIER: [\p{L}_$] [\p{L}0-9_$]*
+FV_NAME: DOLLAR IDENTIFIER;
+
+IDENTIFIER: [\p{L}_] [\p{L}0-9_$]*
 	        | BACK_QUOTE ~[`]* BACK_QUOTE;
 fragment BACK_QUOTE : '`';
 
diff --git a/src/main/java/dev/vepo/jsonata/functions/BlockContext.java b/src/main/java/dev/vepo/jsonata/functions/BlockContext.java
@@ -0,0 +1,69 @@
+package dev.vepo.jsonata.functions;
+
+import static dev.vepo.jsonata.functions.json.JsonFactory.objectBuilder;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Queue;
+import java.util.function.Predicate;
+
+import dev.vepo.jsonata.functions.data.Data;
+
+public class BlockContext {
+    private final Map<String, JSONataFunction> variables;
+    private final Map<String, DeclaredFunction> functions;
+    private final List<BlockContext> parentContexts;
+
+    public BlockContext(Queue<BlockContext> parentContexts) {
+        this.variables = new HashMap<>();
+        this.functions = new HashMap<>();
+        this.parentContexts = new ArrayList<>(parentContexts);
+    }
+
+    public void defineVariable(String identifier, JSONataFunction variableExpression) {
+        variables.put(identifier, variableExpression);
+    }
+
+    public void defineFunction(String identifier, DeclaredFunction fn) {
+        functions.put(identifier, fn);
+    }
+
+    public Optional<DeclaredFunction> function(String identifier) {
+        return Optional.ofNullable(functions.get(identifier)).or(() -> findFunctionOnParent(identifier));
+    }
+
+    public Optional<JSONataFunction> variable(String identifier) {
+        return Optional.ofNullable(variables.get(identifier)).or(() -> findVariableOnParent(identifier));
+    }
+
+    public Data variables(Data original, Data current) {
+        var builder = objectBuilder();
+        variables.forEach((key, definition) -> builder.set(key, definition.map(original, current)));
+        parentContexts.forEach(context -> context.variables.forEach((key, definition) -> {
+            if (!builder.hasValue(key)) {
+                builder.set(key, definition.map(original, current));
+            }
+        }));
+        return builder.build();
+    }
+
+    private Optional<DeclaredFunction> findFunctionOnParent(String identifier) {
+        return parentContexts.stream()
+                             .map(c -> c.function(identifier))
+                             .filter(Predicate.not(Optional::isEmpty))
+                             .map(Optional::get)
+                             .findFirst();
+    }
+
+    private Optional<JSONataFunction> findVariableOnParent(String identifier) {
+        return parentContexts.stream()
+                             .map(c -> c.variable(identifier))
+                             .filter(Predicate.not(Optional::isEmpty))
+                             .map(Optional::get)
+                             .findFirst();
+    }
+
+}
diff --git a/src/main/java/dev/vepo/jsonata/functions/BockContext.java b/src/main/java/dev/vepo/jsonata/functions/BockContext.java
diff --git a/src/main/java/dev/vepo/jsonata/functions/BuiltInSortJSONataFunction.java b/src/main/java/dev/vepo/jsonata/functions/BuiltInSortJSONataFunction.java
@@ -1,6 +1,5 @@
 package dev.vepo.jsonata.functions;
 
-import java.util.Comparator;
 import java.util.List;
 import java.util.Optional;
 import java.util.stream.IntStream;
@@ -10,21 +9,28 @@
 import dev.vepo.jsonata.functions.data.GroupedData;
 
 public record BuiltInSortJSONataFunction(List<JSONataFunction> providers, Optional<DeclaredFunction> function,
-                                         Comparator<Data> comparator)
+                                         SortComparator comparator)
         implements JSONataFunction {
     public BuiltInSortJSONataFunction {
         if (providers.size() != 1) {
             throw new IllegalArgumentException("Sort function must have 1 argument");
         }
     }
 
+    @FunctionalInterface
+    public interface SortComparator {
+        int compare(Data original, Data current, Data left, Data right);
+    }
+
     public BuiltInSortJSONataFunction(List<JSONataFunction> providers, Optional<DeclaredFunction> function) {
         this(providers, function, buildComparator(function));
     }
 
-    private static Comparator<Data> buildComparator(DeclaredFunction fn) {
-        return (left, right) -> {
-            var result = fn.accept(left, right);
+    private static SortComparator buildComparator(DeclaredFunction fn) {
+        return (original, current, left, right) -> {
+            fn.context().defineVariable(fn.parameterNames().get(0), (o, c) -> left);
+            fn.context().defineVariable(fn.parameterNames().get(1), (o, c) -> right);
+            var result = fn.accept(original, current, fn.context());
             if (result.toJson().isInt()) {
                 return result.toJson().asInt();
             } else if (result.toJson().isBoolean()) {
@@ -35,7 +41,7 @@ private static Comparator<Data> buildComparator(DeclaredFunction fn) {
         };
     }
 
-    private static int defaultComparator(Data left, Data right) {
+    private static int defaultComparator(Data original, Data current, Data left, Data right) {
         if (left.toJson().isInt()) {
             return Integer.compare(left.toJson().asInt(), right.toJson().asInt());
         } else if (left.toJson().isTextual()) {
@@ -45,7 +51,7 @@ private static int defaultComparator(Data left, Data right) {
         }
     }
 
-    private static Comparator<Data> buildComparator(Optional<DeclaredFunction> fn) {
+    private static SortComparator buildComparator(Optional<DeclaredFunction> fn) {
         return fn.map(BuiltInSortJSONataFunction::buildComparator)
                  .orElse(BuiltInSortJSONataFunction::defaultComparator);
     }
@@ -56,7 +62,7 @@ public Data map(Data original, Data current) {
         if (sortValue.isArray()) {
             return new GroupedData(IntStream.range(0, sortValue.length())
                                             .mapToObj(sortValue::at)
-                                            .sorted(comparator)
+                                            .sorted((left, right) -> comparator.compare(original, current, left, right))
                                             .toList());
         } else {
             return sortValue;
diff --git a/src/main/java/dev/vepo/jsonata/functions/DeclaredFunction.java b/src/main/java/dev/vepo/jsonata/functions/DeclaredFunction.java
@@ -1,18 +1,17 @@
 package dev.vepo.jsonata.functions;
 
+import static dev.vepo.jsonata.functions.json.JsonFactory.objectBuilder;
+
 import java.util.List;
-import java.util.stream.IntStream;
 
 import dev.vepo.jsonata.functions.data.Data;
-import dev.vepo.jsonata.functions.json.JsonFactory;
 
-public record DeclaredFunction(List<String> parameterNames, JSONataFunction functions) {
-    Data accept(Data... args) {
-        var input = JsonFactory.objectBuilder();
-        IntStream.range(0, parameterNames.size())
-                 .forEach(i -> input.set(parameterNames.get(i), args[i]));
-        var inputData = input.build();
+public record DeclaredFunction(List<String> parameterNames, BlockContext context, JSONataFunction functions) {
 
-        return functions.map(inputData, inputData);
+    Data accept(Data original, Data current, BlockContext context) {
+        var builder = objectBuilder();
+        builder.fill(current);
+        builder.fill(context.variables(original, current));
+        return functions.map(original, builder.build());
     }
 }
diff --git a/src/main/java/dev/vepo/jsonata/functions/UserDefinedFunctionJSONataFunction.java b/src/main/java/dev/vepo/jsonata/functions/UserDefinedFunctionJSONataFunction.java
@@ -1,16 +1,18 @@
 package dev.vepo.jsonata.functions;
 
 import java.util.List;
+import java.util.stream.IntStream;
 
 import dev.vepo.jsonata.functions.data.Data;
 
 public record UserDefinedFunctionJSONataFunction(List<JSONataFunction> valueProviders, DeclaredFunction fn) implements JSONataFunction {
 
     @Override
     public Data map(Data original, Data current) {
-        return fn.accept(valueProviders.stream()
-                                       .map(provider -> provider.map(original, current))
-                                       .toArray(Data[]::new));
+        IntStream.range(0, fn.parameterNames().size())
+                 .forEach(i -> fn.context()
+                                 .defineVariable(fn.parameterNames().get(i), valueProviders.get(i)));
+        return fn.accept(original, current, fn.context());
     }
 
 }
diff --git a/src/main/java/dev/vepo/jsonata/functions/json/JsonFactory.java b/src/main/java/dev/vepo/jsonata/functions/json/JsonFactory.java
@@ -54,6 +54,7 @@ public static Stream<Data> planify(JsonNode value) {
     public static Data numberValue(Integer value) {
         return new ObjectData(mapper.getNodeFactory().numberNode(value));
     }
+
     public static Data numberValue(BigDecimal value) {
         return new ObjectData(mapper.getNodeFactory().numberNode(value));
     }
@@ -84,7 +85,8 @@ public static ArrayNode arrayNode(List<JsonNode> elements) {
         return array;
     }
 
-    private JsonFactory() {}
+    private JsonFactory() {
+    }
 
     public static record ObjectBuilder(ObjectNode root, boolean groupRecordsInArray) {
 
@@ -159,6 +161,16 @@ public void add(String field, Data value) {
                 root.set(field, arr);
             }
         }
+
+        public void fill(Data current) {
+            current.toJson()
+                   .fields()
+                   .forEachRemaining(entry -> root.set(entry.getKey(), entry.getValue()));
+        }
+
+        public boolean hasValue(String key) {
+            return root.has(key);
+        }
     }
 
     public static ObjectBuilder objectBuilder() {
diff --git a/src/main/java/dev/vepo/jsonata/parser/JSONataGrammarListener.java b/src/main/java/dev/vepo/jsonata/parser/JSONataGrammarListener.java
diff --git a/src/test/java/dev/vepo/jsonata/JSONataTest.java b/src/test/java/dev/vepo/jsonata/JSONataTest.java

Original file line number	Diff line number	Diff line change
`@@ -54,6 +54,7 @@ public static Stream<Data> planify(JsonNode value) {`
`54`	`54`	`public static Data numberValue(Integer value) {`
`55`	`55`	`return new ObjectData(mapper.getNodeFactory().numberNode(value));`
`56`	`56`	`}`
	`57`	`+`
`57`	`58`	`public static Data numberValue(BigDecimal value) {`
`58`	`59`	`return new ObjectData(mapper.getNodeFactory().numberNode(value));`
`59`	`60`	`}`
`@@ -84,7 +85,8 @@ public static ArrayNode arrayNode(List<JsonNode> elements) {`
`84`	`85`	`return array;`
`85`	`86`	`}`
`86`	`87`
`87`		`- private JsonFactory() {}`
	`88`	`+ private JsonFactory() {`
	`89`	`+ }`
`88`	`90`
`89`	`91`	`public static record ObjectBuilder(ObjectNode root, boolean groupRecordsInArray) {`
`90`	`92`
`@@ -159,6 +161,16 @@ public void add(String field, Data value) {`
`159`	`161`	`root.set(field, arr);`
`160`	`162`	`}`
`161`	`163`	`}`
	`164`	`+`
	`165`	`+ public void fill(Data current) {`
	`166`	`+ current.toJson()`
	`167`	`+ .fields()`
	`168`	`+ .forEachRemaining(entry -> root.set(entry.getKey(), entry.getValue()));`
	`169`	`+ }`
	`170`	`+`
	`171`	`+ public boolean hasValue(String key) {`
	`172`	`+ return root.has(key);`
	`173`	`+ }`
`162`	`174`	`}`
`163`	`175`
`164`	`176`	`public static ObjectBuilder objectBuilder() {`