GitHub #8: Seed indexes from index.yml

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"
+
+        "gopkg.in/yaml.v2"
 )
 
 // IndexColumn represents a sort order for a single entity field.
 type IndexColumn struct {
         Property   string
         Descending bool
 }
 
 // ParseIndexColumn takes a spec in the form of /\s*-?\s*.+\s*/, and
 // returns an IndexColumn. Examples are:
@@ skipping 21 matching lines @@
 func (i IndexColumn) cmp(o IndexColumn) int {
         // sort ascending first
         if !i.Descending && o.Descending {
                 return -1
         } else if i.Descending && !o.Descending {
                 return 1
         }
         return cmpString(i.Property, o.Property)()
 }
 
+// UnmarshalYAML deserializes a index.yml `property` into an IndexColumn.
+func (i *IndexColumn) UnmarshalYAML(unmarshal func(interface{}) error) error {

[iannucci, 2016/01/13 19:12:20]

I would consider making the Property and Descending fields be their own types
which independently implement the *marshalYAML functions. That said, if it
requires you to start changing oodles of files then never mind :).

[nishanths (utexas), 2016/01/14 21:12:56]

Good idea. Will create a separate issue for these changes. :)

+        var m map[string]string
+
+        if err := unmarshal(&m); err != nil {
+                return err
+        }
+
+        i.Property = m["name"]

[iannucci, 2016/01/13 19:12:20]

should return an error if there's somehow no name

[nishanths (utexas), 2016/01/14 21:12:56]

Done.

+        i.Descending = false // default direction is "asc"
+
+        if v, ok := m["direction"]; ok && v == "desc" {
+                i.Descending = true
+        }
+
+        return nil
+}
+
+// MarshalYAML serializes an IndexColumn into a index.yml `property`.
+func (i *IndexColumn) MarshalYAML() (interface{}, error) {
+        direction := "asc"
+
+        if i.Descending {
+                direction = "desc"
+        }
+
+        return yaml.Marshal(map[string]string{
+                "name":      i.Property,
+                "direction": direction,
+        })
+}
+
 // String returns a human-readable version of this IndexColumn which is
 // compatible with ParseIndexColumn.
 func (i IndexColumn) String() string {
         ret := ""
         if i.Descending {
                 ret = "-"
         }
         return ret + i.Property
 }
 
 // GQL returns a correctly formatted Cloud Datastore GQL literal which
 // is valid for the `ORDER BY` clause.
 //
 // The flavor of GQL that this emits is defined here:
 //   https://cloud.google.com/datastore/docs/apis/gql/gql_reference
 func (i IndexColumn) GQL() string {
         if i.Descending {
                 return gqlQuoteName(i.Property) + " DESC"
         }
         return gqlQuoteName(i.Property)
 }
 
 // IndexDefinition holds the parsed definition of a datastore index definition.
 type IndexDefinition struct {
-        Kind     string
-        Ancestor bool
-        SortBy   []IndexColumn
+        Kind     string        `yaml:"kind"`
+        Ancestor bool          `yaml:"ancestor"`
+        SortBy   []IndexColumn `yaml:"properties"`
+}
+
+// MarshalYAML serializes an IndexDefinition into a index.yml `index`.
+func (id *IndexDefinition) MarshalYAML() (interface{}, error) {
+        if id.Builtin() || !id.Compound() {
+                return nil, fmt.Errorf("cannot generate YAML for %s", id)
+        }
+
+        return yaml.Marshal(map[string]interface{}{
+                "kind":       id.Kind,
+                "ancestor":   id.Ancestor,
+                "properties": id.SortBy,
+        })
 }
 
 // Equal returns true if the two IndexDefinitions are equivalent.
 func (id *IndexDefinition) Equal(o *IndexDefinition) bool {
         if id.Kind != o.Kind || id.Ancestor != o.Ancestor || len(id.SortBy) != len(o.SortBy) {
                 return false
         }
         for i, col := range id.SortBy {
                 if col != o.SortBy[i] {
                         return false
@@ skipping 202 matching lines @@
         }
         for _, sb := range id.SortBy {
                 wr('/')
                 if sb.Descending {
                         wr('-')
                 }
                 ws(sb.Property)
         }
         return ret.String()
 }