add cumston options for component template

README.md

@@ -107,30 +107,6 @@ Run your application with a configuration file:
 - `-t`: Test the configuration for validity ✅
 - `-T`: Enable template processing for component configurations 🧩
 
-### Example with Template Processing
-
-```sh
-./demo -T app.json
-```
-
-```json
-{
-	"Context": {
-		"Name": "world"
-	},
-	"Components": [
-		{
-			"Name": "hello",
-			"Options": {
-				"Message": "{{.Name}}"
-			}
-		}
-	]
-}
-```
-
-This example demonstrates how to use template processing in your component configurations. Cool, huh? 😎
-
 ## 📚 Documentation
 
 For detailed documentation of each package and component, please refer to the GoDoc:

component/builtin/httpserver.go

@@ -2,6 +2,7 @@ package builtin
 
 import (
 	"context"
+	"net"
 	"net/http"
 
 	"github.com/gopherd/core/component"
@@ -12,7 +13,8 @@ type HTTPServerComponent interface {
 	Handle(path string, handler http.Handler)
 }
 
-const HTTPServerComponentName = "github.com/gopherd/core/component/httpserver"
+// HTTPServerComponentName is the unique identifier for the HTTPServerComponent.
+const HTTPServerComponentName = "go/httpserver"
 
 func init() {
 	// Register the HTTPServerComponent implementation.
@@ -26,24 +28,42 @@ var _ HTTPServerComponent = (*httpServerComponent)(nil)
 
 type httpServerComponent struct {
 	component.BaseComponent[struct {
-		Addr            string
-		DefaultServeMux bool
+		Addr   string // Addr is the address to listen on.
+		Block  bool   // Block indicates whether the Start method should block.
+		NewMux bool   // NewMux indicates whether to create a new ServeMux.
 	}]
 	mux    *http.ServeMux
 	server *http.Server
 }
 
+// Start implements the component.Component interface.
 func (com *httpServerComponent) Start(ctx context.Context) error {
-	if com.Options().DefaultServeMux {
-		com.mux = http.DefaultServeMux
-	} else {
+	addr := com.Options().Addr
+	if addr == "" {
+		addr = ":http"
+	}
+	ln, err := net.Listen("tcp", addr)
+	if err != nil {
+		return err
+	}
+	if com.Options().NewMux {
 		com.mux = http.NewServeMux()
+	} else {
+		com.mux = http.DefaultServeMux
+	}
+	com.server = &http.Server{Addr: addr, Handler: com.mux}
+	if com.Options().Block {
+		com.Logger().Info("http server started", "addr", addr)
+		return com.server.Serve(ln)
 	}
-	com.server = &http.Server{Addr: com.Options().Addr, Handler: com.mux}
-	go com.server.ListenAndServe()
+	go func() {
+		com.Logger().Info("http server started", "addr", addr)
+		com.server.Serve(ln)
+	}()
 	return nil
 }
 
+// Shutdown implements the component.Component interface.
 func (com *httpServerComponent) Shutdown(ctx context.Context) error {
 	return com.server.Shutdown(ctx)
 }

component/component.go

@@ -20,10 +20,29 @@ import (
 
 // Config defines the configuration structure for creating a component.
 type Config struct {
-	Name    string
-	UUID    string     `json:",omitempty"`
-	Refs    raw.Object `json:",omitempty"`
+	// Name is the component name. It's required.
+	Name string
+
+	// UUID is the unique identifier for the component. It can be empty.
+	UUID string `json:",omitempty"`
+
+	// Refs is the references to other components.
+	Refs raw.Object `json:",omitempty"`
+
+	// Options is the configuration options for the component.
 	Options raw.Object `json:",omitempty"`
+
+	// TemplateUUID determines if the UUID should be templated.
+	// If not set, the default value is determined by the service.
+	TemplateUUID *bool `json:",omitempty"`
+
+	// TemplateRefs determines if the Refs should be templated.
+	// If not set, the default value is determined by the service.
+	TemplateRefs *bool `json:",omitempty"`
+
+	// TemplateOptions determines if the Options should be templated.
+	// If not set, the default value is determined by the service.
+	TemplateOptions *bool `json:",omitempty"`
 }
 
 // Component defines the interface for a generic logic component.

errkit/errno.go

@@ -83,8 +83,3 @@ func Errno(err error) int {
 	}
 	return EUnknown
 }
-
-// Is reports whether any error in err's chain matches target.
-func Is[T constraints.Integer](err error, code T) bool {
-	return Errno(err) == int(code)
-}

errkit/errno_test.go

@@ -91,32 +91,6 @@ func TestErrno(t *testing.T) {
 	}
 }
 
-func TestIs(t *testing.T) {
-	tests := []struct {
-		name     string
-		err      error
-		code     int
-		expected bool
-	}{
-		{"nil error", nil, EOK, true},
-		{"matching code", New(42, errors.New("custom error")), 42, true},
-		{"non-matching code", New(42, errors.New("custom error")), 43, false},
-		{"wrapped matching code", fmt.Errorf("wrapped: %w", New(42, errors.New("custom error"))), 42, true},
-		{"non-errno error", errors.New("regular error"), EUnknown, true},
-		{"EOK with nil error", nil, EOK, true},
-		{"EOK with non-nil error", errors.New("some error"), EOK, false},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			result := Is(tt.err, tt.code)
-			if result != tt.expected {
-				t.Errorf("Is(%v, %d) = %v, want %v", tt.err, tt.code, result, tt.expected)
-			}
-		})
-	}
-}
-
 func TestErrnoMethods(t *testing.T) {
 	err := New(42, errors.New("test error"))
 

operator/operator.go

@@ -15,12 +15,12 @@ func Or[T comparable](a, b T) T {
 	return a
 }
 
-// OrFunc returns the result of calling new() if a is the zero value for T,
+// OrFunc returns the result of calling b() if a is the zero value for T,
 // otherwise returns a. It allows for lazy evaluation of the alternative value.
-func OrFunc[T comparable](a T, new func() T) T {
+func OrFunc[T comparable](a T, b func() T) T {
 	var zero T
 	if a == zero {
-		return new()
+		return b()
 	}
 	return a
 }
@@ -33,12 +33,12 @@ func SetDefault[T comparable](a *T, b T) {
 	}
 }
 
-// SetDefaultFunc sets the value of a to the result of calling new() if a is
+// SetDefaultFunc sets the value of a to the result of calling b() if a is
 // the zero value for T.
-func SetDefaultFunc[T comparable](a *T, new func() T) {
+func SetDefaultFunc[T comparable](a *T, b func() T) {
 	var zero T
 	if *a == zero {
-		*a = new()
+		*a = b()
 	}
 }
 
@@ -51,10 +51,18 @@ func Ternary[T any](condition bool, a, b T) T {
 	return b
 }
 
-// TernaryFunc returns the result of calling a() if condition is true,
+// TernaryFunc returns the a if condition is true, otherwise returns the result of calling b().
+func TernaryFunc[T any](condition bool, a T, b func() T) T {
+	if condition {
+		return a
+	}
+	return b()
+}
+
+// TernaryCall returns the result of calling a() if condition is true,
 // otherwise returns the result of calling b().
 // It allows for lazy evaluation of both alternatives.
-func TernaryFunc[T any](condition bool, a, b func() T) T {
+func TernaryCall[T any](condition bool, a, b func() T) T {
 	if condition {
 		return a()
 	}

operator/operator_test.go

@@ -92,7 +92,7 @@ func TestTernary(t *testing.T) {
 	}
 }
 
-func TestTernaryFunc(t *testing.T) {
+func TestTernaryCall(t *testing.T) {
 	aCounter, bCounter := 0, 0
 	aFunc := func() int {
 		aCounter++
@@ -117,7 +117,7 @@ func TestTernaryFunc(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			aCounter, bCounter = 0, 0
-			if got := operator.TernaryFunc(tt.condition, aFunc, bFunc); got != tt.wantResult {
+			if got := operator.TernaryCall(tt.condition, aFunc, bFunc); got != tt.wantResult {
 				t.Errorf("TernaryFunc(%v, aFunc, bFunc) = %v, want %v", tt.condition, got, tt.wantResult)
 			}
 			if aCounter != tt.wantACalls {

service/config.go

@@ -11,6 +11,7 @@ import (
 	"strings"
 
 	"github.com/gopherd/core/component"
+	"github.com/gopherd/core/operator"
 	"github.com/gopherd/core/text/templateutil"
 )
 
@@ -84,7 +85,7 @@ func (c *Config[T]) loadFromHTTP(source string) (io.ReadCloser, error) {
 
 // processTemplate processes the UUID, Refs, and Options fields of each component.Config
 // as text/template templates, using c.Context as the template context.
-func (c *Config[T]) processTemplate(source string) error {
+func (c *Config[T]) processTemplate(enableTemplate bool, source string) error {
 	if source == "-" {
 		source = ""
 	}
@@ -97,23 +98,23 @@ func (c *Config[T]) processTemplate(source string) error {
 			identifier += "#" + com.UUID
 		}
 		sourcePrefix := fmt.Sprintf("%s[%s].", source, identifier)
-		if com.UUID != "" {
+		if operator.Ternary(com.TemplateUUID == nil, enableTemplate, *com.TemplateUUID) && com.UUID != "" {
 			new, err := templateutil.Execute(sourcePrefix+"UUID", com.UUID, c.Context, option)
 			if err != nil {
 				return err
 			}
 			com.UUID = new
 		}
 
-		if com.Refs.Len() > 0 {
+		if operator.Ternary(com.TemplateRefs == nil, enableTemplate, *com.TemplateRefs) && com.Refs.Len() > 0 {
 			new, err := templateutil.Execute(sourcePrefix+"Refs", com.Refs.String(), c.Context, option)
 			if err != nil {
 				return err
 			}
 			com.Refs.SetString(new)
 		}
 
-		if com.Options.Len() > 0 {
+		if operator.Ternary(com.TemplateOptions == nil, enableTemplate, *com.TemplateOptions) && com.Options.Len() > 0 {
 			new, err := templateutil.Execute(sourcePrefix+"Options", com.Options.String(), c.Context, option)
 			if err != nil {
 				return err

service/service.go

@@ -135,10 +135,8 @@ func (s *BaseService[T]) setupConfig() error {
 	if err := s.config.load(s.flags.source); err != nil {
 		return err
 	}
-	if s.flags.enableTemplate {
-		if err := s.config.processTemplate(s.flags.source); err != nil {
-			return err
-		}
+	if err := s.config.processTemplate(s.flags.enableTemplate, s.flags.source); err != nil {
+		return err
 	}
 	return nil
 }
@@ -157,7 +155,8 @@ func (s *BaseService[T]) Init(ctx context.Context) error {
 
 	if s.flags.printConfig {
 		if err != nil {
-			return err
+			fmt.Fprintf(os.Stderr, "Config test failed: %v\n", err)
+			return errkit.NewExitError(2, err.Error())
 		}
 		s.config.output()
 		return errkit.NewExitError(0)