GoWrap

You can write custom templates to provide specific functionality to your interfaces.

Template Capabilities:

• Sprig Library: All functions from the Sprig template library are available.
• GoWrap Built-in Functions:
  • up: Converts input to UPPERCASE.
  • down: Converts input to lowercase.
  • upFirst: Converts the first letter to Uppercase.
  • downFirst: Converts the first letter to lowercase.
  • replace: Replaces occurrences of the first argument with the second.
  • snake: Converts input to snake_case.

Data Structure: The information passed to your templates is defined by the TemplateInputs struct (see TemplateInputs documentation).

You can install GoWrap as a standalone command-line tool or include it as a dependency in your Go project.

To install the CLI:

go install github.com/hexdigest/gowrap/cmd/gowrap@latest

To add as a module:

go get -u github.com/hexdigest/gowrap/cmd/gowrap

By default, GoWrap adds a //go:generate instruction to generated files. If you use a remote template (via URL), regeneration will require an internet connection. To avoid this, copy the template to your local version control system.

Command to copy a template:

gowrap template copy <template_name> <local_destination>

Example: To copy the fallback template to a local directory named templates/fallback:

gowrap template copy fallback templates/fallback

Then, generate code using the local path:

gowrap gen -p io -i Reader -t templates/fallback reader_with_fallback.go

The Usage(w io.Writer) function generates a formatted help message that lists all registered commands, their names, and their short descriptions. This is typically used when the user provides invalid arguments or requests help.

// Usage writes gowrap usage message to w
func Usage(w io.Writer) error {
	return usageTemplate.Execute(w, struct {
		Commands map[string]Command
		Version  string
	}{
		commands, version})
}

To add a new subcommand to the gowrap CLI, you must implement the Command interface. This interface defines how the command handles flags, execution, and help documentation.

Required methods:

• FlagSet() *flag.FlagSet: Returns the command-specific flag set. Return nil if the command has no flags.
• Run(args []string, stdout io.Writer) error: The core logic of the command. It receives the remaining arguments and an output writer.
• ShortDescription() string: A brief summary of the command for the main help menu.
• UsageLine() string: The usage syntax for the command (e.g., gowrap mycmd [args]).
• HelpMessage(w io.Writer) error: Writes detailed help information to the provided writer.

type Command interface {
	FlagSet() *flag.FlagSet
	Run(args []string, stdout io.Writer) error
	ShortDescription() string
	UsageLine() string
	HelpMessage(w io.Writer) error
}

To programmatically use the template command, use NewTemplateCommand(loader). This requires an implementation of the remoteTemplateLoader interface to handle the fetching and listing of templates.

Interface: remoteTemplateLoader

Any object passed to NewTemplateCommand must implement these methods:

• List() ([]string, error): Returns a slice of available template names.
• Load(path string) (tmpl []byte, url string, err error): Given a template path, returns the template content as bytes, the source URL, and any error encountered.

Commands are managed in a global registry. Use RegisterCommand to add a command to the gowrap CLI. When a command is registered, if it has a FlagSet, it is automatically initialized with flag.ContinueOnError and its output is redirected to io.Discard to prevent premature printing during registration.

Use GetCommand(name string) to retrieve a registered command by its name.

// RegisterCommand adds command to the global Commands map
func RegisterCommand(name string, cmd Command) {
	commands[name] = cmd
	if fs := cmd.FlagSet(); fs != nil {
		fs.Init("", flag.ContinueOnError)
		fs.SetOutput(io.Discard)
	}
}

// GetCommand returns command from the global Commands map
func GetCommand(name string) Command {
	return commands[name]
}

The gowrap CLI provides the following primary subcommands:

• gen: Used for generating code.
• template: Used for managing or interacting with templates.

The gen command uses the following flag definitions:

When using templates with gowrap, you have access to sprig functions plus several custom helper functions for string manipulation:

• up: Converts string to uppercase.
• down: Converts string to lowercase.
• upFirst: Capitalizes the first character of a string.
• downFirst: Lowercases the first character of a string.
• replace: Performs string replacement (alias for strings.ReplaceAll).
• snake: Converts a string to snake_case.