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{}
+
+        first := true
+        ws := func(s string, indent int) {
+                nl := "\n"
+                if first {
+                        nl = ""
+                        first = false
+                }
+                fmt.Fprintf(&ret, "%s%s%s", nl, strings.Repeat("  ", indent), s)
+        }
+
+        ws(fmt.Sprintf("- kind: %s", id.Kind), 0)
+        if id.Ancestor {
+                ws("ancestor: yes", 1)
+        }
+        ws("properties:", 1)
+        for _, o := range id.SortBy {
+                ws(fmt.Sprintf("- name: %s", o.Property), 1)
+                if o.Descending {
+                        ws("direction: desc", 2)
+                }
+        }
+        return ret.String(), nil
+}
+
 func (id *IndexDefinition) String() string {
-        ret := &bytes.Buffer{}
+        ret := bytes.Buffer{}
         wr := func(r rune) {
                 _, err := ret.WriteRune(r)
                 if err != nil {
                         panic(err)
                 }
         }
 
         ws := func(s string) {
                 _, err := ret.WriteString(s)
                 if err != nil {
@@ skipping 13 matching lines @@
         }
         for _, sb := range id.SortBy {
                 wr('/')
                 if sb.Descending {
                         wr('-')
                 }
                 ws(sb.Property)
         }
         return ret.String()
 }