Milo: Print raw json for buildbot build properties

milo/appengine/common/funcs.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 common
 
 import (
         "bytes"
+        "encoding/json"
         "fmt"
         "html/template"
         "strings"
         "time"
 
         "github.com/luci/luci-go/milo/api/resp"
 )
 
 // A collection of useful templating functions
 
 // funcMap is what gets fed into the template bundle.
 var funcMap = template.FuncMap{
         "humanDuration":  humanDuration,
         "parseRFC3339":   parseRFC3339,
         "linkify":        linkify,
         "linkifySet":     linkifySet,
         "obfuscateEmail": obfuscateEmail,
         "localTime":      localTime,
         "shortHash":      shortHash,
         "startswith":     strings.HasPrefix,
         "sub":            sub,
         "consoleHeader":  consoleHeader,
+        "formatJson":     formatJson,
 }
 
 // localTime returns a <span> element with t in human format
 // that will be converted to local timezone in the browser.
 // Recommended usage: {{ .Date | localTime "N/A" }}
 func localTime(ifZero string, t time.Time) template.HTML {
         if t.IsZero() {
                 return template.HTML(template.HTMLEscapeString(ifZero))
         }
         milliseconds := t.UnixNano() / 1e6
@@ skipping 153 matching lines @@
 }
 
 // shortHash abbriviates a git hash into 6 characters.
 func shortHash(s string) string {
         if len(s) > 6 {
                 return s[0:6]
         }
         return s
 }
 
+// If the string s is a JSON map, then pretty print it.
+func formatJson(s string) template.HTML {
+        var o interface{}
+        err := json.Unmarshal([]byte(s), &o)

[nodir, 2017/03/24 06:05:40]

here we parse a JSON-formatted value and then conditionally format to JSON
back.. Earlier in the code path with had this value in parsed form, so we did
(parsed -> JSON -> parsed -> JSON) conversion. This is wasteful

Please change formatJson to accept an interface{} and treat the passed value as
already parsed.

Also please rename formatJson to formatJSON because Go likes abbreviation
written with all caps

+        if err != nil {
+                return template.HTML(template.HTMLEscapeString(s))
+        }
+        switch t := o.(type) {
+        case string:
+                return template.HTML(template.HTMLEscapeString(t))
+        case map[string]interface{}:
+                s, err := json.MarshalIndent(t, "", "  ")

[nodir, 2017/03/24 06:05:40]

AFAIR last time we talked about this I asked to render property values of any
type in JSON format, so that a user can clearly see the value type. It is
imporatnt to know the type because users write code that works with the values.
Today it is ambiguous, value `1` may be a string "1" or a number 1. Print only
structs as JSON but other types is confusing. A person who sees a JSON object
presented as valid JSON may reasonably assume that in general milo presents
values in JSON format.

Please format all values in JSON format.

[nodir, 2017/03/24 08:46:06]

Obviously please update the code that is currently encodes values in
JSON before passing them to build page template. Make it pass raw typed values. 

+                if err == nil {
+                        es := strings.Split(string(s), "\n")
+                        var result string
+                        for _, line := range es {
+                                result += strings.Replace(template.HTMLEscapeString(line), " ", "&nbsp;", -1) + "<br>"
+                        }
+                        return template.HTML("<div class=\"left\">" + result + "</span>")
+                }
+        }
+        return template.HTML(template.HTMLEscapeString(s))
+}
+
 func init() {
         linkifySetTemplate = template.Must(
                 template.New("linkifySet").
                         Funcs(template.FuncMap{
                                 "linkify": linkify,
                         }).Parse(
                         `{{ range $i, $link := . }}` +
                                 `{{ if gt $i 0 }} {{ end }}` +
                                 `{{ $link | linkify}}` +
                                 `{{ end }}`))
 
         linkifyTemplate = template.Must(
                 template.New("linkify").
                         Parse(
                                 `<a href="{{.URL}}">` +
                                         `{{if .Img}}<img src="{{.Img}}"{{if .Alt}} alt="{{.Alt}}"{{end}}>` +
                                         `{{else if .Alias}}[{{.Label}}]` +
                                         `{{else}}{{.Label}}{{end}}` +
                                         `</a>`))
 }