2887 lines
62 KiB
Go
2887 lines
62 KiB
Go
//
|
|
// Copyright (c) 2011-2019 Canonical Ltd
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package yaml_test
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"os"
|
|
|
|
. "gopkg.in/check.v1"
|
|
"gopkg.in/yaml.v3"
|
|
"io"
|
|
"strings"
|
|
)
|
|
|
|
var nodeTests = []struct {
|
|
yaml string
|
|
node yaml.Node
|
|
}{
|
|
{
|
|
"null\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 1,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Value: "null",
|
|
Tag: "!!null",
|
|
Line: 1,
|
|
Column: 1,
|
|
}},
|
|
},
|
|
}, {
|
|
"[encode]null\n",
|
|
yaml.Node{},
|
|
}, {
|
|
"foo\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 1,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Value: "foo",
|
|
Tag: "!!str",
|
|
Line: 1,
|
|
Column: 1,
|
|
}},
|
|
},
|
|
}, {
|
|
"\"foo\"\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 1,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Style: yaml.DoubleQuotedStyle,
|
|
Value: "foo",
|
|
Tag: "!!str",
|
|
Line: 1,
|
|
Column: 1,
|
|
}},
|
|
},
|
|
}, {
|
|
"'foo'\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 1,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Style: yaml.SingleQuotedStyle,
|
|
Value: "foo",
|
|
Tag: "!!str",
|
|
Line: 1,
|
|
Column: 1,
|
|
}},
|
|
},
|
|
}, {
|
|
"!!str 123\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 1,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Style: yaml.TaggedStyle,
|
|
Value: "123",
|
|
Tag: "!!str",
|
|
Line: 1,
|
|
Column: 1,
|
|
}},
|
|
},
|
|
}, {
|
|
// Although the node isn't TaggedStyle, dropping the tag would change the value.
|
|
"[encode]!!binary gIGC\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 1,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Value: "gIGC",
|
|
Tag: "!!binary",
|
|
Line: 1,
|
|
Column: 1,
|
|
}},
|
|
},
|
|
}, {
|
|
// Item doesn't have a tag, but needs to be binary encoded due to its content.
|
|
"[encode]!!binary gIGC\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 1,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Value: "\x80\x81\x82",
|
|
Line: 1,
|
|
Column: 1,
|
|
}},
|
|
},
|
|
}, {
|
|
// Same, but with strings we can just quote them.
|
|
"[encode]\"123\"\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 1,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Value: "123",
|
|
Tag: "!!str",
|
|
Line: 1,
|
|
Column: 1,
|
|
}},
|
|
},
|
|
}, {
|
|
"!tag:something 123\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 1,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Style: yaml.TaggedStyle,
|
|
Value: "123",
|
|
Tag: "!tag:something",
|
|
Line: 1,
|
|
Column: 1,
|
|
}},
|
|
},
|
|
}, {
|
|
"[encode]!tag:something 123\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 1,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Value: "123",
|
|
Tag: "!tag:something",
|
|
Line: 1,
|
|
Column: 1,
|
|
}},
|
|
},
|
|
}, {
|
|
"!tag:something {}\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 1,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.MappingNode,
|
|
Style: yaml.TaggedStyle | yaml.FlowStyle,
|
|
Tag: "!tag:something",
|
|
Line: 1,
|
|
Column: 1,
|
|
}},
|
|
},
|
|
}, {
|
|
"[encode]!tag:something {}\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 1,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.MappingNode,
|
|
Style: yaml.FlowStyle,
|
|
Tag: "!tag:something",
|
|
Line: 1,
|
|
Column: 1,
|
|
}},
|
|
},
|
|
}, {
|
|
"!tag:something []\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 1,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.SequenceNode,
|
|
Style: yaml.TaggedStyle | yaml.FlowStyle,
|
|
Tag: "!tag:something",
|
|
Line: 1,
|
|
Column: 1,
|
|
}},
|
|
},
|
|
}, {
|
|
"[encode]!tag:something []\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 1,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.SequenceNode,
|
|
Style: yaml.FlowStyle,
|
|
Tag: "!tag:something",
|
|
Line: 1,
|
|
Column: 1,
|
|
}},
|
|
},
|
|
}, {
|
|
"''\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 1,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Style: yaml.SingleQuotedStyle,
|
|
Value: "",
|
|
Tag: "!!str",
|
|
Line: 1,
|
|
Column: 1,
|
|
}},
|
|
},
|
|
}, {
|
|
"|\n foo\n bar\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 1,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Style: yaml.LiteralStyle,
|
|
Value: "foo\nbar\n",
|
|
Tag: "!!str",
|
|
Line: 1,
|
|
Column: 1,
|
|
}},
|
|
},
|
|
}, {
|
|
"true\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 1,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Value: "true",
|
|
Tag: "!!bool",
|
|
Line: 1,
|
|
Column: 1,
|
|
}},
|
|
},
|
|
}, {
|
|
"-10\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 1,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Value: "-10",
|
|
Tag: "!!int",
|
|
Line: 1,
|
|
Column: 1,
|
|
}},
|
|
},
|
|
}, {
|
|
"4294967296\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 1,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Value: "4294967296",
|
|
Tag: "!!int",
|
|
Line: 1,
|
|
Column: 1,
|
|
}},
|
|
},
|
|
}, {
|
|
"0.1000\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 1,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Value: "0.1000",
|
|
Tag: "!!float",
|
|
Line: 1,
|
|
Column: 1,
|
|
}},
|
|
},
|
|
}, {
|
|
"-.inf\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 1,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Value: "-.inf",
|
|
Tag: "!!float",
|
|
Line: 1,
|
|
Column: 1,
|
|
}},
|
|
},
|
|
}, {
|
|
".nan\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 1,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Value: ".nan",
|
|
Tag: "!!float",
|
|
Line: 1,
|
|
Column: 1,
|
|
}},
|
|
},
|
|
}, {
|
|
"{}\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 1,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.MappingNode,
|
|
Style: yaml.FlowStyle,
|
|
Value: "",
|
|
Tag: "!!map",
|
|
Line: 1,
|
|
Column: 1,
|
|
}},
|
|
},
|
|
}, {
|
|
"a: b c\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 1,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.MappingNode,
|
|
Value: "",
|
|
Tag: "!!map",
|
|
Line: 1,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Value: "a",
|
|
Tag: "!!str",
|
|
Line: 1,
|
|
Column: 1,
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Value: "b c",
|
|
Tag: "!!str",
|
|
Line: 1,
|
|
Column: 4,
|
|
}},
|
|
}},
|
|
},
|
|
}, {
|
|
"a:\n b: c\n d: e\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 1,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.MappingNode,
|
|
Tag: "!!map",
|
|
Line: 1,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Value: "a",
|
|
Tag: "!!str",
|
|
Line: 1,
|
|
Column: 1,
|
|
}, {
|
|
Kind: yaml.MappingNode,
|
|
Tag: "!!map",
|
|
Line: 2,
|
|
Column: 3,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Value: "b",
|
|
Tag: "!!str",
|
|
Line: 2,
|
|
Column: 3,
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Value: "c",
|
|
Tag: "!!str",
|
|
Line: 2,
|
|
Column: 6,
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Value: "d",
|
|
Tag: "!!str",
|
|
Line: 3,
|
|
Column: 3,
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Value: "e",
|
|
Tag: "!!str",
|
|
Line: 3,
|
|
Column: 6,
|
|
}},
|
|
}},
|
|
}},
|
|
},
|
|
}, {
|
|
"a:\n - b: c\n d: e\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 1,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.MappingNode,
|
|
Tag: "!!map",
|
|
Line: 1,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Value: "a",
|
|
Tag: "!!str",
|
|
Line: 1,
|
|
Column: 1,
|
|
}, {
|
|
Kind: yaml.SequenceNode,
|
|
Tag: "!!seq",
|
|
Line: 2,
|
|
Column: 3,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.MappingNode,
|
|
Tag: "!!map",
|
|
Line: 2,
|
|
Column: 5,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Value: "b",
|
|
Tag: "!!str",
|
|
Line: 2,
|
|
Column: 5,
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Value: "c",
|
|
Tag: "!!str",
|
|
Line: 2,
|
|
Column: 8,
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Value: "d",
|
|
Tag: "!!str",
|
|
Line: 3,
|
|
Column: 5,
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Value: "e",
|
|
Tag: "!!str",
|
|
Line: 3,
|
|
Column: 8,
|
|
}},
|
|
}},
|
|
}},
|
|
}},
|
|
},
|
|
}, {
|
|
"a: # AI\n - b\nc:\n - d\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 1,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.MappingNode,
|
|
Tag: "!!map",
|
|
Line: 1,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "a",
|
|
LineComment: "# AI",
|
|
Line: 1,
|
|
Column: 1,
|
|
}, {
|
|
Kind: yaml.SequenceNode,
|
|
Tag: "!!seq",
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "b",
|
|
Line: 2,
|
|
Column: 5,
|
|
}},
|
|
Line: 2,
|
|
Column: 3,
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "c",
|
|
Line: 3,
|
|
Column: 1,
|
|
}, {
|
|
Kind: yaml.SequenceNode,
|
|
Tag: "!!seq",
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "d",
|
|
Line: 4,
|
|
Column: 5,
|
|
}},
|
|
Line: 4,
|
|
Column: 3,
|
|
}},
|
|
}},
|
|
},
|
|
}, {
|
|
"[decode]a:\n # HM\n - # HB1\n # HB2\n b: # IB\n c # IC\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 1,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.MappingNode,
|
|
Tag: "!!map",
|
|
Line: 1,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Style: 0x0,
|
|
Tag: "!!str",
|
|
Value: "a",
|
|
Line: 1,
|
|
Column: 1,
|
|
}, {
|
|
Kind: yaml.SequenceNode,
|
|
Tag: "!!seq",
|
|
Line: 3,
|
|
Column: 3,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.MappingNode,
|
|
Tag: "!!map",
|
|
HeadComment: "# HM",
|
|
Line: 5,
|
|
Column: 5,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "b",
|
|
HeadComment: "# HB1\n# HB2",
|
|
LineComment: "# IB",
|
|
Line: 5,
|
|
Column: 5,
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "c",
|
|
LineComment: "# IC",
|
|
Line: 6,
|
|
Column: 7,
|
|
}},
|
|
}},
|
|
}},
|
|
}},
|
|
},
|
|
}, {
|
|
// When encoding the value above, it loses b's inline comment.
|
|
"[encode]a:\n # HM\n - # HB1\n # HB2\n b: c # IC\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 1,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.MappingNode,
|
|
Tag: "!!map",
|
|
Line: 1,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Style: 0x0,
|
|
Tag: "!!str",
|
|
Value: "a",
|
|
Line: 1,
|
|
Column: 1,
|
|
}, {
|
|
Kind: yaml.SequenceNode,
|
|
Tag: "!!seq",
|
|
Line: 3,
|
|
Column: 3,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.MappingNode,
|
|
Tag: "!!map",
|
|
HeadComment: "# HM",
|
|
Line: 5,
|
|
Column: 5,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "b",
|
|
HeadComment: "# HB1\n# HB2",
|
|
LineComment: "# IB",
|
|
Line: 5,
|
|
Column: 5,
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "c",
|
|
LineComment: "# IC",
|
|
Line: 6,
|
|
Column: 7,
|
|
}},
|
|
}},
|
|
}},
|
|
}},
|
|
},
|
|
}, {
|
|
// Multiple cases of comment inlining next to mapping keys.
|
|
"a: | # IA\n str\nb: >- # IB\n str\nc: # IC\n - str\nd: # ID\n str:\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 1,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.MappingNode,
|
|
Tag: "!!map",
|
|
Line: 1,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "a",
|
|
Line: 1,
|
|
Column: 1,
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Style: yaml.LiteralStyle,
|
|
Tag: "!!str",
|
|
Value: "str\n",
|
|
LineComment: "# IA",
|
|
Line: 1,
|
|
Column: 4,
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "b",
|
|
Line: 3,
|
|
Column: 1,
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Style: yaml.FoldedStyle,
|
|
Tag: "!!str",
|
|
Value: "str",
|
|
LineComment: "# IB",
|
|
Line: 3,
|
|
Column: 4,
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "c",
|
|
LineComment: "# IC",
|
|
Line: 5,
|
|
Column: 1,
|
|
}, {
|
|
Kind: yaml.SequenceNode,
|
|
Tag: "!!seq",
|
|
Line: 6,
|
|
Column: 3,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "str",
|
|
Line: 6,
|
|
Column: 5,
|
|
}},
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "d",
|
|
LineComment: "# ID",
|
|
Line: 7,
|
|
Column: 1,
|
|
}, {
|
|
Kind: yaml.MappingNode,
|
|
Tag: "!!map",
|
|
Line: 8,
|
|
Column: 3,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "str",
|
|
Line: 8,
|
|
Column: 3,
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!null",
|
|
Line: 8,
|
|
Column: 7,
|
|
}},
|
|
}},
|
|
}},
|
|
},
|
|
}, {
|
|
// Indentless sequence.
|
|
"[decode]a:\n# HM\n- # HB1\n # HB2\n b: # IB\n c # IC\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 1,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.MappingNode,
|
|
Tag: "!!map",
|
|
Line: 1,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "a",
|
|
Line: 1,
|
|
Column: 1,
|
|
}, {
|
|
Kind: yaml.SequenceNode,
|
|
Tag: "!!seq",
|
|
Line: 3,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.MappingNode,
|
|
Tag: "!!map",
|
|
HeadComment: "# HM",
|
|
Line: 5,
|
|
Column: 3,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "b",
|
|
HeadComment: "# HB1\n# HB2",
|
|
LineComment: "# IB",
|
|
Line: 5,
|
|
Column: 3,
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "c",
|
|
LineComment: "# IC",
|
|
Line: 6,
|
|
Column: 5,
|
|
}},
|
|
}},
|
|
}},
|
|
}},
|
|
},
|
|
}, {
|
|
"- a\n- b\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 1,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.SequenceNode,
|
|
Value: "",
|
|
Tag: "!!seq",
|
|
Line: 1,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Value: "a",
|
|
Tag: "!!str",
|
|
Line: 1,
|
|
Column: 3,
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Value: "b",
|
|
Tag: "!!str",
|
|
Line: 2,
|
|
Column: 3,
|
|
}},
|
|
}},
|
|
},
|
|
}, {
|
|
"- a\n- - b\n - c\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 1,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.SequenceNode,
|
|
Tag: "!!seq",
|
|
Line: 1,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Value: "a",
|
|
Tag: "!!str",
|
|
Line: 1,
|
|
Column: 3,
|
|
}, {
|
|
Kind: yaml.SequenceNode,
|
|
Tag: "!!seq",
|
|
Line: 2,
|
|
Column: 3,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Value: "b",
|
|
Tag: "!!str",
|
|
Line: 2,
|
|
Column: 5,
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Value: "c",
|
|
Tag: "!!str",
|
|
Line: 3,
|
|
Column: 5,
|
|
}},
|
|
}},
|
|
}},
|
|
},
|
|
}, {
|
|
"[a, b]\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 1,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.SequenceNode,
|
|
Style: yaml.FlowStyle,
|
|
Value: "",
|
|
Tag: "!!seq",
|
|
Line: 1,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Value: "a",
|
|
Tag: "!!str",
|
|
Line: 1,
|
|
Column: 2,
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Value: "b",
|
|
Tag: "!!str",
|
|
Line: 1,
|
|
Column: 5,
|
|
}},
|
|
}},
|
|
},
|
|
}, {
|
|
"- a\n- [b, c]\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 1,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.SequenceNode,
|
|
Tag: "!!seq",
|
|
Line: 1,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Value: "a",
|
|
Tag: "!!str",
|
|
Line: 1,
|
|
Column: 3,
|
|
}, {
|
|
Kind: yaml.SequenceNode,
|
|
Tag: "!!seq",
|
|
Style: yaml.FlowStyle,
|
|
Line: 2,
|
|
Column: 3,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Value: "b",
|
|
Tag: "!!str",
|
|
Line: 2,
|
|
Column: 4,
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Value: "c",
|
|
Tag: "!!str",
|
|
Line: 2,
|
|
Column: 7,
|
|
}},
|
|
}},
|
|
}},
|
|
},
|
|
}, {
|
|
"a: &x 1\nb: &y 2\nc: *x\nd: *y\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 1,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.MappingNode,
|
|
Line: 1,
|
|
Column: 1,
|
|
Tag: "!!map",
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Value: "a",
|
|
Tag: "!!str",
|
|
Line: 1,
|
|
Column: 1,
|
|
},
|
|
saveNode("x", &yaml.Node{
|
|
Kind: yaml.ScalarNode,
|
|
Value: "1",
|
|
Tag: "!!int",
|
|
Anchor: "x",
|
|
Line: 1,
|
|
Column: 4,
|
|
}),
|
|
{
|
|
Kind: yaml.ScalarNode,
|
|
Value: "b",
|
|
Tag: "!!str",
|
|
Line: 2,
|
|
Column: 1,
|
|
},
|
|
saveNode("y", &yaml.Node{
|
|
Kind: yaml.ScalarNode,
|
|
Value: "2",
|
|
Tag: "!!int",
|
|
Anchor: "y",
|
|
Line: 2,
|
|
Column: 4,
|
|
}),
|
|
{
|
|
Kind: yaml.ScalarNode,
|
|
Value: "c",
|
|
Tag: "!!str",
|
|
Line: 3,
|
|
Column: 1,
|
|
}, {
|
|
Kind: yaml.AliasNode,
|
|
Value: "x",
|
|
Alias: dropNode("x"),
|
|
Line: 3,
|
|
Column: 4,
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Value: "d",
|
|
Tag: "!!str",
|
|
Line: 4,
|
|
Column: 1,
|
|
}, {
|
|
Kind: yaml.AliasNode,
|
|
Value: "y",
|
|
Tag: "",
|
|
Alias: dropNode("y"),
|
|
Line: 4,
|
|
Column: 4,
|
|
}},
|
|
}},
|
|
},
|
|
}, {
|
|
|
|
"# One\n# Two\ntrue # Three\n# Four\n# Five\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 3,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Value: "true",
|
|
Tag: "!!bool",
|
|
Line: 3,
|
|
Column: 1,
|
|
HeadComment: "# One\n# Two",
|
|
LineComment: "# Three",
|
|
FootComment: "# Four\n# Five",
|
|
}},
|
|
},
|
|
}, {
|
|
|
|
"# š\ntrue # š\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 2,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Value: "true",
|
|
Tag: "!!bool",
|
|
Line: 2,
|
|
Column: 1,
|
|
HeadComment: "# š",
|
|
LineComment: "# š",
|
|
}},
|
|
},
|
|
}, {
|
|
|
|
"[decode]\n# One\n\n# Two\n\n# Three\ntrue # Four\n# Five\n\n# Six\n\n# Seven\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 7,
|
|
Column: 1,
|
|
HeadComment: "# One\n\n# Two",
|
|
FootComment: "# Six\n\n# Seven",
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Value: "true",
|
|
Tag: "!!bool",
|
|
Line: 7,
|
|
Column: 1,
|
|
HeadComment: "# Three",
|
|
LineComment: "# Four",
|
|
FootComment: "# Five",
|
|
}},
|
|
},
|
|
}, {
|
|
// Write out the pound character if missing from comments.
|
|
"[encode]# One\n# Two\ntrue # Three\n# Four\n# Five\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 3,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Value: "true",
|
|
Tag: "!!bool",
|
|
Line: 3,
|
|
Column: 1,
|
|
HeadComment: "One\nTwo\n",
|
|
LineComment: "Three\n",
|
|
FootComment: "Four\nFive\n",
|
|
}},
|
|
},
|
|
}, {
|
|
"[encode]# One\n# Two\ntrue # Three\n# Four\n# Five\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 3,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Value: "true",
|
|
Tag: "!!bool",
|
|
Line: 3,
|
|
Column: 1,
|
|
HeadComment: " One\n Two",
|
|
LineComment: " Three",
|
|
FootComment: " Four\n Five",
|
|
}},
|
|
},
|
|
}, {
|
|
"# DH1\n\n# DH2\n\n# H1\n# H2\ntrue # I\n# F1\n# F2\n\n# DF1\n\n# DF2\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 7,
|
|
Column: 1,
|
|
HeadComment: "# DH1\n\n# DH2",
|
|
FootComment: "# DF1\n\n# DF2",
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Value: "true",
|
|
Tag: "!!bool",
|
|
Line: 7,
|
|
Column: 1,
|
|
HeadComment: "# H1\n# H2",
|
|
LineComment: "# I",
|
|
FootComment: "# F1\n# F2",
|
|
}},
|
|
},
|
|
}, {
|
|
"# DH1\n\n# DH2\n\n# HA1\n# HA2\nka: va # IA\n# FA1\n# FA2\n\n# HB1\n# HB2\nkb: vb # IB\n# FB1\n# FB2\n\n# DF1\n\n# DF2\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 7,
|
|
Column: 1,
|
|
HeadComment: "# DH1\n\n# DH2",
|
|
FootComment: "# DF1\n\n# DF2",
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.MappingNode,
|
|
Tag: "!!map",
|
|
Line: 7,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Line: 7,
|
|
Column: 1,
|
|
Tag: "!!str",
|
|
Value: "ka",
|
|
HeadComment: "# HA1\n# HA2",
|
|
FootComment: "# FA1\n# FA2",
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Line: 7,
|
|
Column: 5,
|
|
Tag: "!!str",
|
|
Value: "va",
|
|
LineComment: "# IA",
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Line: 13,
|
|
Column: 1,
|
|
Tag: "!!str",
|
|
Value: "kb",
|
|
HeadComment: "# HB1\n# HB2",
|
|
FootComment: "# FB1\n# FB2",
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Line: 13,
|
|
Column: 5,
|
|
Tag: "!!str",
|
|
Value: "vb",
|
|
LineComment: "# IB",
|
|
}},
|
|
}},
|
|
},
|
|
}, {
|
|
"# DH1\n\n# DH2\n\n# HA1\n# HA2\n- la # IA\n# FA1\n# FA2\n\n# HB1\n# HB2\n- lb # IB\n# FB1\n# FB2\n\n# DF1\n\n# DF2\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 7,
|
|
Column: 1,
|
|
HeadComment: "# DH1\n\n# DH2",
|
|
FootComment: "# DF1\n\n# DF2",
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.SequenceNode,
|
|
Tag: "!!seq",
|
|
Line: 7,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Line: 7,
|
|
Column: 3,
|
|
Value: "la",
|
|
HeadComment: "# HA1\n# HA2",
|
|
LineComment: "# IA",
|
|
FootComment: "# FA1\n# FA2",
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Line: 13,
|
|
Column: 3,
|
|
Value: "lb",
|
|
HeadComment: "# HB1\n# HB2",
|
|
LineComment: "# IB",
|
|
FootComment: "# FB1\n# FB2",
|
|
}},
|
|
}},
|
|
},
|
|
}, {
|
|
"# DH1\n\n- la # IA\n# HB1\n- lb\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 3,
|
|
Column: 1,
|
|
HeadComment: "# DH1",
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.SequenceNode,
|
|
Tag: "!!seq",
|
|
Line: 3,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Line: 3,
|
|
Column: 3,
|
|
Value: "la",
|
|
LineComment: "# IA",
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Line: 5,
|
|
Column: 3,
|
|
Value: "lb",
|
|
HeadComment: "# HB1",
|
|
}},
|
|
}},
|
|
},
|
|
}, {
|
|
"- la # IA\n- lb # IB\n- lc # IC\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 1,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.SequenceNode,
|
|
Tag: "!!seq",
|
|
Line: 1,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Line: 1,
|
|
Column: 3,
|
|
Value: "la",
|
|
LineComment: "# IA",
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Line: 2,
|
|
Column: 3,
|
|
Value: "lb",
|
|
LineComment: "# IB",
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Line: 3,
|
|
Column: 3,
|
|
Value: "lc",
|
|
LineComment: "# IC",
|
|
}},
|
|
}},
|
|
},
|
|
}, {
|
|
"# DH1\n\n# HL1\n- - la\n # HB1\n - lb\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 4,
|
|
Column: 1,
|
|
HeadComment: "# DH1",
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.SequenceNode,
|
|
Tag: "!!seq",
|
|
Line: 4,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.SequenceNode,
|
|
Tag: "!!seq",
|
|
Line: 4,
|
|
Column: 3,
|
|
HeadComment: "# HL1",
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Line: 4,
|
|
Column: 5,
|
|
Value: "la",
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Line: 6,
|
|
Column: 5,
|
|
Value: "lb",
|
|
HeadComment: "# HB1",
|
|
}},
|
|
}},
|
|
}},
|
|
},
|
|
}, {
|
|
"# DH1\n\n# HL1\n- # HA1\n - la\n # HB1\n - lb\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 4,
|
|
Column: 1,
|
|
HeadComment: "# DH1",
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.SequenceNode,
|
|
Tag: "!!seq",
|
|
Line: 4,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.SequenceNode,
|
|
Tag: "!!seq",
|
|
Line: 5,
|
|
Column: 3,
|
|
HeadComment: "# HL1",
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Line: 5,
|
|
Column: 5,
|
|
Value: "la",
|
|
HeadComment: "# HA1",
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Line: 7,
|
|
Column: 5,
|
|
Value: "lb",
|
|
HeadComment: "# HB1",
|
|
}},
|
|
}},
|
|
}},
|
|
},
|
|
}, {
|
|
"[decode]# DH1\n\n# HL1\n- # HA1\n\n - la\n # HB1\n - lb\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 4,
|
|
Column: 1,
|
|
HeadComment: "# DH1",
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.SequenceNode,
|
|
Tag: "!!seq",
|
|
Line: 4,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.SequenceNode,
|
|
Tag: "!!seq",
|
|
Line: 6,
|
|
Column: 3,
|
|
HeadComment: "# HL1",
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Line: 6,
|
|
Column: 5,
|
|
Value: "la",
|
|
HeadComment: "# HA1\n",
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Line: 8,
|
|
Column: 5,
|
|
Value: "lb",
|
|
HeadComment: "# HB1",
|
|
}},
|
|
}},
|
|
}},
|
|
},
|
|
}, {
|
|
"# DH1\n\n# HA1\nka:\n # HB1\n kb:\n # HC1\n # HC2\n - lc # IC\n # FC1\n # FC2\n\n # HD1\n - ld # ID\n # FD1\n\n# DF1\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 4,
|
|
Column: 1,
|
|
HeadComment: "# DH1",
|
|
FootComment: "# DF1",
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.MappingNode,
|
|
Tag: "!!map",
|
|
Line: 4,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Line: 4,
|
|
Column: 1,
|
|
Value: "ka",
|
|
HeadComment: "# HA1",
|
|
}, {
|
|
Kind: yaml.MappingNode,
|
|
Tag: "!!map",
|
|
Line: 6,
|
|
Column: 3,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Line: 6,
|
|
Column: 3,
|
|
Value: "kb",
|
|
HeadComment: "# HB1",
|
|
}, {
|
|
Kind: yaml.SequenceNode,
|
|
Line: 9,
|
|
Column: 5,
|
|
Tag: "!!seq",
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Line: 9,
|
|
Column: 7,
|
|
Value: "lc",
|
|
HeadComment: "# HC1\n# HC2",
|
|
LineComment: "# IC",
|
|
FootComment: "# FC1\n# FC2",
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Line: 14,
|
|
Column: 7,
|
|
Value: "ld",
|
|
HeadComment: "# HD1",
|
|
|
|
LineComment: "# ID",
|
|
FootComment: "# FD1",
|
|
}},
|
|
}},
|
|
}},
|
|
}},
|
|
},
|
|
}, {
|
|
"# DH1\n\n# HA1\nka:\n # HB1\n kb:\n # HC1\n # HC2\n - lc # IC\n # FC1\n # FC2\n\n # HD1\n - ld # ID\n # FD1\nke: ve\n\n# DF1\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 4,
|
|
Column: 1,
|
|
HeadComment: "# DH1",
|
|
FootComment: "# DF1",
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.MappingNode,
|
|
Tag: "!!map",
|
|
Line: 4,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Line: 4,
|
|
Column: 1,
|
|
Value: "ka",
|
|
HeadComment: "# HA1",
|
|
}, {
|
|
Kind: yaml.MappingNode,
|
|
Tag: "!!map",
|
|
Line: 6,
|
|
Column: 3,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Line: 6,
|
|
Column: 3,
|
|
Value: "kb",
|
|
HeadComment: "# HB1",
|
|
}, {
|
|
Kind: yaml.SequenceNode,
|
|
Line: 9,
|
|
Column: 5,
|
|
Tag: "!!seq",
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Line: 9,
|
|
Column: 7,
|
|
Value: "lc",
|
|
HeadComment: "# HC1\n# HC2",
|
|
LineComment: "# IC",
|
|
FootComment: "# FC1\n# FC2",
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Line: 14,
|
|
Column: 7,
|
|
Value: "ld",
|
|
HeadComment: "# HD1",
|
|
LineComment: "# ID",
|
|
FootComment: "# FD1",
|
|
}},
|
|
}},
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Line: 16,
|
|
Column: 1,
|
|
Value: "ke",
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Line: 16,
|
|
Column: 5,
|
|
Value: "ve",
|
|
}},
|
|
}},
|
|
},
|
|
}, {
|
|
"# DH1\n\n# DH2\n\n# HA1\n# HA2\nka:\n # HB1\n # HB2\n kb:\n" +
|
|
" # HC1\n # HC2\n kc:\n # HD1\n # HD2\n kd: vd\n # FD1\n # FD2\n" +
|
|
" # FC1\n # FC2\n # FB1\n # FB2\n# FA1\n# FA2\n\n# HE1\n# HE2\nke: ve\n# FE1\n# FE2\n\n# DF1\n\n# DF2\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
HeadComment: "# DH1\n\n# DH2",
|
|
FootComment: "# DF1\n\n# DF2",
|
|
Line: 7,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.MappingNode,
|
|
Tag: "!!map",
|
|
Line: 7,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "ka",
|
|
HeadComment: "# HA1\n# HA2",
|
|
FootComment: "# FA1\n# FA2",
|
|
Line: 7,
|
|
Column: 1,
|
|
}, {
|
|
Kind: yaml.MappingNode,
|
|
Tag: "!!map",
|
|
Line: 10,
|
|
Column: 3,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "kb",
|
|
HeadComment: "# HB1\n# HB2",
|
|
FootComment: "# FB1\n# FB2",
|
|
Line: 10,
|
|
Column: 3,
|
|
}, {
|
|
Kind: yaml.MappingNode,
|
|
Tag: "!!map",
|
|
Line: 13,
|
|
Column: 5,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "kc",
|
|
HeadComment: "# HC1\n# HC2",
|
|
FootComment: "# FC1\n# FC2",
|
|
Line: 13,
|
|
Column: 5,
|
|
}, {
|
|
Kind: yaml.MappingNode,
|
|
Tag: "!!map",
|
|
Line: 16,
|
|
Column: 7,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "kd",
|
|
HeadComment: "# HD1\n# HD2",
|
|
FootComment: "# FD1\n# FD2",
|
|
Line: 16,
|
|
Column: 7,
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "vd",
|
|
Line: 16,
|
|
Column: 11,
|
|
}},
|
|
}},
|
|
}},
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "ke",
|
|
HeadComment: "# HE1\n# HE2",
|
|
FootComment: "# FE1\n# FE2",
|
|
Line: 28,
|
|
Column: 1,
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "ve",
|
|
Line: 28,
|
|
Column: 5,
|
|
}},
|
|
}},
|
|
},
|
|
}, {
|
|
// Same as above but indenting ke in so it's also part of ka's value.
|
|
"# DH1\n\n# DH2\n\n# HA1\n# HA2\nka:\n # HB1\n # HB2\n kb:\n" +
|
|
" # HC1\n # HC2\n kc:\n # HD1\n # HD2\n kd: vd\n # FD1\n # FD2\n" +
|
|
" # FC1\n # FC2\n # FB1\n # FB2\n\n # HE1\n # HE2\n ke: ve\n # FE1\n # FE2\n# FA1\n# FA2\n\n# DF1\n\n# DF2\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
HeadComment: "# DH1\n\n# DH2",
|
|
FootComment: "# DF1\n\n# DF2",
|
|
Line: 7,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.MappingNode,
|
|
Tag: "!!map",
|
|
Line: 7,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "ka",
|
|
HeadComment: "# HA1\n# HA2",
|
|
FootComment: "# FA1\n# FA2",
|
|
Line: 7,
|
|
Column: 1,
|
|
}, {
|
|
Kind: yaml.MappingNode,
|
|
Tag: "!!map",
|
|
Line: 10,
|
|
Column: 3,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "kb",
|
|
HeadComment: "# HB1\n# HB2",
|
|
FootComment: "# FB1\n# FB2",
|
|
Line: 10,
|
|
Column: 3,
|
|
}, {
|
|
Kind: yaml.MappingNode,
|
|
Tag: "!!map",
|
|
Line: 13,
|
|
Column: 5,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "kc",
|
|
HeadComment: "# HC1\n# HC2",
|
|
FootComment: "# FC1\n# FC2",
|
|
Line: 13,
|
|
Column: 5,
|
|
}, {
|
|
Kind: yaml.MappingNode,
|
|
Tag: "!!map",
|
|
Line: 16,
|
|
Column: 7,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "kd",
|
|
HeadComment: "# HD1\n# HD2",
|
|
FootComment: "# FD1\n# FD2",
|
|
Line: 16,
|
|
Column: 7,
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "vd",
|
|
Line: 16,
|
|
Column: 11,
|
|
}},
|
|
}},
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "ke",
|
|
HeadComment: "# HE1\n# HE2",
|
|
FootComment: "# FE1\n# FE2",
|
|
Line: 26,
|
|
Column: 3,
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "ve",
|
|
Line: 26,
|
|
Column: 7,
|
|
}},
|
|
}},
|
|
}},
|
|
},
|
|
}, {
|
|
// Decode only due to lack of newline at the end.
|
|
"[decode]# HA1\nka:\n # HB1\n kb: vb\n # FB1\n# FA1",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 2,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.MappingNode,
|
|
Tag: "!!map",
|
|
Line: 2,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "ka",
|
|
HeadComment: "# HA1",
|
|
FootComment: "# FA1",
|
|
Line: 2,
|
|
Column: 1,
|
|
}, {
|
|
Kind: yaml.MappingNode,
|
|
Tag: "!!map",
|
|
Line: 4,
|
|
Column: 3,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "kb",
|
|
HeadComment: "# HB1",
|
|
FootComment: "# FB1",
|
|
Line: 4,
|
|
Column: 3,
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "vb",
|
|
Line: 4,
|
|
Column: 7,
|
|
}},
|
|
}},
|
|
}},
|
|
},
|
|
}, {
|
|
// Same as above, but with newline at the end.
|
|
"# HA1\nka:\n # HB1\n kb: vb\n # FB1\n# FA1\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 2,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.MappingNode,
|
|
Tag: "!!map",
|
|
Line: 2,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "ka",
|
|
HeadComment: "# HA1",
|
|
FootComment: "# FA1",
|
|
Line: 2,
|
|
Column: 1,
|
|
}, {
|
|
Kind: yaml.MappingNode,
|
|
Tag: "!!map",
|
|
Line: 4,
|
|
Column: 3,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "kb",
|
|
HeadComment: "# HB1",
|
|
FootComment: "# FB1",
|
|
Line: 4,
|
|
Column: 3,
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "vb",
|
|
Line: 4,
|
|
Column: 7,
|
|
}},
|
|
}},
|
|
}},
|
|
},
|
|
}, {
|
|
// Same as above, but without FB1.
|
|
"# HA1\nka:\n # HB1\n kb: vb\n# FA1\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 2,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.MappingNode,
|
|
Tag: "!!map",
|
|
Line: 2,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "ka",
|
|
HeadComment: "# HA1",
|
|
FootComment: "# FA1",
|
|
Line: 2,
|
|
Column: 1,
|
|
}, {
|
|
Kind: yaml.MappingNode,
|
|
Tag: "!!map",
|
|
Line: 4,
|
|
Column: 3,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "kb",
|
|
HeadComment: "# HB1",
|
|
Line: 4,
|
|
Column: 3,
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "vb",
|
|
Line: 4,
|
|
Column: 7,
|
|
}},
|
|
}},
|
|
}},
|
|
},
|
|
}, {
|
|
// Same as above, but with two newlines at the end. Decode-only for that.
|
|
"[decode]# HA1\nka:\n # HB1\n kb: vb\n # FB1\n# FA1\n\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 2,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.MappingNode,
|
|
Tag: "!!map",
|
|
Line: 2,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "ka",
|
|
HeadComment: "# HA1",
|
|
FootComment: "# FA1",
|
|
Line: 2,
|
|
Column: 1,
|
|
}, {
|
|
Kind: yaml.MappingNode,
|
|
Tag: "!!map",
|
|
Line: 4,
|
|
Column: 3,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "kb",
|
|
HeadComment: "# HB1",
|
|
FootComment: "# FB1",
|
|
Line: 4,
|
|
Column: 3,
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "vb",
|
|
Line: 4,
|
|
Column: 7,
|
|
}},
|
|
}},
|
|
}},
|
|
},
|
|
}, {
|
|
// Similar to above, but make HB1 look more like a footer of ka.
|
|
"[decode]# HA1\nka:\n# HB1\n\n kb: vb\n# FA1\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 2,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.MappingNode,
|
|
Tag: "!!map",
|
|
Line: 2,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "ka",
|
|
HeadComment: "# HA1",
|
|
FootComment: "# FA1",
|
|
Line: 2,
|
|
Column: 1,
|
|
}, {
|
|
Kind: yaml.MappingNode,
|
|
Tag: "!!map",
|
|
Line: 5,
|
|
Column: 3,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "kb",
|
|
HeadComment: "# HB1\n",
|
|
Line: 5,
|
|
Column: 3,
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "vb",
|
|
Line: 5,
|
|
Column: 7,
|
|
}},
|
|
}},
|
|
}},
|
|
},
|
|
}, {
|
|
"ka:\n kb: vb\n# FA1\n\nkc: vc\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 1,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.MappingNode,
|
|
Tag: "!!map",
|
|
Line: 1,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "ka",
|
|
Line: 1,
|
|
Column: 1,
|
|
FootComment: "# FA1",
|
|
}, {
|
|
Kind: yaml.MappingNode,
|
|
Tag: "!!map",
|
|
Line: 2,
|
|
Column: 3,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "kb",
|
|
Line: 2,
|
|
Column: 3,
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "vb",
|
|
Line: 2,
|
|
Column: 7,
|
|
}},
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "kc",
|
|
Line: 5,
|
|
Column: 1,
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "vc",
|
|
Line: 5,
|
|
Column: 5,
|
|
}},
|
|
}},
|
|
},
|
|
}, {
|
|
"ka:\n kb: vb\n# HC1\nkc: vc\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 1,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.MappingNode,
|
|
Tag: "!!map",
|
|
Line: 1,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "ka",
|
|
Line: 1,
|
|
Column: 1,
|
|
}, {
|
|
Kind: yaml.MappingNode,
|
|
Tag: "!!map",
|
|
Line: 2,
|
|
Column: 3,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "kb",
|
|
Line: 2,
|
|
Column: 3,
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "vb",
|
|
Line: 2,
|
|
Column: 7,
|
|
}},
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "kc",
|
|
HeadComment: "# HC1",
|
|
Line: 4,
|
|
Column: 1,
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "vc",
|
|
Line: 4,
|
|
Column: 5,
|
|
}},
|
|
}},
|
|
},
|
|
}, {
|
|
// Decode only due to empty line before HC1.
|
|
"[decode]ka:\n kb: vb\n\n# HC1\nkc: vc\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 1,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.MappingNode,
|
|
Tag: "!!map",
|
|
Line: 1,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "ka",
|
|
Line: 1,
|
|
Column: 1,
|
|
}, {
|
|
Kind: yaml.MappingNode,
|
|
Tag: "!!map",
|
|
Line: 2,
|
|
Column: 3,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "kb",
|
|
Line: 2,
|
|
Column: 3,
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "vb",
|
|
Line: 2,
|
|
Column: 7,
|
|
}},
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "kc",
|
|
HeadComment: "# HC1",
|
|
Line: 5,
|
|
Column: 1,
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "vc",
|
|
Line: 5,
|
|
Column: 5,
|
|
}},
|
|
}},
|
|
},
|
|
}, {
|
|
// Decode-only due to empty lines around HC1.
|
|
"[decode]ka:\n kb: vb\n\n# HC1\n\nkc: vc\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 1,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.MappingNode,
|
|
Tag: "!!map",
|
|
Line: 1,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "ka",
|
|
Line: 1,
|
|
Column: 1,
|
|
}, {
|
|
Kind: yaml.MappingNode,
|
|
Tag: "!!map",
|
|
Line: 2,
|
|
Column: 3,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "kb",
|
|
Line: 2,
|
|
Column: 3,
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "vb",
|
|
Line: 2,
|
|
Column: 7,
|
|
}},
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "kc",
|
|
HeadComment: "# HC1\n",
|
|
Line: 6,
|
|
Column: 1,
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "vc",
|
|
Line: 6,
|
|
Column: 5,
|
|
}},
|
|
}},
|
|
},
|
|
}, {
|
|
"ka: # IA\n kb: # IB\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 1,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.MappingNode,
|
|
Tag: "!!map",
|
|
Line: 1,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "ka",
|
|
Line: 1,
|
|
Column: 1,
|
|
LineComment: "# IA",
|
|
}, {
|
|
Kind: yaml.MappingNode,
|
|
Tag: "!!map",
|
|
Line: 2,
|
|
Column: 3,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "kb",
|
|
Line: 2,
|
|
Column: 3,
|
|
LineComment: "# IB",
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!null",
|
|
Line: 2,
|
|
Column: 6,
|
|
}},
|
|
}},
|
|
}},
|
|
},
|
|
}, {
|
|
"# HA1\nka:\n # HB1\n kb: vb\n # FB1\n# HC1\n# HC2\nkc: vc\n# FC1\n# FC2\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 2,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.MappingNode,
|
|
Tag: "!!map",
|
|
Line: 2,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "ka",
|
|
HeadComment: "# HA1",
|
|
Line: 2,
|
|
Column: 1,
|
|
}, {
|
|
Kind: yaml.MappingNode,
|
|
Tag: "!!map",
|
|
Line: 4,
|
|
Column: 3,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "kb",
|
|
HeadComment: "# HB1",
|
|
FootComment: "# FB1",
|
|
Line: 4,
|
|
Column: 3,
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "vb",
|
|
Line: 4,
|
|
Column: 7,
|
|
}},
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "kc",
|
|
HeadComment: "# HC1\n# HC2",
|
|
FootComment: "# FC1\n# FC2",
|
|
Line: 8,
|
|
Column: 1,
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "vc",
|
|
Line: 8,
|
|
Column: 5,
|
|
}},
|
|
}},
|
|
},
|
|
}, {
|
|
// Same as above, but decode only due to empty line between ka's value and kc's headers.
|
|
"[decode]# HA1\nka:\n # HB1\n kb: vb\n # FB1\n\n# HC1\n# HC2\nkc: vc\n# FC1\n# FC2\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 2,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.MappingNode,
|
|
Tag: "!!map",
|
|
Line: 2,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "ka",
|
|
HeadComment: "# HA1",
|
|
Line: 2,
|
|
Column: 1,
|
|
}, {
|
|
Kind: yaml.MappingNode,
|
|
Tag: "!!map",
|
|
Line: 4,
|
|
Column: 3,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "kb",
|
|
HeadComment: "# HB1",
|
|
FootComment: "# FB1",
|
|
Line: 4,
|
|
Column: 3,
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "vb",
|
|
Line: 4,
|
|
Column: 7,
|
|
}},
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "kc",
|
|
HeadComment: "# HC1\n# HC2",
|
|
FootComment: "# FC1\n# FC2",
|
|
Line: 9,
|
|
Column: 1,
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "vc",
|
|
Line: 9,
|
|
Column: 5,
|
|
}},
|
|
}},
|
|
},
|
|
}, {
|
|
"# H1\n[la, lb] # I\n# F1\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 2,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.SequenceNode,
|
|
Tag: "!!seq",
|
|
Style: yaml.FlowStyle,
|
|
Line: 2,
|
|
Column: 1,
|
|
HeadComment: "# H1",
|
|
LineComment: "# I",
|
|
FootComment: "# F1",
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Line: 2,
|
|
Column: 2,
|
|
Value: "la",
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Line: 2,
|
|
Column: 6,
|
|
Value: "lb",
|
|
}},
|
|
}},
|
|
},
|
|
}, {
|
|
"# DH1\n\n# SH1\n[\n # HA1\n la, # IA\n # FA1\n\n # HB1\n lb, # IB\n # FB1\n]\n# SF1\n\n# DF1\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 4,
|
|
Column: 1,
|
|
HeadComment: "# DH1",
|
|
FootComment: "# DF1",
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.SequenceNode,
|
|
Tag: "!!seq",
|
|
Style: yaml.FlowStyle,
|
|
Line: 4,
|
|
Column: 1,
|
|
HeadComment: "# SH1",
|
|
FootComment: "# SF1",
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Line: 6,
|
|
Column: 3,
|
|
Value: "la",
|
|
HeadComment: "# HA1",
|
|
LineComment: "# IA",
|
|
FootComment: "# FA1",
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Line: 10,
|
|
Column: 3,
|
|
Value: "lb",
|
|
HeadComment: "# HB1",
|
|
LineComment: "# IB",
|
|
FootComment: "# FB1",
|
|
}},
|
|
}},
|
|
},
|
|
}, {
|
|
// Same as above, but with extra newlines before FB1 and FB2
|
|
"[decode]# DH1\n\n# SH1\n[\n # HA1\n la, # IA\n # FA1\n\n # HB1\n lb, # IB\n\n\n # FB1\n\n# FB2\n]\n# SF1\n\n# DF1\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 4,
|
|
Column: 1,
|
|
HeadComment: "# DH1",
|
|
FootComment: "# DF1",
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.SequenceNode,
|
|
Tag: "!!seq",
|
|
Style: yaml.FlowStyle,
|
|
Line: 4,
|
|
Column: 1,
|
|
HeadComment: "# SH1",
|
|
FootComment: "# SF1",
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Line: 6,
|
|
Column: 3,
|
|
Value: "la",
|
|
HeadComment: "# HA1",
|
|
LineComment: "# IA",
|
|
FootComment: "# FA1",
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Line: 10,
|
|
Column: 3,
|
|
Value: "lb",
|
|
HeadComment: "# HB1",
|
|
LineComment: "# IB",
|
|
FootComment: "# FB1\n\n# FB2",
|
|
}},
|
|
}},
|
|
},
|
|
}, {
|
|
"# DH1\n\n# SH1\n[\n # HA1\n la,\n # FA1\n\n # HB1\n lb,\n # FB1\n]\n# SF1\n\n# DF1\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 4,
|
|
Column: 1,
|
|
HeadComment: "# DH1",
|
|
FootComment: "# DF1",
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.SequenceNode,
|
|
Tag: "!!seq",
|
|
Style: yaml.FlowStyle,
|
|
Line: 4,
|
|
Column: 1,
|
|
HeadComment: "# SH1",
|
|
FootComment: "# SF1",
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Line: 6,
|
|
Column: 3,
|
|
Value: "la",
|
|
HeadComment: "# HA1",
|
|
FootComment: "# FA1",
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Line: 10,
|
|
Column: 3,
|
|
Value: "lb",
|
|
HeadComment: "# HB1",
|
|
FootComment: "# FB1",
|
|
}},
|
|
}},
|
|
},
|
|
}, {
|
|
"ka:\n kb: [\n # HA1\n la,\n # FA1\n\n # HB1\n lb,\n # FB1\n ]\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 1,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.MappingNode,
|
|
Tag: "!!map",
|
|
Line: 1,
|
|
Column: 1,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "ka",
|
|
Line: 1,
|
|
Column: 1,
|
|
}, {
|
|
Kind: 0x4,
|
|
Tag: "!!map",
|
|
Line: 2,
|
|
Column: 3,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "kb",
|
|
Line: 2,
|
|
Column: 3,
|
|
}, {
|
|
Kind: yaml.SequenceNode,
|
|
Style: 0x20,
|
|
Tag: "!!seq",
|
|
Line: 2,
|
|
Column: 7,
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "la",
|
|
HeadComment: "# HA1",
|
|
FootComment: "# FA1",
|
|
Line: 4,
|
|
Column: 5,
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Value: "lb",
|
|
HeadComment: "# HB1",
|
|
FootComment: "# FB1",
|
|
Line: 8,
|
|
Column: 5,
|
|
}},
|
|
}},
|
|
}},
|
|
}},
|
|
},
|
|
}, {
|
|
"# DH1\n\n# MH1\n{\n # HA1\n ka: va, # IA\n # FA1\n\n # HB1\n kb: vb, # IB\n # FB1\n}\n# MF1\n\n# DF1\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 4,
|
|
Column: 1,
|
|
HeadComment: "# DH1",
|
|
FootComment: "# DF1",
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.MappingNode,
|
|
Tag: "!!map",
|
|
Style: yaml.FlowStyle,
|
|
Line: 4,
|
|
Column: 1,
|
|
HeadComment: "# MH1",
|
|
FootComment: "# MF1",
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Line: 6,
|
|
Column: 3,
|
|
Value: "ka",
|
|
HeadComment: "# HA1",
|
|
FootComment: "# FA1",
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Line: 6,
|
|
Column: 7,
|
|
Value: "va",
|
|
LineComment: "# IA",
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Line: 10,
|
|
Column: 3,
|
|
Value: "kb",
|
|
HeadComment: "# HB1",
|
|
FootComment: "# FB1",
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Line: 10,
|
|
Column: 7,
|
|
Value: "vb",
|
|
LineComment: "# IB",
|
|
}},
|
|
}},
|
|
},
|
|
}, {
|
|
"# DH1\n\n# MH1\n{\n # HA1\n ka: va,\n # FA1\n\n # HB1\n kb: vb,\n # FB1\n}\n# MF1\n\n# DF1\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 4,
|
|
Column: 1,
|
|
HeadComment: "# DH1",
|
|
FootComment: "# DF1",
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.MappingNode,
|
|
Tag: "!!map",
|
|
Style: yaml.FlowStyle,
|
|
Line: 4,
|
|
Column: 1,
|
|
HeadComment: "# MH1",
|
|
FootComment: "# MF1",
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Line: 6,
|
|
Column: 3,
|
|
Value: "ka",
|
|
HeadComment: "# HA1",
|
|
FootComment: "# FA1",
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Line: 6,
|
|
Column: 7,
|
|
Value: "va",
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Line: 10,
|
|
Column: 3,
|
|
Value: "kb",
|
|
HeadComment: "# HB1",
|
|
FootComment: "# FB1",
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Line: 10,
|
|
Column: 7,
|
|
Value: "vb",
|
|
}},
|
|
}},
|
|
},
|
|
}, {
|
|
"# DH1\n\n# DH2\n\n# HA1\n# HA2\n- &x la # IA\n# FA1\n# FA2\n\n# HB1\n# HB2\n- *x # IB\n# FB1\n# FB2\n\n# DF1\n\n# DF2\n",
|
|
yaml.Node{
|
|
Kind: yaml.DocumentNode,
|
|
Line: 7,
|
|
Column: 1,
|
|
HeadComment: "# DH1\n\n# DH2",
|
|
FootComment: "# DF1\n\n# DF2",
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.SequenceNode,
|
|
Tag: "!!seq",
|
|
Line: 7,
|
|
Column: 1,
|
|
Content: []*yaml.Node{
|
|
saveNode("x", &yaml.Node{
|
|
Kind: yaml.ScalarNode,
|
|
Tag: "!!str",
|
|
Line: 7,
|
|
Column: 3,
|
|
Value: "la",
|
|
HeadComment: "# HA1\n# HA2",
|
|
LineComment: "# IA",
|
|
FootComment: "# FA1\n# FA2",
|
|
Anchor: "x",
|
|
}), {
|
|
Kind: yaml.AliasNode,
|
|
Line: 13,
|
|
Column: 3,
|
|
Value: "x",
|
|
Alias: dropNode("x"),
|
|
HeadComment: "# HB1\n# HB2",
|
|
LineComment: "# IB",
|
|
FootComment: "# FB1\n# FB2",
|
|
},
|
|
},
|
|
}},
|
|
},
|
|
},
|
|
}
|
|
|
|
func (s *S) TestNodeRoundtrip(c *C) {
|
|
defer os.Setenv("TZ", os.Getenv("TZ"))
|
|
os.Setenv("TZ", "UTC")
|
|
for i, item := range nodeTests {
|
|
c.Logf("test %d: %q", i, item.yaml)
|
|
|
|
if strings.Contains(item.yaml, "#") {
|
|
var buf bytes.Buffer
|
|
fprintComments(&buf, &item.node, " ")
|
|
c.Logf(" expected comments:\n%s", buf.Bytes())
|
|
}
|
|
|
|
decode := true
|
|
encode := true
|
|
|
|
testYaml := item.yaml
|
|
if s := strings.TrimPrefix(testYaml, "[decode]"); s != testYaml {
|
|
encode = false
|
|
testYaml = s
|
|
}
|
|
if s := strings.TrimPrefix(testYaml, "[encode]"); s != testYaml {
|
|
decode = false
|
|
testYaml = s
|
|
}
|
|
|
|
if decode {
|
|
var node yaml.Node
|
|
err := yaml.Unmarshal([]byte(testYaml), &node)
|
|
c.Assert(err, IsNil)
|
|
if strings.Contains(item.yaml, "#") {
|
|
var buf bytes.Buffer
|
|
fprintComments(&buf, &node, " ")
|
|
c.Logf(" obtained comments:\n%s", buf.Bytes())
|
|
}
|
|
c.Assert(&node, DeepEquals, &item.node)
|
|
}
|
|
if encode {
|
|
node := deepCopyNode(&item.node, nil)
|
|
buf := bytes.Buffer{}
|
|
enc := yaml.NewEncoder(&buf)
|
|
enc.SetIndent(2)
|
|
err := enc.Encode(node)
|
|
c.Assert(err, IsNil)
|
|
err = enc.Close()
|
|
c.Assert(err, IsNil)
|
|
c.Assert(buf.String(), Equals, testYaml)
|
|
|
|
// Ensure there were no mutations to the tree.
|
|
c.Assert(node, DeepEquals, &item.node)
|
|
}
|
|
}
|
|
}
|
|
|
|
func deepCopyNode(node *yaml.Node, cache map[*yaml.Node]*yaml.Node) *yaml.Node {
|
|
if n, ok := cache[node]; ok {
|
|
return n
|
|
}
|
|
if cache == nil {
|
|
cache = make(map[*yaml.Node]*yaml.Node)
|
|
}
|
|
copy := *node
|
|
cache[node] = ©
|
|
copy.Content = nil
|
|
for _, elem := range node.Content {
|
|
copy.Content = append(copy.Content, deepCopyNode(elem, cache))
|
|
}
|
|
if node.Alias != nil {
|
|
copy.Alias = deepCopyNode(node.Alias, cache)
|
|
}
|
|
return ©
|
|
}
|
|
|
|
var savedNodes = make(map[string]*yaml.Node)
|
|
|
|
func saveNode(name string, node *yaml.Node) *yaml.Node {
|
|
savedNodes[name] = node
|
|
return node
|
|
}
|
|
|
|
func peekNode(name string) *yaml.Node {
|
|
return savedNodes[name]
|
|
}
|
|
|
|
func dropNode(name string) *yaml.Node {
|
|
node := savedNodes[name]
|
|
delete(savedNodes, name)
|
|
return node
|
|
}
|
|
|
|
var setStringTests = []struct {
|
|
str string
|
|
yaml string
|
|
node yaml.Node
|
|
}{
|
|
{
|
|
"something simple",
|
|
"something simple\n",
|
|
yaml.Node{
|
|
Kind: yaml.ScalarNode,
|
|
Value: "something simple",
|
|
Tag: "!!str",
|
|
},
|
|
}, {
|
|
`"quoted value"`,
|
|
"'\"quoted value\"'\n",
|
|
yaml.Node{
|
|
Kind: yaml.ScalarNode,
|
|
Value: `"quoted value"`,
|
|
Tag: "!!str",
|
|
},
|
|
}, {
|
|
"multi\nline",
|
|
"|-\n multi\n line\n",
|
|
yaml.Node{
|
|
Kind: yaml.ScalarNode,
|
|
Value: "multi\nline",
|
|
Tag: "!!str",
|
|
Style: yaml.LiteralStyle,
|
|
},
|
|
}, {
|
|
"123",
|
|
"\"123\"\n",
|
|
yaml.Node{
|
|
Kind: yaml.ScalarNode,
|
|
Value: "123",
|
|
Tag: "!!str",
|
|
},
|
|
}, {
|
|
"multi\nline\n",
|
|
"|\n multi\n line\n",
|
|
yaml.Node{
|
|
Kind: yaml.ScalarNode,
|
|
Value: "multi\nline\n",
|
|
Tag: "!!str",
|
|
Style: yaml.LiteralStyle,
|
|
},
|
|
}, {
|
|
"\x80\x81\x82",
|
|
"!!binary gIGC\n",
|
|
yaml.Node{
|
|
Kind: yaml.ScalarNode,
|
|
Value: "gIGC",
|
|
Tag: "!!binary",
|
|
},
|
|
},
|
|
}
|
|
|
|
func (s *S) TestSetString(c *C) {
|
|
defer os.Setenv("TZ", os.Getenv("TZ"))
|
|
os.Setenv("TZ", "UTC")
|
|
for i, item := range setStringTests {
|
|
c.Logf("test %d: %q", i, item.str)
|
|
|
|
var node yaml.Node
|
|
|
|
node.SetString(item.str)
|
|
|
|
c.Assert(node, DeepEquals, item.node)
|
|
|
|
buf := bytes.Buffer{}
|
|
enc := yaml.NewEncoder(&buf)
|
|
enc.SetIndent(2)
|
|
err := enc.Encode(&item.node)
|
|
c.Assert(err, IsNil)
|
|
err = enc.Close()
|
|
c.Assert(err, IsNil)
|
|
c.Assert(buf.String(), Equals, item.yaml)
|
|
|
|
var doc yaml.Node
|
|
err = yaml.Unmarshal([]byte(item.yaml), &doc)
|
|
c.Assert(err, IsNil)
|
|
|
|
var str string
|
|
err = node.Decode(&str)
|
|
c.Assert(err, IsNil)
|
|
c.Assert(str, Equals, item.str)
|
|
}
|
|
}
|
|
|
|
var nodeEncodeDecodeTests = []struct {
|
|
value interface{}
|
|
yaml string
|
|
node yaml.Node
|
|
}{{
|
|
"something simple",
|
|
"something simple\n",
|
|
yaml.Node{
|
|
Kind: yaml.ScalarNode,
|
|
Value: "something simple",
|
|
Tag: "!!str",
|
|
},
|
|
}, {
|
|
`"quoted value"`,
|
|
"'\"quoted value\"'\n",
|
|
yaml.Node{
|
|
Kind: yaml.ScalarNode,
|
|
Style: yaml.SingleQuotedStyle,
|
|
Value: `"quoted value"`,
|
|
Tag: "!!str",
|
|
},
|
|
}, {
|
|
123,
|
|
"123",
|
|
yaml.Node{
|
|
Kind: yaml.ScalarNode,
|
|
Value: `123`,
|
|
Tag: "!!int",
|
|
},
|
|
}, {
|
|
[]interface{}{1, 2},
|
|
"[1, 2]",
|
|
yaml.Node{
|
|
Kind: yaml.SequenceNode,
|
|
Tag: "!!seq",
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Value: "1",
|
|
Tag: "!!int",
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Value: "2",
|
|
Tag: "!!int",
|
|
}},
|
|
},
|
|
}, {
|
|
map[string]interface{}{"a": "b"},
|
|
"a: b",
|
|
yaml.Node{
|
|
Kind: yaml.MappingNode,
|
|
Tag: "!!map",
|
|
Content: []*yaml.Node{{
|
|
Kind: yaml.ScalarNode,
|
|
Value: "a",
|
|
Tag: "!!str",
|
|
}, {
|
|
Kind: yaml.ScalarNode,
|
|
Value: "b",
|
|
Tag: "!!str",
|
|
}},
|
|
},
|
|
}}
|
|
|
|
func (s *S) TestNodeEncodeDecode(c *C) {
|
|
for i, item := range nodeEncodeDecodeTests {
|
|
c.Logf("Encode/Decode test value #%d: %#v", i, item.value)
|
|
|
|
var v interface{}
|
|
err := item.node.Decode(&v)
|
|
c.Assert(err, IsNil)
|
|
c.Assert(v, DeepEquals, item.value)
|
|
|
|
var n yaml.Node
|
|
err = n.Encode(item.value)
|
|
c.Assert(err, IsNil)
|
|
c.Assert(n, DeepEquals, item.node)
|
|
}
|
|
}
|
|
|
|
func (s *S) TestNodeZeroEncodeDecode(c *C) {
|
|
// Zero node value behaves as nil when encoding...
|
|
var n yaml.Node
|
|
data, err := yaml.Marshal(&n)
|
|
c.Assert(err, IsNil)
|
|
c.Assert(string(data), Equals, "null\n")
|
|
|
|
// ... and decoding.
|
|
var v *struct{} = &struct{}{}
|
|
c.Assert(n.Decode(&v), IsNil)
|
|
c.Assert(v, IsNil)
|
|
|
|
// ... and even when looking for its tag.
|
|
c.Assert(n.ShortTag(), Equals, "!!null")
|
|
|
|
// Kind zero is still unknown, though.
|
|
n.Line = 1
|
|
_, err = yaml.Marshal(&n)
|
|
c.Assert(err, ErrorMatches, "yaml: cannot encode node with unknown kind 0")
|
|
c.Assert(n.Decode(&v), ErrorMatches, "yaml: cannot decode node with unknown kind 0")
|
|
}
|
|
|
|
func (s *S) TestNodeOmitEmpty(c *C) {
|
|
var v struct {
|
|
A int
|
|
B yaml.Node ",omitempty"
|
|
}
|
|
v.A = 1
|
|
data, err := yaml.Marshal(&v)
|
|
c.Assert(err, IsNil)
|
|
c.Assert(string(data), Equals, "a: 1\n")
|
|
|
|
v.B.Line = 1
|
|
_, err = yaml.Marshal(&v)
|
|
c.Assert(err, ErrorMatches, "yaml: cannot encode node with unknown kind 0")
|
|
}
|
|
|
|
func fprintComments(out io.Writer, node *yaml.Node, indent string) {
|
|
switch node.Kind {
|
|
case yaml.ScalarNode:
|
|
fmt.Fprintf(out, "%s<%s> ", indent, node.Value)
|
|
fprintCommentSet(out, node)
|
|
fmt.Fprintf(out, "\n")
|
|
case yaml.DocumentNode:
|
|
fmt.Fprintf(out, "%s<DOC> ", indent)
|
|
fprintCommentSet(out, node)
|
|
fmt.Fprintf(out, "\n")
|
|
for i := 0; i < len(node.Content); i++ {
|
|
fprintComments(out, node.Content[i], indent+" ")
|
|
}
|
|
case yaml.MappingNode:
|
|
fmt.Fprintf(out, "%s<MAP> ", indent)
|
|
fprintCommentSet(out, node)
|
|
fmt.Fprintf(out, "\n")
|
|
for i := 0; i < len(node.Content); i += 2 {
|
|
fprintComments(out, node.Content[i], indent+" ")
|
|
fprintComments(out, node.Content[i+1], indent+" ")
|
|
}
|
|
case yaml.SequenceNode:
|
|
fmt.Fprintf(out, "%s<SEQ> ", indent)
|
|
fprintCommentSet(out, node)
|
|
fmt.Fprintf(out, "\n")
|
|
for i := 0; i < len(node.Content); i++ {
|
|
fprintComments(out, node.Content[i], indent+" ")
|
|
}
|
|
}
|
|
}
|
|
|
|
func fprintCommentSet(out io.Writer, node *yaml.Node) {
|
|
if len(node.HeadComment)+len(node.LineComment)+len(node.FootComment) > 0 {
|
|
fmt.Fprintf(out, "%q / %q / %q", node.HeadComment, node.LineComment, node.FootComment)
|
|
}
|
|
}
|