library, first version

Author: mcuadros

defaults.go

@@ -0,0 +1,104 @@
+package defaults
+
+import (
+	"reflect"
+	"strconv"
+)
+
+type Field struct {
+	Field reflect.StructField
+	Value reflect.Value
+}
+
+func SetDefaults(variable interface{}) {
+	fields := getFields(variable)
+	setDefaultValues(fields)
+}
+
+func getFields(variable interface{}) []*Field {
+	valueObject := reflect.ValueOf(variable).Elem()
+
+	return getFieldsFromValue(valueObject)
+}
+
+func getFieldsFromValue(valueObject reflect.Value) []*Field {
+	typeObject := valueObject.Type()
+
+	count := valueObject.NumField()
+	results := make([]*Field, 0)
+	for i := 0; i < count; i++ {
+		value := valueObject.Field(i)
+		field := typeObject.Field(i)
+
+		if value.CanSet() {
+			results = append(results, &Field{
+				Value: value,
+				Field: field,
+			})
+		}
+	}
+
+	return results
+}
+
+func setDefaultValues(fields []*Field) {
+	for _, field := range fields {
+		setDefaultValue(field)
+	}
+}
+
+func setDefaultValue(field *Field) {
+	defaultValue := field.Field.Tag.Get("default")
+
+	switch field.Value.Kind() {
+	case reflect.Bool:
+		setDefaultValueToBool(field, defaultValue)
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		setDefaultValueToInt(field, defaultValue)
+	case reflect.Float32, reflect.Float64:
+		setDefaultValueToFloat(field, defaultValue)
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		setDefaultValueToUint(field, defaultValue)
+	case reflect.Slice:
+		setDefaultValueToSlice(field, defaultValue)
+	case reflect.String:
+		setDefaultValueToString(field, defaultValue)
+	case reflect.Struct:
+		setDefaultValueToStruct(field, defaultValue)
+	}
+}
+
+func setDefaultValueToBool(field *Field, defaultValue string) {
+	value, _ := strconv.ParseBool(defaultValue)
+	field.Value.SetBool(value)
+}
+
+func setDefaultValueToInt(field *Field, defaultValue string) {
+	value, _ := strconv.ParseInt(defaultValue, 10, 64)
+	field.Value.SetInt(value)
+}
+
+func setDefaultValueToFloat(field *Field, defaultValue string) {
+	value, _ := strconv.ParseFloat(defaultValue, 64)
+	field.Value.SetFloat(value)
+}
+
+func setDefaultValueToUint(field *Field, defaultValue string) {
+	value, _ := strconv.ParseUint(defaultValue, 10, 64)
+	field.Value.SetUint(value)
+}
+
+func setDefaultValueToSlice(field *Field, defaultValue string) {
+	if field.Value.Type().Elem().Kind() == reflect.Uint8 {
+		field.Value.SetBytes([]byte(defaultValue))
+	}
+}
+
+func setDefaultValueToString(field *Field, defaultValue string) {
+	field.Value.SetString(defaultValue)
+}
+
+func setDefaultValueToStruct(field *Field, defaultValue string) {
+	fields := getFieldsFromValue(field.Value)
+	setDefaultValues(fields)
+}

defaults_test.go

@@ -0,0 +1,72 @@
+package defaults
+
+import (
+	"testing"
+)
+import . "launchpad.net/gocheck"
+
+// Hook up gocheck into the "go test" runner.
+func Test(t *testing.T) { TestingT(t) }
+
+type DefaultsSuite struct{}
+
+var _ = Suite(&DefaultsSuite{})
+
+type ExampleBasic struct {
+	Bool       bool    `default:"true"`
+	Integer    int     `default:"33"`
+	Integer8   int8    `default:"8"`
+	Integer16  int16   `default:"16"`
+	Integer32  int32   `default:"32"`
+	Integer64  int64   `default:"64"`
+	UInteger   uint    `default:"11"`
+	UInteger8  uint8   `default:"18"`
+	UInteger16 uint16  `default:"116"`
+	UInteger32 uint32  `default:"132"`
+	UInteger64 uint64  `default:"164"`
+	String     string  `default:"foo"`
+	Bytes      []byte  `default:"bar"`
+	Float32    float32 `default:"3.2"`
+	Float64    float64 `default:"6.4"`
+	Struct     struct {
+		Bool    bool `default:"true"`
+		Integer int  `default:"33"`
+	}
+}
+
+func (self *DefaultsSuite) TestSetDefaultsBasic(c *C) {
+	foo := &ExampleBasic{}
+	SetDefaults(foo)
+
+	self.assertTypes(c, foo)
+}
+
+type ExampleNested struct {
+	Struct ExampleBasic
+}
+
+func (self *DefaultsSuite) TestSetDefaultsNested(c *C) {
+	foo := &ExampleNested{}
+	SetDefaults(foo)
+
+	self.assertTypes(c, &foo.Struct)
+}
+
+func (self *DefaultsSuite) assertTypes(c *C, foo *ExampleBasic) {
+	c.Assert(foo.Bool, Equals, true)
+	c.Assert(foo.Integer, Equals, 33)
+	c.Assert(foo.Integer8, Equals, int8(8))
+	c.Assert(foo.Integer16, Equals, int16(16))
+	c.Assert(foo.Integer32, Equals, int32(32))
+	c.Assert(foo.Integer64, Equals, int64(64))
+	c.Assert(foo.UInteger, Equals, uint(11))
+	c.Assert(foo.UInteger8, Equals, uint8(18))
+	c.Assert(foo.UInteger16, Equals, uint16(116))
+	c.Assert(foo.UInteger32, Equals, uint32(132))
+	c.Assert(foo.UInteger64, Equals, uint64(164))
+	c.Assert(foo.String, Equals, "foo")
+	c.Assert(string(foo.Bytes), Equals, "bar")
+	c.Assert(foo.Float32, Equals, float32(3.2))
+	c.Assert(foo.Float64, Equals, 6.4)
+	c.Assert(foo.Struct.Bool, Equals, true)
+}