Repository: go-sprout/sprout (go)

Issue:
misc: fix methods cases
### Please exprime yourself

Right now, it's

- toJson
- toYaml
- fromJson
- ...

But these are acronyms

It should be
- toJSON
- toYAML
- fromJSON

The code is OK I think. My problem is the identifier of methods in the template engine

### Code of Conduct

- [x] I agree to follow this project's Code of Conduct

Pull request:
feat: use uppercase acronyms in template functions
## Description

See discussions in 
- #84 

## Changes

The functions are now using uppercase acronym, old ones are aliased, but marked as deprecated.

## Fixes #84

## Checklist
- [X] I have read the **CONTRIBUTING.md** document.
- [X] My code follows the code style of this project.
- [?] I have added tests to cover my changes.
- [X] All new and existing tests passed.
- [X] I have updated the documentation accordingly.
- [?] This change requires a change to the documentation on the website.

## Additional Information
<!-- Any additional information regarding this pull request. -->


Patch:
diff --git a/benchmarks/allFunctions.sprig.tmpl b/benchmarks/allFunctions.sprig.tmpl
index 3315bb3..d74028e 100644
--- a/benchmarks/allFunctions.sprig.tmpl
+++ b/benchmarks/allFunctions.sprig.tmpl
@@ -44,14 +44,23 @@
 {{ "" | b32dec }}
 {{ "JBSWY3DPEBLW64TMMQ======" | b32dec }}
 {{ "JBSWY3DPEBLW64TMMQ" | b32dec }}
+{{ "" | fromJSON }}
 {{ "" | fromJson }}
+{{ .json | fromJSON }}
 {{ .json | fromJson }}
+{{ (.json | fromJSON).foo }}
 {{ (.json | fromJson).foo }}
+{{ "" | toJSON }}
 {{ "" | toJson }}
+{{ .object | toJSON }}
 {{ .object | toJson }}
+{{ "" | toPrettyJSON }}
 {{ "" | toPrettyJson }}
+{{ .object | toPrettyJSON }}
 {{ .object | toPrettyJson }}
+{{ "" | toRawJSON }}
 {{ "" | toRawJson }}
+{{ .object | toRawJSON }}
 {{ .object | toRawJson }}
 {{ .json | mustFromJson }}
 {{ .object | mustToJson }}
diff --git a/benchmarks/allFunctions.sprout.tmpl b/benchmarks/allFunctions.sprout.tmpl
index e47c8f8..8688cf6 100644
--- a/benchmarks/allFunctions.sprout.tmpl
+++ b/benchmarks/allFunctions.sprout.tmpl
@@ -62,18 +62,31 @@
 {{ "JBSWY3DPEBLW64TMMQ======" | base32Decode }}
 {{ "" | safeFromJson }}
 {{ .json | fromJson }}
+{{ .json | fromJSON }}
 {{ (.json | fromJson).foo }}
+{{ (.json | fromJSON).foo }}
 {{ "" | toJson }}
+{{ "" | toJSON }}
 {{ .object | toJson }}
+{{ .object | toJSON }}
 {{ "" | toPrettyJson }}
+{{ "" | toPrettyJSON }}
 {{ .object | toPrettyJson }}
+{{ .object | toPrettyJSON }}
 {{ "" | toRawJson }}
+{{ "" | toRawJSON }}
 {{ .object | toRawJson }}
+{{ .object | toRawJSON }}
 {{ "" | fromYaml }}
+{{ "" | fromYAML }}
 {{ .yaml | fromYaml }}
+{{ .yaml | fromYAML }}
 {{ (.yaml | fromYaml).foo }}
+{{ (.yaml | fromYAML).foo }}
 {{ "" | toYaml }}
+{{ "" | toYAML }}
 {{ .yaml | toYaml }}
+{{ .yaml | toYAML }}
 {{ .json | mustFromJson }}
 {{ .object | mustToJson }}
 {{ .object | mustToPrettyJson }}
diff --git a/docs/registries/encoding.md b/docs/registries/encoding.md
index ea3bd67..3018cfe 100644
--- a/docs/registries/encoding.md
+++ b/docs/registries/encoding.md
@@ -75,114 +75,114 @@ The function decodes a Base32 encoded string back to its original form. If the i
 {% endtab %}
 {% endtabs %}
 
-### <mark style="color:purple;">fromJson</mark>
+### <mark style="color:purple;">fromJSON</mark>
 
 The function converts a JSON string into a corresponding Go data structure, enabling easy manipulation of the JSON data in a Go environment.
 
-<table data-header-hidden><thead><tr><th width="164">Name</th><th>Value</th></tr></thead><tbody><tr><td>Signature</td><td><pre class="language-go"><code class="lang-go">FromJson(v string) (any, error)
+<table data-header-hidden><thead><tr><th width="164">Name</th><th>Value</th></tr></thead><tbody><tr><td>Signature</td><td><pre class="language-go"><code class="lang-go">fromJSON(v string) (any, error)
 </code></pre></td></tr></tbody></table>
 
 {% tabs %}
 {% tab title="Template Example" %}
 ```go
-{{ `{"name":"John", "age":30}` | fromJson }} // Output: map[age:30 name:John]
-{{ "{\\invalid" | fromJson }} // Error
+{{ `{"name":"John", "age":30}` | fromJSON }} // Output: map[age:30 name:John]
+{{ "{\\invalid" | fromJSON }} // Error
 ```
 {% endtab %}
 {% endtabs %}
 
-### <mark style="color:purple;">toJson</mark>
+### <mark style="color:purple;">toJSON</mark>
 
 The function converts a Go data structure into a JSON string, allowing the data to be easily serialized for storage, transmission, or further processing.
 
-<table data-header-hidden><thead><tr><th width="164">Name</th><th>Value</th></tr></thead><tbody><tr><td>Signature</td><td><pre class="language-go"><code class="lang-go">ToJson(v any) (string, error)
+<table data-header-hidden><thead><tr><th width="164">Name</th><th>Value</th></tr></thead><tbody><tr><td>Signature</td><td><pre class="language-go"><code class="lang-go">ToJSON(v any) (string, error)
 </code></pre></td></tr></tbody></table>
 
 {% tabs %}
 {% tab title="Template Example" %}
 ```go
 {{- $d := dict "key1" "value1" "key2" "value2" "key3" "value3" -}}
-{{ toJson $d }} // Output: {\"key1\":\"value1\",\"key2\":\"value2\",\"key3\":\"value3\"}
+{{ toJSON $d }} // Output: {\"key1\":\"value1\",\"key2\":\"value2\",\"key3\":\"value3\"}
 ```
 {% endtab %}
 {% endtabs %}
 
-### <mark style="color:purple;">toPrettyJson</mark>
+### <mark style="color:purple;">toPrettyJSON</mark>
 
 The function converts a Go data structure into a pretty-printed JSON string, formatting the output with indentation and line breaks for better readability.
 
-<table data-header-hidden><thead><tr><th width="164">Name</th><th>Value</th></tr></thead><tbody><tr><td>Signature</td><td><pre class="language-go"><code class="lang-go">ToPrettyJson(v any) (string, error)
+<table data-header-hidden><thead><tr><th width="164">Name</th><th>Value</th></tr></thead><tbody><tr><td>Signature</td><td><pre class="language-go"><code class="lang-go">toPrettyJSON(v any) (string, error)
 </code></pre></td></tr></tbody></table>
 
 {% tabs %}
 {% tab title="Template Example" %}
 ```go
 {{- $d := dict "key1" "value1" "key2" "value2" "key3" "value3" -}}
-{{ toPrettyJson $d }} // Output: "{\n  \"key1\": \"value1\",\n  \"key2\": \"value2\",\n  \"key3\": \"value3\"\n}"
+{{ toPrettyJSON $d }} // Output: "{\n  \"key1\": \"value1\",\n  \"key2\": \"value2\",\n  \"key3\": \"value3\"\n}"
 ```
 {% endtab %}
 {% endtabs %}
 
-### <mark style="color:purple;">toRawJson</mark>
+### <mark style="color:purple;">toRawJSON</mark>
 
 The function converts a Go data structure into a JSON string without escaping HTML characters, preserving the raw content as it is.
 
-<table data-header-hidden><thead><tr><th width="164">Name</th><th>Value</th></tr></thead><tbody><tr><td>Signature</td><td><pre class="language-go"><code class="lang-go">ToRawJson(v any) (string, error)
+<table data-header-hidden><thead><tr><th width="164">Name</th><th>Value</th></tr></thead><tbody><tr><td>Signature</td><td><pre class="language-go"><code class="lang-go">toRawJSON(v any) (string, error)
 </code></pre></td></tr></tbody></table>
 
 {% tabs %}
 {% tab title="Template Example" %}
 ```go
 {{- $d := dict "content" "<p>Hello World</p>" -}}
-{{ toRawJson $d }} // Output: {\"content\":\"<p>Hello World</p>\"}
+{{ toRawJSON $d }} // Output: {\"content\":\"<p>Hello World</p>\"}
 ```
 {% endtab %}
 {% endtabs %}
 
-### <mark style="color:purple;">fromYaml</mark>
+### <mark style="color:purple;">fromYAML</mark>
 
 The function deserializes a YAML string into a Go map, allowing the structured data from YAML to be used and manipulated within a Go program.
 
-<table data-header-hidden><thead><tr><th width="164">Name</th><th>Value</th></tr></thead><tbody><tr><td>Signature</td><td><pre class="language-go"><code class="lang-go">FromYAML(v string) (any, error)
+<table data-header-hidden><thead><tr><th width="164">Name</th><th>Value</th></tr></thead><tbody><tr><td>Signature</td><td><pre class="language-go"><code class="lang-go">fromYAML(v string) (any, error)
 </code></pre></td></tr></tbody></table>
 
 {% tabs %}
 {% tab title="Template Example" %}
 ```go
 
-{{ "name: John Doe\nage: 30" | fromYaml }} // Output: map[age:30 name:John Doe]
+{{ "name: John Doe\nage: 30" | fromYAML }} // Output: map[age:30 name:John Doe]
 ```
 {% endtab %}
 {% endtabs %}
 
-### <mark style="color:purple;">toYaml</mark>
+### <mark style="color:purple;">toYAML</mark>
 
 The function serializes a Go data structure into a YAML string, converting the data into a format suitable for YAML representation.
 
-<table data-header-hidden><thead><tr><th width="164">Name</th><th>Value</th></tr></thead><tbody><tr><td>Signature</td><td><pre class="language-go"><code class="lang-go">ToYAML(v any) (string, error)
+<table data-header-hidden><thead><tr><th width="164">Name</th><th>Value</th></tr></thead><tbody><tr><td>Signature</td><td><pre class="language-go"><code class="lang-go">toYAML(v any) (string, error)
 </code></pre></td></tr></tbody></table>
 
 {% tabs %}
 {% tab title="Template Example" %}
 ```go
 {{- $d := dict "name" "John Doe" "age" 30 -}}
-{{ $d | toYaml }} // Output: age: 30\nname: John Doe
+{{ $d | toYAML }} // Output: age: 30\nname: John Doe
 ```
 {% endtab %}
 {% endtabs %}
 
-### <mark style="color:purple;">toIndentYaml</mark>
+### <mark style="color:purple;">toIndentYAML</mark>
 
-The function serializes a Go data structure into a YAML string, converting the data into a format suitable for YAML representation. In addition to toYaml, toIndentYaml takes a parameter to define the indentation width in spaces.
+The function serializes a Go data structure into a YAML string, converting the data into a format suitable for YAML representation. In addition to toYAML, toIndentYAML takes a parameter to define the indentation width in spaces.
 
-<table data-header-hidden><thead><tr><th width="164">Name</th><th>Value</th></tr></thead><tbody><tr><td>Signature</td><td><pre class="language-go"><code class="lang-go">ToIndentYAML(indent int, v any) (string, error)
+<table data-header-hidden><thead><tr><th width="164">Name</th><th>Value</th></tr></thead><tbody><tr><td>Signature</td><td><pre class="language-go"><code class="lang-go">toIndentYAML(indent int, v any) (string, error)
 </code></pre></td></tr></tbody></table>
 
 {% tabs %}
 {% tab title="Template Example" %}
 ```go
 {{ $person := dict "name" "John Doe" "age" 30 "location" (dict "country" "US" "planet" "Earth") }}
-{{ $person | toIndentYaml 2 }} // Output: \nage: 30\nlocation:\n  country: US\n  planet: Earth\nname: John Doe
+{{ $person | toIndentYAML 2 }} // Output: \nage: 30\nlocation:\n  country: US\n  planet: Earth\nname: John Doe
 ```
 {% endtab %}
 {% endtabs %}
diff --git a/docs/roadmap-to-sprout-v1.0.md b/docs/roadmap-to-sprout-v1.0.md
index a56bab4..61760ac 100644
--- a/docs/roadmap-to-sprout-v1.0.md
+++ b/docs/roadmap-to-sprout-v1.0.md
@@ -103,4 +103,4 @@ This page will be updated each time function are re-implemented correctly in Spr
 
 A list of functions wanted for v1 based on issues, pull requests from sprig, feedback on sprout. All functions listed here will be implemented for the v1.
 
-<table><thead><tr><th width="94" data-type="checkbox">DONE</th><th>Functions</th><th>Description</th></tr></thead><tbody><tr><td>true</td><td><code>toYaml</code></td><td>Convert a struct to a YAML String</td></tr><tr><td>true</td><td><code>fromYaml</code></td><td>Convert YAML String to a struct</td></tr><tr><td>true</td><td><code>toBool</code></td><td>Convert any to a boolean</td></tr><tr><td>true</td><td><code>toDuration</code></td><td>Convert any to a <code>time.Duration</code></td></tr><tr><td>true</td><td><code>default</code>,<code>empty</code>,<code>coalesce</code></td><td>Don't trigger default go value as false</td></tr><tr><td>true</td><td><code>dig</code></td><td>Dig into a map without crashes in format <code>book.author.name</code></td></tr><tr><td>true</td><td><code>sha512sum</code></td><td>Support of SHA512</td></tr><tr><td>true</td><td><code>md5sum</code></td><td>Support of md5 hash</td></tr><tr><td>true</td><td><code>hasField</code></td><td>Detect if a field are present in an object using reflect. <a href="https://github.com/Masterminds/sprig/issues/401">Source</a></td></tr><tr><td>true</td><td><code>toDuration</code></td><td>convert a value to a <code>time.Duration</code></td></tr><tr><td>true</td><td><code>toCamelCase</code>, <code>toPascalCase</code>, <code>toKebakCase</code>, <code>toDotCase</code>, <code>topathCase</code>, <code>toConstantCase</code>,<code>toSnakeCase</code>,<code>toTitleCase</code></td><td>A batch of functions to change casing of a string to aby casing you want.</td></tr><tr><td>true</td><td><code>capitalize</code>, <code>uncapitalize</code></td><td>Capitalize / Uncapitalize a string (Upper/lower only the first character)</td></tr><tr><td>true</td><td><code>flatten</code></td><td>Flatten nested list be one level</td></tr><tr><td>true</td><td><code>regexpFindSubmatch</code>, <code>regexpAllSubmatches</code>,<code>regexpFindNamedSubmatch</code>, <code>regexpAllNamedSubmatches</code></td><td>Collection of function to found and retrieve submatches and named submatches</td></tr><tr><td>true</td><td><code>cidr</code>, <code>ip</code>, <code>mac</code></td><td>A collection of functions for network ip manipulation</td></tr><tr><td>true</td><td><code>toLocalDate</code></td><td>Convert to a <code>time.Time</code> with a timezone support</td></tr></tbody></table>
+<table><thead><tr><th width="94" data-type="checkbox">DONE</th><th>Functions</th><th>Description</th></tr></thead><tbody><tr><td>true</td><td><code>toYAML</code></td><td>Convert a struct to a YAML String</td></tr><tr><td>true</td><td><code>fromYAML</code></td><td>Convert YAML String to a struct</td></tr><tr><td>true</td><td><code>toBool</code></td><td>Convert any to a boolean</td></tr><tr><td>true</td><td><code>toDuration</code></td><td>Convert any to a <code>time.Duration</code></td></tr><tr><td>true</td><td><code>default</code>,<code>empty</code>,<code>coalesce</code></td><td>Don't trigger default go value as false</td></tr><tr><td>true</td><td><code>dig</code></td><td>Dig into a map without crashes in format <code>book.author.name</code></td></tr><tr><td>true</td><td><code>sha512sum</code></td><td>Support of SHA512</td></tr><tr><td>true</td><td><code>md5sum</code></td><td>Support of md5 hash</td></tr><tr><td>true</td><td><code>hasField</code></td><td>Detect if a field are present in an object using reflect. <a href="https://github.com/Masterminds/sprig/issues/401">Source</a></td></tr><tr><td>true</td><td><code>toDuration</code></td><td>convert a value to a <code>time.Duration</code></td></tr><tr><td>true</td><td><code>toCamelCase</code>, <code>toPascalCase</code>, <code>toKebakCase</code>, <code>toDotCase</code>, <code>topathCase</code>, <code>toConstantCase</code>,<code>toSnakeCase</code>,<code>toTitleCase</code></td><td>A batch of functions to change casing of a string to aby casing you want.</td></tr><tr><td>true</td><td><code>capitalize</code>, <code>uncapitalize</code></td><td>Capitalize / Uncapitalize a string (Upper/lower only the first character)</td></tr><tr><td>true</td><td><code>flatten</code></td><td>Flatten nested list be one level</td></tr><tr><td>true</td><td><code>regexpFindSubmatch</code>, <code>regexpAllSubmatches</code>,<code>regexpFindNamedSubmatch</code>, <code>regexpAllNamedSubmatches</code></td><td>Collection of function to found and retrieve submatches and named submatches</td></tr><tr><td>true</td><td><code>cidr</code>, <code>ip</code>, <code>mac</code></td><td>A collection of functions for network ip manipulation</td></tr><tr><td>true</td><td><code>toLocalDate</code></td><td>Convert to a <code>time.Time</code> with a timezone support</td></tr></tbody></table>
diff --git a/registry/encoding/encoding.go b/registry/encoding/encoding.go
index c15c425..597ae51 100644
--- a/registry/encoding/encoding.go
+++ b/registry/encoding/encoding.go
@@ -27,32 +27,40 @@ func (er *EncodingRegistry) RegisterFunctions(funcsMap sprout.FunctionMap) error
 	sprout.AddFunction(funcsMap, "base64Decode", er.Base64Decode)
 	sprout.AddFunction(funcsMap, "base32Encode", er.Base32Encode)
 	sprout.AddFunction(funcsMap, "base32Decode", er.Base32Decode)
-	sprout.AddFunction(funcsMap, "fromJson", er.FromJson)
-	sprout.AddFunction(funcsMap, "toJson", er.ToJson)
-	sprout.AddFunction(funcsMap, "toPrettyJson", er.ToPrettyJson)
-	sprout.AddFunction(funcsMap, "toRawJson", er.ToRawJson)
-	sprout.AddFunction(funcsMap, "fromYaml", er.FromYAML)
-	sprout.AddFunction(funcsMap, "toYaml", er.ToYAML)
-	sprout.AddFunction(funcsMap, "toIndentYaml", er.ToIndentYAML)
+	sprout.AddFunction(funcsMap, "fromJSON", er.FromJSON)
+	sprout.AddFunction(funcsMap, "toJSON", er.ToJSON)
+	sprout.AddFunction(funcsMap, "toPrettyJSON", er.ToPrettyJSON)
+	sprout.AddFunction(funcsMap, "toRawJSON", er.ToRawJSON)
+	sprout.AddFunction(funcsMap, "fromYAML", er.FromYAML)
+	sprout.AddFunction(funcsMap, "toYAML", er.ToYAML)
+	sprout.AddFunction(funcsMap, "toIndentYAML", er.ToIndentYAML)
 	return nil
 }
 
 func (er *EncodingRegistry) RegisterAliases(aliasesMap sprout.FunctionAliasMap) error {
-	sprout.AddAlias(aliasesMap, "fromJson", "mustFromJson")
-	sprout.AddAlias(aliasesMap, "toJson", "mustToJson")
-	sprout.AddAlias(aliasesMap, "toPrettyJson", "mustToPrettyJson")
-	sprout.AddAlias(aliasesMap, "toRawJson", "mustToRawJson")
-	sprout.AddAlias(aliasesMap, "fromYaml", "mustFromYaml")
-	sprout.AddAlias(aliasesMap, "toYaml", "mustToYaml")
+	sprout.AddAlias(aliasesMap, "fromJSON", "fromJson", "mustFromJson")
+	sprout.AddAlias(aliasesMap, "toJSON", "toJson", "mustToJson")
+	sprout.AddAlias(aliasesMap, "toPrettyJSON", "toPrettyJson", "mustToPrettyJson")
+	sprout.AddAlias(aliasesMap, "toRawJSON", "toRawJson", "mustToRawJson")
+	sprout.AddAlias(aliasesMap, "fromYAML", "fromYaml", "mustFromYaml")
+	sprout.AddAlias(aliasesMap, "toYAML", "toYaml", "mustToYaml")
 	return nil
 }
 
 func (er *EncodingRegistry) RegisterNotices(notices *[]sprout.FunctionNotice) error {
-	sprout.AddNotice(notices, sprout.NewDeprecatedNotice("mustFromJson", "please use `fromJson` instead"))
-	sprout.AddNotice(notices, sprout.NewDeprecatedNotice("mustToJson", "please use `toJson` instead"))
-	sprout.AddNotice(notices, sprout.NewDeprecatedNotice("mustToPrettyJson", "please use `toPrettyJson` instead"))
-	sprout.AddNotice(notices, sprout.NewDeprecatedNotice("mustToRawJson", "please use `toRawJson` instead"))
-	sprout.AddNotice(notices, sprout.NewDeprecatedNotice("mustFromYaml", "please use `fromYaml` instead"))
-	sprout.AddNotice(notices, sprout.NewDeprecatedNotice("mustToYaml", "please use `toYaml` instead"))
+	sprout.AddNotice(notices, sprout.NewDeprecatedNotice("mustFromJson", "please use `fromJSON` instead"))
+	sprout.AddNotice(notices, sprout.NewDeprecatedNotice("mustToJson", "please use `toJSON` instead"))
+	sprout.AddNotice(notices, sprout.NewDeprecatedNotice("mustToPrettyJson", "please use `toPrettyJSON` instead"))
+	sprout.AddNotice(notices, sprout.NewDeprecatedNotice("mustToRawJson", "please use `toRawJSON` instead"))
+	sprout.AddNotice(notices, sprout.NewDeprecatedNotice("mustFromYaml", "please use `fromYAML` instead"))
+	sprout.AddNotice(notices, sprout.NewDeprecatedNotice("mustToYaml", "please use `toYAML` instead"))
+
+	sprout.AddNotice(notices, sprout.NewDeprecatedNotice("fromJson", "please use `fromJSON` instead"))
+	sprout.AddNotice(notices, sprout.NewDeprecatedNotice("toJson", "please use `toJSON` instead"))
+	sprout.AddNotice(notices, sprout.NewDeprecatedNotice("toPrettyJson", "please use `toPrettyJSON` instead"))
+	sprout.AddNotice(notices, sprout.NewDeprecatedNotice("toRawJson", "please use `toRawJSON` instead"))
+	sprout.AddNotice(notices, sprout.NewDeprecatedNotice("fromYaml", "please use `fromYAML` instead"))
+	sprout.AddNotice(notices, sprout.NewDeprecatedNotice("toYaml", "please use `toYAML` instead"))
+
 	return nil
 }
diff --git a/registry/encoding/functions.go b/registry/encoding/functions.go
index 8406fc6..50563e0 100644
--- a/registry/encoding/functions.go
+++ b/registry/encoding/functions.go
@@ -93,7 +93,7 @@ func (er *EncodingRegistry) Base32Decode(value string) (string, error) {
 	return string(bytes), nil
 }
 
-// FromJson decodes a JSON string into a Go data structure, returning an
+// FromJSON decodes a JSON string into a Go data structure, returning an
 // error if decoding fails.
 //
 // Parameters:
@@ -105,10 +105,10 @@ func (er *EncodingRegistry) Base32Decode(value string) (string, error) {
 //	any - the decoded Go data structure.
 //	error - error encountered during decoding, if any.
 //
-// For an example of this function in a Go template, refer to [Sprout Documentation: fromJson].
+// For an example of this function in a Go template, refer to [Sprout Documentation: fromJSON].
 //
-// [Sprout Documentation: fromJson]: https://docs.atom.codes/sprout/registries/encoding#fromjson
-func (er *EncodingRegistry) FromJson(value string) (any, error) {
+// [Sprout Documentation: fromJSON]: https://docs.atom.codes/sprout/registries/encoding#fromjson
+func (er *EncodingRegistry) FromJSON(value string) (any, error) {
 	var output any
 	err := json.Unmarshal([]byte(value), &output)
 	if err != nil {
@@ -117,7 +117,7 @@ func (er *EncodingRegistry) FromJson(value string) (any, error) {
 	return output, err
 }
 
-// ToJson encodes a Go data structure into a JSON string, returning an error
+// ToJSON encodes a Go data structure into a JSON string, returning an error
 // if encoding fails.
 //
 // Parameters:
@@ -129,10 +129,10 @@ func (er *EncodingRegistry) FromJson(value string) (any, error) {
 //	string - the JSON-encoded string.
 //	error - error encountered during encoding, if any.
 //
-// For an example of this function in a Go template, refer to [Sprout Documentation: toJson].
+// For an example of this function in a Go template, refer to [Sprout Documentation: toJSON].
 //
-// [Sprout Documentation: toJson]: https://docs.atom.codes/sprout/registries/encoding#tojson
-func (er *EncodingRegistry) ToJson(value any) (string, error) {
+// [Sprout Documentation: toJSON]: https://docs.atom.codes/sprout/registries/encoding#tojson
+func (er *EncodingRegistry) ToJSON(value any) (string, error) {
 	output, err := json.Marshal(value)
 	if err != nil {
 		return "", fmt.Errorf("json encode error: %w", err)
@@ -140,7 +140,7 @@ func (er *EncodingRegistry) ToJson(value any) (string, error) {
 	return string(output), nil
 }
 
-// ToPrettyJson encodes a Go data structure into a pretty-printed JSON
+// ToPrettyJSON encodes a Go data structure into a pretty-printed JSON
 // string, returning an error if encoding fails.
 //
 // Parameters:
@@ -152,10 +152,10 @@ func (er *EncodingRegistry) ToJson(value any) (string, error) {
 //	string - the pretty-printed JSON string.
 //	error - error encountered during encoding, if any.
 //
-// For an example of this function in a Go template, refer to [Sprout Documentation: toPrettyJson].
+// For an example of this function in a Go template, refer to [Sprout Documentation: toPrettyJSON].
 //
-// [Sprout Documentation: toPrettyJson]: https://docs.atom.codes/sprout/registries/encoding#toprettyjson
-func (er *EncodingRegistry) ToPrettyJson(value any) (string, error) {
+// [Sprout Documentation: toPrettyJSON]: https://docs.atom.codes/sprout/registries/encoding#toprettyjson
+func (er *EncodingRegistry) ToPrettyJSON(value any) (string, error) {
 	output, err := json.MarshalIndent(value, "", "  ")
 	if err != nil {
 		return "", fmt.Errorf("json encode error: %w", err)
@@ -163,7 +163,7 @@ func (er *EncodingRegistry) ToPrettyJson(value any) (string, error) {
 	return string(output), nil
 }
 
-// ToRawJson encodes a Go data structure into a JSON string without escaping
+// ToRawJSON encodes a Go data structure into a JSON string without escaping
 // HTML, returning an error if encoding fails.
 //
 // Parameters:
@@ -175,10 +175,10 @@ func (er *EncodingRegistry) ToPrettyJson(value any) (string, error) {
 //	string - the raw JSON string.
 //	error - error encountered during encoding, if any.
 //
-// For an example of this function in a Go template, refer to [Sprout Documentation: toRawJson].
+// For an example of this function in a Go template, refer to [Sprout Documentation: toRawJSON].
 //
-// [Sprout Documentation: toRawJson]: https://docs.atom.codes/sprout/registries/encoding#torawjson
-func (er *EncodingRegistry) ToRawJson(value any) (string, error) {
+// [Sprout Documentation: toRawJSON]: https://docs.atom.codes/sprout/registries/encoding#torawjson
+func (er *EncodingRegistry) ToRawJSON(value any) (string, error) {
 	buf := new(bytes.Buffer)
 	enc := json.NewEncoder(buf)
 	enc.SetEscapeHTML(false)


Test patch:
diff --git a/registry/encoding/functions_test.go b/registry/encoding/functions_test.go
index 1bcaffa..71c8148 100644
--- a/registry/encoding/functions_test.go
+++ b/registry/encoding/functions_test.go
@@ -59,29 +59,29 @@ func TestFromJson(t *testing.T) {
 	pesticide.RunTestCases(t, encoding.NewRegistry(), tc)
 }
 
-func TestToJson(t *testing.T) {
+func TestToJSON(t *testing.T) {
 	tc := []pesticide.TestCase{
-		{Name: "TestEmptyInput", Input: `{{ "" | toJson }}`, ExpectedOutput: `""`},
-		{Name: "TestVariableInput", Input: `{{ .V | toJson }}`, ExpectedOutput: "{\"bar\":\"baz\",\"foo\":55}", Data: map[string]any{"V": map[string]any{"foo": 55, "bar": "baz"}}},
-		{Name: "TestInvalidInput", Input: `{{ .V | toJson }}`, ExpectedErr: "json encode error", Data: map[string]any{"V": make(chan int)}},
+		{Name: "TestEmptyInput", Input: `{{ "" | toJSON }}`, ExpectedOutput: `""`},
+		{Name: "TestVariableInput", Input: `{{ .V | toJSON }}`, ExpectedOutput: "{\"bar\":\"baz\",\"foo\":55}", Data: map[string]any{"V": map[string]any{"foo": 55, "bar": "baz"}}},
+		{Name: "TestInvalidInput", Input: `{{ .V | toJSON }}`, ExpectedErr: "json encode error", Data: map[string]any{"V": make(chan int)}},
 	}
 
 	pesticide.RunTestCases(t, encoding.NewRegistry(), tc)
 }
 
-func TestToPrettyJson(t *testing.T) {
+func TestToPrettyJSON(t *testing.T) {
 	tc := []pesticide.TestCase{
-		{Name: "TestEmptyInput", Input: `{{ "" | toPrettyJson }}`, ExpectedOutput: `""`},
-		{Name: "TestVariableInput", Input: `{{ .V | toPrettyJson }}`, ExpectedOutput: "{\n  \"bar\": \"baz\",\n  \"foo\": 55\n}", Data: map[string]any{"V": map[string]any{"foo": 55, "bar": "baz"}}},
+		{Name: "TestEmptyInput", Input: `{{ "" | toPrettyJSON }}`, ExpectedOutput: `""`},
+		{Name: "TestVariableInput", Input: `{{ .V | toPrettyJSON }}`, ExpectedOutput: "{\n  \"bar\": \"baz\",\n  \"foo\": 55\n}", Data: map[string]any{"V": map[string]any{"foo": 55, "bar": "baz"}}},
 	}
 
 	pesticide.RunTestCases(t, encoding.NewRegistry(), tc)
 }
 
-func TestToRawJson(t *testing.T) {
+func TestToRawJSON(t *testing.T) {
 	tc := []pesticide.TestCase{
-		{Name: "TestEmptyInput", Input: `{{ "" | toRawJson }}`, ExpectedOutput: `""`},
-		{Name: "TestVariableInput", Input: `{{ .V | toRawJson }}`, ExpectedOutput: "{\"bar\":\"baz\",\"foo\":55}", Data: map[string]any{"V": map[string]any{"foo": 55, "bar": "baz"}}},
+		{Name: "TestEmptyInput", Input: `{{ "" | toRawJSON }}`, ExpectedOutput: `""`},
+		{Name: "TestVariableInput", Input: `{{ .V | toRawJSON }}`, ExpectedOutput: "{\"bar\":\"baz\",\"foo\":55}", Data: map[string]any{"V": map[string]any{"foo": 55, "bar": "baz"}}},
 	}
 
 	pesticide.RunTestCases(t, encoding.NewRegistry(), tc)
@@ -89,10 +89,10 @@ func TestToRawJson(t *testing.T) {
 
 func TestFromYAML(t *testing.T) {
 	tc := []pesticide.TestCase{
-		{Name: "TestEmptyInput", Input: `{{ "" | fromYaml }}`, ExpectedOutput: "map[]"},
-		{Name: "TestVariableInput", Input: `{{ .V | fromYaml }}`, ExpectedOutput: "map[bar:map[baz:1] foo:55]", Data: map[string]any{"V": "foo: 55\nbar:\n  baz: 1\n"}},
-		{Name: "TestAccessField", Input: `{{ (.V | fromYaml).foo }}`, ExpectedOutput: "55", Data: map[string]any{"V": "foo: 55"}},
-		{Name: "TestInvalidInput", Input: "{{ .V | fromYaml }}", ExpectedErr: "yaml decode error", Data: map[string]any{"V": "foo: :: baz"}},
+		{Name: "TestEmptyInput", Input: `{{ "" | fromYAML }}`, ExpectedOutput: "map[]"},
+		{Name: "TestVariableInput", Input: `{{ .V | fromYAML }}`, ExpectedOutput: "map[bar:map[baz:1] foo:55]", Data: map[string]any{"V": "foo: 55\nbar:\n  baz: 1\n"}},
+		{Name: "TestAccessField", Input: `{{ (.V | fromYAML).foo }}`, ExpectedOutput: "55", Data: map[string]any{"V": "foo: 55"}},
+		{Name: "TestInvalidInput", Input: "{{ .V | fromYAML }}", ExpectedErr: "yaml decode error", Data: map[string]any{"V": "foo: :: baz"}},
 	}
 
 	pesticide.RunTestCases(t, encoding.NewRegistry(), tc)
@@ -100,9 +100,9 @@ func TestFromYAML(t *testing.T) {
 
 func TestToYAML(t *testing.T) {
 	tc := []pesticide.TestCase{
-		{Name: "TestEmptyInput", Input: `{{ "" | toYaml }}`, ExpectedOutput: `""`},
-		{Name: "TestVariableInput", Input: `{{ .V | toYaml }}`, ExpectedOutput: "bar: baz\nfoo: 55", Data: map[string]any{"V": map[string]any{"foo": 55, "bar": "baz"}}},
-		{Name: "TestInvalidInput", Input: `{{ .V | toYaml }}`, ExpectedErr: "yaml encode error", Data: map[string]any{"V": make(chan int)}},
+		{Name: "TestEmptyInput", Input: `{{ "" | toYAML }}`, ExpectedOutput: `""`},
+		{Name: "TestVariableInput", Input: `{{ .V | toYAML }}`, ExpectedOutput: "bar: baz\nfoo: 55", Data: map[string]any{"V": map[string]any{"foo": 55, "bar": "baz"}}},
+		{Name: "TestInvalidInput", Input: `{{ .V | toYAML }}`, ExpectedErr: "yaml encode error", Data: map[string]any{"V": make(chan int)}},
 	}
 
 	pesticide.RunTestCases(t, encoding.NewRegistry(), tc)
@@ -110,9 +110,9 @@ func TestToYAML(t *testing.T) {
 
 func TestToIndentYAML(t *testing.T) {
 	tc := []pesticide.TestCase{
-		{Name: "TestEmptyInput", Input: `{{ "" | toIndentYaml 8 }}`, ExpectedOutput: `""`},
-		{Name: "TestVariableInput", Input: `{{ .V | toIndentYaml 8 }}`, ExpectedOutput: "bar: baz\nfoo:\n        bar: baz\n        baz: bar", Data: map[string]any{"V": map[string]any{"foo": map[string]any{"baz": "bar", "bar": "baz"}, "bar": "baz"}}},
-		{Name: "TestInvalidInput", Input: `{{ .V | toIndentYaml 8 }}`, ExpectedErr: "yaml encode error", Data: map[string]any{"V": make(chan int)}},
+		{Name: "TestEmptyInput", Input: `{{ "" | toIndentYAML 8 }}`, ExpectedOutput: `""`},
+		{Name: "TestVariableInput", Input: `{{ .V | toIndentYAML 8 }}`, ExpectedOutput: "bar: baz\nfoo:\n        bar: baz\n        baz: bar", Data: map[string]any{"V": map[string]any{"foo": map[string]any{"baz": "bar", "bar": "baz"}, "bar": "baz"}}},
+		{Name: "TestInvalidInput", Input: `{{ .V | toIndentYAML 8 }}`, ExpectedErr: "yaml encode error", Data: map[string]any{"V": make(chan int)}},
 	}
 
 	pesticide.RunTestCases(t, encoding.NewRegistry(), tc)