[TEP-0076]Support Results Array Indexing

This is part of work in TEP-0076.
This commit provides the support to refer array indexing results.
Previous this commit we support emitting array results so users can
write array results to task level, but we cannot pass array results via
index between tasks within one pipeline. This commit adds the support for this.

docs/variables.md

@@ -22,6 +22,9 @@ For instructions on using variable substitutions see the relevant section of [th
 | `tasks.<taskName>.results.<resultName>` | The value of the `Task's` result. Can alter `Task` execution order within a `Pipeline`.) |
 | `tasks.<taskName>.results['<resultName>']` | (see above)) |
 | `tasks.<taskName>.results["<resultName>"]` | (see above)) |
+| `tasks.<taskName>.results.<resultName>[i]` | The ith value of the `Task's` array result. Can alter `Task` execution order within a `Pipeline`.) |
+| `tasks.<taskName>.results['<resultName>'][i]` | (see above)) |
+| `tasks.<taskName>.results["<resultName>"][i]` | (see above)) |
 | `workspaces.<workspaceName>.bound` | Whether a `Workspace` has been bound or not. "false" if the `Workspace` declaration has `optional: true` and the Workspace binding was omitted by the PipelineRun. |
 | `context.pipelineRun.name` | The name of the `PipelineRun` that this `Pipeline` is running in. |
 | `context.pipelineRun.namespace` | The namespace of the `PipelineRun` that this `Pipeline` is running in. |

examples/v1beta1/pipelineruns/alpha/pipelinerun-array-resluts-indexing.yaml

@@ -0,0 +1,43 @@
+apiVersion: tekton.dev/v1beta1
+kind: PipelineRun
+metadata:
+  name: pipelinerun-array-indexing-results
+spec:
+  pipelineSpec:
+    tasks:
+      - name: task1
+        taskSpec:
+          results:
+            - name: array-results
+              type: array
+              description: The array results
+          steps:
+            - name: write-array
+              image: bash:latest
+              script: |
+                #!/usr/bin/env bash
+                echo -n "[\"1\",\"2\",\"3\"]" | tee $(results.array-results.path)
+      - name: task2
+        params:
+          - name: foo
+            value: "$(tasks.task1.results.array-results[1])"
+        taskSpec:
+          params:
+            - name: foo
+              type: string
+              default: defaultparam
+          steps:
+            - name: print-param
+              image: ubuntu
+              script: |
+                #!/bin/bash
+                VALUE=$(params.foo)
+                EXPECTED="2"
+                diff=$(diff <(printf "%s\n" "${VALUE[@]}") <(printf "%s\n" "${EXPECTED[@]}"))
+                if [[ -z "$diff" ]]; then
+                    echo "Get expected result: ${EXPECTED}"
+                    exit 0
+                else
+                    echo "Fail to get expected result, want ${EXPECTED} but got ${VALUE}"
+                    exit 1
+                fi

pkg/apis/pipeline/v1beta1/resultref.go

@@ -19,13 +19,15 @@ package v1beta1
 import (
 	"fmt"
 	"regexp"
+	"strconv"
 	"strings"
 )
 
 // ResultRef is a type that represents a reference to a task run result
 type ResultRef struct {
 	PipelineTask string `json:"pipelineTask"`
 	Result       string `json:"result"`
+	ResultsIndex int    `json:"resultsIndex"`
 }
 
 const (
@@ -35,28 +37,33 @@ const (
 	// ResultResultPart Constant used to define the "results" part of a pipeline result reference
 	ResultResultPart = "results"
 	// TODO(#2462) use one regex across all substitutions
-	variableSubstitutionFormat = `\$\([_a-zA-Z0-9.-]+(\.[_a-zA-Z0-9.-]+)*\)`
+	// variableSubstitutionFormat matches format like $result.resultname, $result.resultname[int] and $result.resultname[*]
+	variableSubstitutionFormat = `\$\([_a-zA-Z0-9.-]+(\.[_a-zA-Z0-9.-]+)*(\[([0-9])*\*?\])?\)`
+	// arrayIndexing will match all `[int]` and `[*]` for parseExpression
+	arrayIndexing = `\[([0-9])*\*?\]`
 	// ResultNameFormat Constant used to define the the regex Result.Name should follow
 	ResultNameFormat = `^([A-Za-z0-9][-A-Za-z0-9_.]*)?[A-Za-z0-9]$`
 )
 
 var variableSubstitutionRegex = regexp.MustCompile(variableSubstitutionFormat)
 var resultNameFormatRegex = regexp.MustCompile(ResultNameFormat)
+var arrayIndexingRegex = regexp.MustCompile(arrayIndexing)
 
 // NewResultRefs extracts all ResultReferences from a param or a pipeline result.
 // If the ResultReference can be extracted, they are returned. Expressions which are not
 // results are ignored.
 func NewResultRefs(expressions []string) []*ResultRef {
 	var resultRefs []*ResultRef
 	for _, expression := range expressions {
-		pipelineTask, result, err := parseExpression(expression)
+		pipelineTask, result, index, err := parseExpression(expression)
 		// If the expression isn't a result but is some other expression,
 		// parseExpression will return an error, in which case we just skip that expression,
 		// since although it's not a result ref, it might be some other kind of reference
 		if err == nil {
 			resultRefs = append(resultRefs, &ResultRef{
 				PipelineTask: pipelineTask,
 				Result:       result,
+				ResultsIndex: index,
 			})
 		}
 	}
@@ -122,12 +129,19 @@ func stripVarSubExpression(expression string) string {
 	return strings.TrimSuffix(strings.TrimPrefix(expression, "$("), ")")
 }
 
-func parseExpression(substitutionExpression string) (string, string, error) {
+func parseExpression(substitutionExpression string) (string, string, int, error) {
 	subExpressions := strings.Split(substitutionExpression, ".")
 	if len(subExpressions) != 4 || subExpressions[0] != ResultTaskPart || subExpressions[2] != ResultResultPart {
-		return "", "", fmt.Errorf("Must be of the form %q", resultExpressionFormat)
+		return "", "", 0, fmt.Errorf("Must be of the form %q", resultExpressionFormat)
 	}
-	return subExpressions[1], subExpressions[3], nil
+
+	stringIdx := strings.TrimSuffix(strings.TrimPrefix(arrayIndexingRegex.FindString(subExpressions[3]), "["), "]")
+	subExpressions[3] = arrayIndexingRegex.ReplaceAllString(subExpressions[3], "")
+	if stringIdx != "" {
+		intIdx, _ := strconv.Atoi(stringIdx)
+		return subExpressions[1], subExpressions[3], intIdx, nil
+	}
+	return subExpressions[1], subExpressions[3], 0, nil
 }
 
 // PipelineTaskResultRefs walks all the places a result reference can be used

pkg/apis/pipeline/v1beta1/resultref_test.go

@@ -41,6 +41,27 @@ func TestNewResultReference(t *testing.T) {
 			PipelineTask: "sumTask",
 			Result:       "sumResult",
 		}},
+	}, {
+		name: "refer whole array result",
+		param: v1beta1.Param{
+			Name:  "param",
+			Value: *v1beta1.NewArrayOrString("$(tasks.sumTask.results.sumResult[*])"),
+		},
+		want: []*v1beta1.ResultRef{{
+			PipelineTask: "sumTask",
+			Result:       "sumResult",
+		}},
+	}, {
+		name: "refer array indexing result",
+		param: v1beta1.Param{
+			Name:  "param",
+			Value: *v1beta1.NewArrayOrString("$(tasks.sumTask.results.sumResult[1])"),
+		},
+		want: []*v1beta1.ResultRef{{
+			PipelineTask: "sumTask",
+			Result:       "sumResult",
+			ResultsIndex: 1,
+		}},
 	}, {
 		name: "substitution within string",
 		param: v1beta1.Param{

pkg/apis/pipeline/v1beta1/swagger.json

@@ -1711,7 +1711,8 @@
       "type": "object",
       "required": [
         "pipelineTask",
-        "result"
+        "result",
+        "resultsIndex"
       ],
       "properties": {
         "pipelineTask": {
@@ -1721,6 +1722,11 @@
         "result": {
           "type": "string",
           "default": ""
+        },
+        "resultsIndex": {
+          "type": "integer",
+          "format": "int32",
+          "default": 0
         }
       }
     },