finish the first state of the vuejs todo mvc example, a simple rest api - todo: websocket and live updates between browser tabs with the same session id

Former-commit-id: 0bd859420cff87014479c44a471ec273c621c1a2

mvc/di/func.go

@@ -11,6 +11,8 @@ type (
 		InputIndex int
 	}
 
+	// FuncInjector keeps the data that are needed in order to do the binding injection
+	// as fast as possible and with the best possible and safest way.
 	FuncInjector struct {
 		// the original function, is being used
 		// only the .Call, which is referring to the same function, always.
@@ -27,6 +29,10 @@ type (
 	}
 )
 
+// MakeFuncInjector returns a new func injector, which will be the object
+// that the caller should use to bind input arguments of the "fn" function.
+//
+// The hijack and the goodFunc are optional, the "values" is the dependencies values.
 func MakeFuncInjector(fn reflect.Value, hijack Hijacker, goodFunc TypeChecker, values ...reflect.Value) *FuncInjector {
 	typ := IndirectType(fn.Type())
 	s := &FuncInjector{
@@ -100,10 +106,14 @@ func MakeFuncInjector(fn reflect.Value, hijack Hijacker, goodFunc TypeChecker, v
 	return s
 }
 
+// String returns a debug trace text.
 func (s *FuncInjector) String() string {
 	return s.trace
 }
 
+// Inject accepts an already created slice of input arguments
+// and fills them, the "ctx" is optional and it's used
+// on the dependencies that depends on one or more input arguments, these are the "ctx".
 func (s *FuncInjector) Inject(in *[]reflect.Value, ctx ...reflect.Value) {
 	args := *in
 	for _, input := range s.inputs {
@@ -118,6 +128,12 @@ func (s *FuncInjector) Inject(in *[]reflect.Value, ctx ...reflect.Value) {
 	*in = args
 }
 
+// Call calls the "Inject" with a new slice of input arguments
+// that are computed by the length of the input argument from the MakeFuncInjector's "fn" function.
+//
+// If the function needs a receiver, so
+// the caller should be able to in[0] = receiver before injection,
+// then the `Inject` method should be used instead.
 func (s *FuncInjector) Call(ctx ...reflect.Value) []reflect.Value {
 	in := make([]reflect.Value, s.Length, s.Length)
 	s.Inject(&in, ctx...)

mvc/di/object.go

@@ -5,11 +5,17 @@ import (
 	"reflect"
 )
 
+// BindType is the type of a binded object/value, it's being used to
+// check if the value is accessible after a function call with a  "ctx" when needed ( Dynamic type)
+// or it's just a struct value (a service | Static type).
 type BindType uint32
 
 const (
-	Static  BindType = iota // simple assignable value, a static value.
-	Dynamic                 // dynamic value, depends on some input arguments from the caller.
+	// Static is the simple assignable value, a static value.
+	Static BindType = iota
+	// Dynamic returns a value but it depends on some input arguments from the caller,
+	// on serve time.
+	Dynamic
 )
 
 func bindTypeString(typ BindType) string {
@@ -21,6 +27,9 @@ func bindTypeString(typ BindType) string {
 	}
 }
 
+// BindObject contains the dependency value's read-only information.
+// FuncInjector and StructInjector keeps information about their
+// input arguments/or fields, these properties contain a `BindObject` inside them.
 type BindObject struct {
 	Type  reflect.Type // the Type of 'Value' or the type of the returned 'ReturnValue' .
 	Value reflect.Value
@@ -29,6 +38,11 @@ type BindObject struct {
 	ReturnValue func([]reflect.Value) reflect.Value
 }
 
+// MakeBindObject accepts any "v" value, struct, pointer or a function
+// and a type checker that is used to check if the fields (if "v.elem()" is struct)
+// or the input arguments (if "v.elem()" is func)
+// are valid to be included as the final object's dependencies, even if the caller added more
+// the "di" is smart enough to select what each "v" needs and what not before serve time.
 func MakeBindObject(v reflect.Value, goodFunc TypeChecker) (b BindObject, err error) {
 	if IsFunc(v) {
 		b.BindType = Dynamic
@@ -93,10 +107,13 @@ func MakeReturnValue(fn reflect.Value, goodFunc TypeChecker) (func([]reflect.Val
 	return bf, outTyp, nil
 }
 
+// IsAssignable checks if "to" type can be used as "b.Value/ReturnValue".
 func (b *BindObject) IsAssignable(to reflect.Type) bool {
 	return equalTypes(b.Type, to)
 }
 
+// Assign sets the values to a setter, "toSetter" contains the setter, so the caller
+// can use it for multiple and different structs/functions as well.
 func (b *BindObject) Assign(ctx []reflect.Value, toSetter func(reflect.Value)) {
 	if b.BindType == Dynamic {
 		toSetter(b.ReturnValue(ctx))

mvc/di/struct.go

@@ -18,6 +18,8 @@ type (
 		FieldIndex []int
 	}
 
+	// StructInjector keeps the data that are needed in order to do the binding injection
+	// as fast as possible and with the best possible and safest way.
 	StructInjector struct {
 		initRef        reflect.Value
 		initRefAsSlice []reflect.Value // useful when the struct is passed on a func as input args via reflection.
@@ -42,6 +44,12 @@ func (s *StructInjector) countBindType(typ BindType) (n int) {
 	return
 }
 
+// MakeStructInjector returns a new struct injector, which will be the object
+// that the caller should use to bind exported fields or
+// embedded unexported fields that contain exported fields
+// of the "v" struct value or pointer.
+//
+// The hijack and the goodFunc are optional, the "values" is the dependencies values.
 func MakeStructInjector(v reflect.Value, hijack Hijacker, goodFunc TypeChecker, values ...reflect.Value) *StructInjector {
 	s := &StructInjector{
 		initRef:        v,
@@ -149,6 +157,7 @@ func (s *StructInjector) fillStruct() {
 	}
 }
 
+// String returns a debug trace message.
 func (s *StructInjector) String() (trace string) {
 	for i, f := range s.fields {
 		elemField := s.elemType.FieldByIndex(f.FieldIndex)

mvc/di/values.go

@@ -2,8 +2,11 @@ package di
 
 import "reflect"
 
+// Values is a shortcut of []reflect.Value,
+// it makes easier to remove and add dependencies.
 type Values []reflect.Value
 
+// NewValues returns new empty (dependencies) values.
 func NewValues() Values {
 	return Values{}
 }
@@ -30,6 +33,7 @@ func (bv Values) CloneWithFieldsOf(s interface{}) Values {
 	return values
 }
 
+// Len returns the length of the current "bv" values slice.
 func (bv Values) Len() int {
 	return len(bv)
 }
@@ -41,6 +45,8 @@ func (bv *Values) Add(values ...interface{}) {
 	bv.AddValues(ValuesOf(values)...)
 }
 
+// AddValues same as `Add` but accepts reflect.Value dependencies instead of interface{}
+// and appends them to the list if they pass some checks.
 func (bv *Values) AddValues(values ...reflect.Value) {
 	for _, v := range values {
 		if !goodVal(v) {