client/flagpb: fix unmarshaling of maps

client/flagpb/unmarshal.go

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package flagpb
 
 import (
         "encoding/hex"
         "fmt"
         "strconv"
@@ skipping 75 matching lines @@
         if err != nil {
                 return nil, err
         }
 
         // Where to assign the value?
         target := &root
         if len(pathMsgs) > 0 {
                 lastMsg := pathMsgs[len(pathMsgs)-1]
                 target = &lastMsg.message
         }
+        name := fieldPath[len(fieldPath)-1]
 
-        // Resolve last field name.
-        name := fieldPath[len(fieldPath)-1]
-        fi := target.desc.FindField(name)
-        if fi == -1 {
-                return nil, fmt.Errorf("field %s not found in message %s", name, target.desc.GetName())
+        // Resolve target field.
+        var fieldIndex int
+        if target.desc.GetOptions().GetMapEntry() {
+                if fieldIndex = target.desc.FindField("value"); fieldIndex == -1 {
+                        return nil, fmt.Errorf("map entry type %s does not have value field", target.desc.GetName())
+                }
+        } else {
+                if fieldIndex = target.desc.FindField(name); fieldIndex == -1 {
+                        return nil, fmt.Errorf("field %s not found in message %s", name, target.desc.GetName())
+                }
         }
-        field := target.desc.Field[fi]
+        field := target.desc.Field[fieldIndex]
 
         var value interface{}
         hasValue := false
 
         if !hasValueStr {
                 switch {
                 // Boolean and repeated message fields may have no value and ignore
                 // next argument.
                 case field.GetType() == descriptor.FieldDescriptorProto_TYPE_BOOL:
                         value = true
@@ skipping 55 matching lines @@
 // If a field is repeated, returns the last message.
 //
 // If a field value is nil, initializes it with an empty message or slice.
 // If a field is not a message field, returns an error.
 func (p *parser) subMessages(root message, path []string) ([]subMsg, error) {
         result := make([]subMsg, 0, len(path))
 
         parent := &root
         for i, name := range path {
                 curPath := path[:i+1]
-                fi := parent.desc.FindField(name)
-                if fi == -1 {
-                        return nil, fmt.Errorf("field %q not found in message %s", name, parent.desc.GetName())
+
+                var fieldIndex int
+                if parent.desc.GetOptions().GetMapEntry() {
+                        if fieldIndex = parent.desc.FindField("value"); fieldIndex == -1 {
+                                return nil, fmt.Errorf("map entry type %s does not have value field", parent.desc.GetName())
+                        }
+                } else {
+                        if fieldIndex = parent.desc.FindField(name); fieldIndex == -1 {
+                                return nil, fmt.Errorf("field %q not found in message %s", name, parent.desc.GetName())
+                        }

[nodir, 2016/04/30 04:43:58]

deduping this would causes an obscure abstraction

                 }
 
-                f := parent.desc.Field[fi]
+                f := parent.desc.Field[fieldIndex]
                 if f.GetType() != descriptor.FieldDescriptorProto_TYPE_MESSAGE {
                         return nil, fmt.Errorf("field %s is not a message", strings.Join(curPath, "."))
                 }
 
                 subDescInterface, err := p.resolve(f.GetTypeName())
                 if err != nil {
                         return nil, err
                 }
                 subDesc, ok := subDescInterface.(*descriptor.DescriptorProto)
                 if !ok {
                         return nil, fmt.Errorf("%s is not a message", f.GetTypeName())
                 }
 
                 sub := subMsg{
                         message:  message{desc: subDesc},
-                        repeated: f.Repeated(),
+                        repeated: f.Repeated() && !subDesc.GetOptions().GetMapEntry(),
                         path:     curPath,
                 }
                 if value, ok := parent.data[name]; !ok {
                         sub.data = map[string]interface{}{}
                         if sub.repeated {
                                 parent.data[name] = []interface{}{sub.data}
                         } else {
                                 parent.data[name] = sub.data
                         }
                 } else {
@@ skipping 117 matching lines @@
         }
         return enum.Value[i].GetNumber(), nil
 }
 
 func asSlice(x interface{}) []interface{} {
         if x == nil {
                 return nil
         }
         return x.([]interface{})
 }