Fabric/plugins/template/template.go

package template

import (
	"fmt"
	"regexp"
	"strings"
)

var (
    textPlugin = &TextPlugin{}
    datetimePlugin = &DateTimePlugin{}
    filePlugin = &FilePlugin{}
    fetchPlugin = &FetchPlugin{}
		sysPlugin = &SysPlugin{} 
    Debug = false  // Debug flag
)

var pluginPattern = regexp.MustCompile(`\{\{plugin:([^:]+):([^:]+)(?::([^}]+))?\}\}`)

func debugf(format string, a ...interface{}) {
    if Debug {
        fmt.Printf(format, a...)
    }
}

func ApplyTemplate(content string, variables map[string]string, input string) (string, error) {
    var missingVars []string
    r := regexp.MustCompile(`\{\{([^{}]+)\}\}`)
    
    debugf("Starting template processing\n")
    for strings.Contains(content, "{{") {
        matches := r.FindAllStringSubmatch(content, -1)
        if len(matches) == 0 {
            break
        }
        
        replaced := false
        for _, match := range matches {
            fullMatch := match[0]
            varName := match[1]
            
            // Check if this is a plugin call
            if strings.HasPrefix(varName, "plugin:") {
                pluginMatches := pluginPattern.FindStringSubmatch(fullMatch)
                if len(pluginMatches) >= 3 {
                    namespace := pluginMatches[1]
                    operation := pluginMatches[2]
                    value := ""
                    if len(pluginMatches) == 4 {
                        value = pluginMatches[3]
                    }
                    
                    debugf("\nPlugin call:\n")
                    debugf("  Namespace: %s\n", namespace)
                    debugf("  Operation: %s\n", operation)
                    debugf("  Value: %s\n", value)
                    
                    var result string
                    var err error
                    
                    switch namespace {
                    case "text":
                        debugf("Executing text plugin\n")
                        result, err = textPlugin.Apply(operation, value)
                    case "datetime":
                        debugf("Executing datetime plugin\n")
                        result, err = datetimePlugin.Apply(operation, value)
                    case "file":
                        debugf("Executing file plugin\n")
                        result, err = filePlugin.Apply(operation, value)
                        debugf("File plugin result: %#v\n", result)
                    case "fetch":
                        debugf("Executing fetch plugin\n")
                        result, err = fetchPlugin.Apply(operation, value)
										case "sys":
												debugf("Executing sys plugin\n")
												result, err = sysPlugin.Apply(operation, value)
                    default:
                        return "", fmt.Errorf("unknown plugin namespace: %s", namespace)
                    }
                    
                    if err != nil {
                        debugf("Plugin error: %v\n", err)
                        return "", fmt.Errorf("plugin %s error: %v", namespace, err)
                    }
                    
                    debugf("Plugin result: %s\n", result)
                    content = strings.ReplaceAll(content, fullMatch, result)
                    debugf("Content after replacement: %s\n", content)
                    continue
                }
            }
            
            // Handle regular variables and input
            debugf("Processing variable: %s\n", varName)
            if varName == "input" {
                debugf("Replacing {{input}}\n")
								replaced = true
                content = strings.ReplaceAll(content, fullMatch, input)
            } else {
                if val, ok := variables[varName]; !ok {
                    debugf("Missing variable: %s\n", varName)
                    missingVars = append(missingVars, varName)
										return "", fmt.Errorf("missing required variable: %s", varName)
                } else {
                    debugf("Replacing variable %s with value: %s\n", varName, val)
                    content = strings.ReplaceAll(content, fullMatch, val)
										replaced = true
                }
            }
						if !replaced {
							return "", fmt.Errorf("template processing stuck - potential infinite loop")
						}
        }
    }

    debugf("Template processing complete\n")
    return content, nil
}