Sprig

Sprig is a comprehensive library of helper functions designed to extend the Go text template engine. It provides a wide array of custom functions that can be injected into the engine to enable complex data manipulation and logic directly within templates.

The project offers specialized capabilities for cryptography, including the generation of private keys, X.509 certificates, and secure password hashes. It also includes advanced logic extensions for semantic versioning comparison, ternary evaluations, and the resolution of environment variables from the host operating system.

The library covers a broad surface of general-purpose utilities, including extensive string processing for case conversion and regular expressions, mathematical operations for floating-point and integer arithmetic, and temporal tools for date and time formatting. It further provides data structure management for deeply merging dictionaries, filtering lists, and encoding or decoding JSON.

The project is implemented as a function map that integrates with the standard Go template system.

Features

Template Extensions - Extends the Go template engine with a comprehensive library of helper functions for data manipulation.

Custom Function Maps - Injects a custom map of Go functions into the template engine to provide helper capabilities.

Template Functions - Provides a comprehensive set of reusable helper functions to extend logic and data manipulation within Go templates.

Structured Data Format Converters - Converts dictionaries and lists into formatted JSON and other structured outputs within the template pipeline.

Math Utilities - Implements basic mathematical operations including sums, products, and maximums.

Regex Pattern Matching - Performs pattern matching, replacements, and string splitting using regular expressions.

Collection Manipulation Utilities - Provides a comprehensive toolkit for creating, sorting, filtering, and extracting values from lists and dictionaries.

Dictionary Copying - Creates independent deep copies of dictionaries to prevent unintended mutations.

Data Manipulation Libraries - Provides a toolkit for transforming structured data, including merging dictionaries and filtering lists, during template execution.

Numeric Extremum Identification - Identifies the largest or smallest integer from a given set of values.

Language Runtime Type Inspection - Provides reflection-based type inspection to retrieve or compare the underlying type of a value.

Configuration File Generators - Generates configuration files by combining environment variables and conditional logic.

Date and Time Utilities - Provides comprehensive functions for transforming timestamps and date strings into specific layouts.

Duration Calculations - Computes elapsed time since a specific date and rounds durations for human-readable display.

Date String Parsers - Includes tools for parsing date strings using specific layouts to create date objects.

Temporal Arithmetic - Allows adjusting timestamps by adding or subtracting time increments via modification strings.

Date Formatting Utilities - Offers utilities to retrieve the current time and format timestamps into human-readable strings.

String Case Transformers - Converts strings between various naming conventions including camelCase, snake_case, and kebab-case.

Text Case Transformers - Transforms raw data into formatted text using casing, pluralization, and regular expression tools.

Cryptographic Helpers - Ships specialized template functions for generating security credentials, hashes, and X.509 certificates.

Template Logic Controllers - Implements conditional branching and logic helpers, such as ternary evaluations and semantic versioning checks, for templates.

Random Value Generators - Produces a random integer within a specified inclusive-minimum and exclusive-maximum range.

Whitespace Removers - Implements functions to remove leading and trailing whitespace or specific characters from strings.

Merging Utilities - Implements logic for recursively combining nested maps with configurable precedence rules.

Extremum Finding - Identifies the largest or smallest number from a series of floating-point values.

String Manipulators - Provides utilities for splitting strings into lists or maps based on specific delimiters.

Runtime Type Introspection - Returns the kind of an object to enable conditional logic within templates.

Text Processing Utilities - Offers extensive text processing utilities for case conversion, regex operations, and date formatting within templates.

Rounding Utilities - Adjusts floating-point values using rounding, flooring, and ceiling operations to a specific precision.

Floating Point Arithmetic - Executes fundamental arithmetic operations including addition and division on floating-point numbers.

Cryptography Libraries - Wraps Go's standard cryptography and encoding packages to provide high-level hashing and encryption functions.

Deep Equality Comparison - Determines if two non-primitive data structures are deeply equal by value.

Integer Arithmetic - Calculates sums and products using a series of integer inputs.

Text Block Formatting - Formats text blocks by wrapping content at specific widths or adding indentation.

String Manipulators - Concatenates multiple strings, replaces characters, and wraps text in quotes.

URL Construction - Assembles structured URL strings from a map of components.

URL Data Parsing - Deconstructs raw URL strings into structured dictionaries of their constituent parts.

JSON Parsing - Decodes JSON documents into usable data structures within templates.

Unique Identifier Generators - Generates randomly produced version 4 universally unique identifiers.

Dictionary Manipulation Utilities - Enables retrieval of specific values from dictionaries using keys and deep traversal.

Null Value Handling - Provides fallback values for empty variables and handles null values within template logic.

Version Constraints - Implements logic to verify if a version string satisfies specific constraints or ranges.

Semantic Versioning Systems - Parses version strings to determine relative order according to semantic versioning specifications.

Dictionary Management Utilities - Implements core dictionary operations including key creation, updates, deletion, and existence checks.

Environment Variable Resolution - Interfaces with the host operating system to retrieve and expand environment variables within templates.

List Filtering Utilities - Includes capabilities to remove duplicates and strip empty entries from lists.

List Manipulation Utilities - Ships functions to append, prepend, concatenate, and slice immutable sequential lists.

List Query Utilities - Provides utilities to retrieve the first, last, or remaining elements of a list.

List Transformation Utilities - Provides functions to reverse the sequence of elements or split lists into smaller chunks.

Key Filtering - Provides logic for extracting a new dictionary containing only a specified subset of keys.

Runtime Type Inspection - Includes functions to identify the underlying type or kind of a variable at runtime.

Binary-to-Text Encodings - Converts text into Base64 or Base32 formats and back again.

Certificate Management - Provides capabilities for generating self-signed and CA-signed X.509 certificates.

Cryptographic Operations - Implements cryptographic primitives for generating private keys, hashing data, and deriving secure passwords.

Cryptographic Random Number Generators - Creates cryptographically secure random strings using alphanumeric or ASCII character sets.

Encryption - Implements AES-256 CBC encryption to transform plain text into base64 encoded strings.

Algorithm-Driven Key Generation - Produces new private keys encoded in PEM blocks using various cryptographic algorithms.

Credential Generation - Produces random UUIDs, private keys, and password hashes for secure system initialization.

Cryptographic Hash Computations - Calculates message digests and checksums using standard algorithms like SHA256 and bcrypt.

Password Hash Generators - Generates secure password hashes for authentication using bcrypt and SHA algorithms.

Environment Variable Injection - Injects operating system environment variables into strings using template syntax.

First Non-Empty Selection - Scans a list of provided values and returns the first one that is not empty.

Fallback Value Logic - Returns a fallback value if the provided input is empty, null, or zero.

Pluralization Rules - Provides logic to select different string representations based on integer counts for singular and plural forms.

Empty Value Validations - Evaluates whether various data types are empty or non-empty based on their zero-value state.

Multi-Value Emptiness Checks - Checks a list of values to determine if all or any are non-empty.

Lexicographical Sorting - Arranges lists of strings into lexicographical order.

String Joining - Combines multiple string elements into a single string using a specified separator.

Content Analysis - Checks if strings contain specific substrings or start and end with certain characters.

Environment Variable Access - Reads and expands environment variables from the host operating system for use in templates.

Ternary Expression Evaluators - Implements ternary logic to return one of two values based on a boolean test.

JSON Encoding - Encodes data structures into JSON strings with support for pretty-printing and HTML escaping.

Template Engines - Collection of useful template functions.

Mastermindssprig

Features

Star history