chore: drop-off v0.1 error handling until rfc safe/must decision (#52)

## Description
Due to the presence of [RFC: Error Handling
Safe/Must](https://github.com/orgs/go-sprout/discussions/32), the old
system of error described in
#5 can be drop off to prevent
usage of mechanism how will never used.

## Changes
- Remove `ErrHandling` options
- Remove `ErrChannel` options

## Fixes #51 

## Checklist
- [x] I have read the **CONTRIBUTING.md** document.
- [x] My code follows the code style of this project.
- [x] I have added tests to cover my changes.
- [x] All new and existing tests passed.
- [x] I have updated the documentation accordingly.
- [x] This change requires a change to the documentation on the website.

## Additional Information
The documentation are updated in this PR.

README.md

@@ -94,12 +94,6 @@ handler := sprout.New(
   // standard slog package or any other logger that implements the slog.Logger interface.
   // By default, Sprout uses a slog.TextHandler.
   sprout.WithLogger(slogLogger),
-  // Set the error handling behavior for the handler. By default, Sprout returns the default value of the return type without crashes or panics.
-  sprout.WithErrHandling(sprout.ErrHandlingReturnDefaultValue),
-  // Set the error channel for the handler. By default, Sprout does not use an error channel. If you set an error channel, Sprout will send errors to it.
-  // This options is only used when the error handling behavior is set to
-  // `ErrHandlingErrorChannel`
-  sprout.WithErrorChannel(errChan),
   // Set the alias for a function. By default, Sprout use alias for some functions for backward compatibility with Sprig.
   sprout.WithAlias("hello", "hi"),
 )

docs/introduction/getting-started.md

@@ -46,15 +46,6 @@ Sprout supports various customization options using handler options:
     logger := slog.New(slog.NewTextHandler(os.Stdout))
     handler := sprout.New(sprout.WithLogger(logger))
     ```
-*   **Error Handling:**
-
-    You can specify how errors are handled within the handler:
-
-    ```go
-    handler := sprout.New(sprout.WithErrHandling(sprout.ErrHandlingPanic))
-    ```
-
-    Available error handling strategies include returning default values, panicking, or sending errors to a channel.
 *   **Aliases Management:**\
     You can specify your custom aliases directly on your handler:
 

docs/migration-from-sprig.md

@@ -45,12 +45,10 @@ Nothing to do, using the new handler is enough.
 ### 3. **Error Handling**
 
 * **Sprig:** Limited and inconsistent error handling, with some functions causing panics (see [#panicking-functions](migration-from-sprig.md#panicking-functions "mention")), and not fully adhering to Go template standards.
-* **Sprout:** Offers configurable error handling strategies, including returning default values, triggering panics, or using error channels, providing a more consistent and flexible approach.
+* **Sprout:** Offers configurable error handling strategies, including returning default values, or return error to stop template generation, providing a more consistent and flexible approach.
 
 {% hint style="info" %}
-**Migration Tip**
-
-Set your preferred error handling strategy using `WithErrHandling` when creating your handler.
+An RFC is currently open for feedback and discussion. You can view and participate in the RFC [here](https://github.com/orgs/go-sprout/discussions/32).
 {% endhint %}
 
 ### 4. **Function Aliases**

handler.go

@@ -24,8 +24,6 @@ type Handler interface {
 // DefaultHandler manages function execution with configurable error handling
 // and logging.
 type DefaultHandler struct {
-	ErrHandling      ErrHandling
-	errChan          chan error
 	logger           *slog.Logger
 	registries       []Registry
 	cachedFuncsMap   FunctionMap

sprout.go

@@ -29,10 +29,8 @@ type HandlerOption[T Handler] func(T)
 // a specific registry.
 func New(opts ...HandlerOption[*DefaultHandler]) *DefaultHandler {
 	dh := &DefaultHandler{
-		ErrHandling: ErrHandlingReturnDefaultValue,
-		errChan:     make(chan error),
-		logger:      slog.New(slog.NewTextHandler(os.Stdout, nil)),
-		registries:  make([]Registry, 0),
+		logger:     slog.New(slog.NewTextHandler(os.Stdout, nil)),
+		registries: make([]Registry, 0),
 
 		cachedFuncsMap:   make(FunctionMap),
 		cachedFuncsAlias: make(FunctionAliasMap),

sprout_test.go

@@ -2,6 +2,7 @@ package sprout
 
 import (
 	"log/slog"
+	"os"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -11,37 +12,21 @@ func TestNewFunctionHandler_DefaultValues(t *testing.T) {
 	handler := NewFunctionHandler()
 
 	assert.NotNil(t, handler)
-	assert.Equal(t, ErrHandlingReturnDefaultValue, handler.ErrHandling)
-	assert.NotNil(t, handler.errChan)
 	assert.NotNil(t, handler.Logger)
 }
 
 func TestNewFunctionHandler_CustomValues(t *testing.T) {
-	errChan := make(chan error, 1)
-	logger := slog.New(&slog.TextHandler{})
+	logger := slog.New(slog.NewTextHandler(os.Stdout, nil))
 	handler := NewFunctionHandler(
-		WithErrHandling(ErrHandlingPanic),
 		WithLogger(logger),
-		WithErrorChannel(errChan),
 	)
 
 	assert.NotNil(t, handler)
-	assert.Equal(t, ErrHandlingPanic, handler.ErrHandling)
-	assert.Equal(t, errChan, handler.errChan)
 	assert.Equal(t, logger, handler.Logger())
 }
 
-func TestWithErrHandling(t *testing.T) {
-	option := WithErrHandling(ErrHandlingPanic)
-
-	handler := NewFunctionHandler()
-	option(handler) // Apply the option
-
-	assert.Equal(t, ErrHandlingPanic, handler.ErrHandling)
-}
-
 func TestWithLogger(t *testing.T) {
-	logger := slog.New(&slog.TextHandler{})
+	logger := slog.New(slog.NewTextHandler(os.Stdout, nil))
 	option := WithLogger(logger)
 
 	handler := NewFunctionHandler()
@@ -50,21 +35,9 @@ func TestWithLogger(t *testing.T) {
 	assert.Equal(t, logger, handler.Logger())
 }
 
-func TestWithErrorChannel(t *testing.T) {
-	errChan := make(chan error, 1)
-	option := WithErrorChannel(errChan)
-
-	handler := NewFunctionHandler()
-	option(handler) // Apply the option
-
-	assert.Equal(t, errChan, handler.errChan)
-}
-
 func TestWithParser(t *testing.T) {
 	fnHandler := &DefaultHandler{
-		ErrHandling: ErrHandlingErrorChannel,
-		logger:      slog.New(&slog.TextHandler{}),
-		errChan:     make(chan error, 1),
+		logger: slog.New(slog.NewTextHandler(os.Stdout, nil)),
 	}
 	option := WithHandler(fnHandler)
 
@@ -76,9 +49,7 @@ func TestWithParser(t *testing.T) {
 
 func TestWithNilHandler(t *testing.T) {
 	fnHandler := &DefaultHandler{
-		ErrHandling: ErrHandlingErrorChannel,
-		logger:      slog.New(&slog.TextHandler{}),
-		errChan:     make(chan error, 1),
+		logger: slog.New(slog.NewTextHandler(os.Stdout, nil)),
 	}
 	option := WithHandler(nil)