Fix Absolute Path to list with Integer/String key

[cps.git] / cps-path-parser / src / main / java / org / onap / cps / cpspath / parser / CpsPathBuilder.java

diff --git a/cps-path-parser/src/main/java/org/onap/cps/cpspath/parser/CpsPathBuilder.java b/cps-path-parser/src/main/java/org/onap/cps/cpspath/parser/CpsPathBuilder.java
index ebf6fd3..21f5173 100644 (file)
--- a/cps-path-parser/src/main/java/org/onap/cps/cpspath/parser/CpsPathBuilder.java
+++ b/cps-path-parser/src/main/java/org/onap/cps/cpspath/parser/CpsPathBuilder.java
@@ -1,6 +1,6 @@
 /*
  *  ============LICENSE_START=======================================================
- *  Copyright (C) 2021 Nordix Foundation
+ *  Copyright (C) 2021-2022 Nordix Foundation
  *  ================================================================================
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
@@ -25,6 +25,7 @@ import static org.onap.cps.cpspath.parser.CpsPathPrefixType.DESCENDANT;
 import java.util.HashMap;
 import java.util.Map;
 import org.onap.cps.cpspath.parser.antlr4.CpsPathBaseListener;
+import org.onap.cps.cpspath.parser.antlr4.CpsPathParser;
 import org.onap.cps.cpspath.parser.antlr4.CpsPathParser.AncestorAxisContext;
 import org.onap.cps.cpspath.parser.antlr4.CpsPathParser.DescendantContext;
 import org.onap.cps.cpspath.parser.antlr4.CpsPathParser.IncorrectPrefixContext;
@@ -35,18 +36,33 @@ import org.onap.cps.cpspath.parser.antlr4.CpsPathParser.TextFunctionConditionCon
 
 public class CpsPathBuilder extends CpsPathBaseListener {
 
+    private static final String OPEN_BRACKET = "[";
+
+    private static final String CLOSE_BRACKET = "]";
+
     final CpsPathQuery cpsPathQuery = new CpsPathQuery();
 
     final Map<String, Object> leavesData = new HashMap<>();
 
+    final StringBuilder normalizedXpathBuilder = new StringBuilder();
+
+    final StringBuilder normalizedAncestorPathBuilder = new StringBuilder();
+
+    boolean processingAncestorAxis = false;
+
+    @Override
+    public void exitInvalidPostFix(final CpsPathParser.InvalidPostFixContext ctx) {
+        throw new PathParsingException(ctx.getText());
+    }
+
     @Override
     public void exitPrefix(final PrefixContext ctx) {
-        cpsPathQuery.setXpathPrefix(ctx.getText());
+        cpsPathQuery.setXpathPrefix(normalizedXpathBuilder.toString());
     }
 
     @Override
     public void exitIncorrectPrefix(final IncorrectPrefixContext ctx) {
-        throw new IllegalStateException("CPS path can only start with one or two slashes (/)");
+        throw new PathParsingException("CPS path can only start with one or two slashes (/)");
     }
 
     @Override
@@ -56,32 +72,49 @@ public class CpsPathBuilder extends CpsPathBaseListener {
             comparisonValue = Integer.valueOf(ctx.IntegerLiteral().getText());
         }
         if (ctx.StringLiteral() != null) {
+            final boolean wasWrappedInDoubleQuote  = ctx.StringLiteral().getText().startsWith("\"");
             comparisonValue = stripFirstAndLastCharacter(ctx.StringLiteral().getText());
+            if (wasWrappedInDoubleQuote) {
+                comparisonValue = String.valueOf(comparisonValue).replace("'", "\\'");
+            }
         } else if (comparisonValue == null) {
-            throw new IllegalStateException("Unsupported comparison value encountered in expression" + ctx.getText());
+            throw new PathParsingException("Unsupported comparison value encountered in expression" + ctx.getText());
         }
         leavesData.put(ctx.leafName().getText(), comparisonValue);
+        appendCondition(normalizedXpathBuilder, ctx.leafName().getText(), comparisonValue);
+        if (processingAncestorAxis) {
+            appendCondition(normalizedAncestorPathBuilder, ctx.leafName().getText(), comparisonValue);
+        }
     }
 
     @Override
     public void exitDescendant(final DescendantContext ctx) {
         cpsPathQuery.setCpsPathPrefixType(DESCENDANT);
-        cpsPathQuery.setDescendantName(ctx.getText().substring(2));
+        cpsPathQuery.setDescendantName(normalizedXpathBuilder.substring(1));
+        normalizedXpathBuilder.insert(0, "/");
     }
 
     @Override
     public void enterMultipleLeafConditions(final MultipleLeafConditionsContext ctx)  {
+        normalizedXpathBuilder.append(OPEN_BRACKET);
         leavesData.clear();
     }
 
     @Override
     public void exitMultipleLeafConditions(final MultipleLeafConditionsContext ctx) {
+        normalizedXpathBuilder.append(CLOSE_BRACKET);
         cpsPathQuery.setLeavesData(leavesData);
     }
 
+    @Override
+    public void enterAncestorAxis(final AncestorAxisContext ctx) {
+        processingAncestorAxis = true;
+    }
+
     @Override
     public void exitAncestorAxis(final AncestorAxisContext ctx) {
-        cpsPathQuery.setAncestorSchemaNodeIdentifier(ctx.ancestorPath().getText());
+        cpsPathQuery.setAncestorSchemaNodeIdentifier(normalizedAncestorPathBuilder.substring(1));
+        processingAncestorAxis = false;
     }
 
     @Override
@@ -90,7 +123,24 @@ public class CpsPathBuilder extends CpsPathBaseListener {
         cpsPathQuery.setTextFunctionConditionValue(stripFirstAndLastCharacter(ctx.StringLiteral().getText()));
     }
 
+    @Override
+    public void enterListElementRef(final CpsPathParser.ListElementRefContext ctx) {
+        normalizedXpathBuilder.append(OPEN_BRACKET);
+        if (processingAncestorAxis) {
+            normalizedAncestorPathBuilder.append(OPEN_BRACKET);
+        }
+    }
+
+    @Override
+    public void exitListElementRef(final CpsPathParser.ListElementRefContext ctx) {
+        normalizedXpathBuilder.append(CLOSE_BRACKET);
+        if (processingAncestorAxis) {
+            normalizedAncestorPathBuilder.append(CLOSE_BRACKET);
+        }
+    }
+
     CpsPathQuery build() {
+        cpsPathQuery.setNormalizedXpath(normalizedXpathBuilder.toString());
         return cpsPathQuery;
     }
 
@@ -98,4 +148,23 @@ public class CpsPathBuilder extends CpsPathBaseListener {
         return wrappedString.substring(1, wrappedString.length() - 1);
     }
 
+    @Override
+    public void exitContainerName(final CpsPathParser.ContainerNameContext ctx) {
+        normalizedXpathBuilder.append("/")
+                .append(ctx.getText());
+        if (processingAncestorAxis) {
+            normalizedAncestorPathBuilder.append("/").append(ctx.getText());
+        }
+    }
+
+    private void appendCondition(final StringBuilder currentNormalizedPathBuilder, final String name,
+                                final Object value) {
+        final char lastCharacter = currentNormalizedPathBuilder.charAt(currentNormalizedPathBuilder.length() - 1);
+        currentNormalizedPathBuilder.append(lastCharacter == '[' ? "" : " and ")
+                .append("@")
+                .append(name)
+                .append("='")
+                .append(value)
+                .append("'");
+    }
 }