Decouple PLS from MGS.

service/datastore/pls_impl.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.
 
 // HEAVILY adapted from github.com/golang/appengine/datastore
 
 package datastore
 
 import (
         "fmt"
@@ skipping 17 matching lines @@
         convert        bool
         metaVal        interface{}
         canSet         bool
 }
 
 type structCodec struct {
         byMeta   map[string]int
         byName   map[string]int
         byIndex  []structTag
         hasSlice bool
-        mgs      bool
         problem  error
 }
 
 type structPLS struct {
         o reflect.Value
         c *structCodec
 }
 
-func (p *structPLS) getMGS() MetaGetterSetter {
-        if !p.c.mgs {
-                return nil
-        }
-        return p.o.Addr().Interface().(MetaGetterSetter)
-}
-
 var _ PropertyLoadSaver = (*structPLS)(nil)
 
 // typeMismatchReason returns a string explaining why the property p could not
 // be stored in an entity field of type v.Type().
 func typeMismatchReason(val interface{}, v reflect.Value) string {
         entityType := reflect.TypeOf(val)
         return fmt.Sprintf("type mismatch: %s versus %v", entityType, v.Type())
 }
 
 func (p *structPLS) Load(propMap PropertyMap) error {
@@ skipping 155 matching lines @@
         } else {
                 ret = make(PropertyMap, len(p.c.byName))
         }
         if _, err := p.save(ret, "", ShouldIndex); err != nil {
                 return nil, err
         }
         return ret, nil
 }
 
 func (p *structPLS) getDefaultKind() string {
+        if !p.o.IsValid() {
+                return ""
+        }
         return p.o.Type().Name()
 }
 
 func (p *structPLS) save(propMap PropertyMap, prefix string, is IndexSetting) (idxCount int, err error) {
         if err = p.Problem(); err != nil {
                 return
         }
 
         saveProp := func(name string, si IndexSetting, v reflect.Value, st *structTag) (err error) {
                 if st.substructCodec != nil {
@@ skipping 56 matching lines @@
 
 func (p *structPLS) GetMeta(key string) (interface{}, error) {
         if err := p.Problem(); err != nil {
                 return nil, err
         }
 
         if idx, ok := p.c.byMeta[key]; ok {
                 return p.getMetaFor(idx), nil
         }
 
-        if p.c.mgs {
-                ret, err := p.getMGS().GetMeta(key)
-                if err == nil {
-                        return ret, err
-                } else if err != ErrMetaFieldUnset {
-                        return nil, err
-                }
-        }
         if key == "kind" {
                 return p.getDefaultKind(), nil
         }
         return nil, ErrMetaFieldUnset
 }
 
 func (p *structPLS) getMetaFor(idx int) interface{} {
         st := p.c.byIndex[idx]
         val := st.metaVal
         f := p.o.Field(idx)
         if st.canSet {
                 if !reflect.DeepEqual(reflect.Zero(f.Type()).Interface(), f.Interface()) {
                         val = f.Interface()
                         if bf, ok := val.(Toggle); ok {
                                 val = bf == On // true if On, otherwise false
                         }
                 }
         }
         return val
 }
 
 func (p *structPLS) GetAllMeta() PropertyMap {
-        ret := PropertyMap(nil)
         needKind := true
-        if p.c.mgs {
-                ret = p.getMGS().GetAllMeta()

[iannucci, 2015/10/30 21:29:29]

This is the code that I was wondering about. I'm not sure why it's gone now?

[dnj, 2015/10/30 21:40:04]

Gone b/c:
1) No fallthroughs, structPLS is pure now!
2) This logic was for friendly fuzziness: you can implement GetAllMeta, and if
you don't export $kind, we'll do it for you for free!

RE (2), the new mentality is, `if you don't export $kind, you should call
GetPLS(me).GetMeta("$kind") and that's on you`. I added a test to assert that
datastore has an issue with this failure higher up.

-                _, haveKind := ret["$kind"]
-                needKind = !haveKind
-        } else {
-                ret = make(PropertyMap, len(p.c.byMeta)+1)
-        }
+        ret := make(PropertyMap, len(p.c.byMeta)+1)
         for k, idx := range p.c.byMeta {
                 val := p.getMetaFor(idx)
                 p := Property{}
                 if err := p.SetValue(val, NoIndex); err != nil {
                         continue
                 }
                 ret["$"+k] = []Property{p}
         }
         if needKind {
                 if _, ok := p.c.byMeta["kind"]; !ok {
                         ret["$kind"] = []Property{MkPropertyNI(p.getDefaultKind())}
                 }
         }
         return ret
 }
 
 func (p *structPLS) GetMetaDefault(key string, def interface{}) interface{} {
         return GetMetaDefaultImpl(p.GetMeta, key, def)
 }
 
 func (p *structPLS) SetMeta(key string, val interface{}) (err error) {
         if err = p.Problem(); err != nil {
                 return
         }
         idx, ok := p.c.byMeta[key]
         if !ok {
-                if p.c.mgs {
-                        return p.getMGS().SetMeta(key, val)
-                }
                 return ErrMetaFieldUnset
         }
         if !p.c.byIndex[idx].canSet {
                 return fmt.Errorf("gae/helper: cannot set meta %q: unexported field", key)
         }
         // setting a BoolField
         if b, ok := val.(bool); ok {
                 if b {
                         val = On
                 } else {
@@ skipping 58 matching lines @@
 
         me := func(fmtStr string, args ...interface{}) error {
                 return fmt.Errorf(fmtStr, args...)
         }
 
         c = &structCodec{
                 byIndex: make([]structTag, t.NumField()),
                 byName:  make(map[string]int, t.NumField()),
                 byMeta:  make(map[string]int, t.NumField()),
                 problem: errRecursiveStruct, // we'll clear this later if it's not recursive
-                mgs:     reflect.PtrTo(t).Implements(typeOfMGS),
         }
         defer func() {
                 // If the codec has a problem, free up the indexes
                 if c.problem != nil {
                         c.byIndex = nil
                         c.byName = nil
                         c.byMeta = nil
                 }
         }()
         structCodecs[t] = c
@@ skipping 142 matching lines @@
                 switch val {
                 case "on", "On", "true":
                         return true, nil
                 case "off", "Off", "false":
                         return false, nil
                 }
                 return nil, fmt.Errorf("Toggle field has bad/missing default, got %q", val)
         }
         return nil, fmt.Errorf("helper: meta field with bad type/value %s/%q", t, val)
 }