Refactoring: optimizes code comments

Author: lvan100

gs/examples/bookman/.cover/cover.html

@@ -23,9 +23,17 @@ import (
 )
 
 func main() {
+	// Register an HTTP handler for the "/echo" endpoint.
 	http.HandleFunc("/echo", func(w http.ResponseWriter, r *http.Request) {
 		_, _ = w.Write([]byte("hello world!"))
 	})
+
+	// Start the Go-Spring framework.
+	// Compared to http.ListenAndServe, gs.Run() starts a full-featured application context with:
+	// - Auto Configuration: Automatically loads properties and beans.
+	// - Property Binding: Binds external configs (YAML, ENV) into structs.
+	// - Dependency Injection: Wires beans automatically.
+	// - Dynamic Refresh: Updates configs at runtime without restart.
 	gs.Run()
 }
 

gs/examples/miniapi/main.go

@@ -21,6 +21,7 @@ import (
 )
 
 func main() {
+	// Disable the built-in HTTP service.
 	gs.Web(false).Run()
 }
 

gs/examples/noweb/main.go

@@ -48,35 +48,38 @@ func As[T any]() reflect.Type {
 type Arg = gs.Arg
 
 // TagArg returns a TagArg with the specified tag.
+// Used for property binding or object injection when providing constructor parameters.
 func TagArg(tag string) Arg {
 	return gs_arg.Tag(tag)
 }
 
 // ValueArg returns a ValueArg with the specified value.
+// Used to provide specific values for constructor parameters.
 func ValueArg(v interface{}) Arg {
 	return gs_arg.Value(v)
 }
 
 // IndexArg returns an IndexArg with the specified index and argument.
+// When most constructor parameters can use default values, IndexArg helps reduce configuration effort.
 func IndexArg(n int, arg Arg) Arg {
 	return gs_arg.Index(n, arg)
 }
 
-// BindArg returns an BindArg for the specified function and arguments.
+// BindArg returns a BindArg for the specified function and arguments.
+// Used to provide argument binding for option-style constructor parameters.
 func BindArg(fn interface{}, args ...Arg) *gs_arg.BindArg {
 	return gs_arg.Bind(fn, args...)
 }
 
 /************************************ cond ***********************************/
 
 type (
-	CondFunc    = gs.CondFunc
 	Condition   = gs.Condition
 	CondContext = gs.CondContext
 )
 
 // OnFunc creates a Condition based on the provided function.
-func OnFunc(fn CondFunc) Condition {
+func OnFunc(fn func(ctx CondContext) (bool, error)) Condition {
 	return gs_cond.OnFunc(fn)
 }
 
@@ -137,6 +140,11 @@ func None(conditions ...Condition) Condition {
 
 /************************************ ioc ************************************/
 
+type (
+	BeanID   = gs.BeanID
+	BeanMock = gs.BeanMock
+)
+
 type (
 	Dync[T any] = gs_dync.Value[T]
 )
@@ -201,21 +209,19 @@ type AppStarter struct{}
 
 // Web enables or disables the built-in web server.
 func Web(enable bool) *AppStarter {
-	if !enable {
-		EnableSimpleHttpServer(false)
-	}
+	EnableSimpleHttpServer(enable)
 	return &AppStarter{}
 }
 
 // Run runs the app and waits for an interrupt signal to exit.
 func (s *AppStarter) Run() {
-	printBanner()
 	var err error
 	defer func() {
 		if err != nil {
 			syslog.Errorf("app run failed: %s", err.Error())
 		}
 	}()
+	printBanner()
 	if err = B.(*gs_app.BootImpl).Run(); err != nil {
 		return
 	}
@@ -274,7 +280,7 @@ func GroupRegister(fn func(p conf.Properties) ([]*BeanDefinition, error)) {
 
 // RefreshProperties refreshes the app configuration.
 func RefreshProperties() error {
-	p, err := Config().Refresh()
+	p, err := gs_app.GS.P.Refresh()
 	if err != nil {
 		return err
 	}

gs/examples/startup/README.md

@@ -26,7 +26,6 @@ import (
 
 	"github.com/go-spring/spring-core/gs"
 	"github.com/go-spring/spring-core/gs/internal/gs_app"
-	"github.com/lvan100/go-assert"
 )
 
 func init() {
@@ -50,7 +49,10 @@ func MockFor[T any](name ...string) BeanMock[T] {
 
 // With registers a mock bean.
 func (m BeanMock[T]) With(obj T) {
-	gs_app.GS.C.Mock(obj, m.selector)
+	gs_app.GS.C.AddMock(gs.BeanMock{
+		Object: obj,
+		Target: m.selector,
+	})
 }
 
 type runArg struct {
@@ -110,6 +112,8 @@ func Get[T any](t *testing.T) T {
 // Wire injects dependencies into the object.
 func Wire[T any](t *testing.T, obj T) T {
 	err := gs_app.GS.C.Wire(obj)
-	assert.Nil(t, err)
+	if err != nil {
+		t.Fatal(err)
+	}
 	return obj
 }

gs/gs.go

@@ -42,12 +42,19 @@ func TestMain(m *testing.M) {
 }
 
 func TestGSTest(t *testing.T) {
+	// The dao.Dao object was not successfully created,
+	// and the corresponding injection will also fail.
+	// The following log will be printed on the console:
+	// autowire error: TagArg::GetArgValue error << bind path=string type=string error << property dao.addr not exist
+
 	a := gstest.Get[*app.App](t)
 	assert.That(t, a.Name).Equal("test")
+
 	s := gstest.Wire(t, new(struct {
 		App     *app.App     `autowire:""`
 		Service *biz.Service `autowire:""`
 	}))
+	assert.Nil(t, s.Service.Dao)
 	assert.That(t, s.App.Name).Equal("test")
 	assert.That(t, s.Service.Hello("xyz")).Equal("hello xyz")
 }

gs/gstest/gstest.go

@@ -21,14 +21,12 @@ import (
 	"net"
 	"net/http"
 	"time"
-
-	"github.com/go-spring/spring-core/gs/internal/gs_cond"
 )
 
 func init() {
 	// Register the default ServeMux as a bean if no other ServeMux instance exists
 	Object(http.DefaultServeMux).Condition(
-		gs_cond.OnMissingBean[*http.ServeMux](),
+		OnMissingBean[*http.ServeMux](),
 		OnProperty(EnableSimpleHttpServerProp).HavingValue("true").MatchIfMissing(),
 	)
 

gs/gstest/gstest_test.go

@@ -108,9 +108,6 @@ type CondContext interface {
 	Find(s BeanSelector) ([]CondBean, error)
 }
 
-// CondFunc is a function type that determines whether a condition is satisfied.
-type CondFunc func(ctx CondContext) (bool, error)
-
 /************************************* arg ***********************************/
 
 // Arg is an interface for retrieving argument values in function parameter binding.
@@ -159,6 +156,12 @@ type Server interface {
 
 /*********************************** bean ************************************/
 
+// BeanMock defines a mock object and its target bean selector for overriding.
+type BeanMock struct {
+	Object interface{}  // Mock instance to replace the target bean
+	Target BeanSelector // Selector to identify the target bean
+}
+
 // BeanID represents the unique identifier for a bean.
 type BeanID struct {
 	Type reflect.Type

gs/http.go

@@ -30,11 +30,11 @@ import (
 // onFunc is an implementation of [gs.Condition] that wraps a function.
 // It allows a condition to be evaluated based on the result of a function.
 type onFunc struct {
-	fn gs.CondFunc
+	fn func(ctx gs.CondContext) (bool, error)
 }
 
 // OnFunc creates a Conditional that evaluates using a custom function.
-func OnFunc(fn gs.CondFunc) gs.Condition {
+func OnFunc(fn func(ctx gs.CondContext) (bool, error)) gs.Condition {
 	return &onFunc{fn: fn}
 }