🌱
Sprout
Github
  • About
  • Roadmap to Sprout v1.0
  • Migration from Sprig
  • Introduction
    • Getting Started
    • Templating Conventions
  • Features
    • Loader System (Registry)
    • Loader System (Registry Group)
    • Function Aliases
    • Function Notices
    • Safe Functions
  • Registries
    • List of all registries
    • Backward
    • Checksum
    • Conversion
    • Crypto
    • Encoding
    • Env
    • Filesystem
    • Maps
    • Numeric
    • Network
    • Random
    • Reflect
    • Regexp
    • SemVer
    • Slices
    • Std
    • Strings
    • Time
    • Uniqueid
  • Groups
    • List of all registry groups
    • All
    • Hermetic
  • Advanced
    • How to create a handler
    • How to create a registry
    • How to create a registry group
  • Links
    • GitHub repository
Powered by GitBook
On this page
  • Introduction
  • Step 1: Understand the Handler Interface
  • Step 2: Create Your Custom Handler Struct
  • Step 3: Implement the Handler Interface
  • Step 4: Initialize and Customize Your Handler
  • Step 5: Use Your Custom Handler
  • Conclusion
Edit on GitHub
  1. Advanced

How to create a handler

Introduction

Creating a custom handler in Sprout allows you to manage function registries, define custom logging, and handle errors according to your specific needs. Here’s a step-by-step guide on how to create your own custom handler.

Step 1: Understand the Handler Interface

The Handler interface in Sprout defines the basic methods required to manage registries and functions. A typical handler in Sprout must implement the following methods:

  • Logger() *slog.Logger: Returns the logger instance used for logging.

  • AddRegistry(registry Registry) error: Adds a single registry to the handler.

  • AddRegistries(registries ...Registry) error: Adds multiple registries to the handler.

  • RawFunctions() FunctionMap: Returns the map of registered functions.

  • RawAliases() FunctionAliasMap: Returns the map of function aliases.

  • Build() FunctionMap: Builds and returns the complete function map, ready to be used in templates.

Step 2: Create Your Custom Handler Struct

Create a struct that will serve as your custom handler. This struct should store the function map, alias map, and any other configurations you need.

type MyCustomHandler struct {
    logger        *slog.Logger
    registries    []sprout.Registry
    funcsMap      sprout.FunctionMap
    funcsAlias    sprout.FunctionAliasMap
}

Step 3: Implement the Handler Interface

Next, implement the Handler interface methods in your custom struct. I take logger as example.

func (h *MyCustomHandler) Logger() *slog.Logger {
    return h.logger
}

Step 4: Initialize and Customize Your Handler

Create a function to initialize your custom handler, setting up the logger and any registries you need.

func NewMyCustomHandler() *MyCustomHandler {
    return &MyCustomHandler{
        logger:        slog.New(slog.NewTextHandler(os.Stdout)),
        registries:    make([]sprout.Registry, 0),
        funcsMap:      make(sprout.FunctionMap),
        funcsAlias:    make(sprout.FunctionAliasMap),
    }
}

Step 5: Use Your Custom Handler

With your custom handler in place, you can now use it to register functions and integrate it with your templates.

handler := NewMyCustomHandler()
handler.AddRegistry(std.NewRegistry())

tpl, err := template.New("example").Funcs(handler.Build()).Parse(`{{ myFunc }}`)
if err != nil {
    log.Fatal(err)
}
tpl.Execute(os.Stdout, nil)

Conclusion

Creating a custom handler in Sprout allows you to extend and customize the templating environment according to your needs. By implementing the Handler interface, you gain full control over how functions are registered, managed, and used in your templates. This flexibility is key to building robust and maintainable Go applications.

PreviousHermeticNextHow to create a registry

Last updated 6 months ago