Move findMapPaths to directory.go (#570)

* Move findMapPaths to directory.go

* Add util helper SchemaEntryPathNoChoiceCase (#571)

Sometimes we want not just the string path, but the entry path as well.

Author: wenovus

util/path.go

@@ -104,16 +104,26 @@ func SchemaTreePathNoModule(e *yang.Entry) string {
 // its path, expressed as a slice of strings, which is returned.
 func SchemaPathNoChoiceCase(elem *yang.Entry) []string {
 	var pp []string
+	for _, e := range SchemaEntryPathNoChoiceCase(elem) {
+		pp = append(pp, e.Name)
+	}
+	return pp
+}
+
+// SchemaEntryPathNoChoiceCase takes an input yang.Entry and walks up the tree to find
+// its path, expressed as a slice of Entrys, which is returned.
+func SchemaEntryPathNoChoiceCase(elem *yang.Entry) []*yang.Entry {
+	var pp []*yang.Entry
 	if elem == nil {
 		return pp
 	}
 	e := elem
 	for ; e.Parent != nil; e = e.Parent {
 		if !IsChoiceOrCase(e) {
-			pp = append(pp, e.Name)
+			pp = append(pp, e)
 		}
 	}
-	pp = append(pp, e.Name)
+	pp = append(pp, e)
 
 	// Reverse the slice that was specified to us as it was appended to
 	// from the leaf to the root.

util/path_test.go

@@ -359,6 +359,50 @@ func TestSchemaPathNoChoiceCase(t *testing.T) {
 	}
 }
 
+func TestSchemaEntryPathNoChoiceCase(t *testing.T) {
+	containerWithChoiceSchema := getContainerWithChoiceSchema()
+
+	tests := []struct {
+		desc  string
+		entry *yang.Entry
+		want  []*yang.Entry
+	}{
+		{
+			desc:  "nil entry",
+			entry: nil,
+			want:  nil,
+		},
+		{
+			desc:  "choice entry",
+			entry: containerWithChoiceSchema.Dir["choice1"],
+			want:  []*yang.Entry{containerWithChoiceSchema},
+		},
+		{
+			desc:  "case entry",
+			entry: containerWithChoiceSchema.Dir["choice1"].Dir["case1"],
+			want:  []*yang.Entry{containerWithChoiceSchema},
+		},
+		{
+			desc:  "case1-leaf1",
+			entry: containerWithChoiceSchema.Dir["choice1"].Dir["case1"].Dir["case1-leaf1"],
+			want:  []*yang.Entry{containerWithChoiceSchema, containerWithChoiceSchema.Dir["choice1"].Dir["case1"].Dir["case1-leaf1"]},
+		},
+		{
+			desc:  "case21-leaf",
+			entry: containerWithChoiceSchema.Dir["choice1"].Dir["case2"].Dir["case2_choice1"].Dir["case21"].Dir["case21-leaf"],
+			want:  []*yang.Entry{containerWithChoiceSchema, containerWithChoiceSchema.Dir["choice1"].Dir["case2"].Dir["case2_choice1"].Dir["case21"].Dir["case21-leaf"]},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.desc, func(t *testing.T) {
+			if got, want := SchemaEntryPathNoChoiceCase(tt.entry), tt.want; !reflect.DeepEqual(got, want) {
+				t.Errorf("got:\n%v\nwant:\n%v\n", got, want)
+			}
+		})
+	}
+}
+
 func TestRemoveXPATHPredicates(t *testing.T) {
 	tests := []struct {
 		desc    string

ygen/directory.go

@@ -22,6 +22,7 @@ import (
 	"fmt"
 	"sort"
 
+	"github.com/google/go-cmp/cmp"
 	"github.com/openconfig/goyang/pkg/yang"
 	"github.com/openconfig/ygot/genutil"
 	"github.com/openconfig/ygot/util"
@@ -169,3 +170,68 @@ func findSchemaPath(parent *Directory, fieldName string, shadowSchemaPaths, abso
 	}
 	return fieldSlicePath[len(parent.Path)-1:], nil
 }
+
+// findMapPaths takes an input field name for a parent Directory and calculates the set of schemapaths that it represents.
+// If absolutePaths is set, the paths are absolute otherwise they are relative to the parent. If
+// the input entry is a key to a list, and is of type leafref, then the corresponding target leaf's
+// path is also returned. If shadowSchemaPaths is set, then the path of the
+// field deprioritized via compression is returned instead of the prioritized paths.
+// The first returned path is the path of the direct child, with the shadow
+// child's path afterwards, and the key leafref, if any, last.
+func findMapPaths(parent *Directory, fieldName string, compressPaths, shadowSchemaPaths, absolutePaths bool) ([][]string, error) {
+	childPath, err := findSchemaPath(parent, fieldName, shadowSchemaPaths, absolutePaths)
+	if err != nil {
+		return nil, err
+	}
+	var mapPaths [][]string
+	if childPath != nil {
+		mapPaths = append(mapPaths, childPath)
+	}
+	// Only for compressed data schema paths for list fields do we have the
+	// possibility for a direct leafref path as a second path for the field.
+	if !compressPaths || parent.ListAttr == nil {
+		return mapPaths, nil
+	}
+
+	field, ok := parent.Fields[fieldName]
+	if !ok {
+		return nil, fmt.Errorf("field name %s does not exist in Directory %s", fieldName, parent.Path)
+	}
+	fieldSlicePath := util.SchemaPathNoChoiceCase(field)
+
+	// Handle specific issue of compressed path schemas, where a key of the
+	// parent list is a leafref to this leaf.
+	for _, k := range parent.ListAttr.KeyElems {
+		// If the key element has the same path as this element, and the
+		// corresponding element that is within the parent's container is of
+		// type leafref, then within an OpenConfig schema this means that
+		// the key leaf was a pointer to this leaf. To this end, we set
+		// isKey to true so that the struct field can be mapped to the
+		// leafref leaf within the schema as well as the target of the
+		// leafref.
+		if k.Parent == nil || k.Parent.Parent == nil || k.Parent.Parent.Dir[k.Name] == nil || k.Parent.Parent.Dir[k.Name].Type == nil {
+			return nil, fmt.Errorf("invalid compressed schema, could not find the key %s or the grandparent of %s", k.Name, k.Path())
+		}
+
+		// If a key of the list is a leafref that points to the field,
+		// then add this as an alternative path.
+		// Note: if k is a leafref, buildListKey() would have already
+		// resolved it the field that the leafref points to. So, we
+		// compare their absolute paths for equality.
+		if k.Parent.Parent.Dir[k.Name].Type.Kind == yang.Yleafref && cmp.Equal(util.SchemaPathNoChoiceCase(k), fieldSlicePath) {
+			// The path of the key element is simply the name of the leaf under the
+			// list, since the YANG specification enforces that keys are direct
+			// children of the list.
+			keyPath := []string{fieldSlicePath[len(fieldSlicePath)-1]}
+			if absolutePaths {
+				// If absolute paths are required, then the 'config' or 'state' container needs to be omitted from
+				// the complete path for the secondary mapping.
+				keyPath = append([]string{""}, fieldSlicePath[1:len(fieldSlicePath)-2]...)
+				keyPath = append(keyPath, fieldSlicePath[len(fieldSlicePath)-1])
+			}
+			mapPaths = append(mapPaths, keyPath)
+			break
+		}
+	}
+	return mapPaths, nil
+}