fix Update.Set with empty typed strings

see: #151
auto-omitted values not caught by isNil were resulting in a SerializationException

encode.go

@@ -712,40 +712,3 @@ func isAVEqual(a, b *dynamodb.AttributeValue) bool {
 	}
 	return false
 }
-
-// isNil returns true if v is considered nil
-// this is used to determine if an attribute should be set or removed
-func isNil(v interface{}) bool {
-	if v == nil || v == "" {
-		return true
-	}
-
-	// consider v nil if it's a special encoder defined on a value type, but v is a pointer
-	rv := reflect.ValueOf(v)
-	switch v.(type) {
-	case Marshaler:
-		if rv.Kind() == reflect.Ptr && rv.IsNil() {
-			if _, ok := rv.Type().Elem().MethodByName("MarshalDynamo"); ok {
-				return true
-			}
-		}
-	case dynamodbattribute.Marshaler:
-		if rv.Kind() == reflect.Ptr && rv.IsNil() {
-			if _, ok := rv.Type().Elem().MethodByName("MarshalDynamoDBAttributeValue"); ok {
-				return true
-			}
-		}
-	case encoding.TextMarshaler:
-		if rv.Kind() == reflect.Ptr && rv.IsNil() {
-			if _, ok := rv.Type().Elem().MethodByName("MarshalText"); ok {
-				return true
-			}
-		}
-	default:
-		// e.g. (*int)(nil)
-		return rv.Kind() == reflect.Ptr && rv.IsNil()
-	}
-
-	// non-pointers or special encoders with a pointer receiver
-	return false
-}

encoding_test.go

@@ -80,6 +80,19 @@ var encodingTests = []struct {
 			"Empty": &dynamodb.AttributeValue{M: map[string]*dynamodb.AttributeValue{}},
 		}},
 	},
+	{
+		name: "textMarshaler maps",
+		in: struct {
+			M1 map[textMarshaler]bool // dont omit
+		}{
+			M1: map[textMarshaler]bool{textMarshaler(true): true},
+		},
+		out: &dynamodb.AttributeValue{M: map[string]*dynamodb.AttributeValue{
+			"M1": &dynamodb.AttributeValue{M: map[string]*dynamodb.AttributeValue{
+				"true": &dynamodb.AttributeValue{BOOL: aws.Bool(true)},
+			}},
+		}},
+	},
 	{
 		name: "struct",
 		in: struct {
@@ -312,6 +325,7 @@ var itemEncodingTests = []struct {
 		in: struct {
 			OK         string
 			EmptyStr   string
+			EmptyStr2  customString
 			EmptyB     []byte
 			EmptyL     []int
 			EmptyM     map[string]bool

substitute.go

@@ -40,6 +40,9 @@ func (s *subber) subValue(value interface{}, flags encodeFlags) (string, error)
 	if err != nil {
 		return "", err
 	}
+	if av == nil {
+		return "", fmt.Errorf("invalid substitue value for '%s': %v", sub, av)
+	}
 	s.valueExpr[sub] = av
 	return sub, nil
 }

update.go

@@ -63,12 +63,16 @@ func (u *Update) Range(name string, value interface{}) *Update {
 // Paths that are reserved words are automatically escaped.
 // Use single quotes to escape complex values like 'User'.'Count'.
 func (u *Update) Set(path string, value interface{}) *Update {
-	if isNil(value) {
+	v, err := marshal(value, flagNone)
+	if v == nil && err == nil {
+		// auto-omitted value
 		return u.Remove(path)
 	}
-	path, err := u.escape(path)
 	u.setError(err)
-	expr, err := u.subExpr("🝕 = ?", path, value)
+
+	path, err = u.escape(path)
+	u.setError(err)
+	expr, err := u.subExpr("🝕 = ?", path, v)
 	u.setError(err)
 	u.set = append(u.set, expr)
 	return u

update_test.go

@@ -181,3 +181,50 @@ func TestUpdateNil(t *testing.T) {
 		t.Errorf("bad result. %+v ≠ %+v", result, expected)
 	}
 }
+
+func TestUpdateSetAutoOmit(t *testing.T) {
+	if testDB == nil {
+		t.Skip(offlineSkipMsg)
+	}
+	table := testDB.Table(testTable)
+
+	type widget2 struct {
+		widget
+		CStr customString
+		SPtr *string
+	}
+
+	// first, add an item to make sure there is at least one
+	str := "delete me ptr"
+	item := widget2{
+		widget: widget{
+			UserID: 11111,
+			Time:   time.Now().UTC(),
+		},
+		CStr: customString("delete me"),
+		SPtr: &str,
+	}
+	err := table.Put(item).Run()
+	if err != nil {
+		t.Error("unexpected error:", err)
+		t.FailNow()
+	}
+
+	// update Msg with 'nil', which should delete it
+	var result widget2
+	err = table.Update("UserID", item.UserID).Range("Time", item.Time).
+		Set("CStr", customString("")).
+		Set("SPtr", nil).
+		Value(&result)
+	if err != nil {
+		t.Error("unexpected error:", err)
+	}
+	expected := widget2{
+		widget: item.widget,
+		CStr:   customString(""),
+		SPtr:   nil,
+	}
+	if !reflect.DeepEqual(result, expected) {
+		t.Errorf("bad result. %+v ≠ %+v", result, expected)
+	}
+}