prepare 2.1.0 release (#13)

Author: LaunchDarklyCI

ldreason/reason.go

@@ -64,6 +64,12 @@ type EvaluationReason struct {
 	errorKind       EvalErrorKind
 }
 
+// IsDefined returns true if this EvaluationReason has a non-empty GetKind(). It is false for a
+// zero value of EvaluationReason{}.
+func (r EvaluationReason) IsDefined() bool {
+	return r.kind != ""
+}
+
 // String returns a concise string representation of the reason. Examples: "OFF", "ERROR(WRONG_TYPE)".
 func (r EvaluationReason) String() string {
 	switch r.kind {

ldreason/reason_test.go

@@ -9,6 +9,16 @@ import (
 	"gopkg.in/launchdarkly/go-sdk-common.v2/jsonstream"
 )
 
+func TestReasonIsDefined(t *testing.T) {
+	assert.False(t, EvaluationReason{}.IsDefined())
+	assert.True(t, NewEvalReasonOff().IsDefined())
+	assert.True(t, NewEvalReasonFallthrough().IsDefined())
+	assert.True(t, NewEvalReasonTargetMatch().IsDefined())
+	assert.True(t, NewEvalReasonRuleMatch(0, "").IsDefined())
+	assert.True(t, NewEvalReasonPrerequisiteFailed("").IsDefined())
+	assert.True(t, NewEvalReasonError(EvalErrorFlagNotFound).IsDefined())
+}
+
 func TestReasonKind(t *testing.T) {
 	assert.Equal(t, EvalReasonOff, NewEvalReasonOff().GetKind())
 	assert.Equal(t, EvalReasonFallthrough, NewEvalReasonFallthrough().GetKind())

ldtime/unix_millis.go

@@ -15,3 +15,11 @@ func UnixMillisFromTime(t time.Time) UnixMillisecondTime {
 func UnixMillisNow() UnixMillisecondTime {
 	return UnixMillisFromTime(time.Now())
 }
+
+// IsDefined returns true if the time value is non-zero.
+//
+// This can be used to treat a zero value as "undefined" as an alternative to using a pointer,
+// assuming that the exact beginning of the Unix epoch itself is not a valid time in this context.
+func (t UnixMillisecondTime) IsDefined() bool {
+	return t > 0
+}

ldtime/unix_millis_test.go

@@ -18,3 +18,8 @@ func TestUnixMillisNow(t *testing.T) {
 	un := UnixMillisNow()
 	assert.GreaterOrEqual(t, uint64(un), uint64(UnixMillisFromTime(tn)))
 }
+
+func TestUnixMillisIsDefined(t *testing.T) {
+	assert.False(t, UnixMillisecondTime(0).IsDefined())
+	assert.True(t, UnixMillisecondTime(1).IsDefined())
+}

lduser/user.go

@@ -58,7 +58,7 @@ type User struct {
 	avatar            ldvalue.OptionalString
 	name              ldvalue.OptionalString
 	anonymous         ldvalue.OptionalBool
-	custom            ldvalue.Value
+	custom            ldvalue.ValueMap
 	privateAttributes map[UserAttribute]struct{}
 }
 
@@ -168,14 +168,19 @@ func (u User) GetAnonymousOptional() (bool, bool) {
 // the desired type, rather than casting it. If the attribute did not exist, the value will be
 // ldvalue.Null() and the second return value will be false.
 func (u User) GetCustom(attribute string) (ldvalue.Value, bool) {
-	return u.custom.TryGetByKey(attribute)
+	return u.custom.TryGet(attribute)
 }
 
 // GetAllCustom returns all of the user's custom attributes.
 //
 // These are represented as a Value that is either an object (with a key-value pair for each attribute)
 // or Null() if there are no custom attributes.
 func (u User) GetAllCustom() ldvalue.Value {
+	return u.custom.AsValue()
+}
+
+// GetAllCustomMap returns all of the user's custom attributes as an immutable ValueMap.
+func (u User) GetAllCustomMap() ldvalue.ValueMap {
 	return u.custom
 }
 

lduser/user_builder.go

@@ -28,6 +28,10 @@ func NewAnonymousUser(key string) User {
 //     user := NewUserBuilder("user-key").Name("Bob").AsPrivateAttribute().Build() // Name is now private
 //
 // A UserBuilder should not be accessed by multiple goroutines at once.
+//
+// This is defined as an interface rather than a concrete type only for syntactic convenience (see
+// UserBuilderCanMakeAttributePrivate). Applications should not implement this interface since the package
+// may add methods to it in the future.
 type UserBuilder interface {
 	// Key changes the unique key for the user being built.
 	Key(value string) UserBuilder
@@ -73,6 +77,13 @@ type UserBuilder interface {
 	//         Build()
 	Custom(attribute string, value ldvalue.Value) UserBuilderCanMakeAttributePrivate
 
+	// CustomAll sets all of the user's custom attributes at once from a ValueMap.
+	//
+	// UserBuilder has copy-on-write behavior to make this method efficient: if you do not make any
+	// changes to custom attributes after this, it reuses the original map rather than allocating a
+	// new one.
+	CustomAll(ldvalue.ValueMap) UserBuilderCanMakeAttributePrivate
+
 	// SetAttribute sets any attribute of the user being built, specified as a UserAttribute, to a value
 	// of type ldvalue.Value.
 	//
@@ -151,8 +162,9 @@ type userBuilderImpl struct {
 	avatar                      ldvalue.OptionalString
 	name                        ldvalue.OptionalString
 	anonymous                   ldvalue.OptionalBool
-	custom                      ldvalue.ObjectBuilder
+	custom                      ldvalue.ValueMapBuilder
 	privateAttrs                map[UserAttribute]struct{}
+	privateAttrsCopyOnWrite     bool
 	lastAttributeCanMakePrivate UserAttribute
 }
 
@@ -166,31 +178,28 @@ func NewUserBuilder(key string) UserBuilder {
 
 // NewUserBuilderFromUser constructs a new UserBuilder, copying all attributes from an existing user. You may
 // then call setter methods on the new UserBuilder to modify those attributes.
+//
+// Custom attributes, and the set of attribute names that are private, are implemented internally as maps.
+// Since the User struct does not expose these maps, they are in effect immutable and will be reused from the
+// original User rather than copied whenever possible. The UserBuilder has copy-on-write behavior so that it
+// only makes copies of these data structures if you actually modify them.
 func NewUserBuilderFromUser(fromUser User) UserBuilder {
 	builder := &userBuilderImpl{
-		key:       fromUser.key,
-		secondary: fromUser.secondary,
-		ip:        fromUser.ip,
-		country:   fromUser.country,
-		email:     fromUser.email,
-		firstName: fromUser.firstName,
-		lastName:  fromUser.lastName,
-		avatar:    fromUser.avatar,
-		name:      fromUser.name,
-		anonymous: fromUser.anonymous,
+		key:                     fromUser.key,
+		secondary:               fromUser.secondary,
+		ip:                      fromUser.ip,
+		country:                 fromUser.country,
+		email:                   fromUser.email,
+		firstName:               fromUser.firstName,
+		lastName:                fromUser.lastName,
+		avatar:                  fromUser.avatar,
+		name:                    fromUser.name,
+		anonymous:               fromUser.anonymous,
+		privateAttrs:            fromUser.privateAttributes,
+		privateAttrsCopyOnWrite: true,
 	}
 	if fromUser.custom.Count() > 0 {
-		builder.custom = ldvalue.ObjectBuildWithCapacity(fromUser.custom.Count())
-		fromUser.custom.Enumerate(func(index int, key string, value ldvalue.Value) bool {
-			builder.custom.Set(key, value)
-			return true
-		})
-	}
-	if len(fromUser.privateAttributes) > 0 {
-		builder.privateAttrs = make(map[UserAttribute]struct{}, len(fromUser.privateAttributes))
-		for name := range fromUser.privateAttributes {
-			builder.privateAttrs[name] = struct{}{}
-		}
+		builder.custom = ldvalue.ValueMapBuildFromMap(fromUser.custom)
 	}
 	return builder
 }
@@ -252,12 +261,22 @@ func (b *userBuilderImpl) Anonymous(value bool) UserBuilder {
 
 func (b *userBuilderImpl) Custom(attribute string, value ldvalue.Value) UserBuilderCanMakeAttributePrivate {
 	if b.custom == nil {
-		b.custom = ldvalue.ObjectBuild()
+		b.custom = ldvalue.ValueMapBuild()
 	}
 	b.custom.Set(attribute, value)
 	return b.canMakeAttributePrivate(UserAttribute(attribute))
 }
 
+func (b *userBuilderImpl) CustomAll(valueMap ldvalue.ValueMap) UserBuilderCanMakeAttributePrivate {
+	if valueMap.Count() == 0 {
+		b.custom = nil
+	} else {
+		b.custom = ldvalue.ValueMapBuildFromMap(valueMap)
+	}
+	b.lastAttributeCanMakePrivate = ""
+	return b
+}
+
 func (b *userBuilderImpl) SetAttribute(
 	attribute UserAttribute,
 	value ldvalue.Value,
@@ -312,36 +331,38 @@ func (b *userBuilderImpl) SetAttribute(
 
 func (b *userBuilderImpl) Build() User {
 	u := User{
-		key:       b.key,
-		secondary: b.secondary,
-		ip:        b.ip,
-		country:   b.country,
-		email:     b.email,
-		firstName: b.firstName,
-		lastName:  b.lastName,
-		avatar:    b.avatar,
-		name:      b.name,
-		anonymous: b.anonymous,
+		key:               b.key,
+		secondary:         b.secondary,
+		ip:                b.ip,
+		country:           b.country,
+		email:             b.email,
+		firstName:         b.firstName,
+		lastName:          b.lastName,
+		avatar:            b.avatar,
+		name:              b.name,
+		anonymous:         b.anonymous,
+		privateAttributes: b.privateAttrs,
 	}
 	if b.custom != nil {
 		u.custom = b.custom.Build()
 	}
-	if len(b.privateAttrs) > 0 {
-		p := make(map[UserAttribute]struct{}, len(b.privateAttrs))
-		for key := range b.privateAttrs {
-			p[key] = struct{}{}
-		}
-		u.privateAttributes = p
-	}
+	b.privateAttrsCopyOnWrite = true
 	return u
 }
 
 func (b *userBuilderImpl) AsPrivateAttribute() UserBuilder {
 	if b.lastAttributeCanMakePrivate != "" {
 		if b.privateAttrs == nil {
 			b.privateAttrs = make(map[UserAttribute]struct{})
+		} else if b.privateAttrsCopyOnWrite {
+			copied := make(map[UserAttribute]struct{}, len(b.privateAttrs))
+			for name := range b.privateAttrs {
+				copied[name] = struct{}{}
+			}
+			b.privateAttrs = copied
 		}
 		b.privateAttrs[b.lastAttributeCanMakePrivate] = struct{}{}
+		b.privateAttrsCopyOnWrite = false
 	}
 	return b
 }