Improve error message when namespace transformer is given invalid fieldspecs

Also remove invalid+ignored fieldspecs from the defaults

kyaml/yaml/alias.go

@@ -87,6 +87,16 @@ var MappingNode yaml.Kind = yaml.MappingNode
 var ScalarNode yaml.Kind = yaml.ScalarNode
 var SequenceNode yaml.Kind = yaml.SequenceNode
 
+func nodeKindString(k yaml.Kind) string {
+	return map[yaml.Kind]string{
+		yaml.SequenceNode: "SequenceNode",
+		yaml.MappingNode:  "MappingNode",
+		yaml.ScalarNode:   "ScalarNode",
+		yaml.DocumentNode: "DocumentNode",
+		yaml.AliasNode:    "AliasNode",
+	}[k]
+}
+
 var DoubleQuotedStyle yaml.Style = yaml.DoubleQuotedStyle
 var FlowStyle yaml.Style = yaml.FlowStyle
 var FoldedStyle yaml.Style = yaml.FoldedStyle

kyaml/yaml/fns.go

@@ -794,12 +794,22 @@ func ErrorIfAnyInvalidAndNonNull(kind yaml.Kind, rn ...*RNode) error {
 	return nil
 }
 
-var nodeTypeIndex = map[yaml.Kind]string{
-	yaml.SequenceNode: "SequenceNode",
-	yaml.MappingNode:  "MappingNode",
-	yaml.ScalarNode:   "ScalarNode",
-	yaml.DocumentNode: "DocumentNode",
-	yaml.AliasNode:    "AliasNode",
+type InvalidNodeKindError struct {
+	expectedKind yaml.Kind
+	node         *RNode
+}
+
+func (e *InvalidNodeKindError) Error() string {
+	msg := fmt.Sprintf("wrong node kind: expected %s but got %s",
+		nodeKindString(e.expectedKind), nodeKindString(e.node.YNode().Kind))
+	if content, err := e.node.String(); err == nil {
+		msg += fmt.Sprintf(": node contents:\n%s", content)
+	}
+	return msg
+}
+
+func (e *InvalidNodeKindError) ActualNodeKind() Kind {
+	return e.node.YNode().Kind
 }
 
 func ErrorIfInvalid(rn *RNode, kind yaml.Kind) error {
@@ -809,11 +819,7 @@ func ErrorIfInvalid(rn *RNode, kind yaml.Kind) error {
 	}
 
 	if rn.YNode().Kind != kind {
-		s, _ := rn.String()
-		return errors.Errorf(
-			"wrong Node Kind for %s expected: %v was %v: value: {%s}",
-			strings.Join(rn.FieldPath(), "."),
-			nodeTypeIndex[kind], nodeTypeIndex[rn.YNode().Kind], strings.TrimSpace(s))
+		return &InvalidNodeKindError{node: rn, expectedKind: kind}
 	}
 
 	if kind == yaml.MappingNode {

kyaml/yaml/fns_test.go

@@ -45,7 +45,7 @@ func TestAppend(t *testing.T) {
 	assert.NoError(t, err)
 	rn, err := node.Pipe(Append(NewScalarRNode("").YNode()))
 	if assert.Error(t, err) {
-		assert.Contains(t, err.Error(), "wrong Node Kind")
+		assert.Contains(t, err.Error(), "wrong node kind")
 	}
 	assert.Nil(t, rn)
 
@@ -159,7 +159,9 @@ func TestElementSetter(t *testing.T) {
 	// Return error because ElementSetter will assume all elements are scalar when
 	// there is only value provided.
 	_, err = node.Pipe(ElementSetter{Values: []string{"b"}})
-	assert.EqualError(t, err, "wrong Node Kind for  expected: ScalarNode was MappingNode: value: {a: b}")
+	assert.EqualError(t, err, `wrong node kind: expected ScalarNode but got MappingNode: node contents:
+a: b
+`)
 
 	node = MustParse(`
 - a
@@ -455,7 +457,7 @@ a: b
 	assert.NoError(t, err)
 	rn, err = node.Pipe(FieldClearer{Name: "a"})
 	if assert.Error(t, err) {
-		assert.Contains(t, err.Error(), "wrong Node Kind")
+		assert.Contains(t, err.Error(), "wrong node kind")
 	}
 	assert.Nil(t, rn)
 	assert.Equal(t, s, assertNoErrorString(t)(node.String()))
@@ -855,7 +857,9 @@ func TestMapEntrySetter(t *testing.T) {
 				Key:   NewScalarRNode("foo"),
 				Value: NewScalarRNode("bar"),
 			},
-			expectedErr: errors.Errorf("wrong Node Kind for  expected: MappingNode was SequenceNode: value: {- foo: baz}"),
+			expectedErr: errors.Errorf(`wrong node kind: expected MappingNode but got SequenceNode: node contents:
+- foo: baz
+`),
 		},
 	}
 	for _, tc := range testCases {
@@ -950,7 +954,7 @@ foo
 	}
 	k, err = instance.Filter(node)
 	if assert.Error(t, err) {
-		assert.Contains(t, err.Error(), "wrong Node Kind")
+		assert.Contains(t, err.Error(), "wrong node kind")
 	}
 	assert.Nil(t, k)
 }
@@ -1009,7 +1013,7 @@ foo: baz
 	if !assert.Error(t, err) {
 		return
 	}
-	assert.Contains(t, err.Error(), "wrong Node Kind")
+	assert.Contains(t, err.Error(), "wrong node kind")
 	assert.Equal(t, `foo: baz
 `, assertNoErrorString(t)(node.String()))
 }
@@ -1029,15 +1033,15 @@ func TestErrorIfInvalid(t *testing.T) {
 	if !assert.Error(t, err) {
 		t.FailNow()
 	}
-	assert.Contains(t, err.Error(), "wrong Node Kind")
+	assert.Contains(t, err.Error(), "wrong node kind")
 
 	err = ErrorIfInvalid(NewRNode(&yaml.Node{}), yaml.SequenceNode)
 	if assert.Error(t, err) {
-		assert.Contains(t, err.Error(), "wrong Node Kind")
+		assert.Contains(t, err.Error(), "wrong node kind")
 	}
 	err = ErrorIfInvalid(NewRNode(&yaml.Node{}), yaml.MappingNode)
 	if assert.Error(t, err) {
-		assert.Contains(t, err.Error(), "wrong Node Kind")
+		assert.Contains(t, err.Error(), "wrong node kind")
 	}
 
 	err = ErrorIfInvalid(NewRNode(&yaml.Node{
@@ -1048,7 +1052,7 @@ func TestErrorIfInvalid(t *testing.T) {
 
 	err = ErrorIfInvalid(NewRNode(&yaml.Node{}), yaml.SequenceNode)
 	if assert.Error(t, err) {
-		assert.Contains(t, err.Error(), "wrong Node Kind")
+		assert.Contains(t, err.Error(), "wrong node kind")
 	}
 
 	err = ErrorIfInvalid(NewRNode(&yaml.Node{

kyaml/yaml/rnode_test.go

@@ -1372,7 +1372,9 @@ spec:
 		{
 			testName: "non mapping node error",
 			input:    `apiVersion`,
-			err:      "wrong Node Kind for  expected: MappingNode was ScalarNode: value: {apiVersion}",
+			err: `wrong node kind: expected MappingNode but got ScalarNode: node contents:
+apiVersion
+`,
 		},
 	}