Merge pull request #27 from tchaurasiya/fix-getAsBase64

fix issues for getAsBase64 template

Author: tchaurasiya

task/expression/custom_resolver.go

@@ -1,6 +1,7 @@
 package expression
 
 import (
+	"bytes"
 	"encoding/json"
 
 	"github.com/drone/go-task/task/common"
@@ -36,10 +37,16 @@ func (r *CustomResolver) Resolve(data []byte) ([]byte, error) {
 	// evaluate the expressions
 	evaler.Eval(v, r.secrets)
 
-	// encode the map back to []byte
-	resolved, err := json.Marshal(v)
+	// encode the map back to []byte using a custom encoder that doesn't escape HTML
+	buf := &bytes.Buffer{}
+	encoder := json.NewEncoder(buf)
+	encoder.SetEscapeHTML(false)
+	err = encoder.Encode(v)
 	if err != nil {
 		return nil, err
 	}
+
+	// trim the trailing newline that Encode adds
+	resolved := bytes.TrimSpace(buf.Bytes())
 	return resolved, nil
 }

task/expression/resolver_ifc.go

@@ -19,19 +19,25 @@ func New(secrets []*common.Secret) *Resolver {
 }
 
 func (r *Resolver) Resolve(taskData []byte) ([]byte, error) {
-	if bytes.Contains(taskData, []byte("${{secrets")) {
-		resolver := newCustomResolver(r.secrets)
-		resolvedTaskData, err := resolver.Resolve(taskData)
+	// Start with the original task data
+	currentData := taskData
+
+	// First pass: Handle custom secrets syntax (${{secrets...}})
+	if bytes.Contains(currentData, []byte("${{secrets")) {
+		customResolver := newCustomResolver(r.secrets)
+		resolvedData, err := customResolver.Resolve(currentData)
 		if err != nil {
 			return nil, err
 		}
-		return resolvedTaskData, nil
+		currentData = resolvedData // Update current data with resolved result
 	}
-	//return taskData, nil
-	resolver := newTemplateResolver(r.secrets)
-	resolvedTaskData, err := resolver.Resolve(taskData)
+
+	// Second pass: Handle template resolver syntax
+	templateResolver := newTemplateResolver(r.secrets)
+	finalResolvedData, err := templateResolver.Resolve(currentData)
 	if err != nil {
 		return nil, err
 	}
-	return resolvedTaskData, nil
+
+	return finalResolvedData, nil
 }

task/expression/template_resolver.go

@@ -2,6 +2,7 @@ package expression
 
 import (
 	"bytes"
+	"strings"
 	"text/template"
 
 	"github.com/drone/go-task/task/common"
@@ -27,11 +28,77 @@ func (r *TemplateResolver) Resolve(data []byte) ([]byte, error) {
 		secretMap[secret.ID] = secret.Value
 	}
 
+	// Extract and process template expressions
+	input := string(data)
+	start := 0
+	processed := ""
+
+	for {
+		// Find start of template expression
+		startIdx := strings.Index(input[start:], RESOLVER_DELIM_START)
+		if startIdx == -1 {
+			// No more template expressions found
+			processed += input[start:]
+			break
+		}
+		startIdx += start
+
+		// Find end of template expression
+		endIdx := strings.Index(input[startIdx:], RESOLVER_DELIM_END)
+		if endIdx == -1 {
+			// No matching end delimiter found
+			processed += input[start:]
+			break
+		}
+		endIdx += startIdx + len(RESOLVER_DELIM_END)
+
+		// Add everything before the template expression
+		processed += input[start:startIdx]
+
+		// Get the template expression content
+		expr := input[startIdx:endIdx]
+		if strings.Contains(expr, "getAsBase64") {
+			// Extract content between delimiters
+			content := expr[len(RESOLVER_DELIM_START) : len(expr)-len(RESOLVER_DELIM_END)]
+			// Split by pipe operator
+			parts := strings.Split(content, "|")
+			if len(parts) > 0 {
+				// Get the quoted string part and trim spaces
+				quotedStr := strings.TrimSpace(parts[0])
+				
+				// Handle the quoted string
+				var unescaped string
+
+                    // handl case use input contains quotes i.e. "abcd"
+					if strings.HasPrefix(quotedStr, "\\\"") && strings.HasSuffix(quotedStr, "\\\"") {
+						// Remove only first and last escaped quotes
+						unescaped = "\"" + quotedStr[2:len(quotedStr)-2] + "\""
+					} else if strings.HasPrefix(quotedStr, "\"") && strings.HasSuffix(quotedStr, "\"") {
+						unescaped = quotedStr
+					}else{
+						unescaped = "\"" + quotedStr + "\""
+					}
+				
+				// Reconstruct the expression
+				expr = RESOLVER_DELIM_START + " " + unescaped
+				if len(parts) > 1 {
+					expr += " |" + parts[1]
+				}
+				expr += RESOLVER_DELIM_END
+			}
+		}
+		processed += expr
+
+		// Move start to after this template expression
+		start = endIdx
+	}
+
 	// Parse the template with custom delimiters
 	tmpl, err := template.New("resolver").
 		Delims(RESOLVER_DELIM_START, RESOLVER_DELIM_END).
 		Funcs(TemplateFunctions()). // Include template functions
-		Parse(string(data))
+		Parse(processed)
+
 	if err != nil {
 		return nil, err
 	}
@@ -42,6 +109,5 @@ func (r *TemplateResolver) Resolve(data []byte) ([]byte, error) {
 	if err != nil {
 		return nil, err
 	}
-
 	return buf.Bytes(), nil
 }