From 64dac20010335302366a4400542ea0a8b07aa148 Mon Sep 17 00:00:00 2001
From: rolaca11 <rolaca12@gmail.com>
Date: Thu, 21 Oct 2021 23:38:34 +0200
Subject: [PATCH] feat: display value selector
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* #81 add a displayExpression property, that allows a different display value to the one included in env variables

* #81 fix test configuration

* #81 enhancements based on review comments

* #81 revert select option values to be the actual value

* fix: parameter rebuild behaviour

* refactor display value logic

* bump version

* remove no longer working tooltip

Co-authored-by: László Stahorszki <laszlo.stahorszki@ropi.dev>
Co-authored-by: h1dden-da3m0n <33120068+h1dden-da3m0n@users.noreply.github.com>
---
 .idea/codeStyles/Project.xml                  |  2 +-
 pom.xml                                       |  2 +-
 .../RestListParameterDefinition.java          | 55 +++++++++++---
 .../restlistparam/RestListParameterValue.java | 18 +++--
 .../restlistparam/logic/RestValueService.java | 65 ++++++++--------
 .../restlistparam/logic/ValueResolver.java    | 75 ++++++++++++++-----
 .../restlistparam/model/ValueItem.java        | 57 ++++++++++++++
 .../plugins/restlistparam/Messages.properties |  1 +
 .../RestListParameterDefinition/config.jelly  |  6 +-
 .../config.properties                         |  1 +
 .../help-displayExpression.html               | 13 ++++
 .../RestListParameterDefinition/index.jelly   |  6 +-
 .../RestListParameterValue/value.jelly        |  2 +-
 .../restlistparam/RestValueServiceTest.java   | 31 ++++----
 .../plugins/restlistparam/TestConst.java      | 19 ++++-
 .../restlistparam/ValueResolverTest.java      | 59 ++++++++++-----
 16 files changed, 303 insertions(+), 109 deletions(-)
 create mode 100644 src/main/java/io/jenkins/plugins/restlistparam/model/ValueItem.java
 create mode 100644 src/main/resources/io/jenkins/plugins/restlistparam/RestListParameterDefinition/help-displayExpression.html

diff --git a/.idea/codeStyles/Project.xml b/.idea/codeStyles/Project.xml
index fc4a467..75afe59 100644
--- a/.idea/codeStyles/Project.xml
+++ b/.idea/codeStyles/Project.xml
@@ -31,7 +31,7 @@
     <codeStyleSettings language="JAVA">
       <option name="BRACE_STYLE" value="5" />
       <option name="CLASS_BRACE_STYLE" value="5" />
-      <option name="METHOD_BRACE_STYLE" value="2" />
+      <option name="METHOD_BRACE_STYLE" value="5" />
       <option name="ELSE_ON_NEW_LINE" value="true" />
       <option name="CATCH_ON_NEW_LINE" value="true" />
       <option name="FINALLY_ON_NEW_LINE" value="true" />
diff --git a/pom.xml b/pom.xml
index d8807d7..f356b7b 100644
--- a/pom.xml
+++ b/pom.xml
@@ -10,7 +10,7 @@
   </parent>
 
   <properties>
-    <revision>1.4.3</revision>
+    <revision>1.5.0</revision>
     <changelist>-SNAPSHOT</changelist>
     <!-- Baseline Jenkins version you use to build the plugin. Users must have this version or newer to run. -->
     <jenkins.version>2.263.4</jenkins.version>
diff --git a/src/main/java/io/jenkins/plugins/restlistparam/RestListParameterDefinition.java b/src/main/java/io/jenkins/plugins/restlistparam/RestListParameterDefinition.java
index 1f5bda7..98f2c7c 100644
--- a/src/main/java/io/jenkins/plugins/restlistparam/RestListParameterDefinition.java
+++ b/src/main/java/io/jenkins/plugins/restlistparam/RestListParameterDefinition.java
@@ -3,6 +3,8 @@
 import com.cloudbees.plugins.credentials.common.StandardCredentials;
 import hudson.Extension;
 import hudson.model.Item;
+import io.jenkins.plugins.restlistparam.logic.ValueResolver;
+import io.jenkins.plugins.restlistparam.model.ValueItem;
 import hudson.model.ParameterDefinition;
 import hudson.model.ParameterValue;
 import hudson.model.SimpleParameterDefinition;
@@ -21,7 +23,6 @@
 import org.kohsuke.stapler.*;
 import org.kohsuke.stapler.verb.POST;
 
-import javax.annotation.CheckForNull;
 import javax.annotation.Nonnull;
 import java.util.Collections;
 import java.util.List;
@@ -36,12 +37,13 @@ public final class RestListParameterDefinition extends SimpleParameterDefinition
   private final String credentialId;
   private final MimeType mimeType;
   private final String valueExpression;
+  private String displayExpression;
   private ValueOrder valueOrder;
   private String defaultValue;
   private String filter;
   private Integer cacheTime;
   private String errorMsg;
-  private List<String> values;
+  private List<ValueItem> values;
 
   @DataBoundConstructor
   public RestListParameterDefinition(final String name,
@@ -49,10 +51,11 @@ public RestListParameterDefinition(final String name,
                                      final String restEndpoint,
                                      final String credentialId,
                                      final MimeType mimeType,
-                                     final String valueExpression)
+                                     final String valueExpression,
+                                     final String displayExpression)
   {
     this(name, description, restEndpoint, credentialId, mimeType, valueExpression,
-         ValueOrder.NONE, ".*", config.getCacheTime(), "");
+      displayExpression, ValueOrder.NONE, ".*", config.getCacheTime(), "");
   }
 
   public RestListParameterDefinition(final String name,
@@ -61,6 +64,7 @@ public RestListParameterDefinition(final String name,
                                      final String credentialId,
                                      final MimeType mimeType,
                                      final String valueExpression,
+                                     final String displayExpression,
                                      final ValueOrder valueOrder,
                                      final String filter,
                                      final Integer cacheTime,
@@ -71,6 +75,9 @@ public RestListParameterDefinition(final String name,
     this.mimeType = mimeType;
     this.valueExpression = valueExpression;
     this.credentialId = StringUtils.isNotBlank(credentialId) ? credentialId : "";
+    if (mimeType == MimeType.APPLICATION_JSON) {
+      this.displayExpression = StringUtils.isNotBlank(displayExpression) ? displayExpression : "$";
+    }
     this.defaultValue = StringUtils.isNotBlank(defaultValue) ? defaultValue : "";
     this.valueOrder = valueOrder != null ? valueOrder : ValueOrder.NONE;
     this.filter = StringUtils.isNotBlank(filter) ? filter : ".*";
@@ -99,6 +106,18 @@ public String getFilter() {
     return filter;
   }
 
+  public String getDisplayExpression() {
+    if (mimeType == MimeType.APPLICATION_JSON) {
+      return StringUtils.isNotBlank(displayExpression) ? displayExpression : "$";
+    }
+    return "";
+  }
+
+  @DataBoundSetter
+  public void setDisplayExpression(final String displayExpression) {
+    this.displayExpression = displayExpression;
+  }
+
   @DataBoundSetter
   public void setValueOrder(final ValueOrder valueOrder) {
     this.valueOrder = valueOrder;
@@ -139,15 +158,16 @@ public String getErrorMsg() {
     return errorMsg;
   }
 
-  public List<String> getValues() {
+  public List<ValueItem> getValues() {
     Optional<StandardCredentials> credentials = CredentialsUtils.findCredentials(null, credentialId);
 
-    ResultContainer<List<String>> container = RestValueService.get(
+    ResultContainer<List<ValueItem>> container = RestValueService.get(
       getRestEndpoint(),
       credentials.orElse(null),
       getMimeType(),
       getCacheTime(),
       getValueExpression(),
+      getDisplayExpression(),
       getFilter(),
       getValueOrder());
 
@@ -162,7 +182,8 @@ public ParameterDefinition copyWithDefaultValue(final ParameterValue defaultValu
       RestListParameterValue value = (RestListParameterValue) defaultValue;
       return new RestListParameterDefinition(
         getName(), getDescription(), getRestEndpoint(), getCredentialId(), getMimeType(),
-        getValueExpression(), getValueOrder(), getFilter(), getCacheTime(), value.getValue());
+        getValueExpression(), getDisplayExpression(), getValueOrder(), getFilter(), getCacheTime(),
+        ValueResolver.parseDisplayValue(getMimeType(), value.getValue(), displayExpression));
     }
     else {
       return this;
@@ -172,16 +193,17 @@ public ParameterDefinition copyWithDefaultValue(final ParameterValue defaultValu
   @Override
   public ParameterValue createValue(final String value) {
     RestListParameterValue parameterValue = new RestListParameterValue(getName(), value, getDescription());
+
     checkValue(parameterValue);
     return parameterValue;
   }
 
   @Override
-  @CheckForNull
   public ParameterValue createValue(final StaplerRequest req,
                                     final JSONObject jo)
   {
     RestListParameterValue value = req.bindJSON(RestListParameterValue.class, jo);
+
     checkValue(value);
     return value;
   }
@@ -194,7 +216,14 @@ private void checkValue(final RestListParameterValue value) {
 
   @Override
   public boolean isValid(ParameterValue value) {
-    return values.contains(((RestListParameterValue) value).getValue());
+    if(value == null || value.getValue() == null) {
+      return false;
+    }
+
+    return values.stream()
+      .map(ValueItem::getValue)
+      .filter(Objects::nonNull)
+      .anyMatch(val -> value.getValue().equals(val));
   }
 
   @Override
@@ -333,6 +362,7 @@ public FormValidation doTestConfiguration(@AncestorInPath final Item context,
                                               @QueryParameter final String credentialId,
                                               @QueryParameter final MimeType mimeType,
                                               @QueryParameter final String valueExpression,
+                                              @QueryParameter final String displayExpression,
                                               @QueryParameter final String filter,
                                               @QueryParameter final ValueOrder valueOrder)
     {
@@ -357,24 +387,25 @@ public FormValidation doTestConfiguration(@AncestorInPath final Item context,
         return FormValidation.error(Messages.RLP_DescriptorImpl_ValidationErr_ExpressionEmpty());
       }
 
-      ResultContainer<List<String>> container = RestValueService.get(
+      ResultContainer<List<ValueItem>> container = RestValueService.get(
         restEndpoint,
         credentials.orElse(null),
         mimeType,
         0,
         valueExpression,
+        displayExpression,
         filter,
         valueOrder);
 
       Optional<String> errorMsg = container.getErrorMsg();
-      List<String> values = container.getValue();
+      List<ValueItem> values = container.getValue();
       if (errorMsg.isPresent()) {
         return FormValidation.error(errorMsg.get());
       }
 
       // values should NEVER be empty here
       // due to all the filtering and error handling done in the RestValueService
-      return FormValidation.ok(Messages.RLP_DescriptorImpl_ValidationOk_ConfigValid(values.size(), values.get(0)));
+      return FormValidation.ok(Messages.RLP_DescriptorImpl_ValidationOk_ConfigValid(values.size(), values.get(0).getDisplayValue()));
     }
   }
 }
\ No newline at end of file
diff --git a/src/main/java/io/jenkins/plugins/restlistparam/RestListParameterValue.java b/src/main/java/io/jenkins/plugins/restlistparam/RestListParameterValue.java
index 6ab6092..de93dfc 100644
--- a/src/main/java/io/jenkins/plugins/restlistparam/RestListParameterValue.java
+++ b/src/main/java/io/jenkins/plugins/restlistparam/RestListParameterValue.java
@@ -18,18 +18,18 @@
 public final class RestListParameterValue extends ParameterValue {
   @Exported(visibility = 4)
   @Restricted(NoExternalUse.class)
-  public String value;
+  private final String value;
 
   @DataBoundConstructor
-  public RestListParameterValue(String name,
-                                String value)
+  public RestListParameterValue(final String name,
+                                final String value)
   {
     this(name, value, null);
   }
 
-  public RestListParameterValue(String name,
-                                String value,
-                                String description)
+  public RestListParameterValue(final String name,
+                                final String value,
+                                final String description)
   {
     super(name, description);
     this.value = value;
@@ -87,7 +87,11 @@ public boolean equals(Object obj) {
 
   @Override
   public String toString() {
-    return "(RestListParameterValue) " + getName() + "='" + value + "'";
+    return "{" +
+      "\"type\": \"RestListParameterValue\", "+
+      "\"name:\": \"" + getName() + "\", " +
+      "\"value\": \"" + value + "\"" +
+      "}";
   }
 
   @Override
diff --git a/src/main/java/io/jenkins/plugins/restlistparam/logic/RestValueService.java b/src/main/java/io/jenkins/plugins/restlistparam/logic/RestValueService.java
index d9419a1..7002267 100644
--- a/src/main/java/io/jenkins/plugins/restlistparam/logic/RestValueService.java
+++ b/src/main/java/io/jenkins/plugins/restlistparam/logic/RestValueService.java
@@ -4,6 +4,7 @@
 import com.cloudbees.plugins.credentials.common.StandardUsernamePasswordCredentials;
 import hudson.util.FormValidation;
 import io.jenkins.plugins.restlistparam.Messages;
+import io.jenkins.plugins.restlistparam.model.ValueItem;
 import io.jenkins.plugins.restlistparam.model.MimeType;
 import io.jenkins.plugins.restlistparam.model.ResultContainer;
 import io.jenkins.plugins.restlistparam.model.ValueOrder;
@@ -39,29 +40,31 @@ private RestValueService() {
    * This method uses its parameters to query a REST/Web endpoint to receive a {@link MimeType} response, which then
    * gets parsed with a supported Path expression to extract a list of string values.
    *
-   * @param restEndpoint A http/https web address to the REST/Web endpoint
-   * @param credentials  The credentials required to access said endpoint
-   * @param mimeType     The MIME type of the expected REST/Web response
-   * @param cacheTime    Time for how long the REST response gets cached for in minutes
-   * @param expression   The Json-Path or xPath expression to filter the values
-   * @param filter       additional regex filter on any parsed values
-   * @param order        Set a {@link ValueOrder} to optionally reorder the values
+   * @param restEndpoint      A http/https web address to the REST/Web endpoint
+   * @param credentials       The credentials required to access said endpoint
+   * @param mimeType          The MIME type of the expected REST/Web response
+   * @param cacheTime         Time for how long the REST response gets cached for in minutes
+   * @param valueExpression   The Json-Path or xPath expression to filter the values
+   * @param displayExpression The Json-Path or xPath expression to filter the display values
+   * @param filter            additional regex filter on any parsed values
+   * @param order             Set a {@link ValueOrder} to optionally reorder the values
    * @return A {@link ResultContainer} that capsules either the desired values or a user friendly error message.
    */
-  public static ResultContainer<List<String>> get(final String restEndpoint,
-                                                  final StandardCredentials credentials,
-                                                  final MimeType mimeType,
-                                                  final Integer cacheTime,
-                                                  final String expression,
-                                                  final String filter,
-                                                  final ValueOrder order)
+  public static ResultContainer<List<ValueItem>> get(final String restEndpoint,
+                                                     final StandardCredentials credentials,
+                                                     final MimeType mimeType,
+                                                     final Integer cacheTime,
+                                                     final String valueExpression,
+                                                     final String displayExpression,
+                                                     final String filter,
+                                                     final ValueOrder order)
   {
-    ResultContainer<List<String>> valueList = new ResultContainer<>(Collections.emptyList());
+    ResultContainer<List<ValueItem>> valueList = new ResultContainer<>(Collections.emptyList());
     ResultContainer<String> rawValues = getValueStringFromRestEndpoint(restEndpoint, credentials, mimeType, cacheTime);
     Optional<String> rawValueError = rawValues.getErrorMsg();
 
     if (!rawValueError.isPresent()) {
-      valueList = convertToValuesList(mimeType, rawValues.getValue(), expression);
+      valueList = convertToValuesList(mimeType, rawValues.getValue(), valueExpression, displayExpression);
     }
     else {
       valueList.setErrorMsg(rawValueError.get());
@@ -224,21 +227,23 @@ else if (credentials instanceof StringCredentials) {
    *
    * @param mimeType    The {@link MimeType} of the {@code valueString}
    * @param valueString The value string to be parsed
-   * @param expression  The Json-Path or xPath expression to apply on the {@code valueString}
+   * @param valueExpression  The Json-Path or xPath expression to apply on the {@code valueString}
+   * @param displayExpression Derives the value to be displayed to the user parsed by value expression
    * @return A {@link ResultContainer} capsuling the results of the applied expression or an error message
    */
-  private static ResultContainer<List<String>> convertToValuesList(final MimeType mimeType,
-                                                                   final String valueString,
-                                                                   final String expression)
+  private static ResultContainer<List<ValueItem>> convertToValuesList(final MimeType mimeType,
+                                                                      final String valueString,
+                                                                      final String valueExpression,
+                                                                      final String displayExpression)
   {
-    ResultContainer<List<String>> container;
+    ResultContainer<List<ValueItem>> container;
 
     switch (mimeType) {
       case APPLICATION_JSON:
-        container = ValueResolver.resolveJsonPath(valueString, expression);
+        container = ValueResolver.resolveJsonPath(valueString, valueExpression, displayExpression);
         break;
       case APPLICATION_XML:
-        container = ValueResolver.resolveXPath(valueString, expression);
+        container = ValueResolver.resolveXPath(valueString, valueExpression, displayExpression);
         break;
       default:
         throw new IllegalStateException("Unexpected value: " + mimeType);
@@ -255,18 +260,18 @@ private static ResultContainer<List<String>> convertToValuesList(final MimeType
    * @param order  The Order to apply (if any)
    * @return A {@link ResultContainer} capsuling a filtered string list or a user friendly error message
    */
-  private static ResultContainer<List<String>> filterAndSortValues(final List<String> values,
-                                                                   final String filter,
-                                                                   final ValueOrder order)
+  private static ResultContainer<List<ValueItem>> filterAndSortValues(final List<ValueItem> values,
+                                                                      final String filter,
+                                                                      final ValueOrder order)
   {
-    ResultContainer<List<String>> container = new ResultContainer<>(Collections.emptyList());
+    ResultContainer<List<ValueItem>> container = new ResultContainer<>(Collections.emptyList());
 
     try {
-      List<String> updatedValues;
+      List<ValueItem> updatedValues;
 
       if (isFilterSet(filter) && !isOrderSet(order)) {
         updatedValues = values.stream()
-                              .filter(value -> value.matches(filter))
+                              .filter(value -> value.getValue().matches(filter))
                               .collect(Collectors.toList());
       }
       else if (!isFilterSet(filter) && isOrderSet(order)) {
@@ -276,7 +281,7 @@ else if (!isFilterSet(filter) && isOrderSet(order)) {
       }
       else {
         updatedValues = values.stream()
-                              .filter(value -> value.matches(filter))
+                              .filter(value -> value.getValue().matches(filter))
                               .sorted(order == ValueOrder.ASC ? Comparator.naturalOrder() : Comparator.reverseOrder())
                               .collect(Collectors.toList());
       }
diff --git a/src/main/java/io/jenkins/plugins/restlistparam/logic/ValueResolver.java b/src/main/java/io/jenkins/plugins/restlistparam/logic/ValueResolver.java
index b432201..06a5883 100644
--- a/src/main/java/io/jenkins/plugins/restlistparam/logic/ValueResolver.java
+++ b/src/main/java/io/jenkins/plugins/restlistparam/logic/ValueResolver.java
@@ -5,7 +5,9 @@
 import com.jayway.jsonpath.JsonPath;
 import com.jayway.jsonpath.PathNotFoundException;
 import io.jenkins.plugins.restlistparam.Messages;
+import io.jenkins.plugins.restlistparam.model.MimeType;
 import io.jenkins.plugins.restlistparam.model.ResultContainer;
+import io.jenkins.plugins.restlistparam.model.ValueItem;
 import org.w3c.dom.Document;
 import org.w3c.dom.NodeList;
 import org.xml.sax.InputSource;
@@ -22,7 +24,9 @@
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
+import java.util.Map;
 import java.util.logging.Logger;
+import java.util.stream.Collectors;
 
 public class ValueResolver {
   private static final Logger log = Logger.getLogger(ValueResolver.class.getName());
@@ -34,14 +38,20 @@ private ValueResolver() {
   /**
    * Parses a {@code xmlStr}, applies a xPath {@code expression} and returns a list of strings based on the result
    *
-   * @param xmlStr     The XML text as string
-   * @param expression The xPath expression
-   * @return A {@link ResultContainer} capsuling either a list of strings or a user friendly error message
+   * @param xmlStr            The XML text as string
+   * @param expression        The xPath expression
+   * @param displayExpression The xPath expression
+   * @return A {@link ResultContainer} capsuling either a list of strings or a user-friendly error message
    */
-  public static ResultContainer<List<String>> resolveXPath(final String xmlStr,
-                                                           final String expression)
+  public static ResultContainer<List<ValueItem>> resolveXPath(final String xmlStr,
+                                                              final String expression,
+                                                              final String displayExpression)
   {
-    ResultContainer<List<String>> container = new ResultContainer<>(Collections.emptyList());
+    ResultContainer<List<ValueItem>> container = new ResultContainer<>(Collections.emptyList());
+
+    if (!displayExpression.equals("")) {
+      log.warning(Messages.RLP_ValueResolver_warn_xPath_DisplayExpression());
+    }
 
     try {
       DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
@@ -86,11 +96,11 @@ public static ResultContainer<List<String>> resolveXPath(final String xmlStr,
    * @param nodeList The {@link NodeList} to convert
    * @return A list of strings converted from the {@code nodeList} (can be empty if {@code nodeList} is empty)
    */
-  private static List<String> xmlNodeListToList(NodeList nodeList) {
-    List<String> res = new ArrayList<>(nodeList.getLength());
+  private static List<ValueItem> xmlNodeListToList(NodeList nodeList) {
+    List<ValueItem> res = new ArrayList<>(nodeList.getLength());
 
     for (int i = 0; i < nodeList.getLength(); ++i) {
-      res.add(nodeList.item(i).getTextContent());
+      res.add(new ValueItem(nodeList.item(i).getTextContent(), nodeList.item(i).getTextContent()));
     }
 
     return res;
@@ -99,20 +109,29 @@ private static List<String> xmlNodeListToList(NodeList nodeList) {
   /**
    * Parses a {@code jsonStr}, applies a Json-Path {@code expression} and returns a list of strings based on the result
    *
-   * @param jsonStr    The Json text as string
-   * @param expression The Json-Path expression
-   * @return A {@link ResultContainer} capsuling either a list of strings or a user friendly error message
+   * @param jsonStr           The Json text as string
+   * @param expression        The Json-Path expression
+   * @param displayExpression The Json-Path expression
+   * @return A {@link ResultContainer} capsuling either a list of strings or a user-friendly error message
    */
-  public static ResultContainer<List<String>> resolveJsonPath(final String jsonStr,
-                                                              final String expression)
+  public static ResultContainer<List<ValueItem>> resolveJsonPath(final String jsonStr,
+                                                                 final String expression,
+                                                                 final String displayExpression)
   {
-    ResultContainer<List<String>> container = new ResultContainer<>(Collections.emptyList());
+    ResultContainer<List<ValueItem>> container = new ResultContainer<>(Collections.emptyList());
 
     try {
-      final List<String> resolved = JsonPath.parse(jsonStr).read(expression);
+      final List<Object> resolved = JsonPath.parse(jsonStr).read(expression);
 
       if (!resolved.isEmpty()) {
-        container.setValue(new ArrayList<>(resolved));
+        container.setValue(
+          resolved.stream()
+                  .map(JsonPath::parse)
+                  .map(context -> context.read("$"))
+                  .map(read -> (read instanceof Map) ? JsonPath.parse(read).jsonString() : (String) read)
+                  .map(value -> new ValueItem(value, parseDisplayValue(value, displayExpression)))
+                  .collect(Collectors.toList())
+        );
       }
       else {
         log.warning(Messages.RLP_ValueResolver_warn_jPath_NoValues());
@@ -139,6 +158,28 @@ public static ResultContainer<List<String>> resolveJsonPath(final String jsonStr
     return container;
   }
 
+  /**
+   * Apply the display expression filter on a given value (only JSON supported).
+   *
+   * @param mime              The {@link MimeType} of the value to pars for the display value.
+   * @param valueStr          The value the display value should be parsed from.
+   * @param displayExpression The display expression to filter for the display value in {@code valueStr}.
+   * @return Returns the display value.
+   */
+  public static String parseDisplayValue(MimeType mime, String valueStr, String displayExpression) {
+    if (mime == MimeType.APPLICATION_JSON) {
+      return parseDisplayValue(valueStr, displayExpression);
+    }
+    if (!displayExpression.isEmpty()) {
+      log.warning(Messages.RLP_ValueResolver_warn_xPath_DisplayExpression());
+    }
+    return valueStr;
+  }
+
+  private static String parseDisplayValue(String jsonStr, String displayExpression) {
+    return JsonPath.parse(jsonStr).read(displayExpression);
+  }
+
   /**
    * A helper method to generate user friendly debug messages (Log level {@code finer})
    *
diff --git a/src/main/java/io/jenkins/plugins/restlistparam/model/ValueItem.java b/src/main/java/io/jenkins/plugins/restlistparam/model/ValueItem.java
new file mode 100644
index 0000000..4f543ab
--- /dev/null
+++ b/src/main/java/io/jenkins/plugins/restlistparam/model/ValueItem.java
@@ -0,0 +1,57 @@
+package io.jenkins.plugins.restlistparam.model;
+
+import java.io.Serializable;
+import java.util.Objects;
+
+public class ValueItem implements Comparable<ValueItem>, Serializable {
+  private String value;
+  private String displayValue;
+
+  public ValueItem() {
+  }
+
+  public ValueItem(String value, String displayValue) {
+    this.value = value;
+    this.displayValue = displayValue;
+  }
+
+  public String getValue() {
+    return value;
+  }
+
+  public void setValue(String value) {
+    this.value = value;
+  }
+
+  public String getDisplayValue() {
+    return displayValue;
+  }
+
+  public void setDisplayValue(String displayValue) {
+    this.displayValue = displayValue;
+  }
+
+  @Override
+  public String toString() {
+    return value;
+  }
+
+
+  @Override
+  public int compareTo(ValueItem o) {
+    return value.compareTo(o.getValue());
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) return true;
+    if (o == null || getClass() != o.getClass()) return false;
+    ValueItem item = (ValueItem) o;
+    return Objects.equals(value, item.value) && Objects.equals(displayValue, item.displayValue);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(value, displayValue);
+  }
+}
diff --git a/src/main/resources/io/jenkins/plugins/restlistparam/Messages.properties b/src/main/resources/io/jenkins/plugins/restlistparam/Messages.properties
index 98abd3d..2f0ca04 100644
--- a/src/main/resources/io/jenkins/plugins/restlistparam/Messages.properties
+++ b/src/main/resources/io/jenkins/plugins/restlistparam/Messages.properties
@@ -30,6 +30,7 @@ RLP.RestValueService.warn.UnsupportedCredential=Attempted to use unsupported Cre
 RLP.RestValueService.info.FilterReturnedNoValues=The filter `{0}` left no values to be displayed
 RLP.RestValueService.warn.FilterErr=Filtering value list threw {0}
 # ValueResolver xPath logging Strings
+RLP.ValueResolver.warn.xPath.DisplayExpression=The DisplayExpression option is unsupported for XML values!
 RLP.ValueResolver.warn.xPath.NoValues=xPath expression yielded no values
 RLP.ValueResolver.warn.xPath.ExpressionErr=Error in provided xPath expression
 RLP.ValueResolver.warn.xPath.MalformedXml=Tried to pars malformed XML
diff --git a/src/main/resources/io/jenkins/plugins/restlistparam/RestListParameterDefinition/config.jelly b/src/main/resources/io/jenkins/plugins/restlistparam/RestListParameterDefinition/config.jelly
index 4a69aab..86f5303 100644
--- a/src/main/resources/io/jenkins/plugins/restlistparam/RestListParameterDefinition/config.jelly
+++ b/src/main/resources/io/jenkins/plugins/restlistparam/RestListParameterDefinition/config.jelly
@@ -25,6 +25,10 @@
   <!-- Some advances options -->
   <f:advanced>
     <f:section title="${%parameter.advanced}" >
+      <f:entry title="${%parameter.displayExpression}" field="displayExpression">
+        <f:textbox default="" checkMethod="post" />
+      </f:entry>
+
       <f:entry title="${%parameter.cacheTime}" field="cacheTime">
         <f:number default="${descriptor.getDefaultCacheTime()}" checkMethod="post"/>
       </f:entry>
@@ -45,7 +49,7 @@
 
   <f:validateButton
       title="${%parameter.testConfig}" progress="${%parameter.testing}"
-      method="testConfiguration" with="restEndpoint,credentialId,mimeType,valueExpression,filter,valueOrder" />
+      method="testConfiguration" with="restEndpoint,credentialId,mimeType,valueExpression,displayExpression,filter,valueOrder" />
 
   <f:entry title="${%parameter.description}" field="description">
     <f:textarea />
diff --git a/src/main/resources/io/jenkins/plugins/restlistparam/RestListParameterDefinition/config.properties b/src/main/resources/io/jenkins/plugins/restlistparam/RestListParameterDefinition/config.properties
index fbcc5cf..5c1361d 100644
--- a/src/main/resources/io/jenkins/plugins/restlistparam/RestListParameterDefinition/config.properties
+++ b/src/main/resources/io/jenkins/plugins/restlistparam/RestListParameterDefinition/config.properties
@@ -4,6 +4,7 @@ parameter.restEndpoint=REST Endpoint
 parameter.credentialId=Credential ID
 parameter.mimeTape=MIME Type
 parameter.valueExpression=Value Expression
+parameter.displayExpression=Display Expression
 parameter.advanced=Advanced Section
 parameter.cacheTime=Cache Max Age
 parameter.valueFilterPattern=Value Filter Pattern
diff --git a/src/main/resources/io/jenkins/plugins/restlistparam/RestListParameterDefinition/help-displayExpression.html b/src/main/resources/io/jenkins/plugins/restlistparam/RestListParameterDefinition/help-displayExpression.html
new file mode 100644
index 0000000..ff35837
--- /dev/null
+++ b/src/main/resources/io/jenkins/plugins/restlistparam/RestListParameterDefinition/help-displayExpression.html
@@ -0,0 +1,13 @@
+<div>
+  The Display Expression dictates how the values get displayed based on the object parsed from value expression.<br/>
+  Depending on the selected MIME type the syntax expects is either Json-Path or xPath:<br/>
+  <ul>
+    <li>
+      <b>Json-Path</b> <a href="https://github.com/json-path/JsonPath">Syntax</a> <a
+      href="https://restfulapi.net/json-jsonpath/">Cheatsheet</a> <a href="https://jsonpath.com/">Playground</a>
+    </li>
+    <li>
+      <b>xPath</b> <strong>UNSUPPORTED</strong> Due to the limitation of the XML parser.
+    </li>
+  </ul>
+</div>
\ No newline at end of file
diff --git a/src/main/resources/io/jenkins/plugins/restlistparam/RestListParameterDefinition/index.jelly b/src/main/resources/io/jenkins/plugins/restlistparam/RestListParameterDefinition/index.jelly
index 6e03bfd..7a99542 100644
--- a/src/main/resources/io/jenkins/plugins/restlistparam/RestListParameterDefinition/index.jelly
+++ b/src/main/resources/io/jenkins/plugins/restlistparam/RestListParameterDefinition/index.jelly
@@ -18,9 +18,9 @@
       <input type="hidden" name="description" value="${it.description}"/>
 
       <select id="${id}-select" class="setting-input" name="value">
-        <j:forEach var="value" items="${it.values}" varStatus="loop">
-          <f:option value="${value}" selected="${value.equals(it.defaultValue)}">
-            ${value}
+        <j:forEach var="item" items="${it.values}" varStatus="loop">
+          <f:option value="${item.value}" selected="${item.displayValue.equals(it.defaultValue)}">
+            ${item.displayValue}
           </f:option>
         </j:forEach>
       </select>
diff --git a/src/main/resources/io/jenkins/plugins/restlistparam/RestListParameterValue/value.jelly b/src/main/resources/io/jenkins/plugins/restlistparam/RestListParameterValue/value.jelly
index d261169..f18dfe2 100644
--- a/src/main/resources/io/jenkins/plugins/restlistparam/RestListParameterValue/value.jelly
+++ b/src/main/resources/io/jenkins/plugins/restlistparam/RestListParameterValue/value.jelly
@@ -4,6 +4,6 @@
     xmlns:i="jelly:fmt" xmlns:p="/lib/hudson/project">
   <j:set var="escapeEntryTitleAndDescription" value="false" />
   <f:entry title="${h.escape(it.name)}" description="${it.formattedDescription}">
-    <f:textbox name="value" value="${it.value}" readonly="true" />
+    <f:textbox name="value" value="${it.getValue()}" readonly="true" />
   </f:entry>
 </j:jelly>
\ No newline at end of file
diff --git a/src/test/java/io/jenkins/plugins/restlistparam/RestValueServiceTest.java b/src/test/java/io/jenkins/plugins/restlistparam/RestValueServiceTest.java
index b96b496..eaa371c 100644
--- a/src/test/java/io/jenkins/plugins/restlistparam/RestValueServiceTest.java
+++ b/src/test/java/io/jenkins/plugins/restlistparam/RestValueServiceTest.java
@@ -2,6 +2,7 @@
 
 import io.jenkins.plugins.restlistparam.logic.RestValueService;
 import io.jenkins.plugins.restlistparam.model.MimeType;
+import io.jenkins.plugins.restlistparam.model.ValueItem;
 import io.jenkins.plugins.restlistparam.model.ResultContainer;
 import io.jenkins.plugins.restlistparam.model.ValueOrder;
 import org.junit.Assert;
@@ -13,28 +14,30 @@
 public class RestValueServiceTest {
   @Test
   public void successfulGetIntegrationTest() {
-    ResultContainer<List<String>> test = RestValueService
+    ResultContainer<List<ValueItem>> test = RestValueService
       .get("http://api.github.com/repos/jellyfin/jellyfin/tags?per_page=3",
-           null,
-           MimeType.APPLICATION_JSON,
-           0,
-           "$.*.name",
-           null,
-           ValueOrder.NONE);
+        null,
+        MimeType.APPLICATION_JSON,
+        0,
+        "$.*.name",
+        "$",
+        null,
+        ValueOrder.NONE);
     Assert.assertFalse(test.getErrorMsg().isPresent());
     Assert.assertEquals(3, test.getValue().size());
   }
 
   @Test
   public void unsuccessfulGetIntegrationTest() {
-    ResultContainer<List<String>> test = RestValueService
+    ResultContainer<List<ValueItem>> test = RestValueService
       .get("https://gitlab.example.com/api/v4/projects/gitlab-org%2Fgitlab-runner/releases",
-           null,
-           MimeType.APPLICATION_JSON,
-           0,
-           "$.*.tag_name",
-           null,
-           ValueOrder.NONE);
+        null,
+        MimeType.APPLICATION_JSON,
+        0,
+        "$.*.tag_name",
+        "$",
+        null,
+        ValueOrder.NONE);
     Assert.assertNotNull(test);
     Assert.assertTrue(test.getErrorMsg().isPresent());
     Assert.assertEquals(0, test.getValue().size());
diff --git a/src/test/java/io/jenkins/plugins/restlistparam/TestConst.java b/src/test/java/io/jenkins/plugins/restlistparam/TestConst.java
index 913854d..50c902b 100644
--- a/src/test/java/io/jenkins/plugins/restlistparam/TestConst.java
+++ b/src/test/java/io/jenkins/plugins/restlistparam/TestConst.java
@@ -1,7 +1,7 @@
 package io.jenkins.plugins.restlistparam;
 
 public class TestConst {
-  public final static String validTestJson = "[\n" +
+  public static final String validTestJson = "[\n" +
     "  {\n" +
     "    \"name\": \"v10.6.4\",\n" +
     "    \"zipball_url\": \"https://api.github.com/repos/jellyfin/jellyfin/zipball/v10.6.4\",\n" +
@@ -34,7 +34,18 @@ public class TestConst {
     "  }\n" +
     "]\n";
 
-  public final static String invalidTestJson = "[\n" +
+  public static final String validJsonValueItem = "{" +
+    "\"name\":\"v10.6.4\"," +
+    "\"zipball_url\":\"https://api.github.com/repos/jellyfin/jellyfin/zipball/v10.6.4\"," +
+    "\"tarball_url\":\"https://api.github.com/repos/jellyfin/jellyfin/tarball/v10.6.4\"," +
+    "\"commit\":{" +
+    "\"sha\":\"b49cd1d3017f23fc75703829ac2ea1d45d8a4881\"," +
+    "\"url\":\"https://api.github.com/repos/jellyfin/jellyfin/commits/b49cd1d3017f23fc75703829ac2ea1d45d8a4881\"" +
+    "}," +
+    "\"node_id\":\"MDM6UmVmMTYxMDEyMDE5OnJlZnMvdGFncy92MTAuNi40\"" +
+    "}";
+
+  public static final String invalidTestJson = "[\n" +
     "  {\n" +
     "    \"name\": \"v10.6.4\",\n" +
     "    \"zipball_url\": \"https://api.github.com/repos/jellyfin/jellyfin/zipball/v10.6.4\",\n" +
@@ -66,7 +77,7 @@ public class TestConst {
     "    \"node_id\": \"MDM6UmVmMTYxMDEyMDE5OnJlZnMvdGFncy92MTAuNi4y\"\n" +
     "  }\n";
 
-  public final static String validTestXml = "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n" +
+  public static final String validTestXml = "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n" +
     "<root>\n" +
     "  <row>\n" +
     "    <name>v10.6.4</name>\n" +
@@ -100,7 +111,7 @@ public class TestConst {
     "  </row>\n" +
     "</root>";
 
-  public final static String invalidTestXml = "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n" +
+  public static final String invalidTestXml = "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n" +
     "<root>\n" +
     "  <row>\n" +
     "    <name>v10.6.4</name>\n" +
diff --git a/src/test/java/io/jenkins/plugins/restlistparam/ValueResolverTest.java b/src/test/java/io/jenkins/plugins/restlistparam/ValueResolverTest.java
index ba79f63..85158de 100644
--- a/src/test/java/io/jenkins/plugins/restlistparam/ValueResolverTest.java
+++ b/src/test/java/io/jenkins/plugins/restlistparam/ValueResolverTest.java
@@ -1,7 +1,10 @@
 package io.jenkins.plugins.restlistparam;
 
+import com.jayway.jsonpath.JsonPath;
 import io.jenkins.plugins.restlistparam.logic.ValueResolver;
+import io.jenkins.plugins.restlistparam.model.MimeType;
 import io.jenkins.plugins.restlistparam.model.ResultContainer;
+import io.jenkins.plugins.restlistparam.model.ValueItem;
 import org.junit.Assert;
 import org.junit.Test;
 
@@ -11,83 +14,103 @@ public class ValueResolverTest {
   // Json-Path Tests
   @Test
   public void resolveJsonPathTest() {
-    ResultContainer<List<String>> res = ValueResolver.resolveJsonPath(TestConst.validTestJson, "$.*.name");
+    ResultContainer<List<ValueItem>> res = ValueResolver.resolveJsonPath(TestConst.validTestJson, "$.*.name", "$");
     Assert.assertNotNull(res);
     Assert.assertFalse(res.getErrorMsg().isPresent());
     Assert.assertEquals(3, res.getValue().size());
-    Assert.assertArrayEquals(new String[]{"v10.6.4", "v10.6.3", "v10.6.2"}, res.getValue().toArray());
+    Assert.assertArrayEquals(new String[]{"v10.6.4", "v10.6.3", "v10.6.2"},
+                             res.getValue().stream().map(ValueItem::getValue).toArray());
+  }
+
+  @Test
+  public void resolveJsonPathWithDifferentDisplayExpressionTest() {
+    ResultContainer<List<ValueItem>> res = ValueResolver.resolveJsonPath(TestConst.validTestJson, "$.*", "$.name");
+    Assert.assertNotNull(res);
+    Assert.assertFalse(res.getErrorMsg().isPresent());
+    Assert.assertEquals(3, res.getValue().size());
+    Assert.assertArrayEquals(new String[]{"v10.6.4", "v10.6.3", "v10.6.2"},
+                             res.getValue().stream().map(ValueItem::getValue).map(JsonPath::parse).map(context -> context.read("$.name")).toArray());
+    Assert.assertArrayEquals(new String[]{"v10.6.4", "v10.6.3", "v10.6.2"},
+                             res.getValue().stream().map(ValueItem::getDisplayValue).toArray());
   }
 
   @Test
   public void emptyJsonPathResultsTest() {
-    ResultContainer<List<String>> res = ValueResolver.resolveJsonPath("[]", "$.*");
+    ResultContainer<List<ValueItem>> res = ValueResolver.resolveJsonPath("[]", "$.*", "$");
     Assert.assertNotNull(res);
     Assert.assertTrue(res.getErrorMsg().isPresent());
     Assert.assertEquals(0, res.getValue().size());
-    Assert.assertArrayEquals(new String[]{}, res.getValue().toArray());
+    Assert.assertArrayEquals(new String[]{}, res.getValue().stream().map(ValueItem::getValue).toArray());
   }
 
   @Test
   public void resolveJsonPathError1Test() {
-    ResultContainer<List<String>> res = ValueResolver.resolveJsonPath(TestConst.validTestJson, "$.");
+    ResultContainer<List<ValueItem>> res = ValueResolver.resolveJsonPath(TestConst.validTestJson, "$.", "$");
     Assert.assertNotNull(res);
     Assert.assertTrue(res.getErrorMsg().isPresent());
     Assert.assertEquals(0, res.getValue().size());
-    Assert.assertArrayEquals(new String[]{}, res.getValue().toArray());
+    Assert.assertArrayEquals(new String[]{}, res.getValue().stream().map(ValueItem::getValue).toArray());
   }
 
   @Test
   public void resolveJsonPathError2Test() {
-    ResultContainer<List<String>> res = ValueResolver.resolveJsonPath(TestConst.validTestJson, "$.name");
+    ResultContainer<List<ValueItem>> res = ValueResolver.resolveJsonPath(TestConst.validTestJson, "$.name", "$");
     Assert.assertNotNull(res);
     Assert.assertTrue(res.getErrorMsg().isPresent());
     Assert.assertEquals(0, res.getValue().size());
-    Assert.assertArrayEquals(new String[]{}, res.getValue().toArray());
+    Assert.assertArrayEquals(new String[]{}, res.getValue().stream().map(ValueItem::getValue).toArray());
   }
 
   @Test
   public void invalidJsonErrorTest() {
-    ResultContainer<List<String>> res = ValueResolver.resolveJsonPath(TestConst.invalidTestJson, "$.*.name");
+    ResultContainer<List<ValueItem>> res = ValueResolver.resolveJsonPath(TestConst.invalidTestJson, "$.*.name", "$");
     Assert.assertNotNull(res);
     Assert.assertTrue(res.getErrorMsg().isPresent());
     Assert.assertEquals(0, res.getValue().size());
-    Assert.assertArrayEquals(new String[]{}, res.getValue().toArray());
+    Assert.assertArrayEquals(new String[]{}, res.getValue().stream().map(ValueItem::getValue).toArray());
+  }
+
+  @Test
+  public void displayJsonValueFuncTest() {
+    String displayValue = ValueResolver.parseDisplayValue(MimeType.APPLICATION_JSON, TestConst.validJsonValueItem, "$.name");
+    Assert.assertEquals("v10.6.4", displayValue);
   }
 
   // xPath Tests
   @Test
   public void resolveXPathTest() {
-    ResultContainer<List<String>> res = ValueResolver.resolveXPath(TestConst.validTestXml, "//row/name");
+    ResultContainer<List<ValueItem>> res = ValueResolver.resolveXPath(TestConst.validTestXml, "//row/name", "/");
     Assert.assertNotNull(res);
     Assert.assertFalse(res.getErrorMsg().isPresent());
     Assert.assertEquals(3, res.getValue().size());
-    Assert.assertArrayEquals(new String[]{"v10.6.4", "v10.6.3", "v10.6.2"}, res.getValue().toArray());
+    Assert.assertArrayEquals(new String[]{"v10.6.4", "v10.6.3", "v10.6.2"},
+                             res.getValue().stream().map(ValueItem::getValue).toArray());
   }
 
   @Test
   public void emptyXPathResultTest() {
-    ResultContainer<List<String>> res = ValueResolver.resolveXPath(TestConst.validTestXml, "//row_name");
+    ResultContainer<List<ValueItem>> res = ValueResolver.resolveXPath(TestConst.validTestXml, "//row_name", "/");
     Assert.assertNotNull(res);
     Assert.assertTrue(res.getErrorMsg().isPresent());
     Assert.assertEquals(0, res.getValue().size());
-    Assert.assertArrayEquals(new String[]{}, res.getValue().toArray());
+    Assert.assertArrayEquals(new String[]{}, res.getValue().stream().map(ValueItem::getValue).toArray());
   }
 
   @Test
   public void resolveXPathErrorTest() {
-    ResultContainer<List<String>> res = ValueResolver.resolveXPath(TestConst.validTestXml, "\\row_name");
+    ResultContainer<List<ValueItem>> res = ValueResolver.resolveXPath(TestConst.validTestXml, "\\row_name", "/");
     Assert.assertNotNull(res);
     Assert.assertTrue(res.getErrorMsg().isPresent());
     Assert.assertEquals(0, res.getValue().size());
-    Assert.assertArrayEquals(new String[]{}, res.getValue().toArray());
+    Assert.assertArrayEquals(new String[]{}, res.getValue().stream().map(ValueItem::getValue).toArray());
   }
 
   @Test
   public void invalidXMLErrorTest() {
-    ResultContainer<List<String>> res = ValueResolver.resolveXPath(TestConst.invalidTestXml, "//row/name");
+    ResultContainer<List<ValueItem>> res = ValueResolver.resolveXPath(TestConst.invalidTestXml, "//row/name", "/");
     Assert.assertNotNull(res);
     Assert.assertTrue(res.getErrorMsg().isPresent());
     Assert.assertEquals(0, res.getValue().size());
-    Assert.assertArrayEquals(new String[]{}, res.getValue().toArray());
+    Assert.assertArrayEquals(new String[]{}, res.getValue().stream().map(ValueItem::getValue).toArray());
   }
 }