template.go

package gofakeit

import (
	"bytes"
	"fmt"
	"strconv"
	"time"

	"math/rand"
	"reflect"
	"strings"
	"text/template"
)

// TemplateOptions defines values needed for template document generation
type TemplateOptions struct {
	Funcs template.FuncMap `fake:"-"`
	Data  any              `json:"data" xml:"data" fake:"-"`
}

// Template generates an document based on the the supplied template
func Template(template string, co *TemplateOptions) (string, error) {
	if co == nil {
		co = &TemplateOptions{}
		globalFaker.Struct(co)
	}
	return templateFunc(template, templateFuncMap(globalFaker.Rand, &co.Funcs), co)
}

// Template generates an document based on the the supplied template
func (f *Faker) Template(template string, co *TemplateOptions) (string, error) {
	if co == nil {
		co = &TemplateOptions{}
		f.Struct(co)
	}
	return templateFunc(template, templateFuncMap(f.Rand, &co.Funcs), co)
}

// MarkdownOptions defines values needed for markdown document generation
type MarkdownOptions struct {
	SectionsCount int `json:"sections" xml:"sections" fake:"{number:1,10}"`
}

// Template for Markdown
const templateMarkdown = `
{{$repo := Gamertag}}
{{$language := RandomString (SliceString "go" "python" "javascript")}}
{{$username := Gamertag}}
{{$weightedSlice := SliceAny "github.com" "gitlab.com" "bitbucket.org"}}
{{$weightedWeights := SliceF32 5 1 1}}
{{$domain := Weighted $weightedSlice $weightedWeights}}
{{$action := RandomString (SliceString "process" "run" "execute" "perform" "handle")}}
{{$usage := RandomString (SliceString "whimsical story" "quirky message" "playful alert" "funny request" "lighthearted command")}}
{{$result := RandomString (SliceString "success" "error" "unknown" "completed" "failed" "finished" "in progress" "terminated")}}

# {{$repo}}

*Author: {{FirstName}} {{LastName}}*

{{Paragraph 2 5 7 "\n\n"}}

## Table of Contents
- [Installation](#installation)
- [Usage](#usage)
- [License](#license)

## Installation
{{if eq $language "go"}}'''go
go get {{$domain}}/{{$username}}/{{$repo}}
'''{{else if eq $language "python"}}'''bash
pip install {{$repo}}
'''{{else if eq $language "javascript"}}'''js
npm install {{$repo}}
'''{{end}}

## Usage
{{if eq $language "go"}}'''go
result := {{$repo}}.{{$action}}("{{ToLower $usage}}")
fmt.Println("{{ToLower $repo}} result:", "{{ToLower $result}}")
'''{{else if eq $language "python"}}'''python
result = {{ToLower $repo}}.{{$action}}("{{ToLower $usage}}")
print("{{ToLower $repo}} result:", "{{ToLower $result}}")
'''{{else if eq $language "javascript"}}'''javascript
const result = {{ToLower $repo}}.{{$action}}("{{ToLower $usage}}");
console.log("{{ToLower $repo}} result:", "{{ToLower $result}}");
'''{{end}}

## License
{{RandomString (SliceString "MIT" "Apache 2.0" "GPL-3.0" "BSD-3-Clause" "ISC")}}
`

// Markdown will return a single random Markdown template document
func Markdown(co *MarkdownOptions) (string, error) {
	if co == nil {
		co = &MarkdownOptions{}
		globalFaker.Struct(co)
	}
	return templateFunc(templateMarkdown, templateFuncMap(globalFaker.Rand, nil), co)
}

// Markdown will return a single random Markdown template document
func (f *Faker) Markdown(co *MarkdownOptions) (string, error) {
	if co == nil {
		co = &MarkdownOptions{}
		f.Struct(co)
	}
	return templateFunc(templateMarkdown, templateFuncMap(f.Rand, nil), co)
}

// EmailOptions defines values needed for email document generation
type EmailOptions struct {
	SectionsCount int `json:"sections" xml:"sections" fake:"{number:1,10}"`
}

// Template for email text
const templateEmail = `
Subject: {{RandomString (SliceString "Greetings" "Hello" "Hi")}} from {{FirstName}}!

Dear {{LastName}},

{{RandomString (SliceString "Greetings!" "Hello there!" "Hi, how are you?")}} {{RandomString (SliceString "How's everything going?" "I hope your day is going well." "Sending positive vibes your way.")}}

{{RandomString (SliceString "I trust this email finds you well." "I hope you're doing great." "Hoping this message reaches you in good spirits.")}} {{RandomString (SliceString  "Wishing you a fantastic day!" "May your week be filled with joy." "Sending good vibes your way.")}}

{{Paragraph 3 5 10 "\n\n"}}

{{RandomString (SliceString "I would appreciate your thoughts on" "I'm eager to hear your feedback on" "I'm curious to know what you think about")}} it. If you have a moment, please feel free to check out the project on {{RandomString (SliceString "GitHub" "GitLab" "Bitbucket")}}

{{RandomString (SliceString "Your insights would be invaluable." "I'm eager to hear what you think." "Feel free to share your opinions with me.")}} {{RandomString (SliceString "Looking forward to your feedback!" "Your perspective is highly valued." "Your thoughts matter to me.")}}

{{RandomString (SliceString "Thank you for your consideration!" "I appreciate your attention to this matter." "Your support means a lot to me.")}} {{RandomString (SliceString "Wishing you a wonderful day!" "Thanks in advance for your time." "Your feedback is greatly appreciated.")}}

{{RandomString (SliceString "Warm regards" "Best wishes" "Kind regards" "Sincerely" "With gratitude")}}
{{FirstName}} {{LastName}}
{{Email}}
{{PhoneFormatted}}
`

// EmailText will return a single random text email template document
func EmailText(co *EmailOptions) (string, error) {
	if co == nil {
		co = &EmailOptions{}
		globalFaker.Struct(co)
	}
	return templateFunc(templateEmail, templateFuncMap(globalFaker.Rand, nil), co)
}

// EmailText will return a single random text email template document
func (f *Faker) EmailText(co *EmailOptions) (string, error) {
	if co == nil {
		co = &EmailOptions{}
		f.Struct(co)
	}
	return templateFunc(templateEmail, templateFuncMap(f.Rand, nil), co)
}

// functions that wont work with template engine
var templateExclusion = []string{
	"RandomMapKey",
	"SQL",
	"Template",
}

// Build the template.FuncMap for the template engine
func templateFuncMap(r *rand.Rand, fm *template.FuncMap) *template.FuncMap {

	// create a new function map
	funcMap := template.FuncMap{}

	// build the function map from a faker using their rand
	f := &Faker{Rand: r}

	v := reflect.ValueOf(f)

	// loop through the methods
	for i := 0; i < v.NumMethod(); i++ {
		// check if the method is in the exclusion list
		if stringInSlice(v.Type().Method(i).Name, templateExclusion) {
			continue
		}

		// Check if method has return values
		// If not don't add to function map
		if v.Type().Method(i).Type.NumOut() == 0 {
			continue
		}

		// add the method to the function map
		funcMap[v.Type().Method(i).Name] = v.Method(i).Interface()
	}

	// make string upper case
	funcMap["ToUpper"] = strings.ToUpper

	// make string lower case
	funcMap["ToLower"] = strings.ToLower

	// make string title case
	funcMap["IntRange"] = func(start, end int) []int {
		n := end - start + 1
		result := make([]int, n)
		for i := 0; i < n; i++ {
			result[i] = start + i
		}
		return result
	}

	// enable passing any type to return a string
	funcMap["ToInt"] = func(args any) int {
		switch v := args.(type) {
		case string:
			i, err := strconv.Atoi(v)
			if err != nil {
				return 0
			}
			return i
		case float64:
			return int(v)
		case float32:
			return int(v)
		case int:
			return v

		// Anything else return 0
		default:
			return 0
		}
	}

	// ensable passing any type to return a string
	funcMap["ToString"] = func(args any) string {
		switch v := args.(type) {
		case string:
			return v
		case float64:
			return strconv.FormatFloat(v, 'f', -1, 64)
		case float32:
			return strconv.FormatFloat(float64(v), 'f', -1, 32)
		case int:
			return strconv.Itoa(v)

		// Anything else return empty string
		default:
			return ""
		}
	}

	// function to convert string to date time
	funcMap["ToDate"] = func(dateString string) time.Time {
		date, err := time.Parse("2006-01-02", dateString)
		if err != nil {
			return time.Now()
		}
		return date
	}

	// enable passing slice of interface to functions
	funcMap["SliceAny"] = func(args ...any) []any {
		return args
	}

	// enable passing slice of string to functions
	funcMap["SliceString"] = func(args ...string) []string {
		return args
	}

	// enable passing slice of uint to functions
	funcMap["SliceUInt"] = func(args ...uint) []uint {
		return args
	}

	// enable passing slice of int to functions
	funcMap["SliceInt"] = func(args ...int) []int {
		return args
	}

	// enable passing slice of int to functions
	funcMap["SliceF32"] = func(args ...float32) []float32 {
		return args
	}

	return &funcMap
}

// function to build the function map for the template engine from the global faker
func templateFunc(temp string, funcs *template.FuncMap, data any) (string, error) {
	if temp == "" {
		return "", fmt.Errorf("template parameter is empty")
	}

	// Create a new template and parse
	template_gen, err := template.New("CodeRun").Funcs(*funcs).Parse(temp)
	if err != nil {
		return "", err
	}

	b := &bytes.Buffer{}
	err = template_gen.Execute(b, data)
	if err != nil {
		return "", err
	}

	// Return the result
	return strings.ReplaceAll(b.String(), "\\n", "\n"), nil

}

// addTemplateLookup will add the template functions to the global lookup
func addTemplateLookup() {
	AddFuncLookup("template", Info{
		Display:     "Template",
		Category:    "template",
		Description: "Generates document from template",
		Example: `
			{{Firstname}} {{Lastname}}
			
			// output
			Markus Moen
		`,
		Output:      "string",
		ContentType: "text/plain",
		Params: []Param{
			{Field: "template", Display: "Template", Type: "string", Description: "Golang template to generate the document from"},
			{Field: "data", Display: "Custom Data", Type: "string", Default: "", Optional: true, Description: "Custom data to pass to the template"},
		},
		Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
			tpl, err := info.GetString(m, "template")
			if err != nil {
				return nil, err
			}

			data, err := info.GetAny(m, "data")
			if err != nil {
				return nil, err
			}

			templateOut, err := templateFunc(tpl, templateFuncMap(r, nil), &TemplateOptions{Data: data})
			if err != nil {
				return nil, err
			}

			return templateOut, nil
		},
	})

	AddFuncLookup("markdown", Info{
		Display:     "Random markdown document",
		Category:    "template",
		Description: "Generates random markdown document",
		Example:     "",
		Output:      "string",
		Params: []Param{
			{Field: "sections_count", Display: "Body Sections", Type: "int", Default: "1", Optional: true, Description: "Number of content sections to generate"},
		},
		Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
			sections, err := info.GetInt(m, "sections_count")
			if err != nil {
				sections = 1
			}

			template_result, err := templateFunc(templateMarkdown, templateFuncMap(r, nil), &MarkdownOptions{SectionsCount: sections})
			return string(template_result), err
		},
	})

	AddFuncLookup("email_text", Info{
		Display:     "Random text email Document",
		Category:    "template",
		Description: "Generates random email document.",
		Example:     "",
		Output:      "string",
		Params: []Param{
			{Field: "sections_count", Display: "Body Sections", Type: "int", Default: "1", Optional: true, Description: "Number of content sections to generate"},
		},
		Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
			sections, err := info.GetInt(m, "sections_count")
			if err != nil {
				sections = 1
			}

			template_result, err := templateFunc(templateEmail, templateFuncMap(r, nil), &EmailOptions{SectionsCount: sections})
			return string(template_result), err
		},
	})
}