Add AutoIndex

service/datastore/index.go

 // Copyright 2015 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 datastore
 
 import (
         "bytes"
         "fmt"
         "strings"
@@ skipping 210 matching lines @@
                 return false
         }
         for _, sb := range id.SortBy {
                 if sb.Property == "" || sb.Property == "__ancestor__" {
                         return false
                 }
         }
         return true
 }
 
+// YAMLString returns the YAML representation of this IndexDefinition.
+//
+// If the index definition is Builtin() or not Compound(), this will return
+// an error.
+func (id *IndexDefinition) YAMLString() (string, error) {
+        if id.Builtin() || !id.Compound() {
+                return "", fmt.Errorf("cannot generate YAML for this IndexDefinition")
+        }
+
+        ret := &bytes.Buffer{}

[Vadim Sh., 2015/09/24 19:17:29]

nit: just bytes.Buffer{}, no need for dynamic allocation

[iannucci, 2015/09/24 19:52:34]

Common misconception: there's no actual difference. The compiler reserves the
right to allocate any 'stack' allocations on the heap, or vice versa.

https://golang.org/doc/faq#stack_or_heap

[Vadim Sh., 2015/09/24 19:57:50]

"""In the current compilers, if a variable has its address taken, that variable
is a candidate for allocation on the heap. However, a basic escape analysis
recognizes some cases when such variables will not live past the return from the
function and can reside on the stack."""

I try to help escape analysis whenever I can :)

Anyhow, in this particular case "&" is just unnecessary symbol. But I don't care
much.

[iannucci, 2015/09/24 20:12:59]

it made more sense before I had the ws function. there were
fmt.Fprintf(&ret,...) everywhere.

+        indent := 0
+
+        first := true
+        ws := func(s string) {
+                nl := "\n"
+                if first {
+                        nl = ""
+                        first = false
+                }
+                _, err := fmt.Fprintf(ret, "%s%s%s", nl, strings.Repeat("  ", indent), s)
+                if err != nil {

[Vadim Sh., 2015/09/24 19:17:29]

just remove errcheck from pre-commit-go.yml >_< Checking Fprintf errors is
clearly paranoia.

[iannucci, 2015/09/24 19:52:34]

lol ok

+                        panic(err)
+                }
+        }
+
+        ws(fmt.Sprintf("- kind: %s", id.Kind))
+        indent++
+        if id.Ancestor {
+                ws("ancestor: yes")
+        }
+        ws("properties:")
+        for _, o := range id.SortBy {
+                ws(fmt.Sprintf("- name: %s", o.Property))
+                if o.Descending {
+                        indent++

[Vadim Sh., 2015/09/24 19:17:29]

:) just pass indent explicitly, e.g.

ws("properties:", 1)
...
ws("direction: desc", 2)

[iannucci, 2015/09/24 19:52:35]

done :)

+                        ws("direction: desc")
+                        indent--
+                }
+        }
+        return ret.String(), nil
+}
+
 func (id *IndexDefinition) String() string {
         ret := &bytes.Buffer{}
         wr := func(r rune) {
                 _, err := ret.WriteRune(r)
                 if err != nil {
                         panic(err)
                 }
         }
 
         ws := func(s string) {
@@ skipping 15 matching lines @@
         }
         for _, sb := range id.SortBy {
                 wr('/')
                 if sb.Descending {
                         wr('-')
                 }
                 ws(sb.Property)
         }
         return ret.String()
 }