Milo: Print raw json for buildbot build properties

milo/appengine/buildbot/build.go

 // Copyright 2016 The LUCI Authors. All rights reserved.
 // Use of this source code is governed under the Apache License, Version 2.0
 // that can be found in the LICENSE file.
 
 package buildbot
 
 import (
         "encoding/json"
         "errors"
         "fmt"
         "io/ioutil"
+        "math"
         "path/filepath"
         "regexp"
         "sort"
         "strings"
         "time"
 
         "golang.org/x/net/context"
 
         "github.com/luci/gae/service/datastore"
         "github.com/luci/luci-go/common/data/stringset"
@@ skipping 284 matching lines @@
                 }
 
                 // Figure out the times.
                 bc.Started, bc.Finished, bc.Duration = parseTimes(endingTime, step.Times)
 
                 result = append(result, bc)
         }
         return
 }
 
-// parseProp returns a representation of v based off k, and a boolean to
-// specify whether or not to hide it altogether.
-func parseProp(prop map[string]Prop, k string, v interface{}) (string, bool) {
-        switch k {
-        case "requestedAt":
-                if vf, ok := v.(float64); ok {
-                        return time.Unix(int64(vf), 0).UTC().Format(time.RFC3339), true
-                }
-        case "buildbucket":
-                var b map[string]interface{}
-                json.Unmarshal([]byte(v.(string)), &b)
-                if b["build"] == nil {
-                        return "", false
-                }
-                build := b["build"].(map[string]interface{})
-                id := build["id"]
-                if id == nil {
-                        return "", false
-                }
-                return fmt.Sprintf("https://cr-buildbucket.appspot.com/b/%s", id.(string)), true
-        case "issue":
-                if rv, ok := prop["rietveld"]; ok {
-                        rietveld := rv.Value.(string)
-                        // Issue could be a float, int, or string.
-                        switch v := v.(type) {
-                        case float64:
-                                return fmt.Sprintf("%s/%d", rietveld, int(v)), true
-                        default: // Probably int or string
-                                return fmt.Sprintf("%s/%v", rietveld, v), true
-                        }
-                }
-                return fmt.Sprintf("%d", int(v.(float64))), true
-        case "rietveld":
-                return "", false
-        default:
-                if vs, ok := v.(string); ok && vs == "" {
-                        return "", false // Value is empty, don't show it.
-                }
-                if v == nil {
-                        return "", false
+// parseProp returns a string representation of v.
+func parseProp(v interface{}) string {
+        // if v is a whole number, force it into an int.  json.Marshal() would turn
+        // it into what looks like a float instead.  We want this to remain and
+        // int instead of a number.
+        if vf, ok := v.(float64); ok {
+                if math.Floor(vf) == vf {
+                        return fmt.Sprintf("%d", int64(vf))
                 }
         }
-        return fmt.Sprintf("%v", v), true
+        // return the json representation of the value.
+        b, err := json.Marshal(v)
+        if err == nil {
+                return string(b)
+        }
+        return fmt.Sprintf("%v", v)
 }
 
 // Prop is a struct used to store a value and group so that we can make a map
 // of key:Prop to pass into parseProp() for the purpose of cross referencing
 // one prop while working on another.
 type Prop struct {
         Value interface{}
         Group string
 }
 
 // properties extracts all properties from buildbot builds and groups them into
 // property groups.
 func properties(b *buildbotBuild) (result []*resp.PropertyGroup) {
         groups := map[string]*resp.PropertyGroup{}
         allProps := map[string]Prop{}
         for _, prop := range b.Properties {
                 allProps[prop.Name] = Prop{
                         Value: prop.Value,
                         Group: prop.Source,
                 }
         }
         for key, prop := range allProps {
                 value := prop.Value
                 groupName := prop.Group
                 if _, ok := groups[groupName]; !ok {
                         groups[groupName] = &resp.PropertyGroup{GroupName: groupName}
                 }
-                vs, ok := parseProp(allProps, key, value)
-                if !ok {
-                        continue
-                }
+                vs := parseProp(value)
                 groups[groupName].Property = append(groups[groupName].Property, &resp.Property{
                         Key:   key,
                         Value: vs,
                 })
         }
         // Insert the groups into a list in alphabetical order.
         // You have to make a separate sorting data structure because Go doesn't like
         // sorting things for you.
         groupNames := []string{}
         for n := range groups {
@@ skipping 259 matching lines @@
         var newAliases map[string][]*buildbotLinkAlias
         if l := remainingAliases.Len(); l > 0 {
                 newAliases = make(map[string][]*buildbotLinkAlias, l)
                 remainingAliases.Iter(func(v string) bool {
                         newAliases[v] = s.Aliases[v]
                         return true
                 })
         }
         s.Aliases = newAliases
 }