> }) => {
const { setVisibility } = props;
if (isXS()) {
return (
{
setVisibility('visible');
}}>
)
}
return (
}
onClick={() => {
setVisibility('visible');
}}
>
Share
)
}
const GitHubLink = () => {
if (isXS()) {
return (
)
}
return (
)
};
const TabPanel = (props: { children: any, value: number, index: number }) => {
const { children, value, index, ...other } = props;
return (
{value === index && (
{children}
)}
);
}
const TerminalComponent = (v: any) => {
const terminalRef = useRef(null)
const [terminalInstance, setTerminalInstance] = useState(null)
const fitAddon = new FitAddon();
const out = v.out;
useEffect(() => {
const instance = new Terminal({
cursorInactiveStyle: 'none',
cursorStyle: 'bar',
letterSpacing: 4,
fontFamily: 'monospace',
fontSize: 16,
fontWeightBold: 'bold',
convertEol: true,
theme: {
background: themeBlack,
cursor: themeBlack,
brightRed: '#da433a',
},
});
instance.loadAddon(fitAddon);
if (terminalRef.current) {
instance.open(terminalRef.current)
}
setTerminalInstance(instance)
return () => {
instance.dispose()
setTerminalInstance(null)
}
}, [
terminalRef,
]);
useEffect(() => {
if (!terminalInstance) {
return;
}
terminalInstance.loadAddon(fitAddon);
fitAddon.fit();
terminalInstance.clear();
terminalInstance.writeln(out);
const handleResize = () => fitAddon.fit()
window.addEventListener('resize', handleResize)
return () => {
window.removeEventListener('resize', handleResize);
}
}, [terminalRef, terminalInstance, out]);
return (
)
}
const CustomTooltip = styled(({ className, ...props }: TooltipProps) => (
))({
[`& .${tooltipClasses.tooltip}`]: {
fontSize: 16,
whiteSpace: 'pre-wrap',
},
});
const EmptyTokenContainer = () => {
return (
)
};
const TokenContainer = ({ children }: { children: any }) => {
return (
{children}
)
};
const Lexer = (v: any) => {
if (!v.tokens) {
return
}
const tokens = v.tokens as Token[];
return (
<>
{
tokens.map((tk, idx) => {
if (tokens.length > idx + 1) {
return tokenToComponent(tk, tokens[idx + 1]);
}
return tokenToComponent(tk, null)
})
}
)
};
const groupedTokenToComponent = (g: GroupedToken, groups: string[]) => {
if (g.token) {
return tokenToComponentWithoutTip(g.token);
}
return groupTokenToComponent(g.group, groups);
};
const tokenGroupToKey = (g: TokenGroup): string => {
return g.type + g.tokens.map(tk => groupedTokenToKey(tk)).join('-');
};
const groupedTokenToKey = (g: GroupedToken): string => {
if (g.group) {
return tokenGroupToKey(g.group)
}
return `${g.token.offset}`
}
const groupTokenToComponent = (g: TokenGroup, groups: string[]) => {
if (!g) {
return <>
}
const groupColor = () => {
switch (g.type) {
case "directive":
return "dimgray";
case "directive_name":
return "orange"
case "document":
return "hotpink";
case "document_body":
return "olive"
case "anchor":
return "deepskyblue";
case "anchor_name":
return "brown"
case "alias":
return "limegreen";
case "literal":
return "gold"
case "folded":
return "gold"
case "scalar_tag":
return "blueviolet";
case "map_key":
return "coral";
case "map_key_value":
return "teal"
}
return 'white';
}
const newGroups = [...groups, g.type];
return (
')}
>
{
g.tokens.map(tk => {
return groupedTokenToComponent(tk, newGroups);
})
}
)
};
const tokenToComponent = (tk: Token, nextTk: Token | null) => {
if (!tk) {
return <>
}
const orgs = tk.origin.split('\n').map((v, idx) => {
if (idx > 0) {
return ["\n", v];
}
return v;
});
const color = () => {
if (nextTk && nextTk.type === 'MappingValue') {
return '#008b8b';
}
switch (tk.type) {
case "String":
return '#ff7f50';
}
return 'black';
};
const prop = `type: ${tk.type}
origin: ${JSON.stringify(tk.origin)}
value: ${JSON.stringify(tk.value)}
line: ${tk.line}
column: ${tk.column}
`
return (
{
orgs.map((v, index) => {
return (
{v}
)
})
}
)
};
const tokenToComponentWithoutTip = (tk: Token) => {
if (!tk) {
return <>
}
const orgs = tk.origin.split('\n').map((v, idx) => {
if (idx > 0) {
return ["\n", v];
}
return v;
});
return (
{
orgs.map((v, index) => {
return (
{v}
)
})
}
)
};
const ParserGroup = (v: any) => {
if (!v.tokens) {
return
}
const tokens = v.tokens as GroupedToken[];
return (
{
tokens.map(tk => { return groupedTokenToComponent(tk, []); })
}
)
};
const AST = (v: any) => {
if (!v || !v.svg) {
return
}
const parser = new DOMParser()
const dom = parser.parseFromString(v.svg, 'text/xml');
const g = dom.getElementById('graph0');
if (!g) {
return
}
const viewBox = g.parentElement!.getAttribute('viewBox')!;
return (
)
}
function App() {
const [content, setContent] = useState('');
const editorRef = useRef(null);
const workerRef = useRef(null);
const [tokens, setTokens] = useState([]);
const [groupedTokens, setGroupedTokens] = useState([]);
const [out, setOut] = useState('');
const [svg, setSvg] = useState('');
const [tabIndex, setTabIndex] = useState(0);
useEffect(() => {
workerRef.current = new yamlWorker();
workerRef.current.onmessage = (event) => {
const v = event.data as YAMLProcessResult;
switch (v.type) {
case YAMLProcessResultType.Decode:
setOut(v.result as string);
break;
case YAMLProcessResultType.Lexer:
if (typeof v.result === 'string') {
console.error(v.result);
} else {
setTokens(v.result as Token[]);
}
break;
case YAMLProcessResultType.ParserGroup:
if (typeof v.result === 'string') {
console.error(v.result);
} else {
setGroupedTokens(v.result as GroupedToken[]);
}
break;
case YAMLProcessResultType.Parser:
setSvg(v.result as string);
break;
default:
break;
}
}
return () => {
workerRef.current?.terminate();
};
}, []);
const onCodeChange = () => {
if (!editorRef || !editorRef.current) {
return
}
const code = editorRef.current.getValue()!;
setContent(code);
if (workerRef.current) {
workerRef.current.postMessage({
code: code,
tabIndex: tabIndex,
});
}
};
loader.init().then((monaco) => {
monaco.editor.defineTheme('go-yaml-theme', {
base: 'vs-dark',
inherit: true,
rules: [],
colors: {
'editor.background': themeBlack,
'editor.selectionHighlightBorder': themeBlack,
'editor.lineHighlightBackground': themeBlack,
'editor.selectionBackground': themeBlack,
},
});
});
const search = window.location.search;
const yamlDataBinary = new URLSearchParams(search).get('content');
const onMount = (editor: editor.IStandaloneCodeEditor) => {
editorRef.current = editor;
if (yamlDataBinary) {
const code = atob(yamlDataBinary)
editor.setValue(code);
setContent(code);
if (workerRef.current) {
workerRef.current.postMessage({
code: code,
tabIndex: tabIndex,
});
}
}
};
const onTabChange = (_: React.SyntheticEvent, newValue: number) => {
setTabIndex(newValue);
if (workerRef.current) {
workerRef.current.postMessage({
code: content,
tabIndex: newValue,
});
}
};
const tabProps = (index: number) => {
return {
id: `simple-tab-${index}`,
'aria-controls': `simple-tabpanel-${index}`,
};
};
return (
<>
} iconPosition="end" style={{ marginLeft: 20 }} label="OUTPUT" {...tabProps(0)} />
} iconPosition="end" style={{ marginLeft: 0 }} label="AST" {...tabProps(1)} />
} iconPosition="end" style={{ marginLeft: 0 }} label="GROUPED TOKENS" {...tabProps(2)} />
)
}
export default App
goccy-go-yaml-52dacb8/docs/playground/src/YAML.ts 0000664 0000000 0000000 00000003116 15015766371 0021704 0 ustar 00root root 0000000 0000000 import init from './yaml.wasm?init';
export interface GoValueType {
response: string
error: string
}
export interface YAMLGoFuncMap {
decode: (v: string) => GoValueType;
tokenize: (v: string) => GoValueType;
parseGroup: (v: string) => GoValueType;
parse: (v: string) => GoValueType;
}
export interface YAMLFuncMap {
decode: (code: string) => Promise
tokenize: (code: string) => Promise
parseGroup: (code: string) => Promise
parse: (code: string) => Promise
}
export enum YAMLProcessResultType {
Decode,
Lexer,
ParserGroup,
Parser,
}
export interface YAMLProcessResult {
type: YAMLProcessResultType
result: Token[] | GroupedToken[] | string
}
export interface Token {
type: string
value: string
origin: string
error: string
line: number
column: number
offset: number
}
export interface GroupedToken {
token: Token
group: TokenGroup
lineComment: Token
}
export interface TokenGroup {
type: string
tokens: GroupedToken[]
}
declare function decode(v: string): GoValueType;
declare function tokenize(v: string): GoValueType;
declare function parseGroup(v: string): GoValueType;
declare function parse(v: string): GoValueType;
export const initWASM = async (): Promise => {
const go = new Go();
return new Promise(resolve => {
init(
go.importObject,
).then((instance) => {
go.run(instance);
resolve({
decode: decode,
tokenize: tokenize,
parseGroup: parseGroup,
parse: parse,
});
});
});
}; goccy-go-yaml-52dacb8/docs/playground/src/index.css 0000664 0000000 0000000 00000000201 15015766371 0022403 0 ustar 00root root 0000000 0000000 body {
margin: 0;
display: flex;
place-items: center;
min-width: 320px;
min-height: 100vh;
background-color: white;
} goccy-go-yaml-52dacb8/docs/playground/src/main.tsx 0000664 0000000 0000000 00000000346 15015766371 0022260 0 ustar 00root root 0000000 0000000 import { StrictMode } from 'react'
import { createRoot } from 'react-dom/client'
import './index.css'
import App from './App.tsx'
createRoot(document.getElementById('root')!).render(
,
)
goccy-go-yaml-52dacb8/docs/playground/src/vite-env.d.ts 0000664 0000000 0000000 00000000127 15015766371 0023120 0 ustar 00root root 0000000 0000000 ///
/// goccy-go-yaml-52dacb8/docs/playground/src/wasm_exec.js 0000664 0000000 0000000 00000041140 15015766371 0023102 0 ustar 00root root 0000000 0000000 // Copyright 2018 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
"use strict";
(() => {
const enosys = () => {
const err = new Error("not implemented");
err.code = "ENOSYS";
return err;
};
if (!globalThis.fs) {
let outputBuf = "";
globalThis.fs = {
constants: { O_WRONLY: -1, O_RDWR: -1, O_CREAT: -1, O_TRUNC: -1, O_APPEND: -1, O_EXCL: -1, O_DIRECTORY: -1 }, // unused
writeSync(fd, buf) {
outputBuf += decoder.decode(buf);
const nl = outputBuf.lastIndexOf("\n");
if (nl != -1) {
console.log(outputBuf.substring(0, nl));
outputBuf = outputBuf.substring(nl + 1);
}
return buf.length;
},
write(fd, buf, offset, length, position, callback) {
if (offset !== 0 || length !== buf.length || position !== null) {
callback(enosys());
return;
}
const n = this.writeSync(fd, buf);
callback(null, n);
},
chmod(path, mode, callback) { callback(enosys()); },
chown(path, uid, gid, callback) { callback(enosys()); },
close(fd, callback) { callback(enosys()); },
fchmod(fd, mode, callback) { callback(enosys()); },
fchown(fd, uid, gid, callback) { callback(enosys()); },
fstat(fd, callback) { callback(enosys()); },
fsync(fd, callback) { callback(null); },
ftruncate(fd, length, callback) { callback(enosys()); },
lchown(path, uid, gid, callback) { callback(enosys()); },
link(path, link, callback) { callback(enosys()); },
lstat(path, callback) { callback(enosys()); },
mkdir(path, perm, callback) { callback(enosys()); },
open(path, flags, mode, callback) { callback(enosys()); },
read(fd, buffer, offset, length, position, callback) { callback(enosys()); },
readdir(path, callback) { callback(enosys()); },
readlink(path, callback) { callback(enosys()); },
rename(from, to, callback) { callback(enosys()); },
rmdir(path, callback) { callback(enosys()); },
stat(path, callback) { callback(enosys()); },
symlink(path, link, callback) { callback(enosys()); },
truncate(path, length, callback) { callback(enosys()); },
unlink(path, callback) { callback(enosys()); },
utimes(path, atime, mtime, callback) { callback(enosys()); },
};
}
if (!globalThis.process) {
globalThis.process = {
getuid() { return -1; },
getgid() { return -1; },
geteuid() { return -1; },
getegid() { return -1; },
getgroups() { throw enosys(); },
pid: -1,
ppid: -1,
umask() { throw enosys(); },
cwd() { throw enosys(); },
chdir() { throw enosys(); },
}
}
if (!globalThis.path) {
globalThis.path = {
resolve(...pathSegments) {
return pathSegments.join("/");
}
}
}
if (!globalThis.crypto) {
throw new Error("globalThis.crypto is not available, polyfill required (crypto.getRandomValues only)");
}
if (!globalThis.performance) {
throw new Error("globalThis.performance is not available, polyfill required (performance.now only)");
}
if (!globalThis.TextEncoder) {
throw new Error("globalThis.TextEncoder is not available, polyfill required");
}
if (!globalThis.TextDecoder) {
throw new Error("globalThis.TextDecoder is not available, polyfill required");
}
const encoder = new TextEncoder("utf-8");
const decoder = new TextDecoder("utf-8");
globalThis.Go = class {
constructor() {
this.argv = ["js"];
this.env = {};
this.exit = (code) => {
if (code !== 0) {
console.warn("exit code:", code);
}
};
this._exitPromise = new Promise((resolve) => {
this._resolveExitPromise = resolve;
});
this._pendingEvent = null;
this._scheduledTimeouts = new Map();
this._nextCallbackTimeoutID = 1;
const setInt64 = (addr, v) => {
this.mem.setUint32(addr + 0, v, true);
this.mem.setUint32(addr + 4, Math.floor(v / 4294967296), true);
}
const setInt32 = (addr, v) => {
this.mem.setUint32(addr + 0, v, true);
}
const getInt64 = (addr) => {
const low = this.mem.getUint32(addr + 0, true);
const high = this.mem.getInt32(addr + 4, true);
return low + high * 4294967296;
}
const loadValue = (addr) => {
const f = this.mem.getFloat64(addr, true);
if (f === 0) {
return undefined;
}
if (!isNaN(f)) {
return f;
}
const id = this.mem.getUint32(addr, true);
return this._values[id];
}
const storeValue = (addr, v) => {
const nanHead = 0x7FF80000;
if (typeof v === "number" && v !== 0) {
if (isNaN(v)) {
this.mem.setUint32(addr + 4, nanHead, true);
this.mem.setUint32(addr, 0, true);
return;
}
this.mem.setFloat64(addr, v, true);
return;
}
if (v === undefined) {
this.mem.setFloat64(addr, 0, true);
return;
}
let id = this._ids.get(v);
if (id === undefined) {
id = this._idPool.pop();
if (id === undefined) {
id = this._values.length;
}
this._values[id] = v;
this._goRefCounts[id] = 0;
this._ids.set(v, id);
}
this._goRefCounts[id]++;
let typeFlag = 0;
switch (typeof v) {
case "object":
if (v !== null) {
typeFlag = 1;
}
break;
case "string":
typeFlag = 2;
break;
case "symbol":
typeFlag = 3;
break;
case "function":
typeFlag = 4;
break;
}
this.mem.setUint32(addr + 4, nanHead | typeFlag, true);
this.mem.setUint32(addr, id, true);
}
const loadSlice = (addr) => {
const array = getInt64(addr + 0);
const len = getInt64(addr + 8);
return new Uint8Array(this._inst.exports.mem.buffer, array, len);
}
const loadSliceOfValues = (addr) => {
const array = getInt64(addr + 0);
const len = getInt64(addr + 8);
const a = new Array(len);
for (let i = 0; i < len; i++) {
a[i] = loadValue(array + i * 8);
}
return a;
}
const loadString = (addr) => {
const saddr = getInt64(addr + 0);
const len = getInt64(addr + 8);
return decoder.decode(new DataView(this._inst.exports.mem.buffer, saddr, len));
}
const testCallExport = (a, b) => {
this._inst.exports.testExport0();
return this._inst.exports.testExport(a, b);
}
const timeOrigin = Date.now() - performance.now();
this.importObject = {
_gotest: {
add: (a, b) => a + b,
callExport: testCallExport,
},
gojs: {
// Go's SP does not change as long as no Go code is running. Some operations (e.g. calls, getters and setters)
// may synchronously trigger a Go event handler. This makes Go code get executed in the middle of the imported
// function. A goroutine can switch to a new stack if the current stack is too small (see morestack function).
// This changes the SP, thus we have to update the SP used by the imported function.
// func wasmExit(code int32)
"runtime.wasmExit": (sp) => {
sp >>>= 0;
const code = this.mem.getInt32(sp + 8, true);
this.exited = true;
delete this._inst;
delete this._values;
delete this._goRefCounts;
delete this._ids;
delete this._idPool;
this.exit(code);
},
// func wasmWrite(fd uintptr, p unsafe.Pointer, n int32)
"runtime.wasmWrite": (sp) => {
sp >>>= 0;
const fd = getInt64(sp + 8);
const p = getInt64(sp + 16);
const n = this.mem.getInt32(sp + 24, true);
fs.writeSync(fd, new Uint8Array(this._inst.exports.mem.buffer, p, n));
},
// func resetMemoryDataView()
"runtime.resetMemoryDataView": (sp) => {
sp >>>= 0;
this.mem = new DataView(this._inst.exports.mem.buffer);
},
// func nanotime1() int64
"runtime.nanotime1": (sp) => {
sp >>>= 0;
setInt64(sp + 8, (timeOrigin + performance.now()) * 1000000);
},
// func walltime() (sec int64, nsec int32)
"runtime.walltime": (sp) => {
sp >>>= 0;
const msec = (new Date).getTime();
setInt64(sp + 8, msec / 1000);
this.mem.setInt32(sp + 16, (msec % 1000) * 1000000, true);
},
// func scheduleTimeoutEvent(delay int64) int32
"runtime.scheduleTimeoutEvent": (sp) => {
sp >>>= 0;
const id = this._nextCallbackTimeoutID;
this._nextCallbackTimeoutID++;
this._scheduledTimeouts.set(id, setTimeout(
() => {
this._resume();
while (this._scheduledTimeouts.has(id)) {
// for some reason Go failed to register the timeout event, log and try again
// (temporary workaround for https://github.com/golang/go/issues/28975)
console.warn("scheduleTimeoutEvent: missed timeout event");
this._resume();
}
},
getInt64(sp + 8),
));
this.mem.setInt32(sp + 16, id, true);
},
// func clearTimeoutEvent(id int32)
"runtime.clearTimeoutEvent": (sp) => {
sp >>>= 0;
const id = this.mem.getInt32(sp + 8, true);
clearTimeout(this._scheduledTimeouts.get(id));
this._scheduledTimeouts.delete(id);
},
// func getRandomData(r []byte)
"runtime.getRandomData": (sp) => {
sp >>>= 0;
crypto.getRandomValues(loadSlice(sp + 8));
},
// func finalizeRef(v ref)
"syscall/js.finalizeRef": (sp) => {
sp >>>= 0;
const id = this.mem.getUint32(sp + 8, true);
this._goRefCounts[id]--;
if (this._goRefCounts[id] === 0) {
const v = this._values[id];
this._values[id] = null;
this._ids.delete(v);
this._idPool.push(id);
}
},
// func stringVal(value string) ref
"syscall/js.stringVal": (sp) => {
sp >>>= 0;
storeValue(sp + 24, loadString(sp + 8));
},
// func valueGet(v ref, p string) ref
"syscall/js.valueGet": (sp) => {
sp >>>= 0;
const result = Reflect.get(loadValue(sp + 8), loadString(sp + 16));
sp = this._inst.exports.getsp() >>> 0; // see comment above
storeValue(sp + 32, result);
},
// func valueSet(v ref, p string, x ref)
"syscall/js.valueSet": (sp) => {
sp >>>= 0;
Reflect.set(loadValue(sp + 8), loadString(sp + 16), loadValue(sp + 32));
},
// func valueDelete(v ref, p string)
"syscall/js.valueDelete": (sp) => {
sp >>>= 0;
Reflect.deleteProperty(loadValue(sp + 8), loadString(sp + 16));
},
// func valueIndex(v ref, i int) ref
"syscall/js.valueIndex": (sp) => {
sp >>>= 0;
storeValue(sp + 24, Reflect.get(loadValue(sp + 8), getInt64(sp + 16)));
},
// valueSetIndex(v ref, i int, x ref)
"syscall/js.valueSetIndex": (sp) => {
sp >>>= 0;
Reflect.set(loadValue(sp + 8), getInt64(sp + 16), loadValue(sp + 24));
},
// func valueCall(v ref, m string, args []ref) (ref, bool)
"syscall/js.valueCall": (sp) => {
sp >>>= 0;
try {
const v = loadValue(sp + 8);
const m = Reflect.get(v, loadString(sp + 16));
const args = loadSliceOfValues(sp + 32);
const result = Reflect.apply(m, v, args);
sp = this._inst.exports.getsp() >>> 0; // see comment above
storeValue(sp + 56, result);
this.mem.setUint8(sp + 64, 1);
} catch (err) {
sp = this._inst.exports.getsp() >>> 0; // see comment above
storeValue(sp + 56, err);
this.mem.setUint8(sp + 64, 0);
}
},
// func valueInvoke(v ref, args []ref) (ref, bool)
"syscall/js.valueInvoke": (sp) => {
sp >>>= 0;
try {
const v = loadValue(sp + 8);
const args = loadSliceOfValues(sp + 16);
const result = Reflect.apply(v, undefined, args);
sp = this._inst.exports.getsp() >>> 0; // see comment above
storeValue(sp + 40, result);
this.mem.setUint8(sp + 48, 1);
} catch (err) {
sp = this._inst.exports.getsp() >>> 0; // see comment above
storeValue(sp + 40, err);
this.mem.setUint8(sp + 48, 0);
}
},
// func valueNew(v ref, args []ref) (ref, bool)
"syscall/js.valueNew": (sp) => {
sp >>>= 0;
try {
const v = loadValue(sp + 8);
const args = loadSliceOfValues(sp + 16);
const result = Reflect.construct(v, args);
sp = this._inst.exports.getsp() >>> 0; // see comment above
storeValue(sp + 40, result);
this.mem.setUint8(sp + 48, 1);
} catch (err) {
sp = this._inst.exports.getsp() >>> 0; // see comment above
storeValue(sp + 40, err);
this.mem.setUint8(sp + 48, 0);
}
},
// func valueLength(v ref) int
"syscall/js.valueLength": (sp) => {
sp >>>= 0;
setInt64(sp + 16, parseInt(loadValue(sp + 8).length));
},
// valuePrepareString(v ref) (ref, int)
"syscall/js.valuePrepareString": (sp) => {
sp >>>= 0;
const str = encoder.encode(String(loadValue(sp + 8)));
storeValue(sp + 16, str);
setInt64(sp + 24, str.length);
},
// valueLoadString(v ref, b []byte)
"syscall/js.valueLoadString": (sp) => {
sp >>>= 0;
const str = loadValue(sp + 8);
loadSlice(sp + 16).set(str);
},
// func valueInstanceOf(v ref, t ref) bool
"syscall/js.valueInstanceOf": (sp) => {
sp >>>= 0;
this.mem.setUint8(sp + 24, (loadValue(sp + 8) instanceof loadValue(sp + 16)) ? 1 : 0);
},
// func copyBytesToGo(dst []byte, src ref) (int, bool)
"syscall/js.copyBytesToGo": (sp) => {
sp >>>= 0;
const dst = loadSlice(sp + 8);
const src = loadValue(sp + 32);
if (!(src instanceof Uint8Array || src instanceof Uint8ClampedArray)) {
this.mem.setUint8(sp + 48, 0);
return;
}
const toCopy = src.subarray(0, dst.length);
dst.set(toCopy);
setInt64(sp + 40, toCopy.length);
this.mem.setUint8(sp + 48, 1);
},
// func copyBytesToJS(dst ref, src []byte) (int, bool)
"syscall/js.copyBytesToJS": (sp) => {
sp >>>= 0;
const dst = loadValue(sp + 8);
const src = loadSlice(sp + 16);
if (!(dst instanceof Uint8Array || dst instanceof Uint8ClampedArray)) {
this.mem.setUint8(sp + 48, 0);
return;
}
const toCopy = src.subarray(0, dst.length);
dst.set(toCopy);
setInt64(sp + 40, toCopy.length);
this.mem.setUint8(sp + 48, 1);
},
"debug": (value) => {
console.log(value);
},
}
};
}
async run(instance) {
if (!(instance instanceof WebAssembly.Instance)) {
throw new Error("Go.run: WebAssembly.Instance expected");
}
this._inst = instance;
this.mem = new DataView(this._inst.exports.mem.buffer);
this._values = [ // JS values that Go currently has references to, indexed by reference id
NaN,
0,
null,
true,
false,
globalThis,
this,
];
this._goRefCounts = new Array(this._values.length).fill(Infinity); // number of references that Go has to a JS value, indexed by reference id
this._ids = new Map([ // mapping from JS values to reference ids
[0, 1],
[null, 2],
[true, 3],
[false, 4],
[globalThis, 5],
[this, 6],
]);
this._idPool = []; // unused ids that have been garbage collected
this.exited = false; // whether the Go program has exited
// Pass command line arguments and environment variables to WebAssembly by writing them to the linear memory.
let offset = 4096;
const strPtr = (str) => {
const ptr = offset;
const bytes = encoder.encode(str + "\0");
new Uint8Array(this.mem.buffer, offset, bytes.length).set(bytes);
offset += bytes.length;
if (offset % 8 !== 0) {
offset += 8 - (offset % 8);
}
return ptr;
};
const argc = this.argv.length;
const argvPtrs = [];
this.argv.forEach((arg) => {
argvPtrs.push(strPtr(arg));
});
argvPtrs.push(0);
const keys = Object.keys(this.env).sort();
keys.forEach((key) => {
argvPtrs.push(strPtr(`${key}=${this.env[key]}`));
});
argvPtrs.push(0);
const argv = offset;
argvPtrs.forEach((ptr) => {
this.mem.setUint32(offset, ptr, true);
this.mem.setUint32(offset + 4, 0, true);
offset += 8;
});
// The linker guarantees global data starts from at least wasmMinDataAddr.
// Keep in sync with cmd/link/internal/ld/data.go:wasmMinDataAddr.
const wasmMinDataAddr = 4096 + 8192;
if (offset >= wasmMinDataAddr) {
throw new Error("total length of command line and environment variables exceeds limit");
}
this._inst.exports.run(argc, argv);
if (this.exited) {
this._resolveExitPromise();
}
await this._exitPromise;
}
_resume() {
if (this.exited) {
throw new Error("Go program has already exited");
}
this._inst.exports.resume();
if (this.exited) {
this._resolveExitPromise();
}
}
_makeFuncWrapper(id) {
const go = this;
return function () {
const event = { id: id, this: this, args: arguments };
go._pendingEvent = event;
go._resume();
return event.result;
};
}
}
})();
goccy-go-yaml-52dacb8/docs/playground/src/worker.ts 0000664 0000000 0000000 00000006646 15015766371 0022466 0 ustar 00root root 0000000 0000000 import './wasm_exec';
import { YAMLFuncMap, YAMLProcessResultType, YAMLProcessResult, Token, GroupedToken, initWASM } from './YAML.ts';
const yaml = initWASM();
const funcMap = yaml.then((v): Promise => {
const decode = (code: string): Promise => {
return new Promise((resolve) => {
const res = v.decode(code);
if (res.error !== undefined) {
resolve({
type: YAMLProcessResultType.Decode,
result: res.error,
});
return
}
resolve({
type: YAMLProcessResultType.Decode,
result: res.response as string,
});
});
};
const tokenize = (code: string): Promise => {
return new Promise((resolve) => {
const res = v.tokenize(code);
if (res.error !== undefined) {
resolve({
type: YAMLProcessResultType.Lexer,
result: res.error,
});
return
}
resolve({
type: YAMLProcessResultType.Lexer,
result: JSON.parse(res.response) as Token[],
});
});
};
const parseGroup = (code: string): Promise => {
return new Promise((resolve) => {
const res = v.parseGroup(code);
if (res.error !== undefined) {
resolve({
type: YAMLProcessResultType.ParserGroup,
result: res.error,
});
return
}
resolve({
type: YAMLProcessResultType.ParserGroup,
result: JSON.parse(res.response) as GroupedToken[],
});
});
};
const parse = (code: string): Promise => {
return new Promise((resolve) => {
const res = v.parse(code);
if (res.error !== undefined) {
resolve({
type: YAMLProcessResultType.Parser,
result: res.error,
});
return
}
resolve({
type: YAMLProcessResultType.Parser,
result: res.response as string,
});
});
};
return new Promise((resolve) => {
resolve({
decode: decode,
tokenize: tokenize,
parseGroup: parseGroup,
parse: parse,
});
})
});
self.addEventListener('message', (e) => {
const data = e.data as {
code: string
tabIndex: number
}
funcMap.then((v) => {
switch (data.tabIndex) {
case 0:
v.decode(data.code).then((value) => {
self.postMessage(value);
})
break;
case 1:
v.parse(data.code).then((value) => {
self.postMessage(value);
})
break;
case 2:
v.parseGroup(data.code).then((value) => {
self.postMessage(value);
})
break;
case 3:
v.tokenize(data.code).then((value) => {
self.postMessage(value);
})
break;
default:
break;
}
})
});
export default {} goccy-go-yaml-52dacb8/docs/playground/tsconfig.app.json 0000664 0000000 0000000 00000001231 15015766371 0023265 0 ustar 00root root 0000000 0000000 {
"compilerOptions": {
"tsBuildInfoFile": "./node_modules/.tmp/tsconfig.app.tsbuildinfo",
"target": "ES2020",
"useDefineForClassFields": true,
"lib": ["ES2020", "DOM", "DOM.Iterable"],
"module": "ESNext",
"skipLibCheck": true,
/* Bundler mode */
"moduleResolution": "bundler",
"allowImportingTsExtensions": true,
"isolatedModules": true,
"moduleDetection": "force",
"noEmit": true,
"jsx": "react-jsx",
/* Linting */
"strict": true,
"noUnusedLocals": true,
"noUnusedParameters": true,
"noFallthroughCasesInSwitch": true,
"noUncheckedSideEffectImports": true
},
"include": ["src"]
}
goccy-go-yaml-52dacb8/docs/playground/tsconfig.json 0000664 0000000 0000000 00000000167 15015766371 0022515 0 ustar 00root root 0000000 0000000 {
"files": [],
"references": [
{ "path": "./tsconfig.app.json" },
{ "path": "./tsconfig.node.json" }
]
}
goccy-go-yaml-52dacb8/docs/playground/tsconfig.node.json 0000664 0000000 0000000 00000001121 15015766371 0023430 0 ustar 00root root 0000000 0000000 {
"compilerOptions": {
"tsBuildInfoFile": "./node_modules/.tmp/tsconfig.node.tsbuildinfo",
"target": "ES2022",
"lib": ["ES2023"],
"module": "ESNext",
"skipLibCheck": true,
/* Bundler mode */
"moduleResolution": "bundler",
"allowImportingTsExtensions": true,
"isolatedModules": true,
"moduleDetection": "force",
"noEmit": true,
/* Linting */
"strict": true,
"noUnusedLocals": true,
"noUnusedParameters": true,
"noFallthroughCasesInSwitch": true,
"noUncheckedSideEffectImports": true
},
"include": ["vite.config.ts"]
}
goccy-go-yaml-52dacb8/docs/playground/vite.config.ts 0000664 0000000 0000000 00000000342 15015766371 0022564 0 ustar 00root root 0000000 0000000 import { defineConfig } from 'vite'
import react from '@vitejs/plugin-react'
import svgr from 'vite-plugin-svgr'
// https://vite.dev/config/
export default defineConfig({
base: '/go-yaml/',
plugins: [react(), svgr()],
})
goccy-go-yaml-52dacb8/encode.go 0000664 0000000 0000000 00000070542 15015766371 0016462 0 ustar 00root root 0000000 0000000 package yaml
import (
"context"
"encoding"
"fmt"
"io"
"math"
"reflect"
"sort"
"strconv"
"strings"
"time"
"github.com/goccy/go-yaml/ast"
"github.com/goccy/go-yaml/internal/errors"
"github.com/goccy/go-yaml/parser"
"github.com/goccy/go-yaml/printer"
"github.com/goccy/go-yaml/token"
)
const (
// DefaultIndentSpaces default number of space for indent
DefaultIndentSpaces = 2
)
// Encoder writes YAML values to an output stream.
type Encoder struct {
writer io.Writer
opts []EncodeOption
singleQuote bool
isFlowStyle bool
isJSONStyle bool
useJSONMarshaler bool
enableSmartAnchor bool
aliasRefToName map[uintptr]string
anchorRefToName map[uintptr]string
anchorNameMap map[string]struct{}
anchorCallback func(*ast.AnchorNode, interface{}) error
customMarshalerMap map[reflect.Type]func(context.Context, interface{}) ([]byte, error)
omitZero bool
omitEmpty bool
autoInt bool
useLiteralStyleIfMultiline bool
commentMap map[*Path][]*Comment
written bool
line int
column int
offset int
indentNum int
indentLevel int
indentSequence bool
}
// NewEncoder returns a new encoder that writes to w.
// The Encoder should be closed after use to flush all data to w.
func NewEncoder(w io.Writer, opts ...EncodeOption) *Encoder {
return &Encoder{
writer: w,
opts: opts,
customMarshalerMap: map[reflect.Type]func(context.Context, interface{}) ([]byte, error){},
line: 1,
column: 1,
offset: 0,
indentNum: DefaultIndentSpaces,
anchorRefToName: make(map[uintptr]string),
anchorNameMap: make(map[string]struct{}),
aliasRefToName: make(map[uintptr]string),
}
}
// Close closes the encoder by writing any remaining data.
// It does not write a stream terminating string "...".
func (e *Encoder) Close() error {
return nil
}
// Encode writes the YAML encoding of v to the stream.
// If multiple items are encoded to the stream,
// the second and subsequent document will be preceded with a "---" document separator,
// but the first will not.
//
// See the documentation for Marshal for details about the conversion of Go values to YAML.
func (e *Encoder) Encode(v interface{}) error {
return e.EncodeContext(context.Background(), v)
}
// EncodeContext writes the YAML encoding of v to the stream with context.Context.
func (e *Encoder) EncodeContext(ctx context.Context, v interface{}) error {
node, err := e.EncodeToNodeContext(ctx, v)
if err != nil {
return err
}
if err := e.setCommentByCommentMap(node); err != nil {
return err
}
if !e.written {
e.written = true
} else {
// write document separator
_, _ = e.writer.Write([]byte("---\n"))
}
var p printer.Printer
_, _ = e.writer.Write(p.PrintNode(node))
return nil
}
// EncodeToNode convert v to ast.Node.
func (e *Encoder) EncodeToNode(v interface{}) (ast.Node, error) {
return e.EncodeToNodeContext(context.Background(), v)
}
// EncodeToNodeContext convert v to ast.Node with context.Context.
func (e *Encoder) EncodeToNodeContext(ctx context.Context, v interface{}) (ast.Node, error) {
for _, opt := range e.opts {
if err := opt(e); err != nil {
return nil, err
}
}
if e.enableSmartAnchor {
// during the first encoding, store all mappings between alias addresses and their names.
if _, err := e.encodeValue(ctx, reflect.ValueOf(v), 1); err != nil {
return nil, err
}
e.clearSmartAnchorRef()
}
node, err := e.encodeValue(ctx, reflect.ValueOf(v), 1)
if err != nil {
return nil, err
}
return node, nil
}
func (e *Encoder) setCommentByCommentMap(node ast.Node) error {
if e.commentMap == nil {
return nil
}
for path, comments := range e.commentMap {
n, err := path.FilterNode(node)
if err != nil {
return err
}
if n == nil {
continue
}
for _, comment := range comments {
commentTokens := []*token.Token{}
for _, text := range comment.Texts {
commentTokens = append(commentTokens, token.New(text, text, nil))
}
commentGroup := ast.CommentGroup(commentTokens)
switch comment.Position {
case CommentHeadPosition:
if err := e.setHeadComment(node, n, commentGroup); err != nil {
return err
}
case CommentLinePosition:
if err := e.setLineComment(node, n, commentGroup); err != nil {
return err
}
case CommentFootPosition:
if err := e.setFootComment(node, n, commentGroup); err != nil {
return err
}
default:
return ErrUnknownCommentPositionType
}
}
}
return nil
}
func (e *Encoder) setHeadComment(node ast.Node, filtered ast.Node, comment *ast.CommentGroupNode) error {
parent := ast.Parent(node, filtered)
if parent == nil {
return ErrUnsupportedHeadPositionType(node)
}
switch p := parent.(type) {
case *ast.MappingValueNode:
if err := p.SetComment(comment); err != nil {
return err
}
case *ast.MappingNode:
if err := p.SetComment(comment); err != nil {
return err
}
case *ast.SequenceNode:
if len(p.ValueHeadComments) == 0 {
p.ValueHeadComments = make([]*ast.CommentGroupNode, len(p.Values))
}
var foundIdx int
for idx, v := range p.Values {
if v == filtered {
foundIdx = idx
break
}
}
p.ValueHeadComments[foundIdx] = comment
default:
return ErrUnsupportedHeadPositionType(node)
}
return nil
}
func (e *Encoder) setLineComment(node ast.Node, filtered ast.Node, comment *ast.CommentGroupNode) error {
switch filtered.(type) {
case *ast.MappingValueNode, *ast.SequenceNode:
// Line comment cannot be set for mapping value node.
// It should probably be set for the parent map node
if err := e.setLineCommentToParentMapNode(node, filtered, comment); err != nil {
return err
}
default:
if err := filtered.SetComment(comment); err != nil {
return err
}
}
return nil
}
func (e *Encoder) setLineCommentToParentMapNode(node ast.Node, filtered ast.Node, comment *ast.CommentGroupNode) error {
parent := ast.Parent(node, filtered)
if parent == nil {
return ErrUnsupportedLinePositionType(node)
}
switch p := parent.(type) {
case *ast.MappingValueNode:
if err := p.Key.SetComment(comment); err != nil {
return err
}
case *ast.MappingNode:
if err := p.SetComment(comment); err != nil {
return err
}
default:
return ErrUnsupportedLinePositionType(parent)
}
return nil
}
func (e *Encoder) setFootComment(node ast.Node, filtered ast.Node, comment *ast.CommentGroupNode) error {
parent := ast.Parent(node, filtered)
if parent == nil {
return ErrUnsupportedFootPositionType(node)
}
switch n := parent.(type) {
case *ast.MappingValueNode:
n.FootComment = comment
case *ast.MappingNode:
n.FootComment = comment
case *ast.SequenceNode:
n.FootComment = comment
default:
return ErrUnsupportedFootPositionType(n)
}
return nil
}
func (e *Encoder) encodeDocument(doc []byte) (ast.Node, error) {
f, err := parser.ParseBytes(doc, 0)
if err != nil {
return nil, err
}
for _, docNode := range f.Docs {
if docNode.Body != nil {
return docNode.Body, nil
}
}
return nil, nil
}
func (e *Encoder) isInvalidValue(v reflect.Value) bool {
if !v.IsValid() {
return true
}
kind := v.Type().Kind()
if kind == reflect.Ptr && v.IsNil() {
return true
}
if kind == reflect.Interface && v.IsNil() {
return true
}
return false
}
type jsonMarshaler interface {
MarshalJSON() ([]byte, error)
}
func (e *Encoder) existsTypeInCustomMarshalerMap(t reflect.Type) bool {
if _, exists := e.customMarshalerMap[t]; exists {
return true
}
globalCustomMarshalerMu.Lock()
defer globalCustomMarshalerMu.Unlock()
if _, exists := globalCustomMarshalerMap[t]; exists {
return true
}
return false
}
func (e *Encoder) marshalerFromCustomMarshalerMap(t reflect.Type) (func(context.Context, interface{}) ([]byte, error), bool) {
if marshaler, exists := e.customMarshalerMap[t]; exists {
return marshaler, exists
}
globalCustomMarshalerMu.Lock()
defer globalCustomMarshalerMu.Unlock()
if marshaler, exists := globalCustomMarshalerMap[t]; exists {
return marshaler, exists
}
return nil, false
}
func (e *Encoder) canEncodeByMarshaler(v reflect.Value) bool {
if !v.CanInterface() {
return false
}
if e.existsTypeInCustomMarshalerMap(v.Type()) {
return true
}
iface := v.Interface()
switch iface.(type) {
case BytesMarshalerContext:
return true
case BytesMarshaler:
return true
case InterfaceMarshalerContext:
return true
case InterfaceMarshaler:
return true
case time.Time, *time.Time:
return true
case time.Duration:
return true
case encoding.TextMarshaler:
return true
case jsonMarshaler:
return e.useJSONMarshaler
}
return false
}
func (e *Encoder) encodeByMarshaler(ctx context.Context, v reflect.Value, column int) (ast.Node, error) {
iface := v.Interface()
if marshaler, exists := e.marshalerFromCustomMarshalerMap(v.Type()); exists {
doc, err := marshaler(ctx, iface)
if err != nil {
return nil, err
}
node, err := e.encodeDocument(doc)
if err != nil {
return nil, err
}
return node, nil
}
if marshaler, ok := iface.(BytesMarshalerContext); ok {
doc, err := marshaler.MarshalYAML(ctx)
if err != nil {
return nil, err
}
node, err := e.encodeDocument(doc)
if err != nil {
return nil, err
}
return node, nil
}
if marshaler, ok := iface.(BytesMarshaler); ok {
doc, err := marshaler.MarshalYAML()
if err != nil {
return nil, err
}
node, err := e.encodeDocument(doc)
if err != nil {
return nil, err
}
return node, nil
}
if marshaler, ok := iface.(InterfaceMarshalerContext); ok {
marshalV, err := marshaler.MarshalYAML(ctx)
if err != nil {
return nil, err
}
return e.encodeValue(ctx, reflect.ValueOf(marshalV), column)
}
if marshaler, ok := iface.(InterfaceMarshaler); ok {
marshalV, err := marshaler.MarshalYAML()
if err != nil {
return nil, err
}
return e.encodeValue(ctx, reflect.ValueOf(marshalV), column)
}
if t, ok := iface.(time.Time); ok {
return e.encodeTime(t, column), nil
}
// Handle *time.Time explicitly since it implements TextMarshaler and shouldn't be treated as plain text
if t, ok := iface.(*time.Time); ok && t != nil {
return e.encodeTime(*t, column), nil
}
if t, ok := iface.(time.Duration); ok {
return e.encodeDuration(t, column), nil
}
if marshaler, ok := iface.(encoding.TextMarshaler); ok {
text, err := marshaler.MarshalText()
if err != nil {
return nil, err
}
node := e.encodeString(string(text), column)
return node, nil
}
if e.useJSONMarshaler {
if marshaler, ok := iface.(jsonMarshaler); ok {
jsonBytes, err := marshaler.MarshalJSON()
if err != nil {
return nil, err
}
doc, err := JSONToYAML(jsonBytes)
if err != nil {
return nil, err
}
node, err := e.encodeDocument(doc)
if err != nil {
return nil, err
}
return node, nil
}
}
return nil, errors.New("does not implemented Marshaler")
}
func (e *Encoder) encodeValue(ctx context.Context, v reflect.Value, column int) (ast.Node, error) {
if e.isInvalidValue(v) {
return e.encodeNil(), nil
}
if e.canEncodeByMarshaler(v) {
node, err := e.encodeByMarshaler(ctx, v, column)
if err != nil {
return nil, err
}
return node, nil
}
switch v.Type().Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
return e.encodeInt(v.Int()), nil
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
return e.encodeUint(v.Uint()), nil
case reflect.Float32:
return e.encodeFloat(v.Float(), 32), nil
case reflect.Float64:
return e.encodeFloat(v.Float(), 64), nil
case reflect.Ptr:
if value := e.encodePtrAnchor(v, column); value != nil {
return value, nil
}
return e.encodeValue(ctx, v.Elem(), column)
case reflect.Interface:
return e.encodeValue(ctx, v.Elem(), column)
case reflect.String:
return e.encodeString(v.String(), column), nil
case reflect.Bool:
return e.encodeBool(v.Bool()), nil
case reflect.Slice:
if mapSlice, ok := v.Interface().(MapSlice); ok {
return e.encodeMapSlice(ctx, mapSlice, column)
}
if value := e.encodePtrAnchor(v, column); value != nil {
return value, nil
}
return e.encodeSlice(ctx, v)
case reflect.Array:
return e.encodeArray(ctx, v)
case reflect.Struct:
if v.CanInterface() {
if mapItem, ok := v.Interface().(MapItem); ok {
return e.encodeMapItem(ctx, mapItem, column)
}
if t, ok := v.Interface().(time.Time); ok {
return e.encodeTime(t, column), nil
}
}
return e.encodeStruct(ctx, v, column)
case reflect.Map:
if value := e.encodePtrAnchor(v, column); value != nil {
return value, nil
}
return e.encodeMap(ctx, v, column)
default:
return nil, fmt.Errorf("unknown value type %s", v.Type().String())
}
}
func (e *Encoder) encodePtrAnchor(v reflect.Value, column int) ast.Node {
anchorName, exists := e.getAnchor(v.Pointer())
if !exists {
return nil
}
aliasName := anchorName
alias := ast.Alias(token.New("*", "*", e.pos(column)))
alias.Value = ast.String(token.New(aliasName, aliasName, e.pos(column)))
e.setSmartAlias(aliasName, v.Pointer())
return alias
}
func (e *Encoder) pos(column int) *token.Position {
return &token.Position{
Line: e.line,
Column: column,
Offset: e.offset,
IndentNum: e.indentNum,
IndentLevel: e.indentLevel,
}
}
func (e *Encoder) encodeNil() *ast.NullNode {
value := "null"
return ast.Null(token.New(value, value, e.pos(e.column)))
}
func (e *Encoder) encodeInt(v int64) *ast.IntegerNode {
value := strconv.FormatInt(v, 10)
return ast.Integer(token.New(value, value, e.pos(e.column)))
}
func (e *Encoder) encodeUint(v uint64) *ast.IntegerNode {
value := strconv.FormatUint(v, 10)
return ast.Integer(token.New(value, value, e.pos(e.column)))
}
func (e *Encoder) encodeFloat(v float64, bitSize int) ast.Node {
if v == math.Inf(0) {
value := ".inf"
return ast.Infinity(token.New(value, value, e.pos(e.column)))
} else if v == math.Inf(-1) {
value := "-.inf"
return ast.Infinity(token.New(value, value, e.pos(e.column)))
} else if math.IsNaN(v) {
value := ".nan"
return ast.Nan(token.New(value, value, e.pos(e.column)))
}
value := strconv.FormatFloat(v, 'g', -1, bitSize)
if !strings.Contains(value, ".") && !strings.Contains(value, "e") {
if e.autoInt {
return ast.Integer(token.New(value, value, e.pos(e.column)))
}
// append x.0 suffix to keep float value context
value = fmt.Sprintf("%s.0", value)
}
return ast.Float(token.New(value, value, e.pos(e.column)))
}
func (e *Encoder) isNeedQuoted(v string) bool {
if e.isJSONStyle {
return true
}
if e.useLiteralStyleIfMultiline && strings.ContainsAny(v, "\n\r") {
return false
}
if e.isFlowStyle && strings.ContainsAny(v, `]},'"`) {
return true
}
if e.isFlowStyle {
for i := 0; i < len(v); i++ {
if v[i] != ':' {
continue
}
if i+1 < len(v) && v[i+1] == '/' {
continue
}
return true
}
}
if token.IsNeedQuoted(v) {
return true
}
return false
}
func (e *Encoder) encodeString(v string, column int) *ast.StringNode {
if e.isNeedQuoted(v) {
if e.singleQuote {
v = quoteWith(v, '\'')
} else {
v = strconv.Quote(v)
}
}
return ast.String(token.New(v, v, e.pos(column)))
}
func (e *Encoder) encodeBool(v bool) *ast.BoolNode {
value := strconv.FormatBool(v)
return ast.Bool(token.New(value, value, e.pos(e.column)))
}
func (e *Encoder) encodeSlice(ctx context.Context, value reflect.Value) (*ast.SequenceNode, error) {
if e.indentSequence {
e.column += e.indentNum
defer func() { e.column -= e.indentNum }()
}
column := e.column
sequence := ast.Sequence(token.New("-", "-", e.pos(column)), e.isFlowStyle)
for i := 0; i < value.Len(); i++ {
node, err := e.encodeValue(ctx, value.Index(i), column)
if err != nil {
return nil, err
}
sequence.Values = append(sequence.Values, node)
}
return sequence, nil
}
func (e *Encoder) encodeArray(ctx context.Context, value reflect.Value) (*ast.SequenceNode, error) {
if e.indentSequence {
e.column += e.indentNum
defer func() { e.column -= e.indentNum }()
}
column := e.column
sequence := ast.Sequence(token.New("-", "-", e.pos(column)), e.isFlowStyle)
for i := 0; i < value.Len(); i++ {
node, err := e.encodeValue(ctx, value.Index(i), column)
if err != nil {
return nil, err
}
sequence.Values = append(sequence.Values, node)
}
return sequence, nil
}
func (e *Encoder) encodeMapItem(ctx context.Context, item MapItem, column int) (*ast.MappingValueNode, error) {
k := reflect.ValueOf(item.Key)
v := reflect.ValueOf(item.Value)
value, err := e.encodeValue(ctx, v, column)
if err != nil {
return nil, err
}
if e.isMapNode(value) {
value.AddColumn(e.indentNum)
}
if e.isTagAndMapNode(value) {
value.AddColumn(e.indentNum)
}
return ast.MappingValue(
token.New("", "", e.pos(column)),
e.encodeString(k.Interface().(string), column),
value,
), nil
}
func (e *Encoder) encodeMapSlice(ctx context.Context, value MapSlice, column int) (*ast.MappingNode, error) {
node := ast.Mapping(token.New("", "", e.pos(column)), e.isFlowStyle)
for _, item := range value {
encoded, err := e.encodeMapItem(ctx, item, column)
if err != nil {
return nil, err
}
node.Values = append(node.Values, encoded)
}
return node, nil
}
func (e *Encoder) isMapNode(node ast.Node) bool {
_, ok := node.(ast.MapNode)
return ok
}
func (e *Encoder) isTagAndMapNode(node ast.Node) bool {
tn, ok := node.(*ast.TagNode)
return ok && e.isMapNode(tn.Value)
}
func (e *Encoder) encodeMap(ctx context.Context, value reflect.Value, column int) (ast.Node, error) {
node := ast.Mapping(token.New("", "", e.pos(column)), e.isFlowStyle)
keys := make([]interface{}, len(value.MapKeys()))
for i, k := range value.MapKeys() {
keys[i] = k.Interface()
}
sort.Slice(keys, func(i, j int) bool {
return fmt.Sprint(keys[i]) < fmt.Sprint(keys[j])
})
for _, key := range keys {
k := reflect.ValueOf(key)
v := value.MapIndex(k)
encoded, err := e.encodeValue(ctx, v, column)
if err != nil {
return nil, err
}
if e.isMapNode(encoded) {
encoded.AddColumn(e.indentNum)
}
if e.isTagAndMapNode(encoded) {
encoded.AddColumn(e.indentNum)
}
keyText := fmt.Sprint(key)
vRef := e.toPointer(v)
// during the second encoding, an anchor is assigned if it is found to be used by an alias.
if aliasName, exists := e.getSmartAlias(vRef); exists {
anchorName := aliasName
anchorNode := ast.Anchor(token.New("&", "&", e.pos(column)))
anchorNode.Name = ast.String(token.New(anchorName, anchorName, e.pos(column)))
anchorNode.Value = encoded
encoded = anchorNode
}
node.Values = append(node.Values, ast.MappingValue(
nil,
e.encodeString(keyText, column),
encoded,
))
e.setSmartAnchor(vRef, keyText)
}
return node, nil
}
// IsZeroer is used to check whether an object is zero to determine
// whether it should be omitted when marshaling with the omitempty flag.
// One notable implementation is time.Time.
type IsZeroer interface {
IsZero() bool
}
func (e *Encoder) isOmittedByOmitZero(v reflect.Value) bool {
kind := v.Kind()
if z, ok := v.Interface().(IsZeroer); ok {
if (kind == reflect.Ptr || kind == reflect.Interface) && v.IsNil() {
return true
}
return z.IsZero()
}
switch kind {
case reflect.String:
return len(v.String()) == 0
case reflect.Interface, reflect.Ptr, reflect.Slice, reflect.Map:
return v.IsNil()
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
return v.Int() == 0
case reflect.Float32, reflect.Float64:
return v.Float() == 0
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
return v.Uint() == 0
case reflect.Bool:
return !v.Bool()
case reflect.Struct:
vt := v.Type()
for i := v.NumField() - 1; i >= 0; i-- {
if vt.Field(i).PkgPath != "" {
continue // private field
}
if !e.isOmittedByOmitZero(v.Field(i)) {
return false
}
}
return true
}
return false
}
func (e *Encoder) isOmittedByOmitEmptyOption(v reflect.Value) bool {
switch v.Kind() {
case reflect.String:
return len(v.String()) == 0
case reflect.Interface, reflect.Ptr:
return v.IsNil()
case reflect.Slice, reflect.Map:
return v.Len() == 0
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
return v.Int() == 0
case reflect.Float32, reflect.Float64:
return v.Float() == 0
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
return v.Uint() == 0
case reflect.Bool:
return !v.Bool()
}
return false
}
// The current implementation of the omitempty tag combines the functionality of encoding/json's omitempty and omitzero tags.
// This stems from a historical decision to respect the implementation of gopkg.in/yaml.v2, but it has caused confusion,
// so we are working to integrate it into the functionality of encoding/json. (However, this will take some time.)
// In the current implementation, in addition to the exclusion conditions of omitempty,
// if a type implements IsZero, that implementation will be used.
// Furthermore, for non-pointer structs, if all fields are eligible for exclusion,
// the struct itself will also be excluded. These behaviors are originally the functionality of omitzero.
func (e *Encoder) isOmittedByOmitEmptyTag(v reflect.Value) bool {
kind := v.Kind()
if z, ok := v.Interface().(IsZeroer); ok {
if (kind == reflect.Ptr || kind == reflect.Interface) && v.IsNil() {
return true
}
return z.IsZero()
}
switch kind {
case reflect.String:
return len(v.String()) == 0
case reflect.Interface, reflect.Ptr:
return v.IsNil()
case reflect.Slice, reflect.Map:
return v.Len() == 0
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
return v.Int() == 0
case reflect.Float32, reflect.Float64:
return v.Float() == 0
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
return v.Uint() == 0
case reflect.Bool:
return !v.Bool()
case reflect.Struct:
vt := v.Type()
for i := v.NumField() - 1; i >= 0; i-- {
if vt.Field(i).PkgPath != "" {
continue // private field
}
if !e.isOmittedByOmitEmptyTag(v.Field(i)) {
return false
}
}
return true
}
return false
}
func (e *Encoder) encodeTime(v time.Time, column int) *ast.StringNode {
value := v.Format(time.RFC3339Nano)
if e.isJSONStyle {
value = strconv.Quote(value)
}
return ast.String(token.New(value, value, e.pos(column)))
}
func (e *Encoder) encodeDuration(v time.Duration, column int) *ast.StringNode {
value := v.String()
if e.isJSONStyle {
value = strconv.Quote(value)
}
return ast.String(token.New(value, value, e.pos(column)))
}
func (e *Encoder) encodeAnchor(anchorName string, value ast.Node, fieldValue reflect.Value, column int) (*ast.AnchorNode, error) {
anchorNode := ast.Anchor(token.New("&", "&", e.pos(column)))
anchorNode.Name = ast.String(token.New(anchorName, anchorName, e.pos(column)))
anchorNode.Value = value
if e.anchorCallback != nil {
if err := e.anchorCallback(anchorNode, fieldValue.Interface()); err != nil {
return nil, err
}
if snode, ok := anchorNode.Name.(*ast.StringNode); ok {
anchorName = snode.Value
}
}
if fieldValue.Kind() == reflect.Ptr {
e.setAnchor(fieldValue.Pointer(), anchorName)
}
return anchorNode, nil
}
func (e *Encoder) encodeStruct(ctx context.Context, value reflect.Value, column int) (ast.Node, error) {
node := ast.Mapping(token.New("", "", e.pos(column)), e.isFlowStyle)
structType := value.Type()
fieldMap, err := structFieldMap(structType)
if err != nil {
return nil, err
}
hasInlineAnchorField := false
var inlineAnchorValue reflect.Value
for i := 0; i < value.NumField(); i++ {
field := structType.Field(i)
if isIgnoredStructField(field) {
continue
}
fieldValue := value.FieldByName(field.Name)
sf := fieldMap[field.Name]
if (e.omitZero || sf.IsOmitZero) && e.isOmittedByOmitZero(fieldValue) {
// omit encoding by omitzero tag or OmitZero option.
continue
}
if e.omitEmpty && e.isOmittedByOmitEmptyOption(fieldValue) {
// omit encoding by OmitEmpty option.
continue
}
if sf.IsOmitEmpty && e.isOmittedByOmitEmptyTag(fieldValue) {
// omit encoding by omitempty tag.
continue
}
ve := e
if !e.isFlowStyle && sf.IsFlow {
ve = &Encoder{}
*ve = *e
ve.isFlowStyle = true
}
encoded, err := ve.encodeValue(ctx, fieldValue, column)
if err != nil {
return nil, err
}
if e.isMapNode(encoded) {
encoded.AddColumn(e.indentNum)
}
var key ast.MapKeyNode = e.encodeString(sf.RenderName, column)
switch {
case encoded.Type() == ast.AliasType:
if aliasName := sf.AliasName; aliasName != "" {
alias, ok := encoded.(*ast.AliasNode)
if !ok {
return nil, errors.ErrUnexpectedNodeType(encoded.Type(), ast.AliasType, encoded.GetToken())
}
got := alias.Value.String()
if aliasName != got {
return nil, fmt.Errorf("expected alias name is %q but got %q", aliasName, got)
}
}
if sf.IsInline {
// if both used alias and inline, output `<<: *alias`
key = ast.MergeKey(token.New("<<", "<<", e.pos(column)))
}
case sf.AnchorName != "":
anchorNode, err := e.encodeAnchor(sf.AnchorName, encoded, fieldValue, column)
if err != nil {
return nil, err
}
encoded = anchorNode
case sf.IsInline:
isAutoAnchor := sf.IsAutoAnchor
if !hasInlineAnchorField {
hasInlineAnchorField = isAutoAnchor
}
if isAutoAnchor {
inlineAnchorValue = fieldValue
}
mapNode, ok := encoded.(ast.MapNode)
if !ok {
// if an inline field is null, skip encoding it
if _, ok := encoded.(*ast.NullNode); ok {
continue
}
return nil, errors.New("inline value is must be map or struct type")
}
mapIter := mapNode.MapRange()
for mapIter.Next() {
mapKey := mapIter.Key()
mapValue := mapIter.Value()
keyName := mapKey.GetToken().Value
if fieldMap.isIncludedRenderName(keyName) {
// if declared the same key name, skip encoding this field
continue
}
mapKey.AddColumn(-e.indentNum)
mapValue.AddColumn(-e.indentNum)
node.Values = append(node.Values, ast.MappingValue(nil, mapKey, mapValue))
}
continue
case sf.IsAutoAnchor:
anchorNode, err := e.encodeAnchor(sf.RenderName, encoded, fieldValue, column)
if err != nil {
return nil, err
}
encoded = anchorNode
}
node.Values = append(node.Values, ast.MappingValue(nil, key, encoded))
}
if hasInlineAnchorField {
node.AddColumn(e.indentNum)
anchorName := "anchor"
anchorNode := ast.Anchor(token.New("&", "&", e.pos(column)))
anchorNode.Name = ast.String(token.New(anchorName, anchorName, e.pos(column)))
anchorNode.Value = node
if e.anchorCallback != nil {
if err := e.anchorCallback(anchorNode, value.Addr().Interface()); err != nil {
return nil, err
}
if snode, ok := anchorNode.Name.(*ast.StringNode); ok {
anchorName = snode.Value
}
}
if inlineAnchorValue.Kind() == reflect.Ptr {
e.setAnchor(inlineAnchorValue.Pointer(), anchorName)
}
return anchorNode, nil
}
return node, nil
}
func (e *Encoder) toPointer(v reflect.Value) uintptr {
if e.isInvalidValue(v) {
return 0
}
switch v.Type().Kind() {
case reflect.Ptr:
return v.Pointer()
case reflect.Interface:
return e.toPointer(v.Elem())
case reflect.Slice:
return v.Pointer()
case reflect.Map:
return v.Pointer()
}
return 0
}
func (e *Encoder) clearSmartAnchorRef() {
if !e.enableSmartAnchor {
return
}
e.anchorRefToName = make(map[uintptr]string)
e.anchorNameMap = make(map[string]struct{})
}
func (e *Encoder) setSmartAnchor(ptr uintptr, name string) {
if !e.enableSmartAnchor {
return
}
e.setAnchor(ptr, e.generateAnchorName(name))
}
func (e *Encoder) setAnchor(ptr uintptr, name string) {
if ptr == 0 {
return
}
if name == "" {
return
}
e.anchorRefToName[ptr] = name
e.anchorNameMap[name] = struct{}{}
}
func (e *Encoder) generateAnchorName(base string) string {
if _, exists := e.anchorNameMap[base]; !exists {
return base
}
for i := 1; i < 100; i++ {
name := base + strconv.Itoa(i)
if _, exists := e.anchorNameMap[name]; exists {
continue
}
return name
}
return ""
}
func (e *Encoder) getAnchor(ref uintptr) (string, bool) {
anchorName, exists := e.anchorRefToName[ref]
return anchorName, exists
}
func (e *Encoder) setSmartAlias(name string, ref uintptr) {
if !e.enableSmartAnchor {
return
}
e.aliasRefToName[ref] = name
}
func (e *Encoder) getSmartAlias(ref uintptr) (string, bool) {
if !e.enableSmartAnchor {
return "", false
}
aliasName, exists := e.aliasRefToName[ref]
return aliasName, exists
}
goccy-go-yaml-52dacb8/encode_test.go 0000664 0000000 0000000 00000115273 15015766371 0017522 0 ustar 00root root 0000000 0000000 package yaml_test
import (
"bytes"
"context"
"errors"
"fmt"
"math"
"net/netip"
"reflect"
"strconv"
"strings"
"testing"
"time"
"unsafe"
"github.com/goccy/go-yaml"
"github.com/goccy/go-yaml/ast"
"github.com/goccy/go-yaml/parser"
)
var zero = 0
var emptyStr = ""
type TestTextMarshaler string
func (t TestTextMarshaler) MarshalText() ([]byte, error) {
return []byte(t), nil
}
type TestTextUnmarshalerContainer struct {
V TestTextMarshaler
}
func TestEncoder(t *testing.T) {
tests := []struct {
source string
value interface{}
options []yaml.EncodeOption
}{
{
"null\n",
(*struct{})(nil),
nil,
},
{
"v: hi\n",
map[string]string{"v": "hi"},
nil,
},
{
"v: \"true\"\n",
map[string]string{"v": "true"},
nil,
},
{
"v: \"false\"\n",
map[string]string{"v": "false"},
nil,
},
{
"v: true\n",
map[string]interface{}{"v": true},
nil,
},
{
"v: false\n",
map[string]bool{"v": false},
nil,
},
{
"v: 10\n",
map[string]int{"v": 10},
nil,
},
{
"v: -10\n",
map[string]int{"v": -10},
nil,
},
{
"v: 4294967296\n",
map[string]int64{"v": int64(4294967296)},
nil,
},
{
"v: 0.1\n",
map[string]interface{}{"v": 0.1},
nil,
},
{
"v: 0.99\n",
map[string]float32{"v": 0.99},
nil,
},
{
"v: 1e-06\n",
map[string]float32{"v": 1e-06},
nil,
},
{
"v: 1e-06\n",
map[string]float64{"v": 0.000001},
nil,
},
{
"v: 0.123456789\n",
map[string]float64{"v": 0.123456789},
nil,
},
{
"v: -0.1\n",
map[string]float64{"v": -0.1},
nil,
},
{
"v: 1.0\n",
map[string]float64{"v": 1.0},
nil,
},
{
"v: 1e+06\n",
map[string]float64{"v": 1000000},
nil,
},
{
"v: 1e-06\n",
map[string]float64{"v": 0.000001},
nil,
},
{
"v: 1e-06\n",
map[string]float64{"v": 1e-06},
nil,
},
{
"v: .inf\n",
map[string]interface{}{"v": math.Inf(0)},
nil,
},
{
"v: -.inf\n",
map[string]interface{}{"v": math.Inf(-1)},
nil,
},
{
"v: .nan\n",
map[string]interface{}{"v": math.NaN()},
nil,
},
{
"v: null\n",
map[string]interface{}{"v": nil},
nil,
},
{
"v: \"\"\n",
map[string]string{"v": ""},
nil,
},
{
"v:\n- A\n- B\n",
map[string][]string{"v": {"A", "B"}},
nil,
},
{
"v:\n - A\n - B\n",
map[string][]string{"v": {"A", "B"}},
[]yaml.EncodeOption{
yaml.IndentSequence(true),
},
},
{
"v:\n- A\n- B\n",
map[string][2]string{"v": {"A", "B"}},
nil,
},
{
"v:\n - A\n - B\n",
map[string][2]string{"v": {"A", "B"}},
[]yaml.EncodeOption{
yaml.IndentSequence(true),
},
},
{
"a: \"-\"\n",
map[string]string{"a": "-"},
nil,
},
{
"123\n",
123,
nil,
},
{
"hello: world\n",
map[string]string{"hello": "world"},
nil,
},
{
"hello: |\n hello\n world\n",
map[string]string{"hello": "hello\nworld\n"},
nil,
},
{
"hello: |-\n hello\n world\n",
map[string]string{"hello": "hello\nworld"},
nil,
},
{
"hello: |+\n hello\n world\n\n",
map[string]string{"hello": "hello\nworld\n\n"},
nil,
},
{
"hello:\n hello: |\n hello\n world\n",
map[string]map[string]string{"hello": {"hello": "hello\nworld\n"}},
nil,
},
{
"hello: |\r hello\r world\n",
map[string]string{"hello": "hello\rworld\r"},
nil,
},
{
"hello: |\r\n hello\r\n world\n",
map[string]string{"hello": "hello\r\nworld\r\n"},
nil,
},
{
"v: |-\n username: hello\n password: hello123\n",
map[string]interface{}{"v": "username: hello\npassword: hello123"},
[]yaml.EncodeOption{
yaml.UseLiteralStyleIfMultiline(true),
},
},
{
"v: |-\n # comment\n username: hello\n password: hello123\n",
map[string]interface{}{"v": "# comment\nusername: hello\npassword: hello123"},
[]yaml.EncodeOption{
yaml.UseLiteralStyleIfMultiline(true),
},
},
{
"v: \"# comment\\nusername: hello\\npassword: hello123\"\n",
map[string]interface{}{"v": "# comment\nusername: hello\npassword: hello123"},
[]yaml.EncodeOption{
yaml.UseLiteralStyleIfMultiline(false),
},
},
{
"v:\n- A\n- 1\n- B:\n - 2\n - 3\n",
map[string]interface{}{
"v": []interface{}{
"A",
1,
map[string][]int{
"B": {2, 3},
},
},
},
nil,
},
{
"v:\n - A\n - 1\n - B:\n - 2\n - 3\n - 2\n",
map[string]interface{}{
"v": []interface{}{
"A",
1,
map[string][]int{
"B": {2, 3},
},
2,
},
},
[]yaml.EncodeOption{
yaml.IndentSequence(true),
},
},
{
"a:\n b: c\n",
map[string]interface{}{
"a": map[string]string{
"b": "c",
},
},
nil,
},
{
"t2: \"2018-01-09T10:40:47Z\"\nt4: \"2098-01-09T10:40:47Z\"\n",
map[string]string{
"t2": "2018-01-09T10:40:47Z",
"t4": "2098-01-09T10:40:47Z",
},
nil,
},
{
"a:\n b: c\n d: e\n",
map[string]interface{}{
"a": map[string]string{
"b": "c",
"d": "e",
},
},
nil,
},
{
"a: 3s\n",
map[string]string{
"a": "3s",
},
nil,
},
{
"a: \n",
map[string]string{"a": ""},
nil,
},
{
"a: \"1:1\"\n",
map[string]string{"a": "1:1"},
nil,
},
{
"a: 1.2.3.4\n",
map[string]string{"a": "1.2.3.4"},
nil,
},
{
"a: \"b: c\"\n",
map[string]string{"a": "b: c"},
nil,
},
{
"a: \"Hello #comment\"\n",
map[string]string{"a": "Hello #comment"},
nil,
},
{
"a: \" b\"\n",
map[string]string{"a": " b"},
nil,
},
{
"a: \"b \"\n",
map[string]string{"a": "b "},
nil,
},
{
"a: \" b \"\n",
map[string]string{"a": " b "},
nil,
},
{
"a: \"`b` c\"\n",
map[string]string{"a": "`b` c"},
nil,
},
{
"a: 100.5\n",
map[string]interface{}{
"a": 100.5,
},
nil,
},
{
"a: \"\\\\0\"\n",
map[string]string{"a": "\\0"},
nil,
},
{
"a: 1\nb: 2\nc: 3\nd: 4\nsub:\n e: 5\n",
map[string]interface{}{
"a": 1,
"b": 2,
"c": 3,
"d": 4,
"sub": map[string]int{
"e": 5,
},
},
nil,
},
{
"a: 1\nb: []\n",
struct {
A int
B []string
}{
1, ([]string)(nil),
},
nil,
},
{
"a: 1\nb: []\n",
struct {
A int
B []string
}{
1, []string{},
},
nil,
},
{
"a: {}\n",
struct {
A map[string]interface{}
}{
map[string]interface{}{},
},
nil,
},
{
"a: b\nc: d\n",
struct {
A string
C string `yaml:"c"`
}{
"b", "d",
},
nil,
},
{
"a: 1\n",
struct {
A int
B int `yaml:"-"`
}{
1, 0,
},
nil,
},
{
"a: \"\"\n",
struct {
A string
}{
"",
},
nil,
},
{
"a: null\n",
struct {
A *string
}{
nil,
},
nil,
},
{
"a: \"\"\n",
struct {
A *string
}{
&emptyStr,
},
nil,
},
{
"a: null\n",
struct {
A *int
}{
nil,
},
nil,
},
{
"a: 0\n",
struct {
A *int
}{
&zero,
},
nil,
},
// Omitempty flag.
{
"a: 1\n",
struct {
A int `yaml:"a,omitempty"`
B int `yaml:"b,omitempty"`
}{1, 0},
nil,
},
{
"{}\n",
struct {
A int `yaml:"a,omitempty"`
B int `yaml:"b,omitempty"`
}{0, 0},
nil,
},
{
"a:\n \"y\": \"\"\n",
struct {
A *struct {
X string `yaml:"x,omitempty"`
Y string
}
}{&struct {
X string `yaml:"x,omitempty"`
Y string
}{}},
nil,
},
{
"a: {}\n",
struct {
A *struct {
X string `yaml:"x,omitempty"`
Y string `yaml:"y,omitempty"`
}
}{&struct {
X string `yaml:"x,omitempty"`
Y string `yaml:"y,omitempty"`
}{}},
nil,
},
{
"a: {x: 1}\n",
struct {
A *struct{ X, y int } `yaml:"a,omitempty,flow"`
}{&struct{ X, y int }{1, 2}},
nil,
},
{
"{}\n",
struct {
A *struct{ X, y int } `yaml:"a,omitempty,flow"`
}{nil},
nil,
},
{
"a: {x: 0}\n",
struct {
A *struct{ X, y int } `yaml:"a,omitempty,flow"`
}{&struct{ X, y int }{}},
nil,
},
{
"a: {x: 1}\n",
struct {
A struct{ X, y int } `yaml:"a,omitempty,flow"`
}{struct{ X, y int }{1, 2}},
nil,
},
{
"{}\n",
struct {
A struct{ X, y int } `yaml:"a,omitempty,flow"`
}{struct{ X, y int }{0, 1}},
nil,
},
{
"a: 1.0\n",
struct {
A float64 `yaml:"a,omitempty"`
B float64 `yaml:"b,omitempty"`
}{1, 0},
nil,
},
{
"a: 1\n",
struct {
A int
B []string `yaml:"b,omitempty"`
}{
1, []string{},
},
nil,
},
// Highlighting differences of go-yaml omitempty vs std encoding/json
// omitempty. Encoding/json will emit the following fields: https://go.dev/play/p/VvNpdM0GD4d
{
"{}\n",
struct {
// This type has a custom IsZero method.
A netip.Addr `yaml:"a,omitempty"`
B struct{ X, y int } `yaml:"b,omitempty"`
}{},
nil,
},
// omitzero flag.
{
"a: 1\n",
struct {
A int `yaml:"a,omitzero"`
B int `yaml:"b,omitzero"`
}{1, 0},
nil,
},
{
"{}\n",
struct {
A int `yaml:"a,omitzero"`
B int `yaml:"b,omitzero"`
}{0, 0},
nil,
},
{
"a:\n \"y\": \"\"\n",
struct {
A *struct {
X string `yaml:"x,omitzero"`
Y string
}
}{&struct {
X string `yaml:"x,omitzero"`
Y string
}{}},
nil,
},
{
"a: {}\n",
struct {
A *struct {
X string `yaml:"x,omitzero"`
Y string `yaml:"y,omitzero"`
}
}{&struct {
X string `yaml:"x,omitzero"`
Y string `yaml:"y,omitzero"`
}{}},
nil,
},
{
"a: {x: 1}\n",
struct {
A *struct{ X, y int } `yaml:"a,omitzero,flow"`
}{&struct{ X, y int }{1, 2}},
nil,
},
{
"{}\n",
struct {
A *struct{ X, y int } `yaml:"a,omitzero,flow"`
}{nil},
nil,
},
{
"a: {x: 0}\n",
struct {
A *struct{ X, y int } `yaml:"a,omitzero,flow"`
}{&struct{ X, y int }{}},
nil,
},
{
"a: {x: 1}\n",
struct {
A struct{ X, y int } `yaml:"a,omitzero,flow"`
}{struct{ X, y int }{1, 2}},
nil,
},
{
"{}\n",
struct {
A struct{ X, y int } `yaml:"a,omitzero,flow"`
}{struct{ X, y int }{0, 1}},
nil,
},
{
"a: 1.0\n",
struct {
A float64 `yaml:"a,omitzero"`
B float64 `yaml:"b,omitzero"`
}{1, 0},
nil,
},
{
"a: 1\nb: []\n",
struct {
A int
B []string `yaml:"b,omitzero"`
}{
1, []string{},
},
nil,
},
{
"{}\n",
struct {
A netip.Addr `yaml:"a,omitzero"`
B struct{ X, y int } `yaml:"b,omitzero"`
}{},
nil,
},
// OmitEmpty global option.
{
"a: 1\n",
struct {
A int
B int `yaml:"b,omitempty"`
}{1, 0},
[]yaml.EncodeOption{
yaml.OmitEmpty(),
},
},
{
"{}\n",
struct {
A int
B int `yaml:"b,omitempty"`
}{0, 0},
[]yaml.EncodeOption{
yaml.OmitEmpty(),
},
},
{
"a: \"\"\nb: {}\n",
struct {
A netip.Addr `yaml:"a"`
B struct{ X, y int } `yaml:"b"`
}{},
[]yaml.EncodeOption{
yaml.OmitEmpty(),
},
},
// OmitZero global option.
{
"a: 1\n",
struct {
A int
B int
}{1, 0},
[]yaml.EncodeOption{
yaml.OmitZero(),
},
},
{
"{}\n",
struct {
A int
B int
}{0, 0},
[]yaml.EncodeOption{
yaml.OmitZero(),
},
},
{
"{}\n",
struct {
A netip.Addr `yaml:"a"`
B struct{ X, y int } `yaml:"b"`
}{},
[]yaml.EncodeOption{
yaml.OmitZero(),
},
},
// Flow flag.
{
"a: [1, 2]\n",
struct {
A []int `yaml:"a,flow"`
}{[]int{1, 2}},
nil,
},
{
"a: {b: c, d: e}\n",
&struct {
A map[string]string `yaml:"a,flow"`
}{map[string]string{"b": "c", "d": "e"}},
nil,
},
{
"a: {b: c, d: e}\n",
struct {
A struct {
B, D string
} `yaml:"a,flow"`
}{struct{ B, D string }{"c", "e"}},
nil,
},
// Quoting in flow mode
{
`a: [b, "c,d", e]` + "\n",
struct {
A []string `yaml:"a,flow"`
}{[]string{"b", "c,d", "e"}},
[]yaml.EncodeOption{
yaml.UseSingleQuote(false),
},
},
{
`a: [b, "c]", d]` + "\n",
struct {
A []string `yaml:"a,flow"`
}{[]string{"b", "c]", "d"}},
[]yaml.EncodeOption{
yaml.UseSingleQuote(false),
},
},
{
`a: [b, "c}", d]` + "\n",
struct {
A []string `yaml:"a,flow"`
}{[]string{"b", "c}", "d"}},
[]yaml.EncodeOption{
yaml.UseSingleQuote(false),
},
},
{
`a: [b, "c\"", d]` + "\n",
struct {
A []string `yaml:"a,flow"`
}{[]string{"b", `c"`, "d"}},
[]yaml.EncodeOption{
yaml.UseSingleQuote(false),
},
},
{
`a: [b, "c'", d]` + "\n",
struct {
A []string `yaml:"a,flow"`
}{[]string{"b", "c'", "d"}},
[]yaml.EncodeOption{
yaml.UseSingleQuote(false),
},
},
// No quoting in non-flow mode
{
"a:\n- b\n- c,d\n- e\n",
struct {
A []string `yaml:"a"`
}{[]string{"b", "c,d", "e"}},
nil,
},
{
`a: [b, "c]", d]` + "\n",
struct {
A []string `yaml:"a,flow"`
}{[]string{"b", "c]", "d"}},
nil,
},
{
`a: [b, "c}", d]` + "\n",
struct {
A []string `yaml:"a,flow"`
}{[]string{"b", "c}", "d"}},
nil,
},
{
`a: [b, "c\"", d]` + "\n",
struct {
A []string `yaml:"a,flow"`
}{[]string{"b", `c"`, "d"}},
nil,
},
{
`a: [b, "c'", d]` + "\n",
struct {
A []string `yaml:"a,flow"`
}{[]string{"b", "c'", "d"}},
nil,
},
// Multi bytes
{
"v: あいうえお\nv2: かきくけこ\n",
map[string]string{"v": "あいうえお", "v2": "かきくけこ"},
nil,
},
// time value
{
"v: 0001-01-01T00:00:00Z\n",
map[string]time.Time{"v": {}},
nil,
},
{
"v: 0001-01-01T00:00:00Z\n",
map[string]*time.Time{"v": {}},
nil,
},
{
"v: null\n",
map[string]*time.Time{"v": nil},
nil,
},
{
"v: 30s\n",
map[string]time.Duration{"v": 30 * time.Second},
nil,
},
{
"v: 30s\n",
map[string]*time.Duration{"v": ptr(30 * time.Second)},
nil,
},
{
"v: null\n",
map[string]*time.Duration{"v": nil},
nil,
},
{
"v: test\n",
TestTextUnmarshalerContainer{V: "test"},
nil,
},
{
"v: \"1\"\n",
TestTextUnmarshalerContainer{V: "1"},
nil,
},
{
"v: \"#\"\n",
TestTextUnmarshalerContainer{V: "#"},
nil,
},
// Quote style
{
`v: '''a''b'` + "\n",
map[string]string{"v": `'a'b`},
[]yaml.EncodeOption{
yaml.UseSingleQuote(true),
},
},
{
`v: "'a'b"` + "\n",
map[string]string{"v": `'a'b`},
[]yaml.EncodeOption{
yaml.UseSingleQuote(false),
},
},
{
`a: '\.yaml'` + "\n",
map[string]string{"a": `\.yaml`},
[]yaml.EncodeOption{
yaml.UseSingleQuote(true),
},
},
}
for _, test := range tests {
t.Run(test.source, func(t *testing.T) {
var buf bytes.Buffer
enc := yaml.NewEncoder(&buf, test.options...)
if err := enc.Encode(test.value); err != nil {
t.Fatalf("%+v", err)
}
if test.source != buf.String() {
t.Fatalf("expect = [%s], actual = [%s]", test.source, buf.String())
}
})
}
}
func TestEncodeStructIncludeMap(t *testing.T) {
type U struct {
M map[string]string
}
type T struct {
A U
}
bytes, err := yaml.Marshal(T{
A: U{
M: map[string]string{"x": "y"},
},
})
if err != nil {
t.Fatalf("%+v", err)
}
expect := "a:\n m:\n x: \"y\"\n"
actual := string(bytes)
if actual != expect {
t.Fatalf("unexpected output. expect:[%s] actual:[%s]", expect, actual)
}
}
func TestEncodeDefinedTypeKeyMap(t *testing.T) {
type K string
type U struct {
M map[K]string
}
bytes, err := yaml.Marshal(U{
M: map[K]string{K("x"): "y"},
})
if err != nil {
t.Fatalf("%+v", err)
}
expect := "m:\n x: \"y\"\n"
actual := string(bytes)
if actual != expect {
t.Fatalf("unexpected output. expect:[%s] actual:[%s]", expect, actual)
}
}
func TestEncodeWithAnchorAndAlias(t *testing.T) {
var buf bytes.Buffer
enc := yaml.NewEncoder(&buf)
type T struct {
A int
B string
}
var v struct {
A *T `yaml:"a,anchor=c"`
B *T `yaml:"b,alias=c"`
}
v.A = &T{A: 1, B: "hello"}
v.B = v.A
if err := enc.Encode(v); err != nil {
t.Fatalf("%+v", err)
}
expect := "a: &c\n a: 1\n b: hello\nb: *c\n"
if expect != buf.String() {
t.Fatalf("expect = [%s], actual = [%s]", expect, buf.String())
}
}
func TestEncodeWithAutoAlias(t *testing.T) {
var buf bytes.Buffer
enc := yaml.NewEncoder(&buf)
type T struct {
I int
S string
}
var v struct {
A *T `yaml:"a,anchor=a"`
B *T `yaml:"b,anchor=b"`
C *T `yaml:"c"`
D *T `yaml:"d"`
}
v.A = &T{I: 1, S: "hello"}
v.B = &T{I: 2, S: "world"}
v.C = v.A
v.D = v.B
if err := enc.Encode(v); err != nil {
t.Fatalf("%+v", err)
}
expect := `a: &a
i: 1
s: hello
b: &b
i: 2
s: world
c: *a
d: *b
`
if expect != buf.String() {
t.Fatalf("expect = [%s], actual = [%s]", expect, buf.String())
}
}
func TestEncodeWithImplicitAnchorAndAlias(t *testing.T) {
var buf bytes.Buffer
enc := yaml.NewEncoder(&buf)
type T struct {
I int
S string
}
var v struct {
A *T `yaml:"a,anchor"`
B *T `yaml:"b,anchor"`
C *T `yaml:"c"`
D *T `yaml:"d"`
}
v.A = &T{I: 1, S: "hello"}
v.B = &T{I: 2, S: "world"}
v.C = v.A
v.D = v.B
if err := enc.Encode(v); err != nil {
t.Fatalf("%+v", err)
}
expect := `a: &a
i: 1
s: hello
b: &b
i: 2
s: world
c: *a
d: *b
`
if expect != buf.String() {
t.Fatalf("expect = [%s], actual = [%s]", expect, buf.String())
}
}
func TestEncodeWithMerge(t *testing.T) {
type Person struct {
*Person `yaml:",omitempty,inline"`
Name string `yaml:",omitempty"`
Age int `yaml:",omitempty"`
}
defaultPerson := &Person{
Name: "John Smith",
Age: 20,
}
people := []*Person{
{
Person: defaultPerson,
Name: "Ken",
Age: 10,
},
{
Person: defaultPerson,
},
}
var doc struct {
Default *Person `yaml:"default,anchor"`
People []*Person `yaml:"people"`
}
doc.Default = defaultPerson
doc.People = people
var buf bytes.Buffer
enc := yaml.NewEncoder(&buf)
if err := enc.Encode(doc); err != nil {
t.Fatalf("%+v", err)
}
expect := `default: &default
name: John Smith
age: 20
people:
- <<: *default
name: Ken
age: 10
- <<: *default
`
if expect != buf.String() {
t.Fatalf("expect = [%s], actual = [%s]", expect, buf.String())
}
}
func TestEncodeWithNestedYAML(t *testing.T) {
// Represents objects containing stringified YAML, and special chars
tests := []struct {
value interface{}
// If true, expects a different result between when using forced literal style or not
expectDifferent bool
}{
{
value: map[string]interface{}{"v": "# comment\nname: hello\npassword: hello123\nspecial: \":ghost:\"\ntext: |\n nested multiline!"},
expectDifferent: true,
},
{
value: map[string]interface{}{"v": "# comment\nusername: hello\npassword: hello123"},
expectDifferent: true,
},
{
value: map[string]interface{}{"v": "# comment\n"},
expectDifferent: true,
},
}
for _, test := range tests {
yamlBytesForced, err := yaml.MarshalWithOptions(test.value, yaml.UseLiteralStyleIfMultiline(true))
if err != nil {
t.Fatalf("%+v", err)
}
// Convert it back for proper equality testing
var unmarshaled interface{}
if err := yaml.Unmarshal(yamlBytesForced, &unmarshaled); err != nil {
t.Fatalf("%+v", err)
}
if !reflect.DeepEqual(test.value, unmarshaled) {
t.Fatalf("expected %v(%T). but actual %v(%T)", test.value, test.value, unmarshaled, unmarshaled)
}
if test.expectDifferent {
yamlBytesNotForced, err := yaml.MarshalWithOptions(test.value)
if err != nil {
t.Fatalf("%+v", err)
}
if string(yamlBytesForced) == string(yamlBytesNotForced) {
t.Fatalf("expected different strings when force literal style is not enabled. forced: %s, not forced: %s", string(yamlBytesForced), string(yamlBytesNotForced))
}
}
}
}
func TestEncoder_Inline(t *testing.T) {
type base struct {
A int
B string
}
var buf bytes.Buffer
enc := yaml.NewEncoder(&buf)
if err := enc.Encode(struct {
*base `yaml:",inline"`
C bool
}{
base: &base{
A: 1,
B: "hello",
},
C: true,
}); err != nil {
t.Fatalf("%+v", err)
}
expect := `
a: 1
b: hello
c: true
`
actual := "\n" + buf.String()
if expect != actual {
t.Fatalf("inline marshal error: expect=[%s] actual=[%s]", expect, actual)
}
}
func TestEncoder_InlineAndConflictKey(t *testing.T) {
type base struct {
A int
B string
}
var buf bytes.Buffer
enc := yaml.NewEncoder(&buf)
if err := enc.Encode(struct {
*base `yaml:",inline"`
A int // conflict
C bool
}{
base: &base{
A: 1,
B: "hello",
},
A: 0, // default value
C: true,
}); err != nil {
t.Fatalf("%+v", err)
}
expect := `
b: hello
a: 0
c: true
`
actual := "\n" + buf.String()
if expect != actual {
t.Fatalf("inline marshal error: expect=[%s] actual=[%s]", expect, actual)
}
}
func TestEncoder_InlineNil(t *testing.T) {
type base struct {
A int
B string
}
var buf bytes.Buffer
enc := yaml.NewEncoder(&buf)
if err := enc.Encode(struct {
*base `yaml:",inline"`
C bool
}{
C: true,
}); err != nil {
t.Fatalf("%+v", err)
}
expect := `
c: true
`
actual := "\n" + buf.String()
if expect != actual {
t.Fatalf("inline marshal error: expect=[%s] actual=[%s]", expect, actual)
}
}
func TestEncoder_Flow(t *testing.T) {
var buf bytes.Buffer
enc := yaml.NewEncoder(&buf, yaml.Flow(true))
var v struct {
A int
B string
C struct {
D int
E string
}
F []int
}
v.A = 1
v.B = "hello"
v.C.D = 3
v.C.E = "world"
v.F = []int{1, 2}
if err := enc.Encode(v); err != nil {
t.Fatalf("%+v", err)
}
expect := `
{a: 1, b: hello, c: {d: 3, e: world}, f: [1, 2]}
`
actual := "\n" + buf.String()
if expect != actual {
t.Fatalf("flow style marshal error: expect=[%s] actual=[%s]", expect, actual)
}
}
func TestEncoder_FlowRecursive(t *testing.T) {
var v struct {
M map[string][]int `yaml:",flow"`
}
v.M = map[string][]int{
"test": {1, 2, 3},
}
var buf bytes.Buffer
if err := yaml.NewEncoder(&buf).Encode(v); err != nil {
t.Fatalf("%+v", err)
}
expect := `
m: {test: [1, 2, 3]}
`
actual := "\n" + buf.String()
if expect != actual {
t.Fatalf("flow style marshal error: expect=[%s] actual=[%s]", expect, actual)
}
}
func TestEncoder_JSON(t *testing.T) {
var buf bytes.Buffer
enc := yaml.NewEncoder(&buf, yaml.JSON())
type st struct {
I int8
S string
F float32
}
if err := enc.Encode(struct {
I int
U uint
S string
F float64
Struct *st
Slice []int
Map map[string]interface{}
Time time.Time
Duration time.Duration
}{
I: -10,
U: 10,
S: "hello",
F: 3.14,
Struct: &st{
I: 2,
S: "world",
F: 1.23,
},
Slice: []int{1, 2, 3, 4, 5},
Map: map[string]interface{}{
"a": 1,
"b": 1.23,
"c": "json",
},
Time: time.Time{},
Duration: 5 * time.Minute,
}); err != nil {
t.Fatalf("%+v", err)
}
expect := `
{"i": -10, "u": 10, "s": "hello", "f": 3.14, "struct": {"i": 2, "s": "world", "f": 1.23}, "slice": [1, 2, 3, 4, 5], "map": {"a": 1, "b": 1.23, "c": "json"}, "time": "0001-01-01T00:00:00Z", "duration": "5m0s"}
`
actual := "\n" + buf.String()
if expect != actual {
t.Fatalf("JSON style marshal error: expect=[%s] actual=[%s]", expect, actual)
}
}
func TestEncoder_MarshalAnchor(t *testing.T) {
type Host struct {
Hostname string
Username string
Password string
}
type HostDecl struct {
Host *Host `yaml:",anchor"`
}
type Queue struct {
Name string `yaml:","`
*Host
}
var doc struct {
Hosts []*HostDecl `yaml:"hosts"`
Queues []*Queue `yaml:"queues"`
}
host1 := &Host{
Hostname: "host1.example.com",
Username: "userA",
Password: "pass1",
}
host2 := &Host{
Hostname: "host2.example.com",
Username: "userB",
Password: "pass2",
}
doc.Hosts = []*HostDecl{
{
Host: host1,
},
{
Host: host2,
},
}
doc.Queues = []*Queue{
{
Name: "queue",
Host: host1,
}, {
Name: "queue2",
Host: host2,
},
}
hostIdx := 1
opt := yaml.MarshalAnchor(func(anchor *ast.AnchorNode, value interface{}) error {
if _, ok := value.(*Host); ok {
nameNode, _ := anchor.Name.(*ast.StringNode)
nameNode.Value = fmt.Sprintf("host%d", hostIdx)
hostIdx++
}
return nil
})
var buf bytes.Buffer
if err := yaml.NewEncoder(&buf, opt).Encode(doc); err != nil {
t.Fatalf("%+v", err)
}
expect := `
hosts:
- host: &host1
hostname: host1.example.com
username: userA
password: pass1
- host: &host2
hostname: host2.example.com
username: userB
password: pass2
queues:
- name: queue
host: *host1
- name: queue2
host: *host2
`
if "\n"+buf.String() != expect {
t.Fatalf("unexpected output. %s", buf.String())
}
}
type useJSONMarshalerTest struct{}
func (t useJSONMarshalerTest) MarshalJSON() ([]byte, error) {
return []byte(`{"a":[1, 2, 3]}`), nil
}
func TestEncoder_UseJSONMarshaler(t *testing.T) {
got, err := yaml.MarshalWithOptions(useJSONMarshalerTest{}, yaml.UseJSONMarshaler())
if err != nil {
t.Fatal(err)
}
expected := `
a:
- 1
- 2
- 3
`
if expected != "\n"+string(got) {
t.Fatalf("failed to use json marshaler. expected [%q] but got [%q]", expected, string(got))
}
}
func TestEncoder_CustomMarshaler(t *testing.T) {
t.Run("override struct type", func(t *testing.T) {
type T struct {
Foo string `yaml:"foo"`
}
b, err := yaml.MarshalWithOptions(&T{Foo: "bar"}, yaml.CustomMarshaler[T](func(v T) ([]byte, error) {
return []byte(`"override"`), nil
}))
if err != nil {
t.Fatal(err)
}
if !bytes.Equal(b, []byte("\"override\"\n")) {
t.Fatalf("failed to switch to custom marshaler. got: %q", b)
}
})
t.Run("override bytes type", func(t *testing.T) {
type T struct {
Foo []byte `yaml:"foo"`
}
b, err := yaml.MarshalWithOptions(&T{Foo: []byte("bar")}, yaml.CustomMarshaler[[]byte](func(v []byte) ([]byte, error) {
if !bytes.Equal(v, []byte("bar")) {
t.Fatalf("failed to get src buffer: %q", v)
}
return []byte(`override`), nil
}))
if err != nil {
t.Fatal(err)
}
if !bytes.Equal(b, []byte("foo: override\n")) {
t.Fatalf("failed to switch to custom marshaler. got: %q", b)
}
})
t.Run("override bytes type with context", func(t *testing.T) {
type T struct {
Foo []byte `yaml:"foo"`
}
ctx := context.WithValue(context.Background(), "plop", uint(42))
b, err := yaml.MarshalContext(ctx, &T{Foo: []byte("bar")}, yaml.CustomMarshalerContext[[]byte](func(ctx context.Context, v []byte) ([]byte, error) {
if !bytes.Equal(v, []byte("bar")) {
t.Fatalf("failed to get src buffer: %q", v)
}
if ctx.Value("plop") != uint(42) {
t.Fatalf("context value is not correct")
}
return []byte(`override`), nil
}))
if err != nil {
t.Fatal(err)
}
if !bytes.Equal(b, []byte("foo: override\n")) {
t.Fatalf("failed to switch to custom marshaler. got: %q", b)
}
})
}
func TestEncoder_AutoInt(t *testing.T) {
for _, test := range []struct {
desc string
input any
expected string
}{
{
desc: "int-convertible float64",
input: map[string]float64{
"key": 1.0,
},
expected: "key: 1\n",
},
{
desc: "non int-convertible float64",
input: map[string]float64{
"key": 1.1,
},
expected: "key: 1.1\n",
},
{
desc: "int-convertible float32",
input: map[string]float32{
"key": 1.0,
},
expected: "key: 1\n",
},
{
desc: "non int-convertible float32",
input: map[string]float32{
"key": 1.1,
},
expected: "key: 1.1\n",
},
} {
t.Run(test.desc, func(t *testing.T) {
var buf bytes.Buffer
enc := yaml.NewEncoder(&buf, yaml.AutoInt())
if err := enc.Encode(test.input); err != nil {
t.Fatalf("failed to encode: %s", err)
}
if actual := buf.String(); actual != test.expected {
t.Errorf("expect:\n%s\nactual\n%s\n", test.expected, actual)
}
})
}
}
func TestEncoder_MultipleDocuments(t *testing.T) {
var buf bytes.Buffer
enc := yaml.NewEncoder(&buf)
if err := enc.Encode(1); err != nil {
t.Fatalf("failed to encode: %s", err)
}
if err := enc.Encode(2); err != nil {
t.Fatalf("failed to encode: %s", err)
}
if actual, expect := buf.String(), "1\n---\n2\n"; actual != expect {
t.Errorf("expect:\n%s\nactual\n%s\n", expect, actual)
}
}
func TestEncoder_UnmarshallableTypes(t *testing.T) {
for _, test := range []struct {
desc string
input any
expectedErr string
}{
{
desc: "channel",
input: make(chan int),
expectedErr: "unknown value type chan int",
},
{
desc: "function",
input: func() {},
expectedErr: "unknown value type func()",
},
{
desc: "complex number",
input: complex(10, 11),
expectedErr: "unknown value type complex128",
},
{
desc: "unsafe pointer",
input: unsafe.Pointer(&struct{}{}),
expectedErr: "unknown value type unsafe.Pointer",
},
{
desc: "uintptr",
input: uintptr(0x1234),
expectedErr: "unknown value type uintptr",
},
{
desc: "map with channel",
input: map[string]any{"key": make(chan string)},
expectedErr: "unknown value type chan string",
},
{
desc: "nested map with func",
input: map[string]any{
"a": map[string]any{
"b": func(_ string) {},
},
},
expectedErr: "unknown value type func(string)",
},
{
desc: "slice with channel",
input: []any{make(chan bool)},
expectedErr: "unknown value type chan bool",
},
{
desc: "nested slice with complex number",
input: []any{[]any{complex(10, 11)}},
expectedErr: "unknown value type complex128",
},
{
desc: "struct with unsafe pointer",
input: struct {
Field unsafe.Pointer `yaml:"field"`
}{},
expectedErr: "unknown value type unsafe.Pointer",
},
} {
t.Run(test.desc, func(t *testing.T) {
var buf bytes.Buffer
err := yaml.NewEncoder(&buf).Encode(test.input)
if err == nil {
t.Errorf("expect error:\n%s\nbut got none\n", test.expectedErr)
} else if err.Error() != test.expectedErr {
t.Errorf("expect error:\n%s\nactual\n%s\n", test.expectedErr, err)
}
})
}
}
func ExampleMarshal_node() {
type T struct {
Text ast.Node `yaml:"text"`
}
stringNode, err := yaml.ValueToNode("node example")
if err != nil {
panic(err)
}
bytes, err := yaml.Marshal(T{Text: stringNode})
if err != nil {
panic(err)
}
fmt.Println(string(bytes))
// OUTPUT:
// text: node example
}
func ExampleMarshal_explicitAnchorAlias() {
type T struct {
A int
B string
}
var v struct {
C *T `yaml:"c,anchor=x"`
D *T `yaml:"d,alias=x"`
}
v.C = &T{A: 1, B: "hello"}
v.D = v.C
bytes, err := yaml.Marshal(v)
if err != nil {
panic(err)
}
fmt.Println(string(bytes))
// OUTPUT:
// c: &x
// a: 1
// b: hello
// d: *x
}
func ExampleMarshal_implicitAnchorAlias() {
type T struct {
I int
S string
}
var v struct {
A *T `yaml:"a,anchor"`
B *T `yaml:"b,anchor"`
C *T `yaml:"c"`
D *T `yaml:"d"`
}
v.A = &T{I: 1, S: "hello"}
v.B = &T{I: 2, S: "world"}
v.C = v.A // C has same pointer address to A
v.D = v.B // D has same pointer address to B
bytes, err := yaml.Marshal(v)
if err != nil {
panic(err)
}
fmt.Println(string(bytes))
// OUTPUT:
// a: &a
// i: 1
// s: hello
// b: &b
// i: 2
// s: world
// c: *a
// d: *b
}
type tMarshal []string
func (t *tMarshal) MarshalYAML() ([]byte, error) {
var buf bytes.Buffer
buf.WriteString("tags:\n")
for i, v := range *t {
if i == 0 {
fmt.Fprintf(&buf, "- %s\n", v)
} else {
fmt.Fprintf(&buf, " %s\n", v)
}
}
return buf.Bytes(), nil
}
func Test_Marshaler(t *testing.T) {
const expected = `- hello-world
`
// sanity check
var l []string
if err := yaml.Unmarshal([]byte(expected), &l); err != nil {
t.Fatalf("failed to parse string: %s", err)
}
buf, err := yaml.Marshal(tMarshal{"hello-world"})
if err != nil {
t.Fatalf("failed to marshal: %s", err)
}
if string(buf) != expected {
t.Fatalf("expected '%s', got '%s'", expected, buf)
}
t.Logf("%s", buf)
}
type marshalContext struct{}
func (c *marshalContext) MarshalYAML(ctx context.Context) ([]byte, error) {
v, ok := ctx.Value("k").(int)
if !ok {
return nil, errors.New("cannot get valid context")
}
if v != 1 {
return nil, errors.New("cannot get valid context")
}
return []byte("1"), nil
}
func Test_MarshalerContext(t *testing.T) {
ctx := context.WithValue(context.Background(), "k", 1)
bytes, err := yaml.MarshalContext(ctx, &marshalContext{})
if err != nil {
t.Fatalf("%+v", err)
}
if string(bytes) != "1\n" {
t.Fatalf("failed marshal: %q", string(bytes))
}
}
type SlowMarshaler struct {
A string
B int
}
type FastMarshaler struct {
A string
B int
}
type TextMarshaler int64
type TextMarshalerContainer struct {
Field TextMarshaler `yaml:"field"`
}
func (v SlowMarshaler) MarshalYAML() ([]byte, error) {
var buf bytes.Buffer
buf.WriteString("tags:\n")
buf.WriteString("- slow-marshaler\n")
buf.WriteString("a: " + v.A + "\n")
buf.WriteString("b: " + strconv.FormatInt(int64(v.B), 10) + "\n")
return buf.Bytes(), nil
}
func (v FastMarshaler) MarshalYAML() (interface{}, error) {
return yaml.MapSlice{
{"tags", []string{"fast-marshaler"}},
{"a", v.A},
{"b", v.B},
}, nil
}
func (t TextMarshaler) MarshalText() ([]byte, error) {
return []byte(strconv.FormatInt(int64(t), 8)), nil
}
func ExampleMarshal() {
var slow SlowMarshaler
slow.A = "Hello slow poke"
slow.B = 100
buf, err := yaml.Marshal(slow)
if err != nil {
panic(err.Error())
}
fmt.Println(string(buf))
var fast FastMarshaler
fast.A = "Hello speed demon"
fast.B = 100
buf, err = yaml.Marshal(fast)
if err != nil {
panic(err.Error())
}
fmt.Println(string(buf))
text := TextMarshalerContainer{
Field: 11,
}
buf, err = yaml.Marshal(text)
if err != nil {
panic(err.Error())
}
fmt.Println(string(buf))
// OUTPUT:
// tags:
// - slow-marshaler
// a: Hello slow poke
// b: 100
//
// tags:
// - fast-marshaler
// a: Hello speed demon
// b: 100
//
// field: "13"
}
func TestIssue356(t *testing.T) {
tests := map[string]struct {
in string
}{
"content on first line": {
in: `args:
- |
key:
nest1: something
nest2:
nest2a: b
`,
},
"empty first line": {
in: `args:
- |
key:
nest1: something
nest2:
nest2a: b
`,
},
}
for name, test := range tests {
t.Run(name, func(t *testing.T) {
f, err := parser.ParseBytes([]byte(test.in), 0)
if err != nil {
t.Fatalf("parse: %v", err)
}
got := f.String()
if test.in != got {
t.Fatalf("failed to encode.\nexpected:\n%s\nbut got:\n%s\n", test.in, got)
}
})
}
}
func TestMarshalIndentWithMultipleText(t *testing.T) {
tests := []struct {
name string
input map[string]interface{}
indent yaml.EncodeOption
want string
}{
{
name: "depth1",
input: map[string]interface{}{
"key": []string{`line1
line2
line3`},
},
indent: yaml.Indent(2),
want: `key:
- |-
line1
line2
line3
`,
},
{
name: "depth2",
input: map[string]interface{}{
"key": map[string]interface{}{
"key2": []string{`line1
line2
line3`},
},
},
indent: yaml.Indent(2),
want: `key:
key2:
- |-
line1
line2
line3
`,
},
{
name: "raw string new lines",
input: map[string]interface{}{
"key": "line1\nline2\nline3",
},
indent: yaml.Indent(4),
want: `key: |-
line1
line2
line3
`,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
b, err := yaml.MarshalWithOptions(tt.input, tt.indent)
if err != nil {
t.Fatalf("failed to marshal yaml: %v", err)
}
got := string(b)
if tt.want != got {
t.Fatalf("failed to encode.\nexpected:\n%s\nbut got:\n%s\n", tt.want, got)
}
})
}
}
type bytesMarshaler struct{}
func (b *bytesMarshaler) MarshalYAML() ([]byte, error) {
return yaml.Marshal(map[string]interface{}{"d": "foo"})
}
func TestBytesMarshaler(t *testing.T) {
b, err := yaml.Marshal(map[string]interface{}{
"a": map[string]interface{}{
"b": map[string]interface{}{
"c": &bytesMarshaler{},
},
},
})
if err != nil {
t.Fatal(err)
}
expected := `
a:
b:
c:
d: foo
`
got := "\n" + string(b)
if expected != got {
t.Fatalf("failed to encode. expected %s but got %s", expected, got)
}
}
type customMapSliceOneItemMarshaler struct{}
func (m *customMapSliceOneItemMarshaler) MarshalYAML() ([]byte, error) {
var v yaml.MapSlice
v = append(v, yaml.MapItem{"a", "b"})
return yaml.Marshal(v)
}
type customMapSliceTwoItemMarshaler struct{}
func (m *customMapSliceTwoItemMarshaler) MarshalYAML() ([]byte, error) {
var v yaml.MapSlice
v = append(v, yaml.MapItem{"a", "b"})
v = append(v, yaml.MapItem{"b", "c"})
return yaml.Marshal(v)
}
func TestCustomMapSliceMarshaler(t *testing.T) {
type T struct {
A *customMapSliceOneItemMarshaler `yaml:"a"`
B *customMapSliceTwoItemMarshaler `yaml:"b"`
}
b, err := yaml.Marshal(&T{
A: &customMapSliceOneItemMarshaler{},
B: &customMapSliceTwoItemMarshaler{},
})
if err != nil {
t.Fatal(err)
}
expected := `
a:
a: b
b:
a: b
b: c
`
got := "\n" + string(b)
if expected != got {
t.Fatalf("failed to encode. expected %s but got %s", expected, got)
}
}
type Issue174 struct {
K string
V []int
}
func (v Issue174) MarshalYAML() ([]byte, error) {
return yaml.MarshalWithOptions(map[string][]int{v.K: v.V}, yaml.Flow(true))
}
func TestIssue174(t *testing.T) {
b, err := yaml.Marshal(Issue174{"00:00:00-23:59:59", []int{1, 2, 3}})
if err != nil {
t.Fatal(err)
}
got := strings.TrimSuffix(string(b), "\n")
if got != `{"00:00:00-23:59:59": [1, 2, 3]}` {
t.Fatalf("failed to encode: %q", got)
}
}
func TestIssue259(t *testing.T) {
type AnchorValue struct {
Foo uint64
Bar string
}
type Value struct {
Baz string `yaml:"baz"`
Value *AnchorValue `yaml:"value,anchor"`
}
type Schema struct {
Values []*Value
}
schema := Schema{}
anchorValue := AnchorValue{Foo: 3, Bar: "bar"}
schema.Values = []*Value{
{Baz: "xxx", Value: &anchorValue},
{Baz: "yyy", Value: &anchorValue},
{Baz: "zzz", Value: &anchorValue},
}
b, err := yaml.Marshal(schema)
if err != nil {
t.Fatal(err)
}
expected := `
values:
- baz: xxx
value: &value
foo: 3
bar: bar
- baz: yyy
value: *value
- baz: zzz
value: *value
`
if strings.TrimPrefix(expected, "\n") != string(b) {
t.Fatalf("failed to encode: got = %s", string(b))
}
}
func TestTagMarshalling(t *testing.T) {
tests := []struct {
name string
input string
}{
{name: "scalar", input: "a: !mytag 1"},
{name: "mapping", input: `
a: !mytag
b: 2`},
{name: "sequence", input: `
a: !mytag
- 1
- 2
- 3`},
{name: "anchor before tag", input: `
a: &anc !mytag
- 1
- 2
- 3`},
{name: "flow mapping", input: "a: !mytag {b: 2}"},
{name: "flow sequence", input: "a: !mytag [1, 2, 3]"},
{name: "explicit type", input: "a: !!timestamp test"},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
res, _ := parser.ParseBytes([]byte(tt.input), 0)
result, err := yaml.Marshal(res.Docs[0])
if err != nil {
t.Fatal(err)
}
expected := strings.TrimSpace(tt.input)
output := strings.TrimSpace(string(result))
if expected != output {
t.Fatalf("input is not equal to output.\n\nexpected:\n%v\n actual:\n%v", expected, output)
}
})
}
}
func ptr[T any](v T) *T {
return &v
}
goccy-go-yaml-52dacb8/error.go 0000664 0000000 0000000 00000005116 15015766371 0016351 0 ustar 00root root 0000000 0000000 package yaml
import (
"fmt"
"github.com/goccy/go-yaml/ast"
"github.com/goccy/go-yaml/internal/errors"
)
var (
ErrInvalidQuery = errors.New("invalid query")
ErrInvalidPath = errors.New("invalid path instance")
ErrInvalidPathString = errors.New("invalid path string")
ErrNotFoundNode = errors.New("node not found")
ErrUnknownCommentPositionType = errors.New("unknown comment position type")
ErrInvalidCommentMapValue = errors.New("invalid comment map value. it must be not nil value")
ErrDecodeRequiredPointerType = errors.New("required pointer type value")
ErrExceededMaxDepth = errors.New("exceeded max depth")
FormatErrorWithToken = errors.FormatError
)
type (
SyntaxError = errors.SyntaxError
TypeError = errors.TypeError
OverflowError = errors.OverflowError
DuplicateKeyError = errors.DuplicateKeyError
UnknownFieldError = errors.UnknownFieldError
UnexpectedNodeTypeError = errors.UnexpectedNodeTypeError
Error = errors.Error
)
func ErrUnsupportedHeadPositionType(node ast.Node) error {
return fmt.Errorf("unsupported comment head position for %s", node.Type())
}
func ErrUnsupportedLinePositionType(node ast.Node) error {
return fmt.Errorf("unsupported comment line position for %s", node.Type())
}
func ErrUnsupportedFootPositionType(node ast.Node) error {
return fmt.Errorf("unsupported comment foot position for %s", node.Type())
}
// IsInvalidQueryError whether err is ErrInvalidQuery or not.
func IsInvalidQueryError(err error) bool {
return errors.Is(err, ErrInvalidQuery)
}
// IsInvalidPathError whether err is ErrInvalidPath or not.
func IsInvalidPathError(err error) bool {
return errors.Is(err, ErrInvalidPath)
}
// IsInvalidPathStringError whether err is ErrInvalidPathString or not.
func IsInvalidPathStringError(err error) bool {
return errors.Is(err, ErrInvalidPathString)
}
// IsNotFoundNodeError whether err is ErrNotFoundNode or not.
func IsNotFoundNodeError(err error) bool {
return errors.Is(err, ErrNotFoundNode)
}
// IsInvalidTokenTypeError whether err is ast.ErrInvalidTokenType or not.
func IsInvalidTokenTypeError(err error) bool {
return errors.Is(err, ast.ErrInvalidTokenType)
}
// IsInvalidAnchorNameError whether err is ast.ErrInvalidAnchorName or not.
func IsInvalidAnchorNameError(err error) bool {
return errors.Is(err, ast.ErrInvalidAnchorName)
}
// IsInvalidAliasNameError whether err is ast.ErrInvalidAliasName or not.
func IsInvalidAliasNameError(err error) bool {
return errors.Is(err, ast.ErrInvalidAliasName)
}
goccy-go-yaml-52dacb8/fuzz_test.go 0000664 0000000 0000000 00000001545 15015766371 0017257 0 ustar 00root root 0000000 0000000 package yaml_test
import (
"strings"
"testing"
"github.com/goccy/go-yaml"
)
func FuzzUnmarshalToMap(f *testing.F) {
const validYAML = `
id: 1
message: Hello, World
verified: true
`
invalidYAML := []string{
"0::",
"{0",
"*-0",
">\n>",
"&{0",
"0_",
"0\n:",
"0\n-",
"0\n0",
"0\n0\n",
"0\n0\n0",
"0\n0\n0\n",
"0\n0\n0\n0",
"0\n0\n0\n0\n",
"0\n0\n0\n0\n0",
"0\n0\n0\n0\n0\n",
"0\n0\n0\n0\n0\n0",
"0\n0\n0\n0\n0\n0\n",
"",
"00A: 0000A",
"{\"000\":0000A,",
}
f.Add([]byte(validYAML))
for _, s := range invalidYAML {
f.Add([]byte(s))
f.Add([]byte(validYAML + s))
f.Add([]byte(s + validYAML))
f.Add([]byte(s + validYAML + s))
f.Add([]byte(strings.Repeat(s, 3)))
}
f.Fuzz(func(t *testing.T, src []byte) {
v := map[string]any{}
if err := yaml.Unmarshal(src, &v); err != nil {
t.Log(err.Error())
}
})
}
goccy-go-yaml-52dacb8/go.mod 0000664 0000000 0000000 00000000053 15015766371 0015772 0 ustar 00root root 0000000 0000000 module github.com/goccy/go-yaml
go 1.21.0
goccy-go-yaml-52dacb8/go.sum 0000664 0000000 0000000 00000000000 15015766371 0016007 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/internal/ 0000775 0000000 0000000 00000000000 15015766371 0016502 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/internal/errors/ 0000775 0000000 0000000 00000000000 15015766371 0020016 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/internal/errors/error.go 0000664 0000000 0000000 00000013153 15015766371 0021501 0 ustar 00root root 0000000 0000000 package errors
import (
"errors"
"fmt"
"reflect"
"github.com/goccy/go-yaml/ast"
"github.com/goccy/go-yaml/printer"
"github.com/goccy/go-yaml/token"
)
var (
As = errors.As
Is = errors.Is
New = errors.New
)
const (
defaultFormatColor = false
defaultIncludeSource = true
)
type Error interface {
error
GetToken() *token.Token
GetMessage() string
FormatError(bool, bool) string
}
var (
_ Error = new(SyntaxError)
_ Error = new(TypeError)
_ Error = new(OverflowError)
_ Error = new(DuplicateKeyError)
_ Error = new(UnknownFieldError)
_ Error = new(UnexpectedNodeTypeError)
)
type SyntaxError struct {
Message string
Token *token.Token
}
type TypeError struct {
DstType reflect.Type
SrcType reflect.Type
StructFieldName *string
Token *token.Token
}
type OverflowError struct {
DstType reflect.Type
SrcNum string
Token *token.Token
}
type DuplicateKeyError struct {
Message string
Token *token.Token
}
type UnknownFieldError struct {
Message string
Token *token.Token
}
type UnexpectedNodeTypeError struct {
Actual ast.NodeType
Expected ast.NodeType
Token *token.Token
}
// ErrSyntax create syntax error instance with message and token
func ErrSyntax(msg string, tk *token.Token) *SyntaxError {
return &SyntaxError{
Message: msg,
Token: tk,
}
}
// ErrOverflow creates an overflow error instance with message and a token.
func ErrOverflow(dstType reflect.Type, num string, tk *token.Token) *OverflowError {
return &OverflowError{
DstType: dstType,
SrcNum: num,
Token: tk,
}
}
// ErrTypeMismatch cerates an type mismatch error instance with token.
func ErrTypeMismatch(dstType, srcType reflect.Type, token *token.Token) *TypeError {
return &TypeError{
DstType: dstType,
SrcType: srcType,
Token: token,
}
}
// ErrDuplicateKey creates an duplicate key error instance with token.
func ErrDuplicateKey(msg string, tk *token.Token) *DuplicateKeyError {
return &DuplicateKeyError{
Message: msg,
Token: tk,
}
}
// ErrUnknownField creates an unknown field error instance with token.
func ErrUnknownField(msg string, tk *token.Token) *UnknownFieldError {
return &UnknownFieldError{
Message: msg,
Token: tk,
}
}
func ErrUnexpectedNodeType(actual, expected ast.NodeType, tk *token.Token) *UnexpectedNodeTypeError {
return &UnexpectedNodeTypeError{
Actual: actual,
Expected: expected,
Token: tk,
}
}
func (e *SyntaxError) GetMessage() string {
return e.Message
}
func (e *SyntaxError) GetToken() *token.Token {
return e.Token
}
func (e *SyntaxError) Error() string {
return e.FormatError(defaultFormatColor, defaultIncludeSource)
}
func (e *SyntaxError) FormatError(colored, inclSource bool) string {
return FormatError(e.Message, e.Token, colored, inclSource)
}
func (e *OverflowError) GetMessage() string {
return e.msg()
}
func (e *OverflowError) GetToken() *token.Token {
return e.Token
}
func (e *OverflowError) Error() string {
return e.FormatError(defaultFormatColor, defaultIncludeSource)
}
func (e *OverflowError) FormatError(colored, inclSource bool) string {
return FormatError(e.msg(), e.Token, colored, inclSource)
}
func (e *OverflowError) msg() string {
return fmt.Sprintf("cannot unmarshal %s into Go value of type %s ( overflow )", e.SrcNum, e.DstType)
}
func (e *TypeError) msg() string {
if e.StructFieldName != nil {
return fmt.Sprintf("cannot unmarshal %s into Go struct field %s of type %s", e.SrcType, *e.StructFieldName, e.DstType)
}
return fmt.Sprintf("cannot unmarshal %s into Go value of type %s", e.SrcType, e.DstType)
}
func (e *TypeError) GetMessage() string {
return e.msg()
}
func (e *TypeError) GetToken() *token.Token {
return e.Token
}
func (e *TypeError) Error() string {
return e.FormatError(defaultFormatColor, defaultIncludeSource)
}
func (e *TypeError) FormatError(colored, inclSource bool) string {
return FormatError(e.msg(), e.Token, colored, inclSource)
}
func (e *DuplicateKeyError) GetMessage() string {
return e.Message
}
func (e *DuplicateKeyError) GetToken() *token.Token {
return e.Token
}
func (e *DuplicateKeyError) Error() string {
return e.FormatError(defaultFormatColor, defaultIncludeSource)
}
func (e *DuplicateKeyError) FormatError(colored, inclSource bool) string {
return FormatError(e.Message, e.Token, colored, inclSource)
}
func (e *UnknownFieldError) GetMessage() string {
return e.Message
}
func (e *UnknownFieldError) GetToken() *token.Token {
return e.Token
}
func (e *UnknownFieldError) Error() string {
return e.FormatError(defaultFormatColor, defaultIncludeSource)
}
func (e *UnknownFieldError) FormatError(colored, inclSource bool) string {
return FormatError(e.Message, e.Token, colored, inclSource)
}
func (e *UnexpectedNodeTypeError) GetMessage() string {
return e.msg()
}
func (e *UnexpectedNodeTypeError) GetToken() *token.Token {
return e.Token
}
func (e *UnexpectedNodeTypeError) Error() string {
return e.FormatError(defaultFormatColor, defaultIncludeSource)
}
func (e *UnexpectedNodeTypeError) FormatError(colored, inclSource bool) string {
return FormatError(e.msg(), e.Token, colored, inclSource)
}
func (e *UnexpectedNodeTypeError) msg() string {
return fmt.Sprintf("%s was used where %s is expected", e.Actual.YAMLName(), e.Expected.YAMLName())
}
func FormatError(errMsg string, token *token.Token, colored, inclSource bool) string {
var pp printer.Printer
if token == nil {
return pp.PrintErrorMessage(errMsg, colored)
}
pos := fmt.Sprintf("[%d:%d] ", token.Position.Line, token.Position.Column)
msg := pp.PrintErrorMessage(fmt.Sprintf("%s%s", pos, errMsg), colored)
if inclSource {
msg += "\n" + pp.PrintErrorToken(token, colored)
}
return msg
}
goccy-go-yaml-52dacb8/internal/format/ 0000775 0000000 0000000 00000000000 15015766371 0017772 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/internal/format/format.go 0000664 0000000 0000000 00000030765 15015766371 0021624 0 ustar 00root root 0000000 0000000 package format
import (
"strings"
"github.com/goccy/go-yaml/ast"
"github.com/goccy/go-yaml/token"
)
func FormatNodeWithResolvedAlias(n ast.Node, anchorNodeMap map[string]ast.Node) string {
tk := getFirstToken(n)
if tk == nil {
return ""
}
formatter := newFormatter(tk, hasComment(n))
formatter.anchorNodeMap = anchorNodeMap
return formatter.format(n)
}
func FormatNode(n ast.Node) string {
tk := getFirstToken(n)
if tk == nil {
return ""
}
return newFormatter(tk, hasComment(n)).format(n)
}
func FormatFile(file *ast.File) string {
if len(file.Docs) == 0 {
return ""
}
tk := getFirstToken(file.Docs[0])
if tk == nil {
return ""
}
return newFormatter(tk, hasCommentFile(file)).formatFile(file)
}
func hasCommentFile(f *ast.File) bool {
for _, doc := range f.Docs {
if hasComment(doc.Body) {
return true
}
}
return false
}
func hasComment(n ast.Node) bool {
if n == nil {
return false
}
switch nn := n.(type) {
case *ast.DocumentNode:
return hasComment(nn.Body)
case *ast.NullNode:
return nn.Comment != nil
case *ast.BoolNode:
return nn.Comment != nil
case *ast.IntegerNode:
return nn.Comment != nil
case *ast.FloatNode:
return nn.Comment != nil
case *ast.StringNode:
return nn.Comment != nil
case *ast.InfinityNode:
return nn.Comment != nil
case *ast.NanNode:
return nn.Comment != nil
case *ast.LiteralNode:
return nn.Comment != nil
case *ast.DirectiveNode:
if nn.Comment != nil {
return true
}
for _, value := range nn.Values {
if hasComment(value) {
return true
}
}
case *ast.TagNode:
if nn.Comment != nil {
return true
}
return hasComment(nn.Value)
case *ast.MappingNode:
if nn.Comment != nil || nn.FootComment != nil {
return true
}
for _, value := range nn.Values {
if value.Comment != nil || value.FootComment != nil {
return true
}
if hasComment(value.Key) {
return true
}
if hasComment(value.Value) {
return true
}
}
case *ast.MappingKeyNode:
return nn.Comment != nil
case *ast.MergeKeyNode:
return nn.Comment != nil
case *ast.SequenceNode:
if nn.Comment != nil || nn.FootComment != nil {
return true
}
for _, entry := range nn.Entries {
if entry.Comment != nil || entry.HeadComment != nil || entry.LineComment != nil {
return true
}
if hasComment(entry.Value) {
return true
}
}
case *ast.AnchorNode:
if nn.Comment != nil {
return true
}
if hasComment(nn.Name) || hasComment(nn.Value) {
return true
}
case *ast.AliasNode:
if nn.Comment != nil {
return true
}
if hasComment(nn.Value) {
return true
}
}
return false
}
func getFirstToken(n ast.Node) *token.Token {
if n == nil {
return nil
}
switch nn := n.(type) {
case *ast.DocumentNode:
if nn.Start != nil {
return nn.Start
}
return getFirstToken(nn.Body)
case *ast.NullNode:
return nn.Token
case *ast.BoolNode:
return nn.Token
case *ast.IntegerNode:
return nn.Token
case *ast.FloatNode:
return nn.Token
case *ast.StringNode:
return nn.Token
case *ast.InfinityNode:
return nn.Token
case *ast.NanNode:
return nn.Token
case *ast.LiteralNode:
return nn.Start
case *ast.DirectiveNode:
return nn.Start
case *ast.TagNode:
return nn.Start
case *ast.MappingNode:
if nn.IsFlowStyle {
return nn.Start
}
if len(nn.Values) == 0 {
return nn.Start
}
return getFirstToken(nn.Values[0].Key)
case *ast.MappingKeyNode:
return nn.Start
case *ast.MergeKeyNode:
return nn.Token
case *ast.SequenceNode:
return nn.Start
case *ast.AnchorNode:
return nn.Start
case *ast.AliasNode:
return nn.Start
}
return nil
}
type Formatter struct {
existsComment bool
tokenToOriginMap map[*token.Token]string
anchorNodeMap map[string]ast.Node
}
func newFormatter(tk *token.Token, existsComment bool) *Formatter {
tokenToOriginMap := make(map[*token.Token]string)
for tk.Prev != nil {
tk = tk.Prev
}
tokenToOriginMap[tk] = tk.Origin
var origin string
for tk.Next != nil {
tk = tk.Next
if tk.Type == token.CommentType {
origin += strings.Repeat("\n", strings.Count(normalizeNewLineChars(tk.Origin), "\n"))
continue
}
origin += tk.Origin
tokenToOriginMap[tk] = origin
origin = ""
}
return &Formatter{
existsComment: existsComment,
tokenToOriginMap: tokenToOriginMap,
}
}
func getIndentNumByFirstLineToken(tk *token.Token) int {
defaultIndent := tk.Position.Column - 1
// key: value
// ^
// next
if tk.Type == token.SequenceEntryType {
// If the current token is the sequence entry.
// the indent is calculated from the column value of the current token.
return defaultIndent
}
// key: value
// ^
// next
if tk.Next != nil && tk.Next.Type == token.MappingValueType {
// If the current token is the key in the mapping-value,
// the indent is calculated from the column value of the current token.
return defaultIndent
}
if tk.Prev == nil {
return defaultIndent
}
prev := tk.Prev
// key: value
// ^
// prev
if prev.Type == token.MappingValueType {
// If the current token is the value in the mapping-value,
// the indent is calculated from the column value of the key two steps back.
if prev.Prev == nil {
return defaultIndent
}
return prev.Prev.Position.Column - 1
}
// - value
// ^
// prev
if prev.Type == token.SequenceEntryType {
// If the value is not a mapping-value and the previous token was a sequence entry,
// the indent is calculated using the column value of the sequence entry token.
return prev.Position.Column - 1
}
return defaultIndent
}
func (f *Formatter) format(n ast.Node) string {
return f.trimSpacePrefix(
f.trimIndentSpace(
getIndentNumByFirstLineToken(getFirstToken(n)),
f.trimNewLineCharPrefix(f.formatNode(n)),
),
)
}
func (f *Formatter) formatFile(file *ast.File) string {
if len(file.Docs) == 0 {
return ""
}
var ret string
for _, doc := range file.Docs {
ret += f.formatDocument(doc)
}
return ret
}
func (f *Formatter) origin(tk *token.Token) string {
if tk == nil {
return ""
}
if f.existsComment {
return tk.Origin
}
return f.tokenToOriginMap[tk]
}
func (f *Formatter) formatDocument(n *ast.DocumentNode) string {
return f.origin(n.Start) + f.formatNode(n.Body) + f.origin(n.End)
}
func (f *Formatter) formatNull(n *ast.NullNode) string {
return f.origin(n.Token) + f.formatCommentGroup(n.Comment)
}
func (f *Formatter) formatString(n *ast.StringNode) string {
return f.origin(n.Token) + f.formatCommentGroup(n.Comment)
}
func (f *Formatter) formatInteger(n *ast.IntegerNode) string {
return f.origin(n.Token) + f.formatCommentGroup(n.Comment)
}
func (f *Formatter) formatFloat(n *ast.FloatNode) string {
return f.origin(n.Token) + f.formatCommentGroup(n.Comment)
}
func (f *Formatter) formatBool(n *ast.BoolNode) string {
return f.origin(n.Token) + f.formatCommentGroup(n.Comment)
}
func (f *Formatter) formatInfinity(n *ast.InfinityNode) string {
return f.origin(n.Token) + f.formatCommentGroup(n.Comment)
}
func (f *Formatter) formatNan(n *ast.NanNode) string {
return f.origin(n.Token) + f.formatCommentGroup(n.Comment)
}
func (f *Formatter) formatLiteral(n *ast.LiteralNode) string {
return f.origin(n.Start) + f.formatCommentGroup(n.Comment) + f.origin(n.Value.Token)
}
func (f *Formatter) formatMergeKey(n *ast.MergeKeyNode) string {
return f.origin(n.Token)
}
func (f *Formatter) formatMappingValue(n *ast.MappingValueNode) string {
return f.formatCommentGroup(n.Comment) +
f.origin(n.Key.GetToken()) + ":" + f.formatCommentGroup(n.Key.GetComment()) + f.formatNode(n.Value) +
f.formatCommentGroup(n.FootComment)
}
func (f *Formatter) formatDirective(n *ast.DirectiveNode) string {
ret := f.origin(n.Start) + f.formatNode(n.Name)
for _, val := range n.Values {
ret += f.formatNode(val)
}
return ret
}
func (f *Formatter) formatMapping(n *ast.MappingNode) string {
var ret string
if n.IsFlowStyle {
ret = f.origin(n.Start)
}
ret += f.formatCommentGroup(n.Comment)
for _, value := range n.Values {
if value.CollectEntry != nil {
ret += f.origin(value.CollectEntry)
}
ret += f.formatMappingValue(value)
}
if n.IsFlowStyle {
ret += f.origin(n.End)
}
return ret
}
func (f *Formatter) formatTag(n *ast.TagNode) string {
return f.origin(n.Start) + f.formatNode(n.Value)
}
func (f *Formatter) formatMappingKey(n *ast.MappingKeyNode) string {
return f.origin(n.Start) + f.formatNode(n.Value)
}
func (f *Formatter) formatSequence(n *ast.SequenceNode) string {
var ret string
if n.IsFlowStyle {
ret = f.origin(n.Start)
}
if n.Comment != nil {
// add head comment.
ret += f.formatCommentGroup(n.Comment)
}
for _, entry := range n.Entries {
ret += f.formatNode(entry)
}
if n.IsFlowStyle {
ret += f.origin(n.End)
}
ret += f.formatCommentGroup(n.FootComment)
return ret
}
func (f *Formatter) formatSequenceEntry(n *ast.SequenceEntryNode) string {
return f.formatCommentGroup(n.HeadComment) + f.origin(n.Start) + f.formatCommentGroup(n.LineComment) + f.formatNode(n.Value)
}
func (f *Formatter) formatAnchor(n *ast.AnchorNode) string {
return f.origin(n.Start) + f.formatNode(n.Name) + f.formatNode(n.Value)
}
func (f *Formatter) formatAlias(n *ast.AliasNode) string {
if f.anchorNodeMap != nil {
anchorName := n.Value.GetToken().Value
node := f.anchorNodeMap[anchorName]
if node != nil {
formatted := f.formatNode(node)
// If formatted text contains newline characters, indentation needs to be considered.
if strings.Contains(formatted, "\n") {
// If the first character is not a newline, the first line should be output without indentation.
isIgnoredFirstLine := !strings.HasPrefix(formatted, "\n")
formatted = f.addIndentSpace(n.GetToken().Position.IndentNum, formatted, isIgnoredFirstLine)
}
return formatted
}
}
return f.origin(n.Start) + f.formatNode(n.Value)
}
func (f *Formatter) formatNode(n ast.Node) string {
switch nn := n.(type) {
case *ast.DocumentNode:
return f.formatDocument(nn)
case *ast.NullNode:
return f.formatNull(nn)
case *ast.BoolNode:
return f.formatBool(nn)
case *ast.IntegerNode:
return f.formatInteger(nn)
case *ast.FloatNode:
return f.formatFloat(nn)
case *ast.StringNode:
return f.formatString(nn)
case *ast.InfinityNode:
return f.formatInfinity(nn)
case *ast.NanNode:
return f.formatNan(nn)
case *ast.LiteralNode:
return f.formatLiteral(nn)
case *ast.DirectiveNode:
return f.formatDirective(nn)
case *ast.TagNode:
return f.formatTag(nn)
case *ast.MappingNode:
return f.formatMapping(nn)
case *ast.MappingKeyNode:
return f.formatMappingKey(nn)
case *ast.MappingValueNode:
return f.formatMappingValue(nn)
case *ast.MergeKeyNode:
return f.formatMergeKey(nn)
case *ast.SequenceNode:
return f.formatSequence(nn)
case *ast.SequenceEntryNode:
return f.formatSequenceEntry(nn)
case *ast.AnchorNode:
return f.formatAnchor(nn)
case *ast.AliasNode:
return f.formatAlias(nn)
}
return ""
}
func (f *Formatter) formatCommentGroup(g *ast.CommentGroupNode) string {
if g == nil {
return ""
}
var ret string
for _, cm := range g.Comments {
ret += f.formatComment(cm)
}
return ret
}
func (f *Formatter) formatComment(n *ast.CommentNode) string {
if n == nil {
return ""
}
return n.Token.Origin
}
// nolint: unused
func (f *Formatter) formatIndent(col int) string {
if col <= 1 {
return ""
}
return strings.Repeat(" ", col-1)
}
func (f *Formatter) trimNewLineCharPrefix(v string) string {
return strings.TrimLeftFunc(v, func(r rune) bool {
return r == '\n' || r == '\r'
})
}
func (f *Formatter) trimSpacePrefix(v string) string {
return strings.TrimLeftFunc(v, func(r rune) bool {
return r == ' '
})
}
func (f *Formatter) trimIndentSpace(trimIndentNum int, v string) string {
if trimIndentNum == 0 {
return v
}
lines := strings.Split(normalizeNewLineChars(v), "\n")
out := make([]string, 0, len(lines))
for _, line := range lines {
var cnt int
out = append(out, strings.TrimLeftFunc(line, func(r rune) bool {
cnt++
return r == ' ' && cnt <= trimIndentNum
}))
}
return strings.Join(out, "\n")
}
func (f *Formatter) addIndentSpace(indentNum int, v string, isIgnoredFirstLine bool) string {
if indentNum == 0 {
return v
}
indent := strings.Repeat(" ", indentNum)
lines := strings.Split(normalizeNewLineChars(v), "\n")
out := make([]string, 0, len(lines))
for idx, line := range lines {
if line == "" || (isIgnoredFirstLine && idx == 0) {
out = append(out, line)
continue
}
out = append(out, indent+line)
}
return strings.Join(out, "\n")
}
// normalizeNewLineChars normalize CRLF and CR to LF.
func normalizeNewLineChars(v string) string {
return strings.ReplaceAll(strings.ReplaceAll(v, "\r\n", "\n"), "\r", "\n")
}
goccy-go-yaml-52dacb8/lexer/ 0000775 0000000 0000000 00000000000 15015766371 0016005 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/lexer/lexer.go 0000664 0000000 0000000 00000000564 15015766371 0017460 0 ustar 00root root 0000000 0000000 package lexer
import (
"io"
"github.com/goccy/go-yaml/scanner"
"github.com/goccy/go-yaml/token"
)
// Tokenize split to token instances from string
func Tokenize(src string) token.Tokens {
var s scanner.Scanner
s.Init(src)
var tokens token.Tokens
for {
subTokens, err := s.Scan()
if err == io.EOF {
break
}
tokens.Add(subTokens...)
}
return tokens
}
goccy-go-yaml-52dacb8/lexer/lexer_test.go 0000664 0000000 0000000 00000232246 15015766371 0020523 0 ustar 00root root 0000000 0000000 package lexer_test
import (
"sort"
"testing"
"github.com/goccy/go-yaml/lexer"
"github.com/goccy/go-yaml/token"
)
func TestTokenize(t *testing.T) {
tests := []struct {
YAML string
Tokens token.Tokens
}{
{
YAML: `null
`,
Tokens: token.Tokens{
{
Type: token.NullType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "null",
Origin: "null\n ",
},
},
},
{
YAML: `0_`,
Tokens: token.Tokens{
{
Type: token.IntegerType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "0_",
Origin: "0_",
},
},
},
{
YAML: `"hello\tworld"`,
Tokens: token.Tokens{
{
Type: token.DoubleQuoteType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.QuotedScalarIndicator,
Value: "hello\tworld",
Origin: `"hello\tworld"`,
},
},
},
{
YAML: `0x_1A_2B_3C`,
Tokens: token.Tokens{
{
Type: token.HexIntegerType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "0x_1A_2B_3C",
Origin: "0x_1A_2B_3C",
},
},
},
{
YAML: `+0b1010`,
Tokens: token.Tokens{
{
Type: token.BinaryIntegerType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "+0b1010",
Origin: "+0b1010",
},
},
},
{
YAML: `0100`,
Tokens: token.Tokens{
{
Type: token.OctetIntegerType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "0100",
Origin: "0100",
},
},
},
{
YAML: `0o10`,
Tokens: token.Tokens{
{
Type: token.OctetIntegerType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "0o10",
Origin: "0o10",
},
},
},
{
YAML: `0.123e+123`,
Tokens: token.Tokens{
{
Type: token.FloatType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "0.123e+123",
Origin: "0.123e+123",
},
},
},
{
YAML: `{}
`,
Tokens: token.Tokens{
{
Type: token.MappingStartType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.FlowCollectionIndicator,
Value: "{",
Origin: "{",
},
{
Type: token.MappingEndType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.FlowCollectionIndicator,
Value: "}",
Origin: "}",
},
},
},
{
YAML: `v: hi`,
Tokens: token.Tokens{
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "v",
Origin: "v",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "hi",
Origin: " hi",
},
},
},
{
YAML: `v: a`,
Tokens: token.Tokens{
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "v",
Origin: "v",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "a",
// nolint: gci
Origin: " a",
},
},
},
{
YAML: `v: "true"`,
Tokens: token.Tokens{
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "v",
Origin: "v",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.DoubleQuoteType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.QuotedScalarIndicator,
Value: "true",
Origin: " \"true\"",
},
},
},
{
YAML: `v: "false"`,
Tokens: token.Tokens{
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "v",
Origin: "v",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.DoubleQuoteType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.QuotedScalarIndicator,
Value: "false",
Origin: " \"false\"",
},
},
},
{
YAML: `v: true`,
Tokens: token.Tokens{
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "v",
Origin: "v",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.BoolType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "true",
Origin: " true",
},
},
},
{
YAML: `v: false`,
Tokens: token.Tokens{
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "v",
Origin: "v",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.BoolType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "false",
Origin: " false",
},
},
},
{
YAML: `v: 10`,
Tokens: token.Tokens{
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "v",
Origin: "v",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.IntegerType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "10",
Origin: " 10",
},
},
},
{
YAML: `v: -10`,
Tokens: token.Tokens{
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "v",
Origin: "v",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.IntegerType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "-10",
Origin: " -10",
},
},
},
{
YAML: `v: 42`,
Tokens: token.Tokens{
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "v",
Origin: "v",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.IntegerType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "42",
Origin: " 42",
},
},
},
{
YAML: `v: 4294967296`,
Tokens: token.Tokens{
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "v",
Origin: "v",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.IntegerType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "4294967296",
Origin: " 4294967296",
},
},
},
{
YAML: `v: "10"`,
Tokens: token.Tokens{
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "v",
Origin: "v",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.DoubleQuoteType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.QuotedScalarIndicator,
Value: "10",
Origin: " \"10\"",
},
},
},
{
YAML: `v: 0.1`,
Tokens: token.Tokens{
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "v",
Origin: "v",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.FloatType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "0.1",
Origin: " 0.1",
},
},
},
{
YAML: `v: 0.99`,
Tokens: token.Tokens{
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "v",
Origin: "v",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.FloatType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "0.99",
Origin: " 0.99",
},
},
},
{
YAML: `v: -0.1`,
Tokens: token.Tokens{
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "v",
Origin: "v",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.FloatType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "-0.1",
Origin: " -0.1",
},
},
},
{
YAML: `v: .inf`,
Tokens: token.Tokens{
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "v",
Origin: "v",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.InfinityType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: ".inf",
Origin: " .inf",
},
},
},
{
YAML: `v: -.inf`,
Tokens: token.Tokens{
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "v",
Origin: "v",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.InfinityType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "-.inf",
Origin: " -.inf",
},
},
},
{
YAML: `v: .nan`,
Tokens: token.Tokens{
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "v",
Origin: "v",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.NanType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: ".nan",
Origin: " .nan",
},
},
},
{
YAML: `
a:
"bbb \
ccc
ddd eee\n\
\ \ fff ggg\nhhh iii\n
jjj kkk
"
`,
Tokens: token.Tokens{
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "a",
Origin: "\na",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.DoubleQuoteType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.QuotedScalarIndicator,
Value: "bbb ccc\nddd eee\n fff ggg\nhhh iii\n jjj kkk ",
Origin: "\n \"bbb \\\n ccc\n\n ddd eee\\n\\\n \\ \\ fff ggg\\nhhh iii\\n\n jjj kkk\n \"",
},
},
},
{
YAML: `v: null`,
Tokens: token.Tokens{
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "v",
Origin: "v",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.NullType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "null",
Origin: " null",
},
},
},
{
YAML: `v: ""`,
Tokens: token.Tokens{
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "v",
Origin: "v",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.DoubleQuoteType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.QuotedScalarIndicator,
Value: "",
Origin: " \"\"",
},
},
},
{
YAML: `
v:
- A
- B
`,
Tokens: token.Tokens{
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "v",
Origin: "\nv",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.SequenceEntryType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: "-",
Origin: "\n-",
},
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "A",
Origin: " A\n",
},
{
Type: token.SequenceEntryType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: "-",
Origin: "-",
},
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "B",
Origin: " B",
},
},
},
{
YAML: `
v:
- A
- |-
B
C
`,
Tokens: token.Tokens{
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "v",
Origin: "\nv",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.SequenceEntryType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: "-",
Origin: "\n-",
},
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "A",
Origin: " A\n",
},
{
Type: token.SequenceEntryType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: "-",
Origin: "-",
},
{
Type: token.LiteralType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockScalarIndicator,
Value: "|-",
Origin: " |-\n",
},
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "B\nC",
Origin: " B\n C\n",
},
},
},
{
YAML: `
v:
- A
- 1
- B:
- 2
- 3
`,
Tokens: token.Tokens{
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "v",
Origin: "\nv",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.SequenceEntryType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: "-",
Origin: "\n-",
},
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "A",
Origin: " A\n",
},
{
Type: token.SequenceEntryType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: "-",
Origin: "-",
},
{
Type: token.IntegerType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "1",
Origin: " 1\n",
},
{
Type: token.SequenceEntryType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: "-",
Origin: "-",
},
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "B",
Origin: " B",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.SequenceEntryType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: "-",
Origin: "\n -",
},
{
Type: token.IntegerType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "2",
Origin: " 2\n ",
},
{
Type: token.SequenceEntryType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: "-",
Origin: "-",
},
{
Type: token.IntegerType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "3",
Origin: " 3",
},
},
},
{
YAML: `
a:
b: c
`,
Tokens: token.Tokens{
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "a",
Origin: "\na",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "b",
Origin: "\n b",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "c",
Origin: " c",
},
},
},
{
YAML: `a: '-'`,
Tokens: token.Tokens{
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "a",
Origin: "a",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.SingleQuoteType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.QuotedScalarIndicator,
Value: "-",
Origin: " '-'",
},
},
},
{
YAML: `123`,
Tokens: token.Tokens{
{
Type: token.IntegerType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "123",
Origin: "123",
},
},
},
{
YAML: `hello: world
`,
Tokens: token.Tokens{
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "hello",
Origin: "hello",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "world",
Origin: " world",
},
},
},
{
YAML: `a: null`,
Tokens: token.Tokens{
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "a",
Origin: "a",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.NullType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "null",
Origin: " null",
},
},
},
{
YAML: `a: {x: 1}`,
Tokens: token.Tokens{
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "a",
Origin: "a",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.MappingStartType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.FlowCollectionIndicator,
Value: "{",
Origin: " {",
},
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "x",
Origin: "x",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.IntegerType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "1",
Origin: " 1",
},
{
Type: token.MappingEndType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.FlowCollectionIndicator,
Value: "}",
Origin: "}",
},
},
},
{
YAML: `a: [1, 2]`,
Tokens: token.Tokens{
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "a",
Origin: "a",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.SequenceStartType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.FlowCollectionIndicator,
Value: "[",
Origin: " [",
},
{
Type: token.IntegerType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "1",
Origin: "1",
},
{
Type: token.CollectEntryType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.FlowCollectionIndicator,
Value: ",",
Origin: ",",
},
{
Type: token.IntegerType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "2",
Origin: " 2",
},
{
Type: token.SequenceEndType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.FlowCollectionIndicator,
Value: "]",
Origin: "]",
},
},
},
{
YAML: `
t2: 2018-01-09T10:40:47Z
t4: 2098-01-09T10:40:47Z
`,
Tokens: token.Tokens{
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "t2",
Origin: "\nt2",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "2018-01-09T10:40:47Z",
Origin: " 2018-01-09T10:40:47Z\n",
},
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "t4",
Origin: "t4",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "2098-01-09T10:40:47Z",
Origin: " 2098-01-09T10:40:47Z",
},
},
},
{
YAML: `a: {b: c, d: e}`,
Tokens: token.Tokens{
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "a",
Origin: "a",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.MappingStartType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.FlowCollectionIndicator,
Value: "{",
Origin: " {",
},
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "b",
Origin: "b",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "c",
Origin: " c",
},
{
Type: token.CollectEntryType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.FlowCollectionIndicator,
Value: ",",
Origin: ",",
},
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "d",
Origin: " d",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "e",
Origin: " e",
},
{
Type: token.MappingEndType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.FlowCollectionIndicator,
Value: "}",
Origin: "}",
},
},
},
{
YAML: `a: 3s`,
Tokens: token.Tokens{
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "a",
Origin: "a",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "3s",
Origin: " 3s",
},
},
},
{
YAML: `a: `,
Tokens: token.Tokens{
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "a",
Origin: "a",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "",
Origin: " ",
},
},
},
{
YAML: `a: "1:1"`,
Tokens: token.Tokens{
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "a",
Origin: "a",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.DoubleQuoteType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.QuotedScalarIndicator,
Value: "1:1",
Origin: " \"1:1\"",
},
},
},
{
YAML: `a: "\0"`,
Tokens: token.Tokens{
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "a",
Origin: "a",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.DoubleQuoteType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.QuotedScalarIndicator,
Value: "\x00",
Origin: " \"\\0\"",
},
},
},
{
YAML: `a: !!binary gIGC`,
Tokens: token.Tokens{
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "a",
Origin: "a",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.TagType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.NodePropertyIndicator,
Value: "!!binary",
Origin: " !!binary ",
},
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "gIGC",
Origin: "gIGC",
},
},
},
{
YAML: `
a: !!binary |
kJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJ
CQ
`,
Tokens: token.Tokens{
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "a",
Origin: "\na",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.TagType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.NodePropertyIndicator,
Value: "!!binary",
Origin: " !!binary ",
},
{
Type: token.LiteralType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockScalarIndicator,
Value: "|",
Origin: "|\n",
},
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "kJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJ\nCQ\n",
Origin: " kJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJ\n CQ\n",
},
},
},
{
YAML: `
b: 2
a: 1
d: 4
c: 3
sub:
e: 5
`,
Tokens: token.Tokens{
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "b",
Origin: "\nb",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.IntegerType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "2",
Origin: " 2\n",
},
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "a",
Origin: "a",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.IntegerType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "1",
Origin: " 1\n",
},
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "d",
Origin: "d",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.IntegerType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "4",
Origin: " 4\n",
},
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "c",
Origin: "c",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.IntegerType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "3",
Origin: " 3\n",
},
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "sub",
Origin: "sub",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "e",
Origin: "\n e",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.IntegerType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "5",
Origin: " 5",
},
},
},
{
YAML: `a: 1.2.3.4`,
Tokens: token.Tokens{
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "a",
Origin: "a",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "1.2.3.4",
Origin: " 1.2.3.4",
},
},
},
{
YAML: `a: "2015-02-24T18:19:39Z"`,
Tokens: token.Tokens{
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "a",
Origin: "a",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.DoubleQuoteType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.QuotedScalarIndicator,
Value: "2015-02-24T18:19:39Z",
Origin: " \"2015-02-24T18:19:39Z\"",
},
},
},
{
YAML: `a: 'b: c'`,
Tokens: token.Tokens{
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "a",
Origin: "a",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.SingleQuoteType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.QuotedScalarIndicator,
Value: "b: c",
Origin: " 'b: c'",
},
},
},
{
YAML: `a: 'Hello #comment'`,
Tokens: token.Tokens{
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "a",
Origin: "a",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.SingleQuoteType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.QuotedScalarIndicator,
Value: "Hello #comment",
Origin: " 'Hello #comment'",
},
},
},
{
YAML: `a: 100.5`,
Tokens: token.Tokens{
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "a",
Origin: "a",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.FloatType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "100.5",
Origin: " 100.5",
},
},
},
{
YAML: `a: bogus`,
Tokens: token.Tokens{
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "a",
Origin: "a",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "bogus",
Origin: " bogus",
},
},
},
{
YAML: `"a": double quoted map key`,
Tokens: token.Tokens{
{
Type: token.DoubleQuoteType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.QuotedScalarIndicator,
Value: "a",
Origin: "\"a\"",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "double quoted map key",
Origin: " double quoted map key",
},
},
},
{
YAML: `'a': single quoted map key`,
Tokens: token.Tokens{
{
Type: token.SingleQuoteType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.QuotedScalarIndicator,
Value: "a",
Origin: "'a'",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "single quoted map key",
Origin: " single quoted map key",
},
},
},
{
YAML: `
a: "double quoted"
b: "value map"`,
Tokens: token.Tokens{
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "a",
Origin: "\na",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.DoubleQuoteType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.QuotedScalarIndicator,
Value: "double quoted",
Origin: " \"double quoted\"",
},
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "b",
Origin: "\nb",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.DoubleQuoteType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.QuotedScalarIndicator,
Value: "value map",
Origin: " \"value map\"",
},
},
},
{
YAML: `
a: 'single quoted'
b: 'value map'`,
Tokens: token.Tokens{
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "a",
Origin: "\na",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.SingleQuoteType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.QuotedScalarIndicator,
Value: "single quoted",
Origin: " 'single quoted'",
},
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "b",
Origin: "\nb",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.SingleQuoteType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.QuotedScalarIndicator,
Value: "value map",
Origin: " 'value map'",
},
},
},
{
YAML: `json: '\"expression\": \"thi:\"'`,
Tokens: token.Tokens{
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "json",
Origin: "json",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.SingleQuoteType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.QuotedScalarIndicator,
Value: "\\\"expression\\\": \\\"thi:\\\"",
Origin: " '\\\"expression\\\": \\\"thi:\\\"'",
},
},
},
{
YAML: `json: "\"expression\": \"thi:\""`,
Tokens: token.Tokens{
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "json",
Origin: "json",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.DoubleQuoteType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.QuotedScalarIndicator,
Value: "\"expression\": \"thi:\"",
Origin: " \"\\\"expression\\\": \\\"thi:\\\"\"",
},
},
},
{
YAML: `
a:
b
c
`,
Tokens: token.Tokens{
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "a",
Origin: "\na",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "b\nc",
Origin: "\n b\n\n c",
},
},
},
{
YAML: `
a:
b
c
d
e: f
`,
Tokens: token.Tokens{
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "a",
Origin: "\na",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "b\nc d",
Origin: "\n b\n\n\n c\n d\n",
},
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "e",
Origin: "e",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "f",
Origin: " f",
},
},
},
{
YAML: `
a: |
b
c
d
e: f
`,
Tokens: token.Tokens{
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "a",
Origin: "\na",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.LiteralType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockScalarIndicator,
Value: "|",
Origin: " |\n",
},
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "b \n\n \nc\nd \n",
Origin: " b \n\n \n c\n d \n",
},
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "e",
Origin: "e",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "f",
Origin: " f",
},
},
},
{
YAML: `
a: >
b
c
d
e: f
`,
Tokens: token.Tokens{
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "a",
Origin: "\na",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.FoldedType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockScalarIndicator,
Value: ">",
Origin: " >\n",
},
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "b \n\n \nc d \n",
Origin: " b \n\n \n c\n d \n",
},
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "e",
Origin: "e",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "f",
Origin: " f",
},
},
},
{
YAML: `
a: >
Text`,
Tokens: token.Tokens{
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "a",
Origin: "\na",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.FoldedType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockScalarIndicator,
Value: ">",
Origin: " >\n",
},
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "Text",
Origin: " Text",
},
},
},
{
YAML: `
s: >
1s
`,
Tokens: token.Tokens{
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "s",
Origin: "\ns",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.FoldedType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockScalarIndicator,
Value: ">",
Origin: " >\n",
},
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "1s\n",
Origin: " 1s\n",
},
},
},
{
YAML: `
s: >1 # comment
1s
`,
Tokens: token.Tokens{
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "s",
Origin: "\ns",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.FoldedType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockScalarIndicator,
Value: ">1",
Origin: " >1 ",
},
{
Type: token.CommentType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.CommentIndicator,
Value: " comment",
Origin: "# comment\n",
},
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: " 1s\n",
Origin: " 1s\n",
},
},
},
{
YAML: `
s: >+2
1s
`,
Tokens: token.Tokens{
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "s",
Origin: "\ns",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.FoldedType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockScalarIndicator,
Value: ">+2",
Origin: " >+2\n",
},
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: " 1s\n",
Origin: " 1s\n",
},
},
},
{
YAML: `
s: >-3
1s
`,
Tokens: token.Tokens{
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "s",
Origin: "\ns",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.FoldedType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockScalarIndicator,
Value: ">-3",
Origin: " >-3\n",
},
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: " 1s",
Origin: " 1s\n",
},
},
},
{
YAML: `
s: >
1s
2s
`,
Tokens: token.Tokens{
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "s",
Origin: "\ns",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.FoldedType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockScalarIndicator,
Value: ">",
Origin: " >\n",
},
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "1s 2s\n",
Origin: " 1s\n 2s\n",
},
},
},
{
YAML: `
s: >
1s
2s
3s
`,
Tokens: token.Tokens{
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "s",
Origin: "\ns",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.FoldedType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockScalarIndicator,
Value: ">",
Origin: " >\n",
},
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "1s\n 2s\n3s\n",
Origin: " 1s\n 2s\n 3s\n",
},
},
},
{
YAML: `
s: >
1s
2s
3s
4s
5s
`,
Tokens: token.Tokens{
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "s",
Origin: "\ns",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.FoldedType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockScalarIndicator,
Value: ">",
Origin: " >\n",
},
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "1s\n 2s\n 3s\n4s 5s\n",
Origin: " 1s\n 2s\n 3s\n 4s\n 5s\n",
},
},
},
{
YAML: `
s: >-3
1s
2s
3s
4s
5s
`,
Tokens: token.Tokens{
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "s",
Origin: "\ns",
},
{
Type: token.MappingValueType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockStructureIndicator,
Value: ":",
Origin: ":",
},
{
Type: token.FoldedType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockScalarIndicator,
Value: ">-3",
Origin: " >-3\n",
},
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: " 1s\n 2s\n 3s\n 4s\n 5s",
Origin: " 1s\n 2s\n 3s\n 4s\n 5s\n",
},
},
},
{
YAML: `
|2-
text
`,
Tokens: token.Tokens{
{
Type: token.LiteralType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockScalarIndicator,
Value: "|2-",
Origin: "\n|2-\n",
},
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "\n text",
Origin: "\n text\n",
},
},
},
{
YAML: `
|
a
`,
Tokens: token.Tokens{
{
Type: token.LiteralType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockScalarIndicator,
Value: "|",
Origin: "\n|\n",
},
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "a\n",
Origin: " a\n\n\n\n",
},
},
},
{
YAML: `
| # comment
foo
`,
Tokens: token.Tokens{
{
Type: token.LiteralType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.BlockScalarIndicator,
Value: "|",
Origin: "\n| ",
},
{
Type: token.CommentType,
CharacterType: token.CharacterTypeIndicator,
Indicator: token.CommentIndicator,
Value: " comment",
Origin: "# comment\n",
},
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "foo\n",
Origin: " foo\n",
},
},
},
{
YAML: `1x0`,
Tokens: token.Tokens{
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "1x0",
Origin: "1x0",
},
},
},
{
YAML: `0b98765`,
Tokens: token.Tokens{
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "0b98765",
Origin: "0b98765",
},
},
},
{
YAML: `098765`,
Tokens: token.Tokens{
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "098765",
Origin: "098765",
},
},
},
{
YAML: `0o98765`,
Tokens: token.Tokens{
{
Type: token.StringType,
CharacterType: token.CharacterTypeMiscellaneous,
Indicator: token.NotIndicator,
Value: "0o98765",
Origin: "0o98765",
},
},
},
}
for _, test := range tests {
t.Run(test.YAML, func(t *testing.T) {
tokens := lexer.Tokenize(test.YAML)
if len(tokens) != len(test.Tokens) {
t.Fatalf("Tokenize(%q) token count mismatch, expected: %d got: %d", test.YAML, len(test.Tokens), len(tokens))
}
for i := range test.Tokens {
if tokens[i].Type != test.Tokens[i].Type {
t.Errorf("Tokenize(%q)[%d] token.Type mismatch, expected: %s got: %s", test.YAML, i, test.Tokens[i].Type, tokens[i].Type)
}
if tokens[i].CharacterType != test.Tokens[i].CharacterType {
t.Errorf("Tokenize(%q)[%d] token.CharacterType mismatch, expected: %s got: %s", test.YAML, i, test.Tokens[i].CharacterType, tokens[i].CharacterType)
}
if tokens[i].Indicator != test.Tokens[i].Indicator {
t.Errorf("Tokenize(%q)[%d] token.Indicator mismatch, expected: %s got: %s", test.YAML, i, test.Tokens[i].Indicator, tokens[i].Indicator)
}
if tokens[i].Value != test.Tokens[i].Value {
t.Errorf("Tokenize(%q)[%d] token.Value mismatch, expected: %q got: %q", test.YAML, i, test.Tokens[i].Value, tokens[i].Value)
}
if tokens[i].Origin != test.Tokens[i].Origin {
t.Errorf("Tokenize(%q)[%d] token.Origin mismatch, expected: %q got: %q", test.YAML, i, test.Tokens[i].Origin, tokens[i].Origin)
}
}
})
}
}
type testToken struct {
line int
column int
value string
}
func TestSingleLineToken_ValueLineColumnPosition(t *testing.T) {
tests := []struct {
name string
src string
expect map[int]string // Column -> Value map.
}{
{
name: "single quote, single value array",
src: "test: ['test']",
expect: map[int]string{
1: "test",
5: ":",
7: "[",
8: "test",
14: "]",
},
},
{
name: "double quote, single value array",
src: `test: ["test"]`,
expect: map[int]string{
1: "test",
5: ":",
7: "[",
8: "test",
14: "]",
},
},
{
name: "no quotes, single value array",
src: "test: [somevalue]",
expect: map[int]string{
1: "test",
5: ":",
7: "[",
8: "somevalue",
17: "]",
},
},
{
name: "single quote, multi value array",
src: "myarr: ['1','2','3', '444' , '55','66' , '77' ]",
expect: map[int]string{
1: "myarr",
6: ":",
8: "[",
9: "1",
12: ",",
13: "2",
16: ",",
17: "3",
20: ",",
22: "444",
28: ",",
30: "55",
34: ",",
35: "66",
40: ",",
43: "77",
49: "]",
},
},
{
name: "double quote, multi value array",
src: `myarr: ["1","2","3", "444" , "55","66" , "77" ]`,
expect: map[int]string{
1: "myarr",
6: ":",
8: "[",
9: "1",
12: ",",
13: "2",
16: ",",
17: "3",
20: ",",
22: "444",
28: ",",
30: "55",
34: ",",
35: "66",
40: ",",
43: "77",
49: "]",
},
},
{
name: "no quote, multi value array",
src: "numbers: [1, 5, 99,100, 3, 7 ]",
expect: map[int]string{
1: "numbers",
8: ":",
10: "[",
11: "1",
12: ",",
14: "5",
15: ",",
17: "99",
19: ",",
20: "100",
23: ",",
25: "3",
26: ",",
28: "7",
30: "]",
},
},
{
name: "double quotes, nested arrays",
src: `Strings: ["1",["2",["3"]]]`,
expect: map[int]string{
1: "Strings",
8: ":",
10: "[",
11: "1",
14: ",",
15: "[",
16: "2",
19: ",",
20: "[",
21: "3",
24: "]",
25: "]",
26: "]",
},
},
{
name: "mixed quotes, nested arrays",
src: `Values: [1,['2',"3",4,["5",6]]]`,
expect: map[int]string{
1: "Values",
7: ":",
9: "[",
10: "1",
11: ",",
12: "[",
13: "2",
16: ",",
17: "3",
20: ",",
21: "4",
22: ",",
23: "[",
24: "5",
27: ",",
28: "6",
29: "]",
30: "]",
31: "]",
},
},
{
name: "double quote, empty array",
src: `Empty: ["", ""]`,
expect: map[int]string{
1: "Empty",
6: ":",
8: "[",
9: "",
11: ",",
13: "",
15: "]",
},
},
{
name: "double quote key",
src: `"a": b`,
expect: map[int]string{
1: "a",
4: ":",
6: "b",
},
},
{
name: "single quote key",
src: `'a': b`,
expect: map[int]string{
1: "a",
4: ":",
6: "b",
},
},
{
name: "double quote key and value",
src: `"a": "b"`,
expect: map[int]string{
1: "a",
4: ":",
6: "b",
},
},
{
name: "single quote key and value",
src: `'a': 'b'`,
expect: map[int]string{
1: "a",
4: ":",
6: "b",
},
},
{
name: "double quote key, single quote value",
src: `"a": 'b'`,
expect: map[int]string{
1: "a",
4: ":",
6: "b",
},
},
{
name: "single quote key, double quote value",
src: `'a': "b"`,
expect: map[int]string{
1: "a",
4: ":",
6: "b",
},
},
}
for _, tc := range tests {
t.Run(tc.name, func(t *testing.T) {
got := lexer.Tokenize(tc.src)
sort.Slice(got, func(i, j int) bool {
return got[i].Position.Column < got[j].Position.Column
})
var expected []testToken
for k, v := range tc.expect {
tt := testToken{
line: 1,
column: k,
value: v,
}
expected = append(expected, tt)
}
sort.Slice(expected, func(i, j int) bool {
return expected[i].column < expected[j].column
})
if len(got) != len(expected) {
t.Errorf("Tokenize(%s) token count mismatch, expected:%d got:%d", tc.src, len(expected), len(got))
}
for i, tok := range got {
if !tokenMatches(tok, expected[i]) {
t.Errorf("Tokenize(%s) expected:%+v got line:%d column:%d value:%s", tc.src, expected[i], tok.Position.Line, tok.Position.Column, tok.Value)
}
}
})
}
}
func tokenMatches(t *token.Token, e testToken) bool {
return t != nil && t.Position != nil &&
t.Value == e.value &&
t.Position.Line == e.line &&
t.Position.Column == e.column
}
func TestMultiLineToken_ValueLineColumnPosition(t *testing.T) {
tests := []struct {
name string
src string
expect []testToken
}{
{
name: "double quote",
src: `one: "1 2 3 4 5"
two: "1 2
3 4
5"
three: "1 2 3 4
5"`,
expect: []testToken{
{
line: 1,
column: 1,
value: "one",
},
{
line: 1,
column: 4,
value: ":",
},
{
line: 1,
column: 6,
value: "1 2 3 4 5",
},
{
line: 2,
column: 1,
value: "two",
},
{
line: 2,
column: 4,
value: ":",
},
{
line: 2,
column: 6,
value: "1 2 3 4 5",
},
{
line: 5,
column: 1,
value: "three",
},
{
line: 5,
column: 6,
value: ":",
},
{
line: 5,
column: 8,
value: "1 2 3 4 5",
},
},
},
{
name: "single quote in an array",
src: `arr: ['1', 'and
two']
last: 'hello'`,
expect: []testToken{
{
line: 1,
column: 1,
value: "arr",
},
{
line: 1,
column: 4,
value: ":",
},
{
line: 1,
column: 6,
value: "[",
},
{
line: 1,
column: 7,
value: "1",
},
{
line: 1,
column: 10,
value: ",",
},
{
line: 1,
column: 12,
value: "and two",
},
{
line: 2,
column: 5,
value: "]",
},
{
line: 3,
column: 1,
value: "last",
},
{
line: 3,
column: 5,
value: ":",
},
{
line: 3,
column: 7,
value: "hello",
},
},
},
{
name: "single quote and double quote",
src: `foo: "test
bar"
foo2: 'bar2'`,
expect: []testToken{
{
line: 1,
column: 1,
value: "foo",
},
{
line: 1,
column: 4,
value: ":",
},
{
line: 1,
column: 6,
value: "test\n\n\n\nbar",
},
{
line: 7,
column: 1,
value: "foo2",
},
{
line: 7,
column: 5,
value: ":",
},
{
line: 7,
column: 7,
value: "bar2",
},
},
},
{
name: "single and double quote map keys",
src: `"a": test
'b': 1
c: true`,
expect: []testToken{
{
line: 1,
column: 1,
value: "a",
},
{
line: 1,
column: 4,
value: ":",
},
{
line: 1,
column: 6,
value: "test",
},
{
line: 2,
column: 1,
value: "b",
},
{
line: 2,
column: 4,
value: ":",
},
{
line: 2,
column: 6,
value: "1",
},
{
line: 3,
column: 1,
value: "c",
},
{
line: 3,
column: 2,
value: ":",
},
{
line: 3,
column: 4,
value: "true",
},
},
},
{
name: "issue326",
src: `a: |
Text
b: 1`,
expect: []testToken{
{
line: 1,
column: 1,
value: "a",
},
{
line: 1,
column: 2,
value: ":",
},
{
line: 1,
column: 4,
value: "|",
},
{
line: 2,
column: 3,
value: "Text\n",
},
{
line: 3,
column: 1,
value: "b",
},
{
line: 3,
column: 2,
value: ":",
},
{
line: 3,
column: 4,
value: "1",
},
},
},
}
for _, tc := range tests {
t.Run(tc.name, func(t *testing.T) {
got := lexer.Tokenize(tc.src)
sort.Slice(got, func(i, j int) bool {
// sort by line, then column
if got[i].Position.Line < got[j].Position.Line {
return true
} else if got[i].Position.Line == got[j].Position.Line {
return got[i].Position.Column < got[j].Position.Column
}
return false
})
sort.Slice(tc.expect, func(i, j int) bool {
if tc.expect[i].line < tc.expect[j].line {
return true
} else if tc.expect[i].line == tc.expect[j].line {
return tc.expect[i].column < tc.expect[j].column
}
return false
})
if len(got) != len(tc.expect) {
t.Errorf("Tokenize() token count mismatch, expected:%d got:%d", len(tc.expect), len(got))
}
for i, tok := range got {
if !tokenMatches(tok, tc.expect[i]) {
t.Errorf("Tokenize() expected:%+v got line:%d column:%d value:%s", tc.expect[i], tok.Position.Line, tok.Position.Column, tok.Value)
}
}
})
}
}
func TestInvalid(t *testing.T) {
tests := []struct {
name string
src string
}{
{
name: "literal opt with content",
src: `
a: |invalid
foo`,
},
{
name: "literal opt",
src: `
a: |invalid`,
},
{
name: "invalid single-quoted",
src: `a: 'foobarbaz`,
},
{
name: "invalid double-quoted",
src: `a: "\"key\": \"value:\"`,
},
{
name: "invalid document folded",
src: ">\n>",
},
{
name: "invalid document number",
src: ">\n1",
},
{
name: "invalid document header option number",
src: "a: >3\n 1",
},
{
name: "use reserved character @",
src: "key: [@val]",
},
{
name: "use reserved character `",
src: "key: [`val]",
},
{
name: "use tab character as indent",
// nolint: gci
src: " a: b",
},
{
name: "use tab character as indent in literal",
src: `
a: |
b
c
`,
},
{
name: "invalid UTF-16 character",
src: `"\u00"`,
},
{
name: "invalid UTF-16 surrogate pair length",
src: `"\ud800"`,
},
{
name: "invalid UTF-16 low surrogate prefix",
src: `"\ud800\v"`,
},
{
name: "invalid UTF-16 low surrogate",
src: `"\ud800\u0000"`,
},
{
name: "invalid UTF-32 character",
src: `"\U0000"`,
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
got := lexer.Tokenize(test.src)
if got.InvalidToken() == nil {
t.Fatal("expected contains invalid token")
}
})
}
}
func TestTokenOffset(t *testing.T) {
t.Run("crlf", func(t *testing.T) {
content := "project:\r\n version: 1.2.3\r\n"
tokens := lexer.Tokenize(content)
if len(tokens) != 5 {
t.Fatalf("invalid token num. got %d", len(tokens))
}
if tokens[4].Value != "1.2.3" {
t.Fatalf("unexpected value. got %q", tokens[4].Value)
}
if tokens[4].Position.Offset != 22 {
t.Fatalf("unexpected offset. got %d", tokens[4].Position.Offset)
}
})
t.Run("lf", func(t *testing.T) {
content := "project:\n version: 1.2.3\n"
tokens := lexer.Tokenize(content)
if len(tokens) != 5 {
t.Fatalf("invalid token num. got %d", len(tokens))
}
if tokens[4].Value != "1.2.3" {
t.Fatalf("unexpected value. got %q", tokens[4].Value)
}
if tokens[4].Position.Offset != 21 {
t.Fatalf("unexpected offset. got %d", tokens[4].Position.Offset)
}
})
}
goccy-go-yaml-52dacb8/option.go 0000664 0000000 0000000 00000023245 15015766371 0016533 0 ustar 00root root 0000000 0000000 package yaml
import (
"context"
"io"
"reflect"
"github.com/goccy/go-yaml/ast"
)
// DecodeOption functional option type for Decoder
type DecodeOption func(d *Decoder) error
// ReferenceReaders pass to Decoder that reference to anchor defined by passed readers
func ReferenceReaders(readers ...io.Reader) DecodeOption {
return func(d *Decoder) error {
d.referenceReaders = append(d.referenceReaders, readers...)
return nil
}
}
// ReferenceFiles pass to Decoder that reference to anchor defined by passed files
func ReferenceFiles(files ...string) DecodeOption {
return func(d *Decoder) error {
d.referenceFiles = files
return nil
}
}
// ReferenceDirs pass to Decoder that reference to anchor defined by files under the passed dirs
func ReferenceDirs(dirs ...string) DecodeOption {
return func(d *Decoder) error {
d.referenceDirs = dirs
return nil
}
}
// RecursiveDir search yaml file recursively from passed dirs by ReferenceDirs option
func RecursiveDir(isRecursive bool) DecodeOption {
return func(d *Decoder) error {
d.isRecursiveDir = isRecursive
return nil
}
}
// Validator set StructValidator instance to Decoder
func Validator(v StructValidator) DecodeOption {
return func(d *Decoder) error {
d.validator = v
return nil
}
}
// Strict enable DisallowUnknownField
func Strict() DecodeOption {
return func(d *Decoder) error {
d.disallowUnknownField = true
return nil
}
}
// DisallowUnknownField causes the Decoder to return an error when the destination
// is a struct and the input contains object keys which do not match any
// non-ignored, exported fields in the destination.
func DisallowUnknownField() DecodeOption {
return func(d *Decoder) error {
d.disallowUnknownField = true
return nil
}
}
// AllowDuplicateMapKey ignore syntax error when mapping keys that are duplicates.
func AllowDuplicateMapKey() DecodeOption {
return func(d *Decoder) error {
d.allowDuplicateMapKey = true
return nil
}
}
// UseOrderedMap can be interpreted as a map,
// and uses MapSlice ( ordered map ) aggressively if there is no type specification
func UseOrderedMap() DecodeOption {
return func(d *Decoder) error {
d.useOrderedMap = true
return nil
}
}
// UseJSONUnmarshaler if neither `BytesUnmarshaler` nor `InterfaceUnmarshaler` is implemented
// and `UnmashalJSON([]byte)error` is implemented, convert the argument from `YAML` to `JSON` and then call it.
func UseJSONUnmarshaler() DecodeOption {
return func(d *Decoder) error {
d.useJSONUnmarshaler = true
return nil
}
}
// CustomUnmarshaler overrides any decoding process for the type specified in generics.
//
// NOTE: If RegisterCustomUnmarshaler and CustomUnmarshaler of DecodeOption are specified for the same type,
// the CustomUnmarshaler specified in DecodeOption takes precedence.
func CustomUnmarshaler[T any](unmarshaler func(*T, []byte) error) DecodeOption {
return func(d *Decoder) error {
var typ *T
d.customUnmarshalerMap[reflect.TypeOf(typ)] = func(ctx context.Context, v interface{}, b []byte) error {
return unmarshaler(v.(*T), b)
}
return nil
}
}
// CustomUnmarshalerContext overrides any decoding process for the type specified in generics.
// Similar to CustomUnmarshaler, but allows passing a context to the unmarshaler function.
func CustomUnmarshalerContext[T any](unmarshaler func(context.Context, *T, []byte) error) DecodeOption {
return func(d *Decoder) error {
var typ *T
d.customUnmarshalerMap[reflect.TypeOf(typ)] = func(ctx context.Context, v interface{}, b []byte) error {
return unmarshaler(ctx, v.(*T), b)
}
return nil
}
}
// EncodeOption functional option type for Encoder
type EncodeOption func(e *Encoder) error
// Indent change indent number
func Indent(spaces int) EncodeOption {
return func(e *Encoder) error {
e.indentNum = spaces
return nil
}
}
// IndentSequence causes sequence values to be indented the same value as Indent
func IndentSequence(indent bool) EncodeOption {
return func(e *Encoder) error {
e.indentSequence = indent
return nil
}
}
// UseSingleQuote determines if single or double quotes should be preferred for strings.
func UseSingleQuote(sq bool) EncodeOption {
return func(e *Encoder) error {
e.singleQuote = sq
return nil
}
}
// Flow encoding by flow style
func Flow(isFlowStyle bool) EncodeOption {
return func(e *Encoder) error {
e.isFlowStyle = isFlowStyle
return nil
}
}
// WithSmartAnchor when multiple map values share the same pointer,
// an anchor is automatically assigned to the first occurrence, and aliases are used for subsequent elements.
// The map key name is used as the anchor name by default.
// If key names conflict, a suffix is automatically added to avoid collisions.
// This is an experimental feature and cannot be used simultaneously with anchor tags.
func WithSmartAnchor() EncodeOption {
return func(e *Encoder) error {
e.enableSmartAnchor = true
return nil
}
}
// UseLiteralStyleIfMultiline causes encoding multiline strings with a literal syntax,
// no matter what characters they include
func UseLiteralStyleIfMultiline(useLiteralStyleIfMultiline bool) EncodeOption {
return func(e *Encoder) error {
e.useLiteralStyleIfMultiline = useLiteralStyleIfMultiline
return nil
}
}
// JSON encode in JSON format
func JSON() EncodeOption {
return func(e *Encoder) error {
e.isJSONStyle = true
e.isFlowStyle = true
return nil
}
}
// MarshalAnchor call back if encoder find an anchor during encoding
func MarshalAnchor(callback func(*ast.AnchorNode, interface{}) error) EncodeOption {
return func(e *Encoder) error {
e.anchorCallback = callback
return nil
}
}
// UseJSONMarshaler if neither `BytesMarshaler` nor `InterfaceMarshaler`
// nor `encoding.TextMarshaler` is implemented and `MarshalJSON()([]byte, error)` is implemented,
// call `MarshalJSON` to convert the returned `JSON` to `YAML` for processing.
func UseJSONMarshaler() EncodeOption {
return func(e *Encoder) error {
e.useJSONMarshaler = true
return nil
}
}
// CustomMarshaler overrides any encoding process for the type specified in generics.
//
// NOTE: If type T implements MarshalYAML for pointer receiver, the type specified in CustomMarshaler must be *T.
// If RegisterCustomMarshaler and CustomMarshaler of EncodeOption are specified for the same type,
// the CustomMarshaler specified in EncodeOption takes precedence.
func CustomMarshaler[T any](marshaler func(T) ([]byte, error)) EncodeOption {
return func(e *Encoder) error {
var typ T
e.customMarshalerMap[reflect.TypeOf(typ)] = func(ctx context.Context, v interface{}) ([]byte, error) {
return marshaler(v.(T))
}
return nil
}
}
// CustomMarshalerContext overrides any encoding process for the type specified in generics.
// Similar to CustomMarshaler, but allows passing a context to the marshaler function.
func CustomMarshalerContext[T any](marshaler func(context.Context, T) ([]byte, error)) EncodeOption {
return func(e *Encoder) error {
var typ T
e.customMarshalerMap[reflect.TypeOf(typ)] = func(ctx context.Context, v interface{}) ([]byte, error) {
return marshaler(ctx, v.(T))
}
return nil
}
}
// AutoInt automatically converts floating-point numbers to integers when the fractional part is zero.
// For example, a value of 1.0 will be encoded as 1.
func AutoInt() EncodeOption {
return func(e *Encoder) error {
e.autoInt = true
return nil
}
}
// OmitEmpty behaves in the same way as the interpretation of the omitempty tag in the encoding/json library.
// set on all the fields.
// In the current implementation, the omitempty tag is not implemented in the same way as encoding/json,
// so please specify this option if you expect the same behavior.
func OmitEmpty() EncodeOption {
return func(e *Encoder) error {
e.omitEmpty = true
return nil
}
}
// OmitZero forces the encoder to assume an `omitzero` struct tag is
// set on all the fields. See `Marshal` commentary for the `omitzero` tag logic.
func OmitZero() EncodeOption {
return func(e *Encoder) error {
e.omitZero = true
return nil
}
}
// CommentPosition type of the position for comment.
type CommentPosition int
const (
CommentHeadPosition CommentPosition = CommentPosition(iota)
CommentLinePosition
CommentFootPosition
)
func (p CommentPosition) String() string {
switch p {
case CommentHeadPosition:
return "Head"
case CommentLinePosition:
return "Line"
case CommentFootPosition:
return "Foot"
default:
return ""
}
}
// LineComment create a one-line comment for CommentMap.
func LineComment(text string) *Comment {
return &Comment{
Texts: []string{text},
Position: CommentLinePosition,
}
}
// HeadComment create a multiline comment for CommentMap.
func HeadComment(texts ...string) *Comment {
return &Comment{
Texts: texts,
Position: CommentHeadPosition,
}
}
// FootComment create a multiline comment for CommentMap.
func FootComment(texts ...string) *Comment {
return &Comment{
Texts: texts,
Position: CommentFootPosition,
}
}
// Comment raw data for comment.
type Comment struct {
Texts []string
Position CommentPosition
}
// CommentMap map of the position of the comment and the comment information.
type CommentMap map[string][]*Comment
// WithComment add a comment using the location and text information given in the CommentMap.
func WithComment(cm CommentMap) EncodeOption {
return func(e *Encoder) error {
commentMap := map[*Path][]*Comment{}
for k, v := range cm {
path, err := PathString(k)
if err != nil {
return err
}
commentMap[path] = v
}
e.commentMap = commentMap
return nil
}
}
// CommentToMap apply the position and content of comments in a YAML document to a CommentMap.
func CommentToMap(cm CommentMap) DecodeOption {
return func(d *Decoder) error {
if cm == nil {
return ErrInvalidCommentMapValue
}
d.toCommentMap = cm
return nil
}
}
goccy-go-yaml-52dacb8/parser/ 0000775 0000000 0000000 00000000000 15015766371 0016162 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/parser/color.go 0000664 0000000 0000000 00000000736 15015766371 0017635 0 ustar 00root root 0000000 0000000 package parser
import "fmt"
const (
colorFgHiBlack int = iota + 90
colorFgHiRed
colorFgHiGreen
colorFgHiYellow
colorFgHiBlue
colorFgHiMagenta
colorFgHiCyan
)
var colorTable = []int{
colorFgHiRed,
colorFgHiGreen,
colorFgHiYellow,
colorFgHiBlue,
colorFgHiMagenta,
colorFgHiCyan,
}
func colorize(idx int, content string) string {
colorIdx := idx % len(colorTable)
color := colorTable[colorIdx]
return fmt.Sprintf("\x1b[1;%dm", color) + content + "\x1b[22;0m"
}
goccy-go-yaml-52dacb8/parser/context.go 0000664 0000000 0000000 00000006751 15015766371 0020206 0 ustar 00root root 0000000 0000000 package parser
import (
"fmt"
"strings"
"github.com/goccy/go-yaml/token"
)
// context context at parsing
type context struct {
tokenRef *tokenRef
path string
isFlow bool
}
type tokenRef struct {
tokens []*Token
size int
idx int
}
var pathSpecialChars = []string{
"$", "*", ".", "[", "]",
}
func containsPathSpecialChar(path string) bool {
for _, char := range pathSpecialChars {
if strings.Contains(path, char) {
return true
}
}
return false
}
func normalizePath(path string) string {
if containsPathSpecialChar(path) {
return fmt.Sprintf("'%s'", path)
}
return path
}
func (c *context) currentToken() *Token {
if c.tokenRef.idx >= c.tokenRef.size {
return nil
}
return c.tokenRef.tokens[c.tokenRef.idx]
}
func (c *context) isComment() bool {
return c.currentToken().Type() == token.CommentType
}
func (c *context) nextToken() *Token {
if c.tokenRef.idx+1 >= c.tokenRef.size {
return nil
}
return c.tokenRef.tokens[c.tokenRef.idx+1]
}
func (c *context) nextNotCommentToken() *Token {
for i := c.tokenRef.idx + 1; i < c.tokenRef.size; i++ {
tk := c.tokenRef.tokens[i]
if tk.Type() == token.CommentType {
continue
}
return tk
}
return nil
}
func (c *context) isTokenNotFound() bool {
return c.currentToken() == nil
}
func (c *context) withGroup(g *TokenGroup) *context {
ctx := *c
ctx.tokenRef = &tokenRef{
tokens: g.Tokens,
size: len(g.Tokens),
}
return &ctx
}
func (c *context) withChild(path string) *context {
ctx := *c
ctx.path = c.path + "." + normalizePath(path)
return &ctx
}
func (c *context) withIndex(idx uint) *context {
ctx := *c
ctx.path = c.path + "[" + fmt.Sprint(idx) + "]"
return &ctx
}
func (c *context) withFlow(isFlow bool) *context {
ctx := *c
ctx.isFlow = isFlow
return &ctx
}
func newContext() *context {
return &context{
path: "$",
}
}
func (c *context) goNext() {
ref := c.tokenRef
if ref.size <= ref.idx+1 {
ref.idx = ref.size
} else {
ref.idx++
}
}
func (c *context) next() bool {
return c.tokenRef.idx < c.tokenRef.size
}
func (c *context) insertNullToken(tk *Token) *Token {
nullToken := c.createImplicitNullToken(tk)
c.insertToken(nullToken)
c.goNext()
return nullToken
}
func (c *context) addNullValueToken(tk *Token) *Token {
nullToken := c.createImplicitNullToken(tk)
rawTk := nullToken.RawToken()
// add space for map or sequence value.
rawTk.Position.Column++
c.addToken(nullToken)
c.goNext()
return nullToken
}
func (c *context) createImplicitNullToken(base *Token) *Token {
pos := *(base.RawToken().Position)
pos.Column++
tk := token.New("null", " null", &pos)
tk.Type = token.ImplicitNullType
return &Token{Token: tk}
}
func (c *context) insertToken(tk *Token) {
ref := c.tokenRef
idx := ref.idx
if ref.size < idx {
return
}
if ref.size == idx {
curToken := ref.tokens[ref.size-1]
tk.RawToken().Next = curToken.RawToken()
curToken.RawToken().Prev = tk.RawToken()
ref.tokens = append(ref.tokens, tk)
ref.size = len(ref.tokens)
return
}
curToken := ref.tokens[idx]
tk.RawToken().Next = curToken.RawToken()
curToken.RawToken().Prev = tk.RawToken()
ref.tokens = append(ref.tokens[:idx+1], ref.tokens[idx:]...)
ref.tokens[idx] = tk
ref.size = len(ref.tokens)
}
func (c *context) addToken(tk *Token) {
ref := c.tokenRef
lastTk := ref.tokens[ref.size-1]
if lastTk.Group != nil {
lastTk = lastTk.Group.Last()
}
lastTk.RawToken().Next = tk.RawToken()
tk.RawToken().Prev = lastTk.RawToken()
ref.tokens = append(ref.tokens, tk)
ref.size = len(ref.tokens)
}
goccy-go-yaml-52dacb8/parser/node.go 0000664 0000000 0000000 00000014755 15015766371 0017452 0 ustar 00root root 0000000 0000000 package parser
import (
"fmt"
"github.com/goccy/go-yaml/ast"
"github.com/goccy/go-yaml/internal/errors"
"github.com/goccy/go-yaml/token"
)
func newMappingNode(ctx *context, tk *Token, isFlow bool, values ...*ast.MappingValueNode) (*ast.MappingNode, error) {
node := ast.Mapping(tk.RawToken(), isFlow, values...)
node.SetPath(ctx.path)
return node, nil
}
func newMappingValueNode(ctx *context, colonTk, entryTk *Token, key ast.MapKeyNode, value ast.Node) (*ast.MappingValueNode, error) {
node := ast.MappingValue(colonTk.RawToken(), key, value)
node.SetPath(ctx.path)
node.CollectEntry = entryTk.RawToken()
if key.GetToken().Position.Line == value.GetToken().Position.Line {
// originally key was commented, but now that null value has been added, value must be commented.
if err := setLineComment(ctx, value, colonTk); err != nil {
return nil, err
}
// set line comment by colonTk or entryTk.
if err := setLineComment(ctx, value, entryTk); err != nil {
return nil, err
}
} else {
if err := setLineComment(ctx, key, colonTk); err != nil {
return nil, err
}
// set line comment by colonTk or entryTk.
if err := setLineComment(ctx, key, entryTk); err != nil {
return nil, err
}
}
return node, nil
}
func newMappingKeyNode(ctx *context, tk *Token) (*ast.MappingKeyNode, error) {
node := ast.MappingKey(tk.RawToken())
node.SetPath(ctx.path)
if err := setLineComment(ctx, node, tk); err != nil {
return nil, err
}
return node, nil
}
func newAnchorNode(ctx *context, tk *Token) (*ast.AnchorNode, error) {
node := ast.Anchor(tk.RawToken())
node.SetPath(ctx.path)
if err := setLineComment(ctx, node, tk); err != nil {
return nil, err
}
return node, nil
}
func newAliasNode(ctx *context, tk *Token) (*ast.AliasNode, error) {
node := ast.Alias(tk.RawToken())
node.SetPath(ctx.path)
if err := setLineComment(ctx, node, tk); err != nil {
return nil, err
}
return node, nil
}
func newDirectiveNode(ctx *context, tk *Token) (*ast.DirectiveNode, error) {
node := ast.Directive(tk.RawToken())
node.SetPath(ctx.path)
if err := setLineComment(ctx, node, tk); err != nil {
return nil, err
}
return node, nil
}
func newMergeKeyNode(ctx *context, tk *Token) (*ast.MergeKeyNode, error) {
node := ast.MergeKey(tk.RawToken())
node.SetPath(ctx.path)
if err := setLineComment(ctx, node, tk); err != nil {
return nil, err
}
return node, nil
}
func newNullNode(ctx *context, tk *Token) (*ast.NullNode, error) {
node := ast.Null(tk.RawToken())
node.SetPath(ctx.path)
if err := setLineComment(ctx, node, tk); err != nil {
return nil, err
}
return node, nil
}
func newBoolNode(ctx *context, tk *Token) (*ast.BoolNode, error) {
node := ast.Bool(tk.RawToken())
node.SetPath(ctx.path)
if err := setLineComment(ctx, node, tk); err != nil {
return nil, err
}
return node, nil
}
func newIntegerNode(ctx *context, tk *Token) (*ast.IntegerNode, error) {
node := ast.Integer(tk.RawToken())
node.SetPath(ctx.path)
if err := setLineComment(ctx, node, tk); err != nil {
return nil, err
}
return node, nil
}
func newFloatNode(ctx *context, tk *Token) (*ast.FloatNode, error) {
node := ast.Float(tk.RawToken())
node.SetPath(ctx.path)
if err := setLineComment(ctx, node, tk); err != nil {
return nil, err
}
return node, nil
}
func newInfinityNode(ctx *context, tk *Token) (*ast.InfinityNode, error) {
node := ast.Infinity(tk.RawToken())
node.SetPath(ctx.path)
if err := setLineComment(ctx, node, tk); err != nil {
return nil, err
}
return node, nil
}
func newNanNode(ctx *context, tk *Token) (*ast.NanNode, error) {
node := ast.Nan(tk.RawToken())
node.SetPath(ctx.path)
if err := setLineComment(ctx, node, tk); err != nil {
return nil, err
}
return node, nil
}
func newStringNode(ctx *context, tk *Token) (*ast.StringNode, error) {
node := ast.String(tk.RawToken())
node.SetPath(ctx.path)
if err := setLineComment(ctx, node, tk); err != nil {
return nil, err
}
return node, nil
}
func newLiteralNode(ctx *context, tk *Token) (*ast.LiteralNode, error) {
node := ast.Literal(tk.RawToken())
node.SetPath(ctx.path)
if err := setLineComment(ctx, node, tk); err != nil {
return nil, err
}
return node, nil
}
func newTagNode(ctx *context, tk *Token) (*ast.TagNode, error) {
node := ast.Tag(tk.RawToken())
node.SetPath(ctx.path)
if err := setLineComment(ctx, node, tk); err != nil {
return nil, err
}
return node, nil
}
func newSequenceNode(ctx *context, tk *Token, isFlow bool) (*ast.SequenceNode, error) {
node := ast.Sequence(tk.RawToken(), isFlow)
node.SetPath(ctx.path)
if err := setLineComment(ctx, node, tk); err != nil {
return nil, err
}
return node, nil
}
func newTagDefaultScalarValueNode(ctx *context, tag *token.Token) (ast.ScalarNode, error) {
pos := *(tag.Position)
pos.Column++
var (
tk *Token
node ast.ScalarNode
)
switch token.ReservedTagKeyword(tag.Value) {
case token.IntegerTag:
tk = &Token{Token: token.New("0", "0", &pos)}
n, err := newIntegerNode(ctx, tk)
if err != nil {
return nil, err
}
node = n
case token.FloatTag:
tk = &Token{Token: token.New("0", "0", &pos)}
n, err := newFloatNode(ctx, tk)
if err != nil {
return nil, err
}
node = n
case token.StringTag, token.BinaryTag, token.TimestampTag:
tk = &Token{Token: token.New("", "", &pos)}
n, err := newStringNode(ctx, tk)
if err != nil {
return nil, err
}
node = n
case token.BooleanTag:
tk = &Token{Token: token.New("false", "false", &pos)}
n, err := newBoolNode(ctx, tk)
if err != nil {
return nil, err
}
node = n
case token.NullTag:
tk = &Token{Token: token.New("null", "null", &pos)}
n, err := newNullNode(ctx, tk)
if err != nil {
return nil, err
}
node = n
default:
return nil, errors.ErrSyntax(fmt.Sprintf("cannot assign default value for %q tag", tag.Value), tag)
}
ctx.insertToken(tk)
ctx.goNext()
return node, nil
}
func setLineComment(ctx *context, node ast.Node, tk *Token) error {
if tk == nil || tk.LineComment == nil {
return nil
}
comment := ast.CommentGroup([]*token.Token{tk.LineComment})
comment.SetPath(ctx.path)
if err := node.SetComment(comment); err != nil {
return err
}
return nil
}
func setHeadComment(cm *ast.CommentGroupNode, value ast.Node) error {
if cm == nil {
return nil
}
switch n := value.(type) {
case *ast.MappingNode:
if len(n.Values) != 0 && value.GetComment() == nil {
cm.SetPath(n.Values[0].GetPath())
return n.Values[0].SetComment(cm)
}
case *ast.MappingValueNode:
cm.SetPath(n.GetPath())
return n.SetComment(cm)
}
cm.SetPath(value.GetPath())
return value.SetComment(cm)
}
goccy-go-yaml-52dacb8/parser/option.go 0000664 0000000 0000000 00000000463 15015766371 0020024 0 ustar 00root root 0000000 0000000 package parser
// Option represents parser's option.
type Option func(p *parser)
// AllowDuplicateMapKey allow the use of keys with the same name in the same map,
// but by default, this is not permitted.
func AllowDuplicateMapKey() Option {
return func(p *parser) {
p.allowDuplicateMapKey = true
}
}
goccy-go-yaml-52dacb8/parser/parser.go 0000664 0000000 0000000 00000105463 15015766371 0020016 0 ustar 00root root 0000000 0000000 package parser
import (
"fmt"
"os"
"strings"
"github.com/goccy/go-yaml/ast"
"github.com/goccy/go-yaml/internal/errors"
"github.com/goccy/go-yaml/lexer"
"github.com/goccy/go-yaml/token"
)
type Mode uint
const (
ParseComments Mode = 1 << iota // parse comments and add them to AST
)
// ParseBytes parse from byte slice, and returns ast.File
func ParseBytes(bytes []byte, mode Mode, opts ...Option) (*ast.File, error) {
tokens := lexer.Tokenize(string(bytes))
f, err := Parse(tokens, mode, opts...)
if err != nil {
return nil, err
}
return f, nil
}
// Parse parse from token instances, and returns ast.File
func Parse(tokens token.Tokens, mode Mode, opts ...Option) (*ast.File, error) {
if tk := tokens.InvalidToken(); tk != nil {
return nil, errors.ErrSyntax(tk.Error, tk)
}
p, err := newParser(tokens, mode, opts)
if err != nil {
return nil, err
}
f, err := p.parse(newContext())
if err != nil {
return nil, err
}
return f, nil
}
// Parse parse from filename, and returns ast.File
func ParseFile(filename string, mode Mode, opts ...Option) (*ast.File, error) {
file, err := os.ReadFile(filename)
if err != nil {
return nil, err
}
f, err := ParseBytes(file, mode, opts...)
if err != nil {
return nil, err
}
f.Name = filename
return f, nil
}
type YAMLVersion string
const (
YAML10 YAMLVersion = "1.0"
YAML11 YAMLVersion = "1.1"
YAML12 YAMLVersion = "1.2"
YAML13 YAMLVersion = "1.3"
)
var yamlVersionMap = map[string]YAMLVersion{
"1.0": YAML10,
"1.1": YAML11,
"1.2": YAML12,
"1.3": YAML13,
}
type parser struct {
tokens []*Token
pathMap map[string]ast.Node
yamlVersion YAMLVersion
allowDuplicateMapKey bool
secondaryTagDirective *ast.DirectiveNode
}
func newParser(tokens token.Tokens, mode Mode, opts []Option) (*parser, error) {
filteredTokens := []*token.Token{}
if mode&ParseComments != 0 {
filteredTokens = tokens
} else {
for _, tk := range tokens {
if tk.Type == token.CommentType {
continue
}
// keep prev/next reference between tokens containing comments
// https://github.com/goccy/go-yaml/issues/254
filteredTokens = append(filteredTokens, tk)
}
}
tks, err := CreateGroupedTokens(token.Tokens(filteredTokens))
if err != nil {
return nil, err
}
p := &parser{
tokens: tks,
pathMap: make(map[string]ast.Node),
}
for _, opt := range opts {
opt(p)
}
return p, nil
}
func (p *parser) parse(ctx *context) (*ast.File, error) {
file := &ast.File{Docs: []*ast.DocumentNode{}}
for _, token := range p.tokens {
doc, err := p.parseDocument(ctx, token.Group)
if err != nil {
return nil, err
}
file.Docs = append(file.Docs, doc)
}
return file, nil
}
func (p *parser) parseDocument(ctx *context, docGroup *TokenGroup) (*ast.DocumentNode, error) {
if len(docGroup.Tokens) == 0 {
return ast.Document(docGroup.RawToken(), nil), nil
}
p.pathMap = make(map[string]ast.Node)
var (
tokens = docGroup.Tokens
start *token.Token
end *token.Token
)
if docGroup.First().Type() == token.DocumentHeaderType {
start = docGroup.First().RawToken()
tokens = tokens[1:]
}
if docGroup.Last().Type() == token.DocumentEndType {
end = docGroup.Last().RawToken()
tokens = tokens[:len(tokens)-1]
defer func() {
// clear yaml version value if DocumentEnd token (...) is specified.
p.yamlVersion = ""
}()
}
if len(tokens) == 0 {
return ast.Document(docGroup.RawToken(), nil), nil
}
body, err := p.parseDocumentBody(ctx.withGroup(&TokenGroup{
Type: TokenGroupDocumentBody,
Tokens: tokens,
}))
if err != nil {
return nil, err
}
node := ast.Document(start, body)
node.End = end
return node, nil
}
func (p *parser) parseDocumentBody(ctx *context) (ast.Node, error) {
node, err := p.parseToken(ctx, ctx.currentToken())
if err != nil {
return nil, err
}
if ctx.next() {
return nil, errors.ErrSyntax("value is not allowed in this context", ctx.currentToken().RawToken())
}
return node, nil
}
func (p *parser) parseToken(ctx *context, tk *Token) (ast.Node, error) {
switch tk.GroupType() {
case TokenGroupMapKey, TokenGroupMapKeyValue:
return p.parseMap(ctx)
case TokenGroupDirective:
node, err := p.parseDirective(ctx.withGroup(tk.Group), tk.Group)
if err != nil {
return nil, err
}
ctx.goNext()
return node, nil
case TokenGroupDirectiveName:
node, err := p.parseDirectiveName(ctx.withGroup(tk.Group))
if err != nil {
return nil, err
}
ctx.goNext()
return node, nil
case TokenGroupAnchor:
node, err := p.parseAnchor(ctx.withGroup(tk.Group), tk.Group)
if err != nil {
return nil, err
}
ctx.goNext()
return node, nil
case TokenGroupAnchorName:
anchor, err := p.parseAnchorName(ctx.withGroup(tk.Group))
if err != nil {
return nil, err
}
ctx.goNext()
if ctx.isTokenNotFound() {
return nil, errors.ErrSyntax("could not find anchor value", tk.RawToken())
}
value, err := p.parseToken(ctx, ctx.currentToken())
if err != nil {
return nil, err
}
if _, ok := value.(*ast.AnchorNode); ok {
return nil, errors.ErrSyntax("anchors cannot be used consecutively", value.GetToken())
}
anchor.Value = value
return anchor, nil
case TokenGroupAlias:
node, err := p.parseAlias(ctx.withGroup(tk.Group))
if err != nil {
return nil, err
}
ctx.goNext()
return node, nil
case TokenGroupLiteral, TokenGroupFolded:
node, err := p.parseLiteral(ctx.withGroup(tk.Group))
if err != nil {
return nil, err
}
ctx.goNext()
return node, nil
case TokenGroupScalarTag:
node, err := p.parseTag(ctx.withGroup(tk.Group))
if err != nil {
return nil, err
}
ctx.goNext()
return node, nil
}
switch tk.Type() {
case token.CommentType:
return p.parseComment(ctx)
case token.TagType:
return p.parseTag(ctx)
case token.MappingStartType:
return p.parseFlowMap(ctx.withFlow(true))
case token.SequenceStartType:
return p.parseFlowSequence(ctx.withFlow(true))
case token.SequenceEntryType:
return p.parseSequence(ctx)
case token.SequenceEndType:
// SequenceEndType is always validated in parseFlowSequence.
// Therefore, if this is found in other cases, it is treated as a syntax error.
return nil, errors.ErrSyntax("could not find '[' character corresponding to ']'", tk.RawToken())
case token.MappingEndType:
// MappingEndType is always validated in parseFlowMap.
// Therefore, if this is found in other cases, it is treated as a syntax error.
return nil, errors.ErrSyntax("could not find '{' character corresponding to '}'", tk.RawToken())
case token.MappingValueType:
return nil, errors.ErrSyntax("found an invalid key for this map", tk.RawToken())
}
node, err := p.parseScalarValue(ctx, tk)
if err != nil {
return nil, err
}
ctx.goNext()
return node, nil
}
func (p *parser) parseScalarValue(ctx *context, tk *Token) (ast.ScalarNode, error) {
if tk.Group != nil {
switch tk.GroupType() {
case TokenGroupAnchor:
return p.parseAnchor(ctx.withGroup(tk.Group), tk.Group)
case TokenGroupAnchorName:
anchor, err := p.parseAnchorName(ctx.withGroup(tk.Group))
if err != nil {
return nil, err
}
ctx.goNext()
if ctx.isTokenNotFound() {
return nil, errors.ErrSyntax("could not find anchor value", tk.RawToken())
}
value, err := p.parseToken(ctx, ctx.currentToken())
if err != nil {
return nil, err
}
if _, ok := value.(*ast.AnchorNode); ok {
return nil, errors.ErrSyntax("anchors cannot be used consecutively", value.GetToken())
}
anchor.Value = value
return anchor, nil
case TokenGroupAlias:
return p.parseAlias(ctx.withGroup(tk.Group))
case TokenGroupLiteral, TokenGroupFolded:
return p.parseLiteral(ctx.withGroup(tk.Group))
case TokenGroupScalarTag:
return p.parseTag(ctx.withGroup(tk.Group))
default:
return nil, errors.ErrSyntax("unexpected scalar value", tk.RawToken())
}
}
switch tk.Type() {
case token.MergeKeyType:
return newMergeKeyNode(ctx, tk)
case token.NullType, token.ImplicitNullType:
return newNullNode(ctx, tk)
case token.BoolType:
return newBoolNode(ctx, tk)
case token.IntegerType, token.BinaryIntegerType, token.OctetIntegerType, token.HexIntegerType:
return newIntegerNode(ctx, tk)
case token.FloatType:
return newFloatNode(ctx, tk)
case token.InfinityType:
return newInfinityNode(ctx, tk)
case token.NanType:
return newNanNode(ctx, tk)
case token.StringType, token.SingleQuoteType, token.DoubleQuoteType:
return newStringNode(ctx, tk)
case token.TagType:
// this case applies when it is a scalar tag and its value does not exist.
// Examples of cases where the value does not exist include cases like `key: !!str,` or `!!str : value`.
return p.parseScalarTag(ctx)
}
return nil, errors.ErrSyntax("unexpected scalar value type", tk.RawToken())
}
func (p *parser) parseFlowMap(ctx *context) (*ast.MappingNode, error) {
node, err := newMappingNode(ctx, ctx.currentToken(), true)
if err != nil {
return nil, err
}
ctx.goNext() // skip MappingStart token
isFirst := true
for ctx.next() {
tk := ctx.currentToken()
if tk.Type() == token.MappingEndType {
node.End = tk.RawToken()
break
}
var entryTk *Token
if tk.Type() == token.CollectEntryType {
entryTk = tk
ctx.goNext()
} else if !isFirst {
return nil, errors.ErrSyntax("',' or '}' must be specified", tk.RawToken())
}
if tk := ctx.currentToken(); tk.Type() == token.MappingEndType {
// this case is here: "{ elem, }".
// In this case, ignore the last element and break mapping parsing.
node.End = tk.RawToken()
break
}
mapKeyTk := ctx.currentToken()
switch mapKeyTk.GroupType() {
case TokenGroupMapKeyValue:
value, err := p.parseMapKeyValue(ctx.withGroup(mapKeyTk.Group), mapKeyTk.Group, entryTk)
if err != nil {
return nil, err
}
node.Values = append(node.Values, value)
ctx.goNext()
case TokenGroupMapKey:
key, err := p.parseMapKey(ctx.withGroup(mapKeyTk.Group), mapKeyTk.Group)
if err != nil {
return nil, err
}
ctx := ctx.withChild(p.mapKeyText(key))
colonTk := mapKeyTk.Group.Last()
if p.isFlowMapDelim(ctx.nextToken()) {
value, err := newNullNode(ctx, ctx.insertNullToken(colonTk))
if err != nil {
return nil, err
}
mapValue, err := newMappingValueNode(ctx, colonTk, entryTk, key, value)
if err != nil {
return nil, err
}
node.Values = append(node.Values, mapValue)
ctx.goNext()
} else {
ctx.goNext()
if ctx.isTokenNotFound() {
return nil, errors.ErrSyntax("could not find map value", colonTk.RawToken())
}
value, err := p.parseToken(ctx, ctx.currentToken())
if err != nil {
return nil, err
}
mapValue, err := newMappingValueNode(ctx, colonTk, entryTk, key, value)
if err != nil {
return nil, err
}
node.Values = append(node.Values, mapValue)
}
default:
if !p.isFlowMapDelim(ctx.nextToken()) {
errTk := mapKeyTk
if errTk == nil {
errTk = tk
}
return nil, errors.ErrSyntax("could not find flow map content", errTk.RawToken())
}
key, err := p.parseScalarValue(ctx, mapKeyTk)
if err != nil {
return nil, err
}
value, err := newNullNode(ctx, ctx.insertNullToken(mapKeyTk))
if err != nil {
return nil, err
}
mapValue, err := newMappingValueNode(ctx, mapKeyTk, entryTk, key, value)
if err != nil {
return nil, err
}
node.Values = append(node.Values, mapValue)
ctx.goNext()
}
isFirst = false
}
if node.End == nil {
return nil, errors.ErrSyntax("could not find flow mapping end token '}'", node.Start)
}
ctx.goNext() // skip mapping end token.
return node, nil
}
func (p *parser) isFlowMapDelim(tk *Token) bool {
return tk.Type() == token.MappingEndType || tk.Type() == token.CollectEntryType
}
func (p *parser) parseMap(ctx *context) (*ast.MappingNode, error) {
keyTk := ctx.currentToken()
if keyTk.Group == nil {
return nil, errors.ErrSyntax("unexpected map key", keyTk.RawToken())
}
var keyValueNode *ast.MappingValueNode
if keyTk.GroupType() == TokenGroupMapKeyValue {
node, err := p.parseMapKeyValue(ctx.withGroup(keyTk.Group), keyTk.Group, nil)
if err != nil {
return nil, err
}
keyValueNode = node
ctx.goNext()
if err := p.validateMapKeyValueNextToken(ctx, keyTk, ctx.currentToken()); err != nil {
return nil, err
}
} else {
key, err := p.parseMapKey(ctx.withGroup(keyTk.Group), keyTk.Group)
if err != nil {
return nil, err
}
ctx.goNext()
valueTk := ctx.currentToken()
if keyTk.Line() == valueTk.Line() && valueTk.Type() == token.SequenceEntryType {
return nil, errors.ErrSyntax("block sequence entries are not allowed in this context", valueTk.RawToken())
}
ctx := ctx.withChild(p.mapKeyText(key))
value, err := p.parseMapValue(ctx, key, keyTk.Group.Last())
if err != nil {
return nil, err
}
node, err := newMappingValueNode(ctx, keyTk.Group.Last(), nil, key, value)
if err != nil {
return nil, err
}
keyValueNode = node
}
mapNode, err := newMappingNode(ctx, &Token{Token: keyValueNode.GetToken()}, false, keyValueNode)
if err != nil {
return nil, err
}
var tk *Token
if ctx.isComment() {
tk = ctx.nextNotCommentToken()
} else {
tk = ctx.currentToken()
}
for tk.Column() == keyTk.Column() {
typ := tk.Type()
if ctx.isFlow && typ == token.SequenceEndType {
// [
// key: value
// ] <=
break
}
if !p.isMapToken(tk) {
return nil, errors.ErrSyntax("non-map value is specified", tk.RawToken())
}
cm := p.parseHeadComment(ctx)
if typ == token.MappingEndType {
// a: {
// b: c
// } <=
ctx.goNext()
break
}
node, err := p.parseMap(ctx)
if err != nil {
return nil, err
}
if len(node.Values) != 0 {
if err := setHeadComment(cm, node.Values[0]); err != nil {
return nil, err
}
}
mapNode.Values = append(mapNode.Values, node.Values...)
if node.FootComment != nil {
mapNode.Values[len(mapNode.Values)-1].FootComment = node.FootComment
}
tk = ctx.currentToken()
}
if ctx.isComment() {
if keyTk.Column() <= ctx.currentToken().Column() {
// If the comment is in the same or deeper column as the last element column in map value,
// treat it as a footer comment for the last element.
if len(mapNode.Values) == 1 {
mapNode.Values[0].FootComment = p.parseFootComment(ctx, keyTk.Column())
mapNode.Values[0].FootComment.SetPath(mapNode.Values[0].Key.GetPath())
} else {
mapNode.FootComment = p.parseFootComment(ctx, keyTk.Column())
mapNode.FootComment.SetPath(mapNode.GetPath())
}
}
}
return mapNode, nil
}
func (p *parser) validateMapKeyValueNextToken(ctx *context, keyTk, tk *Token) error {
if tk == nil {
return nil
}
if tk.Column() <= keyTk.Column() {
return nil
}
if ctx.isComment() {
return nil
}
if ctx.isFlow && (tk.Type() == token.CollectEntryType || tk.Type() == token.SequenceEndType) {
return nil
}
// a: b
// c <= this token is invalid.
return errors.ErrSyntax("value is not allowed in this context. map key-value is pre-defined", tk.RawToken())
}
func (p *parser) isMapToken(tk *Token) bool {
if tk.Group == nil {
return tk.Type() == token.MappingStartType || tk.Type() == token.MappingEndType
}
g := tk.Group
return g.Type == TokenGroupMapKey || g.Type == TokenGroupMapKeyValue
}
func (p *parser) parseMapKeyValue(ctx *context, g *TokenGroup, entryTk *Token) (*ast.MappingValueNode, error) {
if g.Type != TokenGroupMapKeyValue {
return nil, errors.ErrSyntax("unexpected map key-value pair", g.RawToken())
}
if g.First().Group == nil {
return nil, errors.ErrSyntax("unexpected map key", g.RawToken())
}
keyGroup := g.First().Group
key, err := p.parseMapKey(ctx.withGroup(keyGroup), keyGroup)
if err != nil {
return nil, err
}
c := ctx.withChild(p.mapKeyText(key))
value, err := p.parseToken(c, g.Last())
if err != nil {
return nil, err
}
return newMappingValueNode(c, keyGroup.Last(), entryTk, key, value)
}
func (p *parser) parseMapKey(ctx *context, g *TokenGroup) (ast.MapKeyNode, error) {
if g.Type != TokenGroupMapKey {
return nil, errors.ErrSyntax("unexpected map key", g.RawToken())
}
if g.First().Type() == token.MappingKeyType {
mapKeyTk := g.First()
if mapKeyTk.Group != nil {
ctx = ctx.withGroup(mapKeyTk.Group)
}
key, err := newMappingKeyNode(ctx, mapKeyTk)
if err != nil {
return nil, err
}
ctx.goNext() // skip mapping key token
if ctx.isTokenNotFound() {
return nil, errors.ErrSyntax("could not find value for mapping key", mapKeyTk.RawToken())
}
scalar, err := p.parseScalarValue(ctx, ctx.currentToken())
if err != nil {
return nil, err
}
key.Value = scalar
keyText := p.mapKeyText(scalar)
keyPath := ctx.withChild(keyText).path
key.SetPath(keyPath)
if err := p.validateMapKey(ctx, key.GetToken(), keyPath, g.Last()); err != nil {
return nil, err
}
p.pathMap[keyPath] = key
return key, nil
}
if g.Last().Type() != token.MappingValueType {
return nil, errors.ErrSyntax("expected map key-value delimiter ':'", g.Last().RawToken())
}
scalar, err := p.parseScalarValue(ctx, g.First())
if err != nil {
return nil, err
}
key, ok := scalar.(ast.MapKeyNode)
if !ok {
return nil, errors.ErrSyntax("cannot take map-key node", scalar.GetToken())
}
keyText := p.mapKeyText(key)
keyPath := ctx.withChild(keyText).path
key.SetPath(keyPath)
if err := p.validateMapKey(ctx, key.GetToken(), keyPath, g.Last()); err != nil {
return nil, err
}
p.pathMap[keyPath] = key
return key, nil
}
func (p *parser) validateMapKey(ctx *context, tk *token.Token, keyPath string, colonTk *Token) error {
if !p.allowDuplicateMapKey {
if n, exists := p.pathMap[keyPath]; exists {
pos := n.GetToken().Position
return errors.ErrSyntax(
fmt.Sprintf("mapping key %q already defined at [%d:%d]", tk.Value, pos.Line, pos.Column),
tk,
)
}
}
origin := p.removeLeftWhiteSpace(tk.Origin)
if ctx.isFlow {
if tk.Type == token.StringType {
origin = p.removeRightWhiteSpace(origin)
if tk.Position.Line+p.newLineCharacterNum(origin) != colonTk.Line() {
return errors.ErrSyntax("map key definition includes an implicit line break", tk)
}
}
return nil
}
if tk.Type != token.StringType && tk.Type != token.SingleQuoteType && tk.Type != token.DoubleQuoteType {
return nil
}
if p.existsNewLineCharacter(origin) {
return errors.ErrSyntax("unexpected key name", tk)
}
return nil
}
func (p *parser) removeLeftWhiteSpace(src string) string {
// CR or LF or CRLF
return strings.TrimLeftFunc(src, func(r rune) bool {
return r == ' ' || r == '\r' || r == '\n'
})
}
func (p *parser) removeRightWhiteSpace(src string) string {
// CR or LF or CRLF
return strings.TrimRightFunc(src, func(r rune) bool {
return r == ' ' || r == '\r' || r == '\n'
})
}
func (p *parser) existsNewLineCharacter(src string) bool {
return p.newLineCharacterNum(src) > 0
}
func (p *parser) newLineCharacterNum(src string) int {
var num int
for i := 0; i < len(src); i++ {
switch src[i] {
case '\r':
if len(src) > i+1 && src[i+1] == '\n' {
i++
}
num++
case '\n':
num++
}
}
return num
}
func (p *parser) mapKeyText(n ast.Node) string {
if n == nil {
return ""
}
switch nn := n.(type) {
case *ast.MappingKeyNode:
return p.mapKeyText(nn.Value)
case *ast.TagNode:
return p.mapKeyText(nn.Value)
case *ast.AnchorNode:
return p.mapKeyText(nn.Value)
case *ast.AliasNode:
return ""
}
return n.GetToken().Value
}
func (p *parser) parseMapValue(ctx *context, key ast.MapKeyNode, colonTk *Token) (ast.Node, error) {
tk := ctx.currentToken()
if tk == nil {
return newNullNode(ctx, ctx.addNullValueToken(colonTk))
}
if ctx.isComment() {
tk = ctx.nextNotCommentToken()
}
keyCol := key.GetToken().Position.Column
keyLine := key.GetToken().Position.Line
if tk.Column() != keyCol && tk.Line() == keyLine && (tk.GroupType() == TokenGroupMapKey || tk.GroupType() == TokenGroupMapKeyValue) {
// a: b:
// ^
//
// a: b: c
// ^
return nil, errors.ErrSyntax("mapping value is not allowed in this context", tk.RawToken())
}
if tk.Column() == keyCol && p.isMapToken(tk) {
// in this case,
// ----
// key:
// next
return newNullNode(ctx, ctx.insertNullToken(colonTk))
}
if tk.Line() == keyLine && tk.GroupType() == TokenGroupAnchorName &&
ctx.nextToken().Column() == keyCol && p.isMapToken(ctx.nextToken()) {
// in this case,
// ----
// key: &anchor
// next
group := &TokenGroup{
Type: TokenGroupAnchor,
Tokens: []*Token{tk, ctx.createImplicitNullToken(tk)},
}
anchor, err := p.parseAnchor(ctx.withGroup(group), group)
if err != nil {
return nil, err
}
ctx.goNext()
return anchor, nil
}
if tk.Column() <= keyCol && tk.GroupType() == TokenGroupAnchorName {
// key:
// &anchor
return nil, errors.ErrSyntax("anchor is not allowed in this context", tk.RawToken())
}
if tk.Column() <= keyCol && tk.Type() == token.TagType {
// key:
// !!tag
return nil, errors.ErrSyntax("tag is not allowed in this context", tk.RawToken())
}
if tk.Column() < keyCol {
// in this case,
// ----
// key:
// next
return newNullNode(ctx, ctx.insertNullToken(colonTk))
}
if tk.Line() == keyLine && tk.GroupType() == TokenGroupAnchorName &&
ctx.nextToken().Column() < keyCol {
// in this case,
// ----
// key: &anchor
// next
group := &TokenGroup{
Type: TokenGroupAnchor,
Tokens: []*Token{tk, ctx.createImplicitNullToken(tk)},
}
anchor, err := p.parseAnchor(ctx.withGroup(group), group)
if err != nil {
return nil, err
}
ctx.goNext()
return anchor, nil
}
value, err := p.parseToken(ctx, ctx.currentToken())
if err != nil {
return nil, err
}
if err := p.validateAnchorValueInMapOrSeq(value, keyCol); err != nil {
return nil, err
}
return value, nil
}
func (p *parser) validateAnchorValueInMapOrSeq(value ast.Node, col int) error {
anchor, ok := value.(*ast.AnchorNode)
if !ok {
return nil
}
tag, ok := anchor.Value.(*ast.TagNode)
if !ok {
return nil
}
anchorTk := anchor.GetToken()
tagTk := tag.GetToken()
if anchorTk.Position.Line == tagTk.Position.Line {
// key:
// &anchor !!tag
//
// - &anchor !!tag
return nil
}
if tagTk.Position.Column <= col {
// key: &anchor
// !!tag
//
// - &anchor
// !!tag
return errors.ErrSyntax("tag is not allowed in this context", tagTk)
}
return nil
}
func (p *parser) parseAnchor(ctx *context, g *TokenGroup) (*ast.AnchorNode, error) {
anchorNameGroup := g.First().Group
anchor, err := p.parseAnchorName(ctx.withGroup(anchorNameGroup))
if err != nil {
return nil, err
}
ctx.goNext()
if ctx.isTokenNotFound() {
return nil, errors.ErrSyntax("could not find anchor value", anchor.GetToken())
}
value, err := p.parseToken(ctx, ctx.currentToken())
if err != nil {
return nil, err
}
if _, ok := value.(*ast.AnchorNode); ok {
return nil, errors.ErrSyntax("anchors cannot be used consecutively", value.GetToken())
}
anchor.Value = value
return anchor, nil
}
func (p *parser) parseAnchorName(ctx *context) (*ast.AnchorNode, error) {
anchor, err := newAnchorNode(ctx, ctx.currentToken())
if err != nil {
return nil, err
}
ctx.goNext()
if ctx.isTokenNotFound() {
return nil, errors.ErrSyntax("could not find anchor value", anchor.GetToken())
}
anchorName, err := p.parseScalarValue(ctx, ctx.currentToken())
if err != nil {
return nil, err
}
if anchorName == nil {
return nil, errors.ErrSyntax("unexpected anchor. anchor name is not scalar value", ctx.currentToken().RawToken())
}
anchor.Name = anchorName
return anchor, nil
}
func (p *parser) parseAlias(ctx *context) (*ast.AliasNode, error) {
alias, err := newAliasNode(ctx, ctx.currentToken())
if err != nil {
return nil, err
}
ctx.goNext()
if ctx.isTokenNotFound() {
return nil, errors.ErrSyntax("could not find alias value", alias.GetToken())
}
aliasName, err := p.parseScalarValue(ctx, ctx.currentToken())
if err != nil {
return nil, err
}
if aliasName == nil {
return nil, errors.ErrSyntax("unexpected alias. alias name is not scalar value", ctx.currentToken().RawToken())
}
alias.Value = aliasName
return alias, nil
}
func (p *parser) parseLiteral(ctx *context) (*ast.LiteralNode, error) {
node, err := newLiteralNode(ctx, ctx.currentToken())
if err != nil {
return nil, err
}
ctx.goNext() // skip literal/folded token
tk := ctx.currentToken()
if tk == nil {
value, err := newStringNode(ctx, &Token{Token: token.New("", "", node.Start.Position)})
if err != nil {
return nil, err
}
node.Value = value
return node, nil
}
value, err := p.parseToken(ctx, tk)
if err != nil {
return nil, err
}
str, ok := value.(*ast.StringNode)
if !ok {
return nil, errors.ErrSyntax("unexpected token. required string token", value.GetToken())
}
node.Value = str
return node, nil
}
func (p *parser) parseScalarTag(ctx *context) (*ast.TagNode, error) {
tag, err := p.parseTag(ctx)
if err != nil {
return nil, err
}
if tag.Value == nil {
return nil, errors.ErrSyntax("specified not scalar tag", tag.GetToken())
}
if _, ok := tag.Value.(ast.ScalarNode); !ok {
return nil, errors.ErrSyntax("specified not scalar tag", tag.GetToken())
}
return tag, nil
}
func (p *parser) parseTag(ctx *context) (*ast.TagNode, error) {
tagTk := ctx.currentToken()
tagRawTk := tagTk.RawToken()
node, err := newTagNode(ctx, tagTk)
if err != nil {
return nil, err
}
ctx.goNext()
comment := p.parseHeadComment(ctx)
var tagValue ast.Node
if p.secondaryTagDirective != nil {
value, err := newStringNode(ctx, ctx.currentToken())
if err != nil {
return nil, err
}
tagValue = value
node.Directive = p.secondaryTagDirective
} else {
value, err := p.parseTagValue(ctx, tagRawTk, ctx.currentToken())
if err != nil {
return nil, err
}
tagValue = value
}
if err := setHeadComment(comment, tagValue); err != nil {
return nil, err
}
node.Value = tagValue
return node, nil
}
func (p *parser) parseTagValue(ctx *context, tagRawTk *token.Token, tk *Token) (ast.Node, error) {
if tk == nil {
return newNullNode(ctx, ctx.createImplicitNullToken(&Token{Token: tagRawTk}))
}
switch token.ReservedTagKeyword(tagRawTk.Value) {
case token.MappingTag, token.SetTag:
if !p.isMapToken(tk) {
return nil, errors.ErrSyntax("could not find map", tk.RawToken())
}
if tk.Type() == token.MappingStartType {
return p.parseFlowMap(ctx.withFlow(true))
}
return p.parseMap(ctx)
case token.IntegerTag, token.FloatTag, token.StringTag, token.BinaryTag, token.TimestampTag, token.BooleanTag, token.NullTag:
if tk.GroupType() == TokenGroupLiteral || tk.GroupType() == TokenGroupFolded {
return p.parseLiteral(ctx.withGroup(tk.Group))
} else if tk.Type() == token.CollectEntryType || tk.Type() == token.MappingValueType {
return newTagDefaultScalarValueNode(ctx, tagRawTk)
}
scalar, err := p.parseScalarValue(ctx, tk)
if err != nil {
return nil, err
}
ctx.goNext()
return scalar, nil
case token.SequenceTag, token.OrderedMapTag:
if tk.Type() == token.SequenceStartType {
return p.parseFlowSequence(ctx.withFlow(true))
}
return p.parseSequence(ctx)
}
return p.parseToken(ctx, tk)
}
func (p *parser) parseFlowSequence(ctx *context) (*ast.SequenceNode, error) {
node, err := newSequenceNode(ctx, ctx.currentToken(), true)
if err != nil {
return nil, err
}
ctx.goNext() // skip SequenceStart token
isFirst := true
for ctx.next() {
tk := ctx.currentToken()
if tk.Type() == token.SequenceEndType {
node.End = tk.RawToken()
break
}
var entryTk *Token
if tk.Type() == token.CollectEntryType {
if isFirst {
return nil, errors.ErrSyntax("expected sequence element, but found ','", tk.RawToken())
}
entryTk = tk
ctx.goNext()
} else if !isFirst {
return nil, errors.ErrSyntax("',' or ']' must be specified", tk.RawToken())
}
if tk := ctx.currentToken(); tk.Type() == token.SequenceEndType {
// this case is here: "[ elem, ]".
// In this case, ignore the last element and break sequence parsing.
node.End = tk.RawToken()
break
}
if ctx.isTokenNotFound() {
break
}
ctx := ctx.withIndex(uint(len(node.Values)))
value, err := p.parseToken(ctx, ctx.currentToken())
if err != nil {
return nil, err
}
node.Values = append(node.Values, value)
seqEntry := ast.SequenceEntry(entryTk.RawToken(), value, nil)
if err := setLineComment(ctx, seqEntry, entryTk); err != nil {
return nil, err
}
seqEntry.SetPath(ctx.path)
node.Entries = append(node.Entries, seqEntry)
isFirst = false
}
if node.End == nil {
return nil, errors.ErrSyntax("sequence end token ']' not found", node.Start)
}
ctx.goNext() // skip sequence end token.
return node, nil
}
func (p *parser) parseSequence(ctx *context) (*ast.SequenceNode, error) {
seqTk := ctx.currentToken()
seqNode, err := newSequenceNode(ctx, seqTk, false)
if err != nil {
return nil, err
}
tk := seqTk
for tk.Type() == token.SequenceEntryType && tk.Column() == seqTk.Column() {
seqTk := tk
headComment := p.parseHeadComment(ctx)
ctx.goNext() // skip sequence entry token
ctx := ctx.withIndex(uint(len(seqNode.Values)))
value, err := p.parseSequenceValue(ctx, seqTk)
if err != nil {
return nil, err
}
seqEntry := ast.SequenceEntry(seqTk.RawToken(), value, headComment)
if err := setLineComment(ctx, seqEntry, seqTk); err != nil {
return nil, err
}
seqEntry.SetPath(ctx.path)
seqNode.ValueHeadComments = append(seqNode.ValueHeadComments, headComment)
seqNode.Values = append(seqNode.Values, value)
seqNode.Entries = append(seqNode.Entries, seqEntry)
if ctx.isComment() {
tk = ctx.nextNotCommentToken()
} else {
tk = ctx.currentToken()
}
}
if ctx.isComment() {
if seqTk.Column() <= ctx.currentToken().Column() {
// If the comment is in the same or deeper column as the last element column in sequence value,
// treat it as a footer comment for the last element.
seqNode.FootComment = p.parseFootComment(ctx, seqTk.Column())
if len(seqNode.Values) != 0 {
seqNode.FootComment.SetPath(seqNode.Values[len(seqNode.Values)-1].GetPath())
}
}
}
return seqNode, nil
}
func (p *parser) parseSequenceValue(ctx *context, seqTk *Token) (ast.Node, error) {
tk := ctx.currentToken()
if tk == nil {
return newNullNode(ctx, ctx.addNullValueToken(seqTk))
}
if ctx.isComment() {
tk = ctx.nextNotCommentToken()
}
seqCol := seqTk.Column()
seqLine := seqTk.Line()
if tk.Column() == seqCol && tk.Type() == token.SequenceEntryType {
// in this case,
// ----
// -
// -
return newNullNode(ctx, ctx.insertNullToken(seqTk))
}
if tk.Line() == seqLine && tk.GroupType() == TokenGroupAnchorName &&
ctx.nextToken().Column() == seqCol && ctx.nextToken().Type() == token.SequenceEntryType {
// in this case,
// ----
// - &anchor
// -
group := &TokenGroup{
Type: TokenGroupAnchor,
Tokens: []*Token{tk, ctx.createImplicitNullToken(tk)},
}
anchor, err := p.parseAnchor(ctx.withGroup(group), group)
if err != nil {
return nil, err
}
ctx.goNext()
return anchor, nil
}
if tk.Column() <= seqCol && tk.GroupType() == TokenGroupAnchorName {
// -
// &anchor
return nil, errors.ErrSyntax("anchor is not allowed in this sequence context", tk.RawToken())
}
if tk.Column() <= seqCol && tk.Type() == token.TagType {
// -
// !!tag
return nil, errors.ErrSyntax("tag is not allowed in this sequence context", tk.RawToken())
}
if tk.Column() < seqCol {
// in this case,
// ----
// -
// next
return newNullNode(ctx, ctx.insertNullToken(seqTk))
}
if tk.Line() == seqLine && tk.GroupType() == TokenGroupAnchorName &&
ctx.nextToken().Column() < seqCol {
// in this case,
// ----
// - &anchor
// next
group := &TokenGroup{
Type: TokenGroupAnchor,
Tokens: []*Token{tk, ctx.createImplicitNullToken(tk)},
}
anchor, err := p.parseAnchor(ctx.withGroup(group), group)
if err != nil {
return nil, err
}
ctx.goNext()
return anchor, nil
}
value, err := p.parseToken(ctx, ctx.currentToken())
if err != nil {
return nil, err
}
if err := p.validateAnchorValueInMapOrSeq(value, seqCol); err != nil {
return nil, err
}
return value, nil
}
func (p *parser) parseDirective(ctx *context, g *TokenGroup) (*ast.DirectiveNode, error) {
directiveNameGroup := g.First().Group
directive, err := p.parseDirectiveName(ctx.withGroup(directiveNameGroup))
if err != nil {
return nil, err
}
switch directive.Name.String() {
case "YAML":
if len(g.Tokens) != 2 {
return nil, errors.ErrSyntax("unexpected format YAML directive", g.First().RawToken())
}
valueTk := g.Tokens[1]
valueRawTk := valueTk.RawToken()
value := valueRawTk.Value
ver, exists := yamlVersionMap[value]
if !exists {
return nil, errors.ErrSyntax(fmt.Sprintf("unknown YAML version %q", value), valueRawTk)
}
if p.yamlVersion != "" {
return nil, errors.ErrSyntax("YAML version has already been specified", valueRawTk)
}
p.yamlVersion = ver
versionNode, err := newStringNode(ctx, valueTk)
if err != nil {
return nil, err
}
directive.Values = append(directive.Values, versionNode)
case "TAG":
if len(g.Tokens) != 3 {
return nil, errors.ErrSyntax("unexpected format TAG directive", g.First().RawToken())
}
tagKey, err := newStringNode(ctx, g.Tokens[1])
if err != nil {
return nil, err
}
if tagKey.Value == "!!" {
p.secondaryTagDirective = directive
}
tagValue, err := newStringNode(ctx, g.Tokens[2])
if err != nil {
return nil, err
}
directive.Values = append(directive.Values, tagKey, tagValue)
default:
if len(g.Tokens) > 1 {
for _, tk := range g.Tokens[1:] {
value, err := newStringNode(ctx, tk)
if err != nil {
return nil, err
}
directive.Values = append(directive.Values, value)
}
}
}
return directive, nil
}
func (p *parser) parseDirectiveName(ctx *context) (*ast.DirectiveNode, error) {
directive, err := newDirectiveNode(ctx, ctx.currentToken())
if err != nil {
return nil, err
}
ctx.goNext()
if ctx.isTokenNotFound() {
return nil, errors.ErrSyntax("could not find directive value", directive.GetToken())
}
directiveName, err := p.parseScalarValue(ctx, ctx.currentToken())
if err != nil {
return nil, err
}
if directiveName == nil {
return nil, errors.ErrSyntax("unexpected directive. directive name is not scalar value", ctx.currentToken().RawToken())
}
directive.Name = directiveName
return directive, nil
}
func (p *parser) parseComment(ctx *context) (ast.Node, error) {
cm := p.parseHeadComment(ctx)
if ctx.isTokenNotFound() {
return cm, nil
}
node, err := p.parseToken(ctx, ctx.currentToken())
if err != nil {
return nil, err
}
if err := setHeadComment(cm, node); err != nil {
return nil, err
}
return node, nil
}
func (p *parser) parseHeadComment(ctx *context) *ast.CommentGroupNode {
tks := []*token.Token{}
for ctx.isComment() {
tks = append(tks, ctx.currentToken().RawToken())
ctx.goNext()
}
if len(tks) == 0 {
return nil
}
return ast.CommentGroup(tks)
}
func (p *parser) parseFootComment(ctx *context, col int) *ast.CommentGroupNode {
tks := []*token.Token{}
for ctx.isComment() && col <= ctx.currentToken().Column() {
tks = append(tks, ctx.currentToken().RawToken())
ctx.goNext()
}
if len(tks) == 0 {
return nil
}
return ast.CommentGroup(tks)
}
goccy-go-yaml-52dacb8/parser/parser_test.go 0000664 0000000 0000000 00000061664 15015766371 0021061 0 ustar 00root root 0000000 0000000 package parser_test
import (
"fmt"
"path/filepath"
"reflect"
"strconv"
"strings"
"testing"
"github.com/goccy/go-yaml"
"github.com/goccy/go-yaml/ast"
"github.com/goccy/go-yaml/lexer"
"github.com/goccy/go-yaml/parser"
"github.com/goccy/go-yaml/token"
)
func TestParser(t *testing.T) {
sources := []string{
"",
"null\n",
"0_",
"{}\n",
"v: hi\n",
"v: \"true\"\n",
"v: \"false\"\n",
"v: true\n",
"v: false\n",
"v: 10\n",
"v: -10\n",
"v: 42\n",
"v: 4294967296\n",
"v: \"10\"\n",
"v: 0.1\n",
"v: 0.99\n",
"v: -0.1\n",
"v: .inf\n",
"v: -.inf\n",
"v: .nan\n",
"v: null\n",
"v: \"\"\n",
"v:\n- A\n- B\n",
"a: '-'\n",
"123\n",
"hello: world\n",
"a: null\n",
"v:\n- A\n- 1\n- B:\n - 2\n - 3\n",
"a:\n b: c\n",
"a: {x: 1}\n",
"t2: 2018-01-09T10:40:47Z\nt4: 2098-01-09T10:40:47Z\n",
"a: [1, 2]\n",
"a: {b: c, d: e}\n",
"a: 3s\n",
"a: \n",
"a: \"1:1\"\n",
"a: 1.2.3.4\n",
"a: \"2015-02-24T18:19:39Z\"\n",
"a: 'b: c'\n",
"a: 'Hello #comment'\n",
"a: abc <> ghi",
"a: <-\n B\n C\n",
"v: |-\n 0\n",
"v: |-\n 0\nx: 0",
`"a\n1\nb"`,
`{"a":"b"}`,
`!!map {
? !!str "explicit":!!str "entry",
? !!str "implicit" : !!str "entry",
? !!null "" : !!null "",
}`,
"\"a\": a\n\"b\": b",
"'a': a\n'b': b",
"a: \r\n b: 1\r\n",
"a_ok: \r bc: 2\r",
"a_mk: \n bd: 3\n",
"a: :a",
"{a: , b: c}",
"value: >\n",
"value: >\n\n",
"value: >\nother:",
"value: >\n\nother:",
"a:\n-",
"a: {foo}",
"a: {foo,bar}",
`
{
a: {
b: c
},
d: e
}
`,
`
[
a: {
b: c
}]
`,
`
{
a: {
b: c
}}
`,
`
- !tag
a: b
c: d
`,
`
a: !tag
b: c
`,
`
a: !tag
b: c
d: e
`,
`
a:
b: c
`,
`
foo: xxx
---
foo: yyy
---
foo: zzz
`,
`
v:
a : 'a'
bb : 'a'
`,
`
v:
a : 'x'
b : 'y'
`,
`
v:
a : 'x'
b : 'y'
c : 'z'
`,
`{a: &a c, *a : b}`,
}
for idx, src := range sources {
t.Run(strconv.Itoa(idx), func(t *testing.T) {
f, err := parser.Parse(lexer.Tokenize(src), 0)
if err != nil {
t.Fatalf("parse error: source [%s]: %+v", src, err)
}
_ = f.String() // ensure no panic
})
}
}
func TestParseEmptyDocument(t *testing.T) {
t.Run("empty document", func(t *testing.T) {
f, err := parser.ParseBytes([]byte(""), parser.ParseComments)
if err != nil {
t.Fatal(err)
}
got := f.String()
expected := "\n"
if got != expected {
t.Fatalf("failed to parse comment:\nexpected:\n%q\ngot:\n%q", expected, got)
}
})
t.Run("empty document with comment (parse comment = off)", func(t *testing.T) {
f, err := parser.ParseBytes([]byte("# comment"), 0)
if err != nil {
t.Fatal(err)
}
got := f.String()
expected := "\n"
if got != expected {
t.Fatalf("failed to parse comment:\nexpected:\n%q\ngot:\n%q", expected, got)
}
})
t.Run("empty document with comment (parse comment = on)", func(t *testing.T) {
f, err := parser.ParseBytes([]byte("# comment"), parser.ParseComments)
if err != nil {
t.Fatal(err)
}
got := f.String()
expected := "# comment\n"
if got != expected {
t.Fatalf("failed to parse comment:\nexpected:\n%q\ngot:\n%q", expected, got)
}
})
}
func TestParseComplicatedDocument(t *testing.T) {
tests := []struct {
source string
expect string
}{
{
`
american:
- Boston Red Sox
- Detroit Tigers
- New York Yankees
national:
- New York Mets
- Chicago Cubs
- Atlanta Braves
`, `
american:
- Boston Red Sox
- Detroit Tigers
- New York Yankees
national:
- New York Mets
- Chicago Cubs
- Atlanta Braves
`,
},
{
`
a:
b: c
d: e
f: g
h:
i: j
k:
l: m
n: o
p: q
r: s
`, `
a:
b: c
d: e
f: g
h:
i: j
k:
l: m
n: o
p: q
r: s
`,
},
{
`
- a:
- b
- c
- d
`, `
- a:
- b
- c
- d
`,
},
{
`
- a
- b
- c
- d
- e
- f
`, `
- a
- b
- c - d - e
- f
`,
},
{
`
a: 0 - 1
`,
`
a: 0 - 1
`,
},
{`
- a:
b: c
d: e
- f:
g: h
`,
`
- a:
b: c
d: e
- f:
g: h
`,
},
{
`
a:
b
c
d: e
`, `
a: b c
d: e
`,
},
{
`
a
b
c
`, `
a b c
`,
},
{
`
a:
- b
- c
`, `
a:
- b
- c
`,
},
{
`
- a :
b: c
`, `
- a:
b: c
`,
},
{
`
- a:
b
c
d
hoge: fuga
`, `
- a: b c d
hoge: fuga
`,
},
{
`
- a # ' " # - : %
- b # " # - : % '
- c # # - : % ' "
- d # - : % ' " #
- e # : % ' " # -
- f # % ' : # - :
`,
`
- a
- b
- c
- d
- e
- f
`,
},
{
`
# comment
a: # comment
# comment
b: c # comment
# comment
d: e # comment
# comment
`,
`
a:
b: c
d: e
`,
},
{
`
a: b#notcomment
`,
`
a: b#notcomment
`,
},
{
`
anchored: &anchor foo
aliased: *anchor
`,
`
anchored: &anchor foo
aliased: *anchor
`,
},
{
`
---
- &CENTER { x: 1, y: 2 }
- &LEFT { x: 0, y: 2 }
- &BIG { r: 10 }
- &SMALL { r: 1 }
# All the following maps are equal:
- # Explicit keys
x: 1
y: 2
r: 10
label: center/big
- # Merge one map
<< : *CENTER
r: 10
label: center/big
- # Merge multiple maps
<< : [ *CENTER, *BIG ]
label: center/big
- # Override
<< : [ *BIG, *LEFT, *SMALL ]
x: 1
label: center/big
`,
`
---
- &CENTER {x: 1, y: 2}
- &LEFT {x: 0, y: 2}
- &BIG {r: 10}
- &SMALL {r: 1}
- x: 1
y: 2
r: 10
label: center/big
- <<: *CENTER
r: 10
label: center/big
- <<: [*CENTER, *BIG]
label: center/big
- <<: [*BIG, *LEFT, *SMALL]
x: 1
label: center/big
`,
},
{
`
a:
- - b
- - c
- d
`,
`
a:
- - b
- - c
- d
`,
},
{
`
a:
b:
c: d
e:
f: g
h: i
j: k
`,
`
a:
b:
c: d
e:
f: g
h: i
j: k
`,
},
{
`
---
a: 1
b: 2
...
---
c: 3
d: 4
...
`,
`
---
a: 1
b: 2
...
---
c: 3
d: 4
...
`,
},
{
`
a:
b: |
{
[ 1, 2 ]
}
c: d
`,
`
a:
b: |
{
[ 1, 2 ]
}
c: d
`,
},
{
`
|
hoge
fuga
piyo`,
`
|
hoge
fuga
piyo
`,
},
{
`
v: |
a
b
c`,
`
v: |
a
b
c
`,
},
{
`
a: |
bbbbbbb
ccccccc
d: eeeeeeeeeeeeeeeee
`,
`
a: |
bbbbbbb
ccccccc
d: eeeeeeeeeeeeeeeee
`,
},
{
`
a: b
c
`,
`
a: b c
`,
},
{
`
a:
b: c
`,
`
a:
b: c
`,
},
{
`
a: b
c: d
`,
`
a: b
c: d
`,
},
{
`
- ab - cd
- ef - gh
`,
`
- ab - cd
- ef - gh
`,
},
{
`
- 0 - 1
- 2 - 3
`,
`
- 0 - 1 - 2 - 3
`,
},
{
`
a - b - c: value
`,
`
a - b - c: value
`,
},
{
`
a:
-
b: c
d: e
-
f: g
h: i
`,
`
a:
- b: c
d: e
- f: g
h: i
`,
},
{
`
a: |-
value
b: c
`,
`
a: |-
value
b: c
`,
},
{
`
a: |+
value
b: c
`,
`
a: |+
value
b: c
`,
},
{
`
- key1: val
key2:
(
foo
+
bar
)
`,
`
- key1: val
key2: ( foo + bar )
`,
},
{
`
"a": b
'c': d
"e": "f"
g: "h"
i: 'j'
`,
`
"a": b
'c': d
"e": "f"
g: "h"
i: 'j'
`,
},
{
`
a:
- |2
b
c: d
`,
`
a:
- |2
b
c: d
`,
},
{
`
a:
b: &anchor
c: &anchor2
d: e
`,
`
a:
b: &anchor
c: &anchor2
d: e
`,
},
}
for _, test := range tests {
t.Run(test.source, func(t *testing.T) {
tokens := lexer.Tokenize(test.source)
f, err := parser.Parse(tokens, 0)
if err != nil {
t.Fatalf("%+v", err)
}
got := f.String()
if got != strings.TrimPrefix(test.expect, "\n") {
t.Fatalf("failed to parse comment:\nexpected:\n%s\ngot:\n%s", strings.TrimPrefix(test.expect, "\n"), got)
}
var v Visitor
for _, doc := range f.Docs {
ast.Walk(&v, doc.Body)
}
expect := fmt.Sprintf("\n%+v", f)
if test.expect != expect {
tokens.Dump()
t.Fatalf("unexpected output: [%s] != [%s]", test.expect, expect)
}
})
}
}
func TestParseWhitespace(t *testing.T) {
tests := []struct {
source string
expect string
}{
{
`
a: b
c: d
e: f
g: h
`,
`
a: b
c: d
e: f
g: h
`,
},
{
`
a:
- b: c
d: e
- f: g
h: i
`,
`
a:
- b: c
d: e
- f: g
h: i
`,
},
{
`
a:
- b: c
d: e
- f: g
h: i
`,
`
a:
- b: c
d: e
- f: g
h: i
`,
},
{
`
a:
- b: c
d: e
- f: g
h: i
`,
`
a:
- b: c
d: e
- f: g
h: i
`,
},
{
`
a:
# comment 1
- b: c
d: e
# comment 2
- f: g
h: i
`,
`
a:
# comment 1
- b: c
d: e
# comment 2
- f: g
h: i
`,
},
{
`
a:
# comment 1
- b: c
# comment 2
d: e
# comment 3
# comment 4
- f: g
h: i # comment 5
`,
`
a:
# comment 1
- b: c
# comment 2
d: e
# comment 3
# comment 4
- f: g
h: i # comment 5
`,
},
{
`
a:
# comment 1
- b: c
# comment 2
d: e
# comment 3
# comment 4
- f: |
g
g
h: i # comment 5
`,
`
a:
# comment 1
- b: c
# comment 2
d: e
# comment 3
# comment 4
- f: |
g
g
h: i # comment 5
`,
},
{
`
a:
# comment 1
- b: c
# comment 2
d: e
# comment 3
# comment 4
- f: |
asd
def
h: i # comment 5
`,
`
a:
# comment 1
- b: c
# comment 2
d: e
# comment 3
# comment 4
- f: |
asd
def
h: i # comment 5
`,
},
{
`
- b: c
d: e
- f: g
h: i # comment 4
`,
`
- b: c
d: e
- f: g
h: i # comment 4
`,
},
{
`
a: null
b: null
d: e
`,
`
a: null
b: null
d: e
`,
},
{
`
foo:
bar: null # comment
baz: 1
`,
`
foo:
bar: null # comment
baz: 1
`,
},
{
`
foo:
bar: null # comment
baz: 1
`,
`
foo:
bar: null # comment
baz: 1
`,
},
{
`
{
"apiVersion": "apps/v1",
"kind": "Deployment",
"metadata": {
"name": "foo",
"labels": {
"app": "bar"
}
},
"spec": {
"replicas": 3,
"selector": {
"matchLabels": {
"app": "bar"
}
},
"template": {
"metadata": {
"labels": {
"app": "bar"
}
}
}
}
}
`,
`
{"apiVersion": "apps/v1", "kind": "Deployment", "metadata": {"name": "foo", "labels": {"app": "bar"}}, "spec": {"replicas": 3, "selector": {"matchLabels": {"app": "bar"}}, "template": {"metadata": {"labels": {"app": "bar"}}}}}
`,
},
}
for _, test := range tests {
t.Run(test.source, func(t *testing.T) {
f, err := parser.ParseBytes([]byte(test.source), parser.ParseComments)
if err != nil {
t.Fatal(err)
}
got := f.String()
if got != strings.TrimPrefix(test.expect, "\n") {
t.Fatalf("failed to parse comment:\nexpected:\n%s\ngot:\n%s", strings.TrimPrefix(test.expect, "\n"), got)
}
})
}
}
func TestNewLineChar(t *testing.T) {
for _, f := range []string{
"lf.yml",
"cr.yml",
"crlf.yml",
} {
ast, err := parser.ParseFile(filepath.Join("testdata", f), 0)
if err != nil {
t.Fatalf("%+v", err)
}
actual := fmt.Sprintf("%v", ast)
expect := `a: "a"
b: 1
`
if expect != actual {
t.Fatalf("unexpected result\nexpected:\n%s\ngot:\n%s", expect, actual)
}
}
}
func TestSyntaxError(t *testing.T) {
tests := []struct {
source string
expect string
}{
{
`
a:
- b
c: d
e: f
g: h`,
`
[3:3] unexpected key name
2 | a:
> 3 | - b
4 | c: d
^
5 | e: f
6 | g: h`,
},
{
`
a
- b: c`,
`
[2:1] unexpected key name
> 2 | a
3 | - b: c
^
`,
},
{
`%YAML 1.1 {}`,
`
[1:1] unexpected directive value. document not started
> 1 | %YAML 1.1 {}
^
`,
},
{
`{invalid`,
`
[1:2] could not find flow map content
> 1 | {invalid
^
`,
},
{
`{ "key": "value" `,
`
[1:1] could not find flow mapping end token '}'
> 1 | { "key": "value"
^
`,
},
{
`
a: |invalidopt
foo
`,
`
[2:4] invalid header option: "invalidopt"
> 2 | a: |invalidopt
^
3 | foo`,
},
{
`
a: 1
b
`,
`
[3:1] non-map value is specified
2 | a: 1
> 3 | b
^
`,
},
{
`
a: 'b'
c: d
`,
`
[3:3] value is not allowed in this context. map key-value is pre-defined
2 | a: 'b'
> 3 | c: d
^
`,
},
{
`
a: 'b'
- c
`,
`
[3:3] value is not allowed in this context. map key-value is pre-defined
2 | a: 'b'
> 3 | - c
^
`,
},
{
`
a: 'b'
# comment
- c
`,
`
[4:3] value is not allowed in this context. map key-value is pre-defined
2 | a: 'b'
3 | # comment
> 4 | - c
^
`,
},
{
`
a: 1
b
- c
`,
`
[3:1] non-map value is specified
2 | a: 1
> 3 | b
^
4 | - c`,
},
{
`a: [`,
`
[1:4] sequence end token ']' not found
> 1 | a: [
^
`,
},
{
`a: ]`,
`
[1:4] could not find '[' character corresponding to ']'
> 1 | a: ]
^
`,
},
{
`a: [ [1] [2] [3] ]`,
`
[1:10] ',' or ']' must be specified
> 1 | a: [ [1] [2] [3] ]
^
`,
},
{
`
a: -
b: -
`,
`
[2:4] block sequence entries are not allowed in this context
> 2 | a: -
^
3 | b: -`,
},
{
`
a: - 1
b: - 2
`,
`
[2:4] block sequence entries are not allowed in this context
> 2 | a: - 1
^
3 | b: - 2`,
},
{
`a: 'foobarbaz`,
`
[1:4] could not find end character of single-quoted text
> 1 | a: 'foobarbaz
^
`,
},
{
`a: "\"key\": \"value:\"`,
`
[1:4] could not find end character of double-quoted text
> 1 | a: "\"key\": \"value:\"
^
`,
},
{
`foo: [${should not be allowed}]`,
`
[1:8] ',' or ']' must be specified
> 1 | foo: [${should not be allowed}]
^
`,
},
{
`foo: [$[should not be allowed]]`,
`
[1:8] ',' or ']' must be specified
> 1 | foo: [$[should not be allowed]]
^
`,
},
{
">\n>",
`
[2:1] could not find multi-line content
1 | >
> 2 | >
^
`,
},
{
">\n1",
`
[2:1] could not find multi-line content
1 | >
> 2 | 1
^
`,
},
{
"|\n1",
`
[2:1] could not find multi-line content
1 | |
> 2 | 1
^
`,
},
{
"a: >3\n 1",
`
[2:3] invalid number of indent is specified in the multi-line header
1 | a: >3
> 2 | 1
^
`,
},
{
`
a:
- |
b
c: d
`,
`
[5:5] value is not allowed in this context
2 | a:
3 | - |
4 | b
> 5 | c: d
^
`,
},
{
`
a:
- |
b
c:
d: e
`,
`
[5:5] value is not allowed in this context
2 | a:
3 | - |
4 | b
> 5 | c:
^
6 | d: e`,
},
{
"key: [@val]",
`
[1:7] '@' is a reserved character
> 1 | key: [@val]
^
`,
},
{
"key: [`val]",
"\n[1:7] '`' is a reserved character\n> 1 | key: [`val]\n ^\n",
},
{
`{a: b}: v`,
`
[1:7] found an invalid key for this map
> 1 | {a: b}: v
^
`,
},
{
`[a]: v`,
`
[1:4] found an invalid key for this map
> 1 | [a]: v
^
`,
},
{
`
foo:
bar:
foo: 2
baz:
foo: 3
foo: 2
`,
`
[7:1] mapping key "foo" already defined at [2:1]
4 | foo: 2
5 | baz:
6 | foo: 3
> 7 | foo: 2
^
`,
},
{
`
foo:
bar:
foo: 2
baz:
foo: 3
foo: 4
`,
`
[7:5] mapping key "foo" already defined at [6:5]
4 | foo: 2
5 | baz:
6 | foo: 3
> 7 | foo: 4
^
`,
},
{
`{"000":0000A,`,
`
[1:13] could not find flow map content
> 1 | {"000":0000A,
^
`,
},
}
for _, test := range tests {
t.Run(test.source, func(t *testing.T) {
_, err := parser.ParseBytes([]byte(test.source), 0)
if err == nil {
t.Fatal("cannot catch syntax error")
}
actual := "\n" + err.Error()
if test.expect != actual {
t.Fatalf("expected: [%s] but got [%s]", test.expect, actual)
}
})
}
}
func TestComment(t *testing.T) {
tests := []struct {
name string
yaml string
expected string
}{
{
name: "map with comment",
yaml: `
# commentA
a: #commentB
# commentC
b: c # commentD
# commentE
d: e # commentF
# commentG
f: g # commentH
# commentI
f: g # commentJ
# commentK
`,
},
{
name: "sequence with comment",
yaml: `
# commentA
- a # commentB
# commentC
- b: # commentD
# commentE
- d # commentF
- e # commentG
# commentH
`,
},
{
name: "anchor and alias",
yaml: `
a: &x b # commentA
c: *x # commentB
`,
},
{
name: "multiline",
yaml: `
# foo comment
# foo comment2
foo: # map key comment
# bar above comment
# bar above comment2
bar: 10 # comment for bar
# baz above comment
# baz above comment2
baz: bbbb # comment for baz
piyo: # sequence key comment
# sequence1 above comment 1
# sequence1 above comment 2
- sequence1 # sequence1
# sequence2 above comment 1
# sequence2 above comment 2
- sequence2 # sequence2
# sequence3 above comment 1
# sequence3 above comment 2
- false # sequence3
# foo2 comment
# foo2 comment2
foo2: &anchor text # anchor comment
# foo3 comment
# foo3 comment2
foo3: *anchor # alias comment
`,
},
{
name: "literal",
yaml: `
foo: | # comment
x: 42
`,
},
{
name: "folded",
yaml: `
foo: > # comment
x: 42
`,
},
{
name: "unattached comment",
yaml: `
# This comment is in its own document
---
a: b
`,
},
{
name: "map with misaligned indentation in comments",
yaml: `
# commentA
a: #commentB
# commentC
b: c # commentD
# commentE
d: e # commentF
# commentG
`,
expected: `
# commentA
a: #commentB
# commentC
b: c # commentD
# commentE
d: e # commentF
# commentG
`,
},
{
name: "sequence with misaligned indentation in comments",
yaml: `
# commentA
- a # commentB
# commentC
- b: # commentD
# commentE
- d # commentF
# commentG
- e # commentG
# commentH
`,
expected: `
# commentA
- a # commentB
# commentC
- b: # commentD
# commentE
- d # commentF
# commentG
- e # commentG
# commentH
`,
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
f, err := parser.ParseBytes([]byte(test.yaml), parser.ParseComments)
if err != nil {
t.Fatalf("%+v", err)
}
got := "\n" + f.String()
expected := test.yaml
if test.expected != "" {
expected = test.expected
}
if expected != got {
t.Fatalf("expected:%s\ngot:%s", expected, got)
}
})
}
}
func TestCommentWithNull(t *testing.T) {
t.Run("same line", func(t *testing.T) {
content := `
foo:
bar: # comment
baz: 1
`
expected := `
foo:
bar: # comment
baz: 1`
f, err := parser.ParseBytes([]byte(content), parser.ParseComments)
if err != nil {
t.Fatal(err)
}
if len(f.Docs) != 1 {
t.Fatal("failed to parse content with same line comment")
}
got := f.Docs[0].String()
if got != strings.TrimPrefix(expected, "\n") {
t.Fatalf("failed to parse comment:\nexpected:\n%s\ngot:\n%s", strings.TrimPrefix(expected, "\n"), got)
}
})
t.Run("next line", func(t *testing.T) {
content := `
foo:
bar:
# comment
baz: 1
`
expected := `
foo:
bar:
# comment
baz: 1`
f, err := parser.ParseBytes([]byte(content), parser.ParseComments)
if err != nil {
t.Fatal(err)
}
if len(f.Docs) != 1 {
t.Fatal("failed to parse content with next line comment")
}
got := f.Docs[0].String()
if got != strings.TrimPrefix(expected, "\n") {
t.Fatalf("failed to parse comment:\nexpected:\n%s\ngot:\n%s", strings.TrimPrefix(expected, "\n"), got)
}
})
t.Run("next line and different indent", func(t *testing.T) {
content := `
foo:
bar:
# comment
baz: 1`
f, err := parser.ParseBytes([]byte(content), parser.ParseComments)
if err != nil {
t.Fatal(err)
}
if len(f.Docs) != 1 {
t.Fatal("failed to parse content with next line comment")
}
expected := `
foo:
bar:
# comment
baz: 1`
got := f.Docs[0].String()
if got != strings.TrimPrefix(expected, "\n") {
t.Fatalf("failed to parse comment:\nexpected:\n%s\ngot:\n%s", strings.TrimPrefix(expected, "\n"), got)
}
})
}
func TestSequenceComment(t *testing.T) {
content := `
foo:
- # comment
bar: 1
baz:
- xxx
`
f, err := parser.ParseBytes([]byte(content), parser.ParseComments)
if err != nil {
t.Fatal(err)
}
if len(f.Docs) != 1 {
t.Fatal("failed to parse content with next line with sequence")
}
expected := `
foo:
# comment
- bar: 1
baz:
- xxx`
got := f.Docs[0].String()
if got != strings.TrimPrefix(expected, "\n") {
t.Fatalf("failed to parse comment:\nexpected:\n%s\ngot:\n%s", strings.TrimPrefix(expected, "\n"), got)
}
t.Run("foo[0].bar", func(t *testing.T) {
path, err := yaml.PathString("$.foo[0].bar")
if err != nil {
t.Fatal(err)
}
v, err := path.FilterFile(f)
if err != nil {
t.Fatal(err)
}
if v.String() != "1" {
t.Fatal("failed to get foo[0].bar value")
}
})
t.Run("baz[0]", func(t *testing.T) {
path, err := yaml.PathString("$.baz[0]")
if err != nil {
t.Fatal(err)
}
v, err := path.FilterFile(f)
if err != nil {
t.Fatal(err)
}
if v.String() != "xxx" {
t.Fatal("failed to get baz[0] value")
}
})
}
func TestCommentWithMap(t *testing.T) {
yml := `
single:
# foo comment
foo: bar
multiple:
# a comment
a: b
# c comment
c: d
`
file, err := parser.ParseBytes([]byte(yml), parser.ParseComments)
if err != nil {
t.Fatal(err)
}
if len(file.Docs) == 0 {
t.Fatal("cannot get file docs")
}
if file.Docs[0].Body == nil {
t.Fatal("cannot get docs body")
}
mapNode, ok := file.Docs[0].Body.(*ast.MappingNode)
if !ok {
t.Fatalf("failed to get map node. got: %T\n", file.Docs[0].Body)
}
if len(mapNode.Values) != 2 {
t.Fatalf("failed to get map values. got %d", len(mapNode.Values))
}
singleNode, ok := mapNode.Values[0].Value.(*ast.MappingNode)
if !ok {
t.Fatalf("failed to get single node. got %T", mapNode.Values[0].Value)
}
if len(singleNode.Values) != 1 {
t.Fatalf("failed to get single node values. got %d", len(singleNode.Values))
}
if singleNode.Values[0].GetComment().GetToken().Value != " foo comment" {
t.Fatalf("failed to get comment from single. got %q", singleNode.GetComment().GetToken().Value)
}
multiNode, ok := mapNode.Values[1].Value.(*ast.MappingNode)
if !ok {
t.Fatalf("failed to get multiple node. got: %T", mapNode.Values[1])
}
if multiNode.GetComment() != nil {
t.Fatalf("found unexpected comment")
}
if len(multiNode.Values) != 2 {
t.Fatalf("failed to get multiple node values. got %d", len(multiNode.Values))
}
if multiNode.Values[0].GetComment().GetToken().Value != " a comment" {
t.Fatalf("failed to get comment from multiple[0]. got %q", multiNode.Values[0].GetComment().GetToken().Value)
}
if multiNode.Values[1].GetComment().GetToken().Value != " c comment" {
t.Fatalf("failed to get comment from multiple[1]. got %q", multiNode.Values[1].GetComment().GetToken().Value)
}
}
func TestInFlowStyle(t *testing.T) {
type inFlowStyle interface {
SetIsFlowStyle(bool)
}
tests := []struct {
source string
expect string
}{
{
`
- foo
- bar
- baz
`,
`[foo, bar, baz]
`,
},
{
`
foo: bar
baz: fizz
`,
`{foo: bar, baz: fizz}
`,
},
{
`
foo:
- bar
- baz
- fizz: buzz
`,
`{foo: [bar, baz, {fizz: buzz}]}
`,
},
}
for _, test := range tests {
t.Run(test.source, func(t *testing.T) {
f, err := parser.ParseBytes([]byte(test.source), parser.ParseComments)
if err != nil {
t.Fatal(err)
}
if len(f.Docs) != 1 {
t.Fatal("failed to parse content")
}
ifs, ok := f.Docs[0].Body.(inFlowStyle)
if !ok {
t.Fatalf("failed to get inFlowStyle. got: %T", f.Docs[0].Body)
}
ifs.SetIsFlowStyle(true)
got := f.String()
if got != test.expect {
t.Fatalf("failed to parse comment:\nexpected:\n%s\ngot:\n%s", test.expect, got)
}
})
}
}
func TestNodePath(t *testing.T) {
yml := `
a: # commentA
b: # commentB
c: foo # commentC
d: bar # commentD
e: baz # commentE
f: # commentF
g: hoge # commentG
h: # commentH
- list1 # comment list1
- list2 # comment list2
- list3 # comment list3
i: fuga # commentI
j: piyo # commentJ
k.l.m.n: moge # commentKLMN
o#p: hogera # commentOP
q#.r: hogehoge # commentQR
`
f, err := parser.ParseBytes([]byte(yml), parser.ParseComments)
if err != nil {
t.Fatalf("%+v", err)
}
var capturer pathCapturer
for _, doc := range f.Docs {
ast.Walk(&capturer, doc.Body)
}
commentPaths := []string{}
for i := 0; i < capturer.capturedNum; i++ {
if capturer.orderedTypes[i] == ast.CommentType {
commentPaths = append(commentPaths, capturer.orderedPaths[i])
}
}
expectedPaths := []string{
"$.a",
"$.a.b",
"$.a.b.c",
"$.a.b.d",
"$.a.b.e",
"$.a.f",
"$.a.f.g",
"$.a.h",
"$.a.h[0]",
"$.a.h[1]",
"$.a.h[2]",
"$.a.i",
"$.j",
"$.'k.l.m.n'",
"$.o#p",
"$.'q#.r'",
}
if !reflect.DeepEqual(expectedPaths, commentPaths) {
t.Fatalf("failed to get YAMLPath to the comment node:\nexpected[%s]\ngot [%s]", expectedPaths, commentPaths)
}
}
type pathCapturer struct {
capturedNum int
orderedPaths []string
orderedTypes []ast.NodeType
orderedTokens []*token.Token
}
func (c *pathCapturer) Visit(node ast.Node) ast.Visitor {
c.capturedNum++
c.orderedPaths = append(c.orderedPaths, node.GetPath())
c.orderedTypes = append(c.orderedTypes, node.Type())
c.orderedTokens = append(c.orderedTokens, node.GetToken())
return c
}
type Visitor struct{}
func (v *Visitor) Visit(node ast.Node) ast.Visitor {
tk := node.GetToken()
tk.Prev = nil
tk.Next = nil
return v
}
goccy-go-yaml-52dacb8/parser/testdata/ 0000775 0000000 0000000 00000000000 15015766371 0017773 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/parser/testdata/cr.yml 0000664 0000000 0000000 00000000015 15015766371 0021116 0 ustar 00root root 0000000 0000000 a: "a"
b: 1
goccy-go-yaml-52dacb8/parser/testdata/crlf.yml 0000664 0000000 0000000 00000000020 15015766371 0021434 0 ustar 00root root 0000000 0000000 a: "a"
b: 1
goccy-go-yaml-52dacb8/parser/testdata/lf.yml 0000664 0000000 0000000 00000000015 15015766371 0021113 0 ustar 00root root 0000000 0000000 a: "a"
b: 1
goccy-go-yaml-52dacb8/parser/token.go 0000664 0000000 0000000 00000040515 15015766371 0017636 0 ustar 00root root 0000000 0000000 package parser
import (
"fmt"
"os"
"strings"
"github.com/goccy/go-yaml/internal/errors"
"github.com/goccy/go-yaml/token"
)
type TokenGroupType int
const (
TokenGroupNone TokenGroupType = iota
TokenGroupDirective
TokenGroupDirectiveName
TokenGroupDocument
TokenGroupDocumentBody
TokenGroupAnchor
TokenGroupAnchorName
TokenGroupAlias
TokenGroupLiteral
TokenGroupFolded
TokenGroupScalarTag
TokenGroupMapKey
TokenGroupMapKeyValue
)
func (t TokenGroupType) String() string {
switch t {
case TokenGroupNone:
return "none"
case TokenGroupDirective:
return "directive"
case TokenGroupDirectiveName:
return "directive_name"
case TokenGroupDocument:
return "document"
case TokenGroupDocumentBody:
return "document_body"
case TokenGroupAnchor:
return "anchor"
case TokenGroupAnchorName:
return "anchor_name"
case TokenGroupAlias:
return "alias"
case TokenGroupLiteral:
return "literal"
case TokenGroupFolded:
return "folded"
case TokenGroupScalarTag:
return "scalar_tag"
case TokenGroupMapKey:
return "map_key"
case TokenGroupMapKeyValue:
return "map_key_value"
}
return "none"
}
type Token struct {
Token *token.Token
Group *TokenGroup
LineComment *token.Token
}
func (t *Token) RawToken() *token.Token {
if t == nil {
return nil
}
if t.Token != nil {
return t.Token
}
return t.Group.RawToken()
}
func (t *Token) Type() token.Type {
if t == nil {
return 0
}
if t.Token != nil {
return t.Token.Type
}
return t.Group.TokenType()
}
func (t *Token) GroupType() TokenGroupType {
if t == nil {
return TokenGroupNone
}
if t.Token != nil {
return TokenGroupNone
}
return t.Group.Type
}
func (t *Token) Line() int {
if t == nil {
return 0
}
if t.Token != nil {
return t.Token.Position.Line
}
return t.Group.Line()
}
func (t *Token) Column() int {
if t == nil {
return 0
}
if t.Token != nil {
return t.Token.Position.Column
}
return t.Group.Column()
}
func (t *Token) SetGroupType(typ TokenGroupType) {
if t.Group == nil {
return
}
t.Group.Type = typ
}
func (t *Token) Dump() {
ctx := new(groupTokenRenderContext)
if t.Token != nil {
fmt.Fprint(os.Stdout, t.Token.Value)
return
}
t.Group.dump(ctx)
fmt.Fprintf(os.Stdout, "\n")
}
func (t *Token) dump(ctx *groupTokenRenderContext) {
if t.Token != nil {
fmt.Fprint(os.Stdout, t.Token.Value)
return
}
t.Group.dump(ctx)
}
type groupTokenRenderContext struct {
num int
}
type TokenGroup struct {
Type TokenGroupType
Tokens []*Token
}
func (g *TokenGroup) First() *Token {
if len(g.Tokens) == 0 {
return nil
}
return g.Tokens[0]
}
func (g *TokenGroup) Last() *Token {
if len(g.Tokens) == 0 {
return nil
}
return g.Tokens[len(g.Tokens)-1]
}
func (g *TokenGroup) dump(ctx *groupTokenRenderContext) {
num := ctx.num
fmt.Fprint(os.Stdout, colorize(num, "("))
ctx.num++
for _, tk := range g.Tokens {
tk.dump(ctx)
}
fmt.Fprint(os.Stdout, colorize(num, ")"))
}
func (g *TokenGroup) RawToken() *token.Token {
if len(g.Tokens) == 0 {
return nil
}
return g.Tokens[0].RawToken()
}
func (g *TokenGroup) Line() int {
if len(g.Tokens) == 0 {
return 0
}
return g.Tokens[0].Line()
}
func (g *TokenGroup) Column() int {
if len(g.Tokens) == 0 {
return 0
}
return g.Tokens[0].Column()
}
func (g *TokenGroup) TokenType() token.Type {
if len(g.Tokens) == 0 {
return 0
}
return g.Tokens[0].Type()
}
func CreateGroupedTokens(tokens token.Tokens) ([]*Token, error) {
var err error
tks := newTokens(tokens)
tks = createLineCommentTokenGroups(tks)
tks, err = createLiteralAndFoldedTokenGroups(tks)
if err != nil {
return nil, err
}
tks, err = createAnchorAndAliasTokenGroups(tks)
if err != nil {
return nil, err
}
tks, err = createScalarTagTokenGroups(tks)
if err != nil {
return nil, err
}
tks, err = createAnchorWithScalarTagTokenGroups(tks)
if err != nil {
return nil, err
}
tks, err = createMapKeyTokenGroups(tks)
if err != nil {
return nil, err
}
tks = createMapKeyValueTokenGroups(tks)
tks, err = createDirectiveTokenGroups(tks)
if err != nil {
return nil, err
}
tks, err = createDocumentTokens(tks)
if err != nil {
return nil, err
}
return tks, nil
}
func newTokens(tks token.Tokens) []*Token {
ret := make([]*Token, 0, len(tks))
for _, tk := range tks {
ret = append(ret, &Token{Token: tk})
}
return ret
}
func createLineCommentTokenGroups(tokens []*Token) []*Token {
ret := make([]*Token, 0, len(tokens))
for i := 0; i < len(tokens); i++ {
tk := tokens[i]
switch tk.Type() {
case token.CommentType:
if i > 0 && tokens[i-1].Line() == tk.Line() {
tokens[i-1].LineComment = tk.RawToken()
} else {
ret = append(ret, tk)
}
default:
ret = append(ret, tk)
}
}
return ret
}
func createLiteralAndFoldedTokenGroups(tokens []*Token) ([]*Token, error) {
ret := make([]*Token, 0, len(tokens))
for i := 0; i < len(tokens); i++ {
tk := tokens[i]
switch tk.Type() {
case token.LiteralType:
tks := []*Token{tk}
if i+1 < len(tokens) {
tks = append(tks, tokens[i+1])
}
ret = append(ret, &Token{
Group: &TokenGroup{
Type: TokenGroupLiteral,
Tokens: tks,
},
})
i++
case token.FoldedType:
tks := []*Token{tk}
if i+1 < len(tokens) {
tks = append(tks, tokens[i+1])
}
ret = append(ret, &Token{
Group: &TokenGroup{
Type: TokenGroupFolded,
Tokens: tks,
},
})
i++
default:
ret = append(ret, tk)
}
}
return ret, nil
}
func createAnchorAndAliasTokenGroups(tokens []*Token) ([]*Token, error) {
ret := make([]*Token, 0, len(tokens))
for i := 0; i < len(tokens); i++ {
tk := tokens[i]
switch tk.Type() {
case token.AnchorType:
if i+1 >= len(tokens) {
return nil, errors.ErrSyntax("undefined anchor name", tk.RawToken())
}
if i+2 >= len(tokens) {
return nil, errors.ErrSyntax("undefined anchor value", tk.RawToken())
}
anchorName := &Token{
Group: &TokenGroup{
Type: TokenGroupAnchorName,
Tokens: []*Token{tk, tokens[i+1]},
},
}
valueTk := tokens[i+2]
if tk.Line() == valueTk.Line() && valueTk.Type() == token.SequenceEntryType {
return nil, errors.ErrSyntax("sequence entries are not allowed after anchor on the same line", valueTk.RawToken())
}
if tk.Line() == valueTk.Line() && isScalarType(valueTk) {
ret = append(ret, &Token{
Group: &TokenGroup{
Type: TokenGroupAnchor,
Tokens: []*Token{anchorName, valueTk},
},
})
i++
} else {
ret = append(ret, anchorName)
}
i++
case token.AliasType:
if i+1 == len(tokens) {
return nil, errors.ErrSyntax("undefined alias name", tk.RawToken())
}
ret = append(ret, &Token{
Group: &TokenGroup{
Type: TokenGroupAlias,
Tokens: []*Token{tk, tokens[i+1]},
},
})
i++
default:
ret = append(ret, tk)
}
}
return ret, nil
}
func createScalarTagTokenGroups(tokens []*Token) ([]*Token, error) {
ret := make([]*Token, 0, len(tokens))
for i := 0; i < len(tokens); i++ {
tk := tokens[i]
if tk.Type() != token.TagType {
ret = append(ret, tk)
continue
}
tag := tk.RawToken()
if strings.HasPrefix(tag.Value, "!!") {
// secondary tag.
switch token.ReservedTagKeyword(tag.Value) {
case token.IntegerTag, token.FloatTag, token.StringTag, token.BinaryTag, token.TimestampTag, token.BooleanTag, token.NullTag:
if len(tokens) <= i+1 {
ret = append(ret, tk)
continue
}
if tk.Line() != tokens[i+1].Line() {
ret = append(ret, tk)
continue
}
if tokens[i+1].GroupType() == TokenGroupAnchorName {
ret = append(ret, tk)
continue
}
if isScalarType(tokens[i+1]) {
ret = append(ret, &Token{
Group: &TokenGroup{
Type: TokenGroupScalarTag,
Tokens: []*Token{tk, tokens[i+1]},
},
})
i++
} else {
ret = append(ret, tk)
}
case token.MergeTag:
if len(tokens) <= i+1 {
ret = append(ret, tk)
continue
}
if tk.Line() != tokens[i+1].Line() {
ret = append(ret, tk)
continue
}
if tokens[i+1].GroupType() == TokenGroupAnchorName {
ret = append(ret, tk)
continue
}
if tokens[i+1].Type() != token.MergeKeyType {
return nil, errors.ErrSyntax("could not find merge key", tokens[i+1].RawToken())
}
ret = append(ret, &Token{
Group: &TokenGroup{
Type: TokenGroupScalarTag,
Tokens: []*Token{tk, tokens[i+1]},
},
})
i++
default:
ret = append(ret, tk)
}
} else {
if len(tokens) <= i+1 {
ret = append(ret, tk)
continue
}
if tk.Line() != tokens[i+1].Line() {
ret = append(ret, tk)
continue
}
if tokens[i+1].GroupType() == TokenGroupAnchorName {
ret = append(ret, tk)
continue
}
if isFlowType(tokens[i+1]) {
ret = append(ret, tk)
continue
}
ret = append(ret, &Token{
Group: &TokenGroup{
Type: TokenGroupScalarTag,
Tokens: []*Token{tk, tokens[i+1]},
},
})
i++
}
}
return ret, nil
}
func createAnchorWithScalarTagTokenGroups(tokens []*Token) ([]*Token, error) {
ret := make([]*Token, 0, len(tokens))
for i := 0; i < len(tokens); i++ {
tk := tokens[i]
switch tk.GroupType() {
case TokenGroupAnchorName:
if i+1 >= len(tokens) {
return nil, errors.ErrSyntax("undefined anchor value", tk.RawToken())
}
valueTk := tokens[i+1]
if tk.Line() == valueTk.Line() && valueTk.GroupType() == TokenGroupScalarTag {
ret = append(ret, &Token{
Group: &TokenGroup{
Type: TokenGroupAnchor,
Tokens: []*Token{tk, tokens[i+1]},
},
})
i++
} else {
ret = append(ret, tk)
}
default:
ret = append(ret, tk)
}
}
return ret, nil
}
func createMapKeyTokenGroups(tokens []*Token) ([]*Token, error) {
tks, err := createMapKeyByMappingKey(tokens)
if err != nil {
return nil, err
}
return createMapKeyByMappingValue(tks)
}
func createMapKeyByMappingKey(tokens []*Token) ([]*Token, error) {
ret := make([]*Token, 0, len(tokens))
for i := 0; i < len(tokens); i++ {
tk := tokens[i]
switch tk.Type() {
case token.MappingKeyType:
if i+1 >= len(tokens) {
return nil, errors.ErrSyntax("undefined map key", tk.RawToken())
}
ret = append(ret, &Token{
Group: &TokenGroup{
Type: TokenGroupMapKey,
Tokens: []*Token{tk, tokens[i+1]},
},
})
i++
default:
ret = append(ret, tk)
}
}
return ret, nil
}
func createMapKeyByMappingValue(tokens []*Token) ([]*Token, error) {
ret := make([]*Token, 0, len(tokens))
for i := 0; i < len(tokens); i++ {
tk := tokens[i]
switch tk.Type() {
case token.MappingValueType:
if i == 0 {
return nil, errors.ErrSyntax("unexpected key name", tk.RawToken())
}
mapKeyTk := tokens[i-1]
if isNotMapKeyType(mapKeyTk) {
return nil, errors.ErrSyntax("found an invalid key for this map", tokens[i].RawToken())
}
newTk := &Token{Token: mapKeyTk.Token, Group: mapKeyTk.Group}
mapKeyTk.Token = nil
mapKeyTk.Group = &TokenGroup{
Type: TokenGroupMapKey,
Tokens: []*Token{newTk, tk},
}
default:
ret = append(ret, tk)
}
}
return ret, nil
}
func createMapKeyValueTokenGroups(tokens []*Token) []*Token {
ret := make([]*Token, 0, len(tokens))
for i := 0; i < len(tokens); i++ {
tk := tokens[i]
switch tk.GroupType() {
case TokenGroupMapKey:
if len(tokens) <= i+1 {
ret = append(ret, tk)
continue
}
valueTk := tokens[i+1]
if tk.Line() != valueTk.Line() {
ret = append(ret, tk)
continue
}
if valueTk.GroupType() == TokenGroupAnchorName {
ret = append(ret, tk)
continue
}
if valueTk.Type() == token.TagType && valueTk.GroupType() != TokenGroupScalarTag {
ret = append(ret, tk)
continue
}
if isScalarType(valueTk) || valueTk.Type() == token.TagType {
ret = append(ret, &Token{
Group: &TokenGroup{
Type: TokenGroupMapKeyValue,
Tokens: []*Token{tk, valueTk},
},
})
i++
} else {
ret = append(ret, tk)
continue
}
default:
ret = append(ret, tk)
}
}
return ret
}
func createDirectiveTokenGroups(tokens []*Token) ([]*Token, error) {
ret := make([]*Token, 0, len(tokens))
for i := 0; i < len(tokens); i++ {
tk := tokens[i]
switch tk.Type() {
case token.DirectiveType:
if i+1 >= len(tokens) {
return nil, errors.ErrSyntax("undefined directive value", tk.RawToken())
}
directiveName := &Token{
Group: &TokenGroup{
Type: TokenGroupDirectiveName,
Tokens: []*Token{tk, tokens[i+1]},
},
}
i++
var valueTks []*Token
for j := i + 1; j < len(tokens); j++ {
if tokens[j].Line() != tk.Line() {
break
}
valueTks = append(valueTks, tokens[j])
i++
}
if i+1 >= len(tokens) || tokens[i+1].Type() != token.DocumentHeaderType {
return nil, errors.ErrSyntax("unexpected directive value. document not started", tk.RawToken())
}
if len(valueTks) != 0 {
ret = append(ret, &Token{
Group: &TokenGroup{
Type: TokenGroupDirective,
Tokens: append([]*Token{directiveName}, valueTks...),
},
})
} else {
ret = append(ret, directiveName)
}
default:
ret = append(ret, tk)
}
}
return ret, nil
}
func createDocumentTokens(tokens []*Token) ([]*Token, error) {
var ret []*Token
for i := 0; i < len(tokens); i++ {
tk := tokens[i]
switch tk.Type() {
case token.DocumentHeaderType:
if i != 0 {
ret = append(ret, &Token{
Group: &TokenGroup{Tokens: tokens[:i]},
})
}
if i+1 == len(tokens) {
// if current token is last token, add DocumentHeader only tokens to ret.
return append(ret, &Token{
Group: &TokenGroup{
Type: TokenGroupDocument,
Tokens: []*Token{tk},
},
}), nil
}
if tokens[i+1].Type() == token.DocumentHeaderType {
return append(ret, &Token{
Group: &TokenGroup{
Type: TokenGroupDocument,
Tokens: []*Token{tk},
},
}), nil
}
if tokens[i].Line() == tokens[i+1].Line() {
switch tokens[i+1].GroupType() {
case TokenGroupMapKey, TokenGroupMapKeyValue:
return nil, errors.ErrSyntax("value cannot be placed after document separator", tokens[i+1].RawToken())
}
switch tokens[i+1].Type() {
case token.SequenceEntryType:
return nil, errors.ErrSyntax("value cannot be placed after document separator", tokens[i+1].RawToken())
}
}
tks, err := createDocumentTokens(tokens[i+1:])
if err != nil {
return nil, err
}
if len(tks) != 0 {
tks[0].SetGroupType(TokenGroupDocument)
tks[0].Group.Tokens = append([]*Token{tk}, tks[0].Group.Tokens...)
return append(ret, tks...), nil
}
return append(ret, &Token{
Group: &TokenGroup{
Type: TokenGroupDocument,
Tokens: []*Token{tk},
},
}), nil
case token.DocumentEndType:
if i != 0 {
ret = append(ret, &Token{
Group: &TokenGroup{
Type: TokenGroupDocument,
Tokens: tokens[0 : i+1],
},
})
}
if i+1 == len(tokens) {
return ret, nil
}
if isScalarType(tokens[i+1]) {
return nil, errors.ErrSyntax("unexpected end content", tokens[i+1].RawToken())
}
tks, err := createDocumentTokens(tokens[i+1:])
if err != nil {
return nil, err
}
return append(ret, tks...), nil
}
}
return append(ret, &Token{
Group: &TokenGroup{
Type: TokenGroupDocument,
Tokens: tokens,
},
}), nil
}
func isScalarType(tk *Token) bool {
switch tk.GroupType() {
case TokenGroupMapKey, TokenGroupMapKeyValue:
return false
}
typ := tk.Type()
return typ == token.AnchorType ||
typ == token.AliasType ||
typ == token.LiteralType ||
typ == token.FoldedType ||
typ == token.NullType ||
typ == token.ImplicitNullType ||
typ == token.BoolType ||
typ == token.IntegerType ||
typ == token.BinaryIntegerType ||
typ == token.OctetIntegerType ||
typ == token.HexIntegerType ||
typ == token.FloatType ||
typ == token.InfinityType ||
typ == token.NanType ||
typ == token.StringType ||
typ == token.SingleQuoteType ||
typ == token.DoubleQuoteType
}
func isNotMapKeyType(tk *Token) bool {
typ := tk.Type()
return typ == token.DirectiveType ||
typ == token.DocumentHeaderType ||
typ == token.DocumentEndType ||
typ == token.CollectEntryType ||
typ == token.MappingStartType ||
typ == token.MappingValueType ||
typ == token.MappingEndType ||
typ == token.SequenceStartType ||
typ == token.SequenceEntryType ||
typ == token.SequenceEndType
}
func isFlowType(tk *Token) bool {
typ := tk.Type()
return typ == token.MappingStartType ||
typ == token.MappingEndType ||
typ == token.SequenceStartType ||
typ == token.SequenceEntryType
}
goccy-go-yaml-52dacb8/path.go 0000664 0000000 0000000 00000047505 15015766371 0016164 0 ustar 00root root 0000000 0000000 package yaml
import (
"bytes"
"fmt"
"io"
"strconv"
"strings"
"github.com/goccy/go-yaml/ast"
"github.com/goccy/go-yaml/parser"
"github.com/goccy/go-yaml/printer"
)
// PathString create Path from string
//
// YAMLPath rule
// $ : the root object/element
// . : child operator
// .. : recursive descent
// [num] : object/element of array by number
// [*] : all objects/elements for array.
//
// If you want to use reserved characters such as `.` and `*` as a key name,
// enclose them in single quotation as follows ( $.foo.'bar.baz-*'.hoge ).
// If you want to use a single quote with reserved characters, escape it with `\` ( $.foo.'bar.baz\'s value'.hoge ).
func PathString(s string) (*Path, error) {
buf := []rune(s)
length := len(buf)
cursor := 0
builder := &PathBuilder{}
for cursor < length {
c := buf[cursor]
switch c {
case '$':
builder = builder.Root()
cursor++
case '.':
b, buf, c, err := parsePathDot(builder, buf, cursor)
if err != nil {
return nil, err
}
length = len(buf)
builder = b
cursor = c
case '[':
b, buf, c, err := parsePathIndex(builder, buf, cursor)
if err != nil {
return nil, err
}
length = len(buf)
builder = b
cursor = c
default:
return nil, fmt.Errorf("invalid path at %d: %w", cursor, ErrInvalidPathString)
}
}
return builder.Build(), nil
}
func parsePathRecursive(b *PathBuilder, buf []rune, cursor int) (*PathBuilder, []rune, int, error) {
length := len(buf)
cursor += 2 // skip .. characters
start := cursor
for ; cursor < length; cursor++ {
c := buf[cursor]
switch c {
case '$':
return nil, nil, 0, fmt.Errorf("specified '$' after '..' character: %w", ErrInvalidPathString)
case '*':
return nil, nil, 0, fmt.Errorf("specified '*' after '..' character: %w", ErrInvalidPathString)
case '.', '[':
goto end
case ']':
return nil, nil, 0, fmt.Errorf("specified ']' after '..' character: %w", ErrInvalidPathString)
}
}
end:
if start == cursor {
return nil, nil, 0, fmt.Errorf("not found recursive selector: %w", ErrInvalidPathString)
}
return b.Recursive(string(buf[start:cursor])), buf, cursor, nil
}
func parsePathDot(b *PathBuilder, buf []rune, cursor int) (*PathBuilder, []rune, int, error) {
if b.root == nil || b.node == nil {
return nil, nil, 0, fmt.Errorf("required '$' character at first: %w", ErrInvalidPathString)
}
length := len(buf)
if cursor+1 < length && buf[cursor+1] == '.' {
b, buf, c, err := parsePathRecursive(b, buf, cursor)
if err != nil {
return nil, nil, 0, err
}
return b, buf, c, nil
}
cursor++ // skip . character
start := cursor
// if started single quote, looking for end single quote char
if cursor < length && buf[cursor] == '\'' {
return parseQuotedKey(b, buf, cursor)
}
for ; cursor < length; cursor++ {
c := buf[cursor]
switch c {
case '$':
return nil, nil, 0, fmt.Errorf("specified '$' after '.' character: %w", ErrInvalidPathString)
case '*':
return nil, nil, 0, fmt.Errorf("specified '*' after '.' character: %w", ErrInvalidPathString)
case '.', '[':
goto end
case ']':
return nil, nil, 0, fmt.Errorf("specified ']' after '.' character: %w", ErrInvalidPathString)
}
}
end:
if start == cursor {
return nil, nil, 0, fmt.Errorf("could not find by empty key: %w", ErrInvalidPathString)
}
return b.child(string(buf[start:cursor])), buf, cursor, nil
}
func parseQuotedKey(b *PathBuilder, buf []rune, cursor int) (*PathBuilder, []rune, int, error) {
if b.root == nil || b.node == nil {
return nil, nil, 0, fmt.Errorf("required '$' character at first: %w", ErrInvalidPathString)
}
cursor++ // skip single quote
start := cursor
length := len(buf)
var foundEndDelim bool
for ; cursor < length; cursor++ {
switch buf[cursor] {
case '\\':
buf = append(append([]rune{}, buf[:cursor]...), buf[cursor+1:]...)
length = len(buf)
case '\'':
foundEndDelim = true
goto end
}
}
end:
if !foundEndDelim {
return nil, nil, 0, fmt.Errorf("could not find end delimiter for key: %w", ErrInvalidPathString)
}
if start == cursor {
return nil, nil, 0, fmt.Errorf("could not find by empty key: %w", ErrInvalidPathString)
}
selector := buf[start:cursor]
cursor++
if cursor < length {
switch buf[cursor] {
case '$':
return nil, nil, 0, fmt.Errorf("specified '$' after '.' character: %w", ErrInvalidPathString)
case '*':
return nil, nil, 0, fmt.Errorf("specified '*' after '.' character: %w", ErrInvalidPathString)
case ']':
return nil, nil, 0, fmt.Errorf("specified ']' after '.' character: %w", ErrInvalidPathString)
}
}
return b.child(string(selector)), buf, cursor, nil
}
func parsePathIndex(b *PathBuilder, buf []rune, cursor int) (*PathBuilder, []rune, int, error) {
if b.root == nil || b.node == nil {
return nil, nil, 0, fmt.Errorf("required '$' character at first: %w", ErrInvalidPathString)
}
length := len(buf)
cursor++ // skip '[' character
if length <= cursor {
return nil, nil, 0, fmt.Errorf("unexpected end of YAML Path: %w", ErrInvalidPathString)
}
c := buf[cursor]
switch c {
case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '*':
start := cursor
cursor++
for ; cursor < length; cursor++ {
c := buf[cursor]
switch c {
case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
continue
}
break
}
if buf[cursor] != ']' {
return nil, nil, 0, fmt.Errorf("invalid character %s at %d: %w", string(buf[cursor]), cursor, ErrInvalidPathString)
}
numOrAll := string(buf[start:cursor])
if numOrAll == "*" {
return b.IndexAll(), buf, cursor + 1, nil
}
num, err := strconv.ParseInt(numOrAll, 10, 64)
if err != nil {
return nil, nil, 0, err
}
return b.Index(uint(num)), buf, cursor + 1, nil
}
return nil, nil, 0, fmt.Errorf("invalid character %q at %d: %w", c, cursor, ErrInvalidPathString)
}
// Path represent YAMLPath ( like a JSONPath ).
type Path struct {
node pathNode
}
// String path to text.
func (p *Path) String() string {
return p.node.String()
}
// Read decode from r and set extracted value by YAMLPath to v.
func (p *Path) Read(r io.Reader, v interface{}) error {
node, err := p.ReadNode(r)
if err != nil {
return err
}
if err := Unmarshal([]byte(node.String()), v); err != nil {
return err
}
return nil
}
// ReadNode create AST from r and extract node by YAMLPath.
func (p *Path) ReadNode(r io.Reader) (ast.Node, error) {
if p.node == nil {
return nil, ErrInvalidPath
}
var buf bytes.Buffer
if _, err := io.Copy(&buf, r); err != nil {
return nil, err
}
f, err := parser.ParseBytes(buf.Bytes(), 0)
if err != nil {
return nil, err
}
node, err := p.FilterFile(f)
if err != nil {
return nil, err
}
return node, nil
}
// Filter filter from target by YAMLPath and set it to v.
func (p *Path) Filter(target, v interface{}) error {
b, err := Marshal(target)
if err != nil {
return err
}
if err := p.Read(bytes.NewBuffer(b), v); err != nil {
return err
}
return nil
}
// FilterFile filter from ast.File by YAMLPath.
func (p *Path) FilterFile(f *ast.File) (ast.Node, error) {
for _, doc := range f.Docs {
node, err := p.FilterNode(doc.Body)
if err != nil {
return nil, err
}
if node != nil {
return node, nil
}
}
return nil, fmt.Errorf("failed to find path ( %s ): %w", p.node, ErrNotFoundNode)
}
// FilterNode filter from node by YAMLPath.
func (p *Path) FilterNode(node ast.Node) (ast.Node, error) {
if node == nil {
return nil, nil
}
n, err := p.node.filter(node)
if err != nil {
return nil, err
}
return n, nil
}
// MergeFromReader merge YAML text into ast.File.
func (p *Path) MergeFromReader(dst *ast.File, src io.Reader) error {
var buf bytes.Buffer
if _, err := io.Copy(&buf, src); err != nil {
return err
}
file, err := parser.ParseBytes(buf.Bytes(), 0)
if err != nil {
return err
}
if err := p.MergeFromFile(dst, file); err != nil {
return err
}
return nil
}
// MergeFromFile merge ast.File into ast.File.
func (p *Path) MergeFromFile(dst *ast.File, src *ast.File) error {
base, err := p.FilterFile(dst)
if err != nil {
return err
}
for _, doc := range src.Docs {
if err := ast.Merge(base, doc); err != nil {
return err
}
}
return nil
}
// MergeFromNode merge ast.Node into ast.File.
func (p *Path) MergeFromNode(dst *ast.File, src ast.Node) error {
base, err := p.FilterFile(dst)
if err != nil {
return err
}
if err := ast.Merge(base, src); err != nil {
return err
}
return nil
}
// ReplaceWithReader replace ast.File with io.Reader.
func (p *Path) ReplaceWithReader(dst *ast.File, src io.Reader) error {
var buf bytes.Buffer
if _, err := io.Copy(&buf, src); err != nil {
return err
}
file, err := parser.ParseBytes(buf.Bytes(), 0)
if err != nil {
return err
}
if err := p.ReplaceWithFile(dst, file); err != nil {
return err
}
return nil
}
// ReplaceWithFile replace ast.File with ast.File.
func (p *Path) ReplaceWithFile(dst *ast.File, src *ast.File) error {
for _, doc := range src.Docs {
if err := p.ReplaceWithNode(dst, doc); err != nil {
return err
}
}
return nil
}
// ReplaceNode replace ast.File with ast.Node.
func (p *Path) ReplaceWithNode(dst *ast.File, node ast.Node) error {
for _, doc := range dst.Docs {
if node.Type() == ast.DocumentType {
node = node.(*ast.DocumentNode).Body
}
if err := p.node.replace(doc.Body, node); err != nil {
return err
}
}
return nil
}
// AnnotateSource add annotation to passed source ( see section 5.1 in README.md ).
func (p *Path) AnnotateSource(source []byte, colored bool) ([]byte, error) {
file, err := parser.ParseBytes([]byte(source), 0)
if err != nil {
return nil, err
}
node, err := p.FilterFile(file)
if err != nil {
return nil, err
}
var pp printer.Printer
return []byte(pp.PrintErrorToken(node.GetToken(), colored)), nil
}
// PathBuilder represent builder for YAMLPath.
type PathBuilder struct {
root *rootNode
node pathNode
}
// Root add '$' to current path.
func (b *PathBuilder) Root() *PathBuilder {
root := newRootNode()
return &PathBuilder{root: root, node: root}
}
// IndexAll add '[*]' to current path.
func (b *PathBuilder) IndexAll() *PathBuilder {
b.node = b.node.chain(newIndexAllNode())
return b
}
// Recursive add '..selector' to current path.
func (b *PathBuilder) Recursive(selector string) *PathBuilder {
b.node = b.node.chain(newRecursiveNode(selector))
return b
}
func (b *PathBuilder) containsReservedPathCharacters(path string) bool {
if strings.Contains(path, ".") {
return true
}
if strings.Contains(path, "*") {
return true
}
return false
}
func (b *PathBuilder) enclosedSingleQuote(name string) bool {
return strings.HasPrefix(name, "'") && strings.HasSuffix(name, "'")
}
func (b *PathBuilder) normalizeSelectorName(name string) string {
if b.enclosedSingleQuote(name) {
// already escaped name
return name
}
if b.containsReservedPathCharacters(name) {
escapedName := strings.ReplaceAll(name, `'`, `\'`)
return "'" + escapedName + "'"
}
return name
}
func (b *PathBuilder) child(name string) *PathBuilder {
b.node = b.node.chain(newSelectorNode(name))
return b
}
// Child add '.name' to current path.
func (b *PathBuilder) Child(name string) *PathBuilder {
return b.child(b.normalizeSelectorName(name))
}
// Index add '[idx]' to current path.
func (b *PathBuilder) Index(idx uint) *PathBuilder {
b.node = b.node.chain(newIndexNode(idx))
return b
}
// Build build YAMLPath.
func (b *PathBuilder) Build() *Path {
return &Path{node: b.root}
}
type pathNode interface {
fmt.Stringer
chain(pathNode) pathNode
filter(ast.Node) (ast.Node, error)
replace(ast.Node, ast.Node) error
}
type basePathNode struct {
child pathNode
}
func (n *basePathNode) chain(node pathNode) pathNode {
n.child = node
return node
}
type rootNode struct {
*basePathNode
}
func newRootNode() *rootNode {
return &rootNode{basePathNode: &basePathNode{}}
}
func (n *rootNode) String() string {
s := "$"
if n.child != nil {
s += n.child.String()
}
return s
}
func (n *rootNode) filter(node ast.Node) (ast.Node, error) {
if n.child == nil {
return node, nil
}
filtered, err := n.child.filter(node)
if err != nil {
return nil, err
}
return filtered, nil
}
func (n *rootNode) replace(node ast.Node, target ast.Node) error {
if n.child == nil {
return nil
}
if err := n.child.replace(node, target); err != nil {
return err
}
return nil
}
type selectorNode struct {
*basePathNode
selector string
}
func newSelectorNode(selector string) *selectorNode {
return &selectorNode{
basePathNode: &basePathNode{},
selector: selector,
}
}
func (n *selectorNode) filter(node ast.Node) (ast.Node, error) {
selector := n.selector
if len(selector) > 1 && selector[0] == '\'' && selector[len(selector)-1] == '\'' {
selector = selector[1 : len(selector)-1]
}
switch node.Type() {
case ast.MappingType:
for _, value := range node.(*ast.MappingNode).Values {
key := value.Key.GetToken().Value
if len(key) > 0 {
switch key[0] {
case '"':
var err error
key, err = strconv.Unquote(key)
if err != nil {
return nil, err
}
case '\'':
if len(key) > 1 && key[len(key)-1] == '\'' {
key = key[1 : len(key)-1]
}
}
}
if key == selector {
if n.child == nil {
return value.Value, nil
}
filtered, err := n.child.filter(value.Value)
if err != nil {
return nil, err
}
return filtered, nil
}
}
case ast.MappingValueType:
value, _ := node.(*ast.MappingValueNode)
key := value.Key.GetToken().Value
if key == selector {
if n.child == nil {
return value.Value, nil
}
filtered, err := n.child.filter(value.Value)
if err != nil {
return nil, err
}
return filtered, nil
}
default:
return nil, fmt.Errorf("expected node type is map or map value. but got %s: %w", node.Type(), ErrInvalidQuery)
}
return nil, nil
}
func (n *selectorNode) replaceMapValue(value *ast.MappingValueNode, target ast.Node) error {
key := value.Key.GetToken().Value
if key != n.selector {
return nil
}
if n.child == nil {
if err := value.Replace(target); err != nil {
return err
}
} else {
if err := n.child.replace(value.Value, target); err != nil {
return err
}
}
return nil
}
func (n *selectorNode) replace(node ast.Node, target ast.Node) error {
switch node.Type() {
case ast.MappingType:
for _, value := range node.(*ast.MappingNode).Values {
if err := n.replaceMapValue(value, target); err != nil {
return err
}
}
case ast.MappingValueType:
value, _ := node.(*ast.MappingValueNode)
if err := n.replaceMapValue(value, target); err != nil {
return err
}
default:
return fmt.Errorf("expected node type is map or map value. but got %s: %w", node.Type(), ErrInvalidQuery)
}
return nil
}
func (n *selectorNode) String() string {
var builder PathBuilder
selector := builder.normalizeSelectorName(n.selector)
s := fmt.Sprintf(".%s", selector)
if n.child != nil {
s += n.child.String()
}
return s
}
type indexNode struct {
*basePathNode
selector uint
}
func newIndexNode(selector uint) *indexNode {
return &indexNode{
basePathNode: &basePathNode{},
selector: selector,
}
}
func (n *indexNode) filter(node ast.Node) (ast.Node, error) {
if node.Type() != ast.SequenceType {
return nil, fmt.Errorf("expected sequence type node. but got %s: %w", node.Type(), ErrInvalidQuery)
}
sequence, _ := node.(*ast.SequenceNode)
if n.selector >= uint(len(sequence.Values)) {
return nil, fmt.Errorf("expected index is %d. but got sequences has %d items: %w", n.selector, len(sequence.Values), ErrInvalidQuery)
}
value := sequence.Values[n.selector]
if n.child == nil {
return value, nil
}
filtered, err := n.child.filter(value)
if err != nil {
return nil, err
}
return filtered, nil
}
func (n *indexNode) replace(node ast.Node, target ast.Node) error {
if node.Type() != ast.SequenceType {
return fmt.Errorf("expected sequence type node. but got %s: %w", node.Type(), ErrInvalidQuery)
}
sequence, _ := node.(*ast.SequenceNode)
if n.selector >= uint(len(sequence.Values)) {
return fmt.Errorf("expected index is %d. but got sequences has %d items: %w", n.selector, len(sequence.Values), ErrInvalidQuery)
}
if n.child == nil {
if err := sequence.Replace(int(n.selector), target); err != nil {
return err
}
return nil
}
if err := n.child.replace(sequence.Values[n.selector], target); err != nil {
return err
}
return nil
}
func (n *indexNode) String() string {
s := fmt.Sprintf("[%d]", n.selector)
if n.child != nil {
s += n.child.String()
}
return s
}
type indexAllNode struct {
*basePathNode
}
func newIndexAllNode() *indexAllNode {
return &indexAllNode{
basePathNode: &basePathNode{},
}
}
func (n *indexAllNode) String() string {
s := "[*]"
if n.child != nil {
s += n.child.String()
}
return s
}
func (n *indexAllNode) filter(node ast.Node) (ast.Node, error) {
if node.Type() != ast.SequenceType {
return nil, fmt.Errorf("expected sequence type node. but got %s: %w", node.Type(), ErrInvalidQuery)
}
sequence, _ := node.(*ast.SequenceNode)
if n.child == nil {
return sequence, nil
}
out := *sequence
out.Values = []ast.Node{}
for _, value := range sequence.Values {
filtered, err := n.child.filter(value)
if err != nil {
return nil, err
}
out.Values = append(out.Values, filtered)
}
return &out, nil
}
func (n *indexAllNode) replace(node ast.Node, target ast.Node) error {
if node.Type() != ast.SequenceType {
return fmt.Errorf("expected sequence type node. but got %s: %w", node.Type(), ErrInvalidQuery)
}
sequence, _ := node.(*ast.SequenceNode)
if n.child == nil {
for idx := range sequence.Values {
if err := sequence.Replace(idx, target); err != nil {
return err
}
}
return nil
}
for _, value := range sequence.Values {
if err := n.child.replace(value, target); err != nil {
return err
}
}
return nil
}
type recursiveNode struct {
*basePathNode
selector string
}
func newRecursiveNode(selector string) *recursiveNode {
return &recursiveNode{
basePathNode: &basePathNode{},
selector: selector,
}
}
func (n *recursiveNode) String() string {
s := fmt.Sprintf("..%s", n.selector)
if n.child != nil {
s += n.child.String()
}
return s
}
func (n *recursiveNode) filterNode(node ast.Node) (*ast.SequenceNode, error) {
sequence := &ast.SequenceNode{BaseNode: &ast.BaseNode{}}
switch typedNode := node.(type) {
case *ast.MappingNode:
for _, value := range typedNode.Values {
seq, err := n.filterNode(value)
if err != nil {
return nil, err
}
sequence.Values = append(sequence.Values, seq.Values...)
}
case *ast.MappingValueNode:
key := typedNode.Key.GetToken().Value
if n.selector == key {
sequence.Values = append(sequence.Values, typedNode.Value)
}
seq, err := n.filterNode(typedNode.Value)
if err != nil {
return nil, err
}
sequence.Values = append(sequence.Values, seq.Values...)
case *ast.SequenceNode:
for _, value := range typedNode.Values {
seq, err := n.filterNode(value)
if err != nil {
return nil, err
}
sequence.Values = append(sequence.Values, seq.Values...)
}
}
return sequence, nil
}
func (n *recursiveNode) filter(node ast.Node) (ast.Node, error) {
sequence, err := n.filterNode(node)
if err != nil {
return nil, err
}
sequence.Start = node.GetToken()
return sequence, nil
}
func (n *recursiveNode) replaceNode(node ast.Node, target ast.Node) error {
switch typedNode := node.(type) {
case *ast.MappingNode:
for _, value := range typedNode.Values {
if err := n.replaceNode(value, target); err != nil {
return err
}
}
case *ast.MappingValueNode:
key := typedNode.Key.GetToken().Value
if n.selector == key {
if err := typedNode.Replace(target); err != nil {
return err
}
}
if err := n.replaceNode(typedNode.Value, target); err != nil {
return err
}
case *ast.SequenceNode:
for _, value := range typedNode.Values {
if err := n.replaceNode(value, target); err != nil {
return err
}
}
}
return nil
}
func (n *recursiveNode) replace(node ast.Node, target ast.Node) error {
if err := n.replaceNode(node, target); err != nil {
return err
}
return nil
}
goccy-go-yaml-52dacb8/path_test.go 0000664 0000000 0000000 00000041202 15015766371 0017207 0 ustar 00root root 0000000 0000000 package yaml_test
import (
"fmt"
"log"
"reflect"
"strings"
"testing"
"github.com/goccy/go-yaml"
"github.com/goccy/go-yaml/parser"
)
func builder() *yaml.PathBuilder { return &yaml.PathBuilder{} }
func TestPathBuilder(t *testing.T) {
tests := []struct {
expected string
path *yaml.Path
}{
{
expected: `$.a.b[0]`,
path: builder().Root().Child("a").Child("b").Index(0).Build(),
},
{
expected: `$.'a.b'.'c*d'`,
path: builder().Root().Child("a.b").Child("c*d").Build(),
},
{
expected: `$.'a.b-*'.c`,
path: builder().Root().Child("a.b-*").Child("c").Build(),
},
{
expected: `$.'a'.b`,
path: builder().Root().Child("'a'").Child("b").Build(),
},
{
expected: `$.'a.b'.c`,
path: builder().Root().Child("'a.b'").Child("c").Build(),
},
}
for _, test := range tests {
t.Run(test.expected, func(t *testing.T) {
expected := test.expected
got := test.path.String()
if expected != got {
t.Fatalf("failed to build path. expected:[%q] but got:[%q]", expected, got)
}
})
}
}
func TestPath(t *testing.T) {
yml := `
store:
book:
- author: john
price: 10
- author: ken
price: 12
bicycle:
color: red
price: 19.95
bicycle*unicycle:
price: 20.25
`
tests := []struct {
name string
path *yaml.Path
expected interface{}
}{
{
name: "$.store.book[0].author",
path: builder().Root().Child("store").Child("book").Index(0).Child("author").Build(),
expected: "john",
},
{
name: "$.store.book[1].price",
path: builder().Root().Child("store").Child("book").Index(1).Child("price").Build(),
expected: uint64(12),
},
{
name: "$.store.book[*].author",
path: builder().Root().Child("store").Child("book").IndexAll().Child("author").Build(),
expected: []interface{}{"john", "ken"},
},
{
name: "$.store.book[*]",
path: builder().Root().Child("store").Child("book").IndexAll().Build(),
expected: []interface{}{
map[string]interface{}{
"author": "john",
"price": uint64(10),
},
map[string]interface{}{
"author": "ken",
"price": uint64(12),
},
},
},
{
name: "$..book[*]",
path: builder().Root().Recursive("book").IndexAll().Build(),
expected: []interface{}{
[]interface{}{
map[string]interface{}{
"author": "john",
"price": uint64(10),
},
map[string]interface{}{
"author": "ken",
"price": uint64(12),
},
},
},
},
{
name: "$.store.book[0]",
path: builder().Root().Child("store").Child("book").Index(0).Build(),
expected: map[string]interface{}{"author": "john", "price": uint64(10)},
},
{
name: "$..author",
path: builder().Root().Recursive("author").Build(),
expected: []interface{}{"john", "ken"},
},
{
name: "$.store.bicycle.price",
path: builder().Root().Child("store").Child("bicycle").Child("price").Build(),
expected: float64(19.95),
},
{
name: `$.store.'bicycle*unicycle'.price`,
path: builder().Root().Child("store").Child(`bicycle*unicycle`).Child("price").Build(),
expected: float64(20.25),
},
{
name: "$",
path: builder().Root().Build(),
expected: map[string]interface{}{
"store": map[string]interface{}{
"book": []interface{}{
map[string]interface{}{
"author": "john",
"price": uint64(10),
},
map[string]interface{}{
"author": "ken",
"price": uint64(12),
},
},
"bicycle": map[string]interface{}{
"color": "red",
"price": 19.95,
},
"bicycle*unicycle": map[string]interface{}{
"price": 20.25,
},
},
},
},
}
t.Run("PathString", func(t *testing.T) {
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
path, err := yaml.PathString(test.name)
if err != nil {
t.Fatalf("%+v", err)
}
if test.name != path.String() {
t.Fatalf("expected %s but actual %s", test.name, path.String())
}
})
}
})
t.Run("string", func(t *testing.T) {
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
if test.name != test.path.String() {
t.Fatalf("expected %s but actual %s", test.name, test.path.String())
}
})
}
})
t.Run("read", func(t *testing.T) {
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
var v interface{}
if err := test.path.Read(strings.NewReader(yml), &v); err != nil {
t.Fatalf("%+v", err)
}
if !reflect.DeepEqual(test.expected, v) {
t.Fatalf("expected %v(%T). but actual %v(%T)", test.expected, test.expected, v, v)
}
})
}
})
t.Run("filter", func(t *testing.T) {
var target interface{}
if err := yaml.Unmarshal([]byte(yml), &target); err != nil {
t.Fatalf("failed to unmarshal: %+v", err)
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
var v interface{}
if err := test.path.Filter(target, &v); err != nil {
t.Fatalf("%+v", err)
}
if !reflect.DeepEqual(test.expected, v) {
t.Fatalf("expected %v(%T). but actual %v(%T)", test.expected, test.expected, v, v)
}
})
}
})
}
func TestPath_ReservedKeyword(t *testing.T) {
tests := []struct {
name string
path string
src string
expected interface{}
failure bool
}{
{
name: "quoted path",
path: `$.'a.b.c'.foo`,
src: `
a.b.c:
foo: bar
`,
expected: "bar",
},
{
name: "contains quote key",
path: `$.a'b`,
src: `a'b: 10`,
expected: uint64(10),
},
{
name: "escaped quote",
path: `$.'alice\'s age'`,
src: `alice's age: 10`,
expected: uint64(10),
},
{
name: "directly use white space",
path: `$.a b`,
src: `a b: 10`,
expected: uint64(10),
},
{
name: "empty quoted key",
path: `$.''`,
src: `a: 10`,
failure: true,
},
{
name: "unterminated quote",
path: `$.'abcd`,
src: `abcd: 10`,
failure: true,
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
path, err := yaml.PathString(test.path)
if test.failure {
if err == nil {
t.Fatal("expected error")
}
return
} else {
if err != nil {
t.Fatalf("%+v", err)
}
}
file, err := parser.ParseBytes([]byte(test.src), 0)
if err != nil {
t.Fatal(err)
}
var v interface{}
if err := path.Read(file, &v); err != nil {
t.Fatalf("%+v", err)
}
if v != test.expected {
t.Fatalf("failed to get value. expected:[%v] but got:[%v]", test.expected, v)
}
})
}
}
func TestPath_Invalid(t *testing.T) {
tests := []struct {
path string
src string
}{
{
path: "$.wrong",
src: "foo: bar",
},
}
for _, test := range tests {
path, err := yaml.PathString(test.path)
if err != nil {
t.Fatal(err)
}
t.Run("path.Read", func(t *testing.T) {
file, err := parser.ParseBytes([]byte(test.src), 0)
if err != nil {
t.Fatal(err)
}
var v interface{}
err = path.Read(file, &v)
if err == nil {
t.Fatal("expected error")
}
if !yaml.IsNotFoundNodeError(err) {
t.Fatalf("unexpected error %s", err)
}
})
t.Run("path.ReadNode", func(t *testing.T) {
file, err := parser.ParseBytes([]byte(test.src), 0)
if err != nil {
t.Fatal(err)
}
_, err = path.ReadNode(file)
if err == nil {
t.Fatal("expected error")
}
if !yaml.IsNotFoundNodeError(err) {
t.Fatalf("unexpected error %s", err)
}
})
}
}
func TestPath_ReadNode(t *testing.T) {
tests := []struct {
name string
path string
src string
expected interface{}
}{
{
name: "nested array sequence",
path: `$.a.b[0].c`,
src: `
a:
b:
- c: 123
e: |
Line1
Line2
`,
expected: uint64(123),
},
{
name: "nested array sequence issue#281",
path: `$..a.c`,
src: `
s:
- a:
b: u1
c: get1
d: i1
- w:
c: bad
e:
- a:
b: u2
c: get2
d: i2
`,
// The expected values are
// - get1
// - get2
expected: []interface{}{
map[string]interface{}{
"b": "u1",
"c": "get1",
"d": "i1",
},
map[string]interface{}{
"b": "u2",
"c": "get2",
"d": "i2",
},
},
},
{
name: "nested array sequence issue#281",
path: `$..c`,
src: `
s:
- a:
b: u1
c: get1
d: i1
- w:
c: bad
e:
- a:
b: u2
c: get2
d: i2
`,
expected: []interface{}{"get1", "bad", "get2"},
},
{
name: "nested array sequence issue#281",
path: `$.s[0].a.c`,
src: `
s:
- a:
b: u1
c: get1
d: i1
- w:
c: bad
e:
- a:
b: u2
c: get2
d: i2
`,
expected: "get1",
},
{
name: "nested array sequence issue#281",
path: "$.s[*].a.c",
src: `
s:
- a:
b: u1
c: get1
d: i1
- w:
c: bad
e:
- a:
b: u2
c: get2
d: i2
`,
expected: []interface{}{"get1"},
},
}
for _, test := range tests {
path, err := yaml.PathString(test.path)
if err != nil {
t.Fatal(err)
}
t.Run(fmt.Sprintf("path.ReadNode %s path %s", test.name, test.path), func(t *testing.T) {
file, err := parser.ParseBytes([]byte(test.src), 0)
if err != nil {
t.Fatal(err)
}
n, err := path.ReadNode(file)
if err != nil {
t.Fatal("expected error", err)
}
var v interface{}
err = yaml.Unmarshal([]byte(n.String()), &v)
if err != nil {
t.Fatal(err)
}
if !reflect.DeepEqual(test.expected, v) {
t.Fatalf("expected %v(%T) but got %v(%T)", test.expected, test.expected, v, v)
}
})
}
}
func TestPath_Merge(t *testing.T) {
tests := []struct {
path string
dst string
src string
expected string
}{
{
path: "$.c",
dst: `
a: 1
b: 2
c:
d: 3
e: 4
`,
src: `
f: 5
g: 6
`,
expected: `
a: 1
b: 2
c:
d: 3
e: 4
f: 5
g: 6
`,
},
{
path: "$.a.b",
dst: `
a:
b:
- 1
- 2
`,
src: `
- 3
- map:
- 4
- 5
`,
expected: `
a:
b:
- 1
- 2
- 3
- map:
- 4
- 5
`,
},
}
for _, test := range tests {
t.Run(test.path, func(t *testing.T) {
path, err := yaml.PathString(test.path)
if err != nil {
t.Fatalf("%+v", err)
}
t.Run("FromReader", func(t *testing.T) {
file, err := parser.ParseBytes([]byte(test.dst), 0)
if err != nil {
t.Fatalf("%+v", err)
}
if err := path.MergeFromReader(file, strings.NewReader(test.src)); err != nil {
t.Fatalf("%+v", err)
}
actual := "\n" + file.String()
if test.expected != actual {
t.Fatalf("expected: %q. but got %q", test.expected, actual)
}
})
t.Run("FromFile", func(t *testing.T) {
file, err := parser.ParseBytes([]byte(test.dst), 0)
if err != nil {
t.Fatalf("%+v", err)
}
src, err := parser.ParseBytes([]byte(test.src), 0)
if err != nil {
t.Fatalf("%+v", err)
}
if err := path.MergeFromFile(file, src); err != nil {
t.Fatalf("%+v", err)
}
actual := "\n" + file.String()
if test.expected != actual {
t.Fatalf("expected: %q. but got %q", test.expected, actual)
}
})
t.Run("FromNode", func(t *testing.T) {
file, err := parser.ParseBytes([]byte(test.dst), 0)
if err != nil {
t.Fatalf("%+v", err)
}
src, err := parser.ParseBytes([]byte(test.src), 0)
if err != nil {
t.Fatalf("%+v", err)
}
if len(src.Docs) == 0 {
t.Fatalf("failed to parse")
}
if err := path.MergeFromNode(file, src.Docs[0]); err != nil {
t.Fatalf("%+v", err)
}
actual := "\n" + file.String()
if test.expected != actual {
t.Fatalf("expected: %q. but got %q", test.expected, actual)
}
})
})
}
}
func TestPath_Replace(t *testing.T) {
tests := []struct {
path string
dst string
src string
expected string
}{
{
path: "$.a",
dst: `
a: 1
b: 2
`,
src: `3`,
expected: `
a: 3
b: 2
`,
},
{
path: "$.b",
dst: `
b: 1
c: 2
`,
src: `
d: e
f:
g: h
i: j
`,
expected: `
b:
d: e
f:
g: h
i: j
c: 2
`,
},
{
path: "$.a.b[0]",
dst: `
a:
b:
- hello
c: 2
`,
src: `world`,
expected: `
a:
b:
- world
c: 2
`,
},
{
path: "$.books[*].author",
dst: `
books:
- name: book_a
author: none
- name: book_b
author: none
pictures:
- name: picture_a
author: none
- name: picture_b
author: none
building:
author: none
`,
src: `ken`,
expected: `
books:
- name: book_a
author: ken
- name: book_b
author: ken
pictures:
- name: picture_a
author: none
- name: picture_b
author: none
building:
author: none
`,
},
{
path: "$..author",
dst: `
books:
- name: book_a
author: none
- name: book_b
author: none
pictures:
- name: picture_a
author: none
- name: picture_b
author: none
building:
author: none
`,
src: `ken`,
expected: `
books:
- name: book_a
author: ken
- name: book_b
author: ken
pictures:
- name: picture_a
author: ken
- name: picture_b
author: ken
building:
author: ken
`,
},
}
for _, test := range tests {
t.Run(test.path, func(t *testing.T) {
path, err := yaml.PathString(test.path)
if err != nil {
t.Fatalf("%+v", err)
}
t.Run("WithReader", func(t *testing.T) {
file, err := parser.ParseBytes([]byte(test.dst), 0)
if err != nil {
t.Fatalf("%+v", err)
}
if err := path.ReplaceWithReader(file, strings.NewReader(test.src)); err != nil {
t.Fatalf("%+v", err)
}
actual := "\n" + file.String()
if test.expected != actual {
t.Fatalf("expected: %q. but got %q", test.expected, actual)
}
})
t.Run("WithFile", func(t *testing.T) {
file, err := parser.ParseBytes([]byte(test.dst), 0)
if err != nil {
t.Fatalf("%+v", err)
}
src, err := parser.ParseBytes([]byte(test.src), 0)
if err != nil {
t.Fatalf("%+v", err)
}
if err := path.ReplaceWithFile(file, src); err != nil {
t.Fatalf("%+v", err)
}
actual := "\n" + file.String()
if test.expected != actual {
t.Fatalf("expected: %q. but got %q", test.expected, actual)
}
})
t.Run("WithNode", func(t *testing.T) {
file, err := parser.ParseBytes([]byte(test.dst), 0)
if err != nil {
t.Fatalf("%+v", err)
}
src, err := parser.ParseBytes([]byte(test.src), 0)
if err != nil {
t.Fatalf("%+v", err)
}
if len(src.Docs) == 0 {
t.Fatalf("failed to parse")
}
if err := path.ReplaceWithNode(file, src.Docs[0]); err != nil {
t.Fatalf("%+v", err)
}
actual := "\n" + file.String()
if test.expected != actual {
t.Fatalf("expected: %q. but got %q", test.expected, actual)
}
})
})
}
}
func TestInvalidPath(t *testing.T) {
tests := []struct {
name string
path string
}{
{
name: "missing root with dot",
path: ".foo",
},
{
name: "missing root with index",
path: "foo[0]",
},
{
name: "missing root with recursive",
path: "..foo",
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
if _, err := yaml.PathString(test.path); err == nil {
t.Fatal("expected error")
}
})
}
}
func ExamplePath_AnnotateSource() {
yml := `
a: 1
b: "hello"
`
var v struct {
A int
B string
}
if err := yaml.Unmarshal([]byte(yml), &v); err != nil {
panic(err)
}
if v.A != 2 {
// output error with YAML source
path, err := yaml.PathString("$.a")
if err != nil {
log.Fatal(err)
}
source, err := path.AnnotateSource([]byte(yml), false)
if err != nil {
log.Fatal(err)
}
fmt.Printf("a value expected 2 but actual %d:\n%s\n", v.A, string(source))
}
// OUTPUT:
// a value expected 2 but actual 1:
// > 2 | a: 1
// ^
// 3 | b: "hello"
}
func ExamplePath_AnnotateSource_withComment() {
yml := `
# This is my document
doc:
# This comment should be line 3
map:
# And below should be line 5
- value1
- value2
other: value3
`
path, err := yaml.PathString("$.doc.map[0]")
if err != nil {
log.Fatal(err)
}
msg, err := path.AnnotateSource([]byte(yml), false)
if err != nil {
log.Fatal(err)
}
fmt.Println(string(msg))
// OUTPUT:
// 4 | # This comment should be line 3
// 5 | map:
// 6 | # And below should be line 5
// > 7 | - value1
// ^
// 8 | - value2
// 9 | other: value3
}
func ExamplePathString() {
yml := `
store:
book:
- author: john
price: 10
- author: ken
price: 12
bicycle:
color: red
price: 19.95
`
path, err := yaml.PathString("$.store.book[*].author")
if err != nil {
log.Fatal(err)
}
var authors []string
if err := path.Read(strings.NewReader(yml), &authors); err != nil {
log.Fatal(err)
}
fmt.Println(authors)
// OUTPUT:
// [john ken]
}
goccy-go-yaml-52dacb8/printer/ 0000775 0000000 0000000 00000000000 15015766371 0016351 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/printer/color.go 0000664 0000000 0000000 00000003344 15015766371 0020022 0 ustar 00root root 0000000 0000000 // This source inspired by https://github.com/fatih/color.
package printer
import (
"fmt"
"strings"
)
type ColorAttribute int
const (
ColorReset ColorAttribute = iota
ColorBold
ColorFaint
ColorItalic
ColorUnderline
ColorBlinkSlow
ColorBlinkRapid
ColorReverseVideo
ColorConcealed
ColorCrossedOut
)
const (
ColorFgHiBlack ColorAttribute = iota + 90
ColorFgHiRed
ColorFgHiGreen
ColorFgHiYellow
ColorFgHiBlue
ColorFgHiMagenta
ColorFgHiCyan
ColorFgHiWhite
)
const (
ColorResetBold ColorAttribute = iota + 22
ColorResetItalic
ColorResetUnderline
ColorResetBlinking
ColorResetReversed
ColorResetConcealed
ColorResetCrossedOut
)
const escape = "\x1b"
var colorResetMap = map[ColorAttribute]ColorAttribute{
ColorBold: ColorResetBold,
ColorFaint: ColorResetBold,
ColorItalic: ColorResetItalic,
ColorUnderline: ColorResetUnderline,
ColorBlinkSlow: ColorResetBlinking,
ColorBlinkRapid: ColorResetBlinking,
ColorReverseVideo: ColorResetReversed,
ColorConcealed: ColorResetConcealed,
ColorCrossedOut: ColorResetCrossedOut,
}
func format(attrs ...ColorAttribute) string {
format := make([]string, 0, len(attrs))
for _, attr := range attrs {
format = append(format, fmt.Sprint(attr))
}
return fmt.Sprintf("%s[%sm", escape, strings.Join(format, ";"))
}
func unformat(attrs ...ColorAttribute) string {
format := make([]string, len(attrs))
for _, attr := range attrs {
v := fmt.Sprint(ColorReset)
reset, exists := colorResetMap[attr]
if exists {
v = fmt.Sprint(reset)
}
format = append(format, v)
}
return fmt.Sprintf("%s[%sm", escape, strings.Join(format, ";"))
}
func colorize(msg string, attrs ...ColorAttribute) string {
return format(attrs...) + msg + unformat(attrs...)
}
goccy-go-yaml-52dacb8/printer/printer.go 0000664 0000000 0000000 00000017670 15015766371 0020376 0 ustar 00root root 0000000 0000000 package printer
import (
"fmt"
"math"
"strings"
"github.com/goccy/go-yaml/ast"
"github.com/goccy/go-yaml/token"
)
// Property additional property set for each the token
type Property struct {
Prefix string
Suffix string
}
// PrintFunc returns property instance
type PrintFunc func() *Property
// Printer create text from token collection or ast
type Printer struct {
LineNumber bool
LineNumberFormat func(num int) string
MapKey PrintFunc
Anchor PrintFunc
Alias PrintFunc
Bool PrintFunc
String PrintFunc
Number PrintFunc
Comment PrintFunc
}
func defaultLineNumberFormat(num int) string {
return fmt.Sprintf("%2d | ", num)
}
func (p *Printer) property(tk *token.Token) *Property {
prop := &Property{}
switch tk.PreviousType() {
case token.AnchorType:
if p.Anchor != nil {
return p.Anchor()
}
return prop
case token.AliasType:
if p.Alias != nil {
return p.Alias()
}
return prop
}
switch tk.NextType() {
case token.MappingValueType:
if p.MapKey != nil {
return p.MapKey()
}
return prop
}
switch tk.Type {
case token.BoolType:
if p.Bool != nil {
return p.Bool()
}
return prop
case token.AnchorType:
if p.Anchor != nil {
return p.Anchor()
}
return prop
case token.AliasType:
if p.Anchor != nil {
return p.Alias()
}
return prop
case token.StringType, token.SingleQuoteType, token.DoubleQuoteType:
if p.String != nil {
return p.String()
}
return prop
case token.IntegerType, token.FloatType:
if p.Number != nil {
return p.Number()
}
return prop
case token.CommentType:
if p.Comment != nil {
return p.Comment()
}
return prop
default:
}
return prop
}
// PrintTokens create text from token collection
func (p *Printer) PrintTokens(tokens token.Tokens) string {
if len(tokens) == 0 {
return ""
}
if p.LineNumber {
if p.LineNumberFormat == nil {
p.LineNumberFormat = defaultLineNumberFormat
}
}
texts := []string{}
lineNumber := tokens[0].Position.Line
for _, tk := range tokens {
lines := strings.Split(tk.Origin, "\n")
prop := p.property(tk)
header := ""
if p.LineNumber {
header = p.LineNumberFormat(lineNumber)
}
if len(lines) == 1 {
line := prop.Prefix + lines[0] + prop.Suffix
if len(texts) == 0 {
texts = append(texts, header+line)
lineNumber++
} else {
text := texts[len(texts)-1]
texts[len(texts)-1] = text + line
}
} else {
for idx, src := range lines {
if p.LineNumber {
header = p.LineNumberFormat(lineNumber)
}
line := prop.Prefix + src + prop.Suffix
if idx == 0 {
if len(texts) == 0 {
texts = append(texts, header+line)
lineNumber++
} else {
text := texts[len(texts)-1]
texts[len(texts)-1] = text + line
}
} else {
texts = append(texts, fmt.Sprintf("%s%s", header, line))
lineNumber++
}
}
}
}
return strings.Join(texts, "\n")
}
// PrintNode create text from ast.Node
func (p *Printer) PrintNode(node ast.Node) []byte {
return []byte(fmt.Sprintf("%+v\n", node))
}
func (p *Printer) setDefaultColorSet() {
p.Bool = func() *Property {
return &Property{
Prefix: format(ColorFgHiMagenta),
Suffix: format(ColorReset),
}
}
p.Number = func() *Property {
return &Property{
Prefix: format(ColorFgHiMagenta),
Suffix: format(ColorReset),
}
}
p.MapKey = func() *Property {
return &Property{
Prefix: format(ColorFgHiCyan),
Suffix: format(ColorReset),
}
}
p.Anchor = func() *Property {
return &Property{
Prefix: format(ColorFgHiYellow),
Suffix: format(ColorReset),
}
}
p.Alias = func() *Property {
return &Property{
Prefix: format(ColorFgHiYellow),
Suffix: format(ColorReset),
}
}
p.String = func() *Property {
return &Property{
Prefix: format(ColorFgHiGreen),
Suffix: format(ColorReset),
}
}
p.Comment = func() *Property {
return &Property{
Prefix: format(ColorFgHiBlack),
Suffix: format(ColorReset),
}
}
}
func (p *Printer) PrintErrorMessage(msg string, isColored bool) string {
if isColored {
return fmt.Sprintf("%s%s%s",
format(ColorFgHiRed),
msg,
format(ColorReset),
)
}
return msg
}
func (p *Printer) removeLeftSideNewLineChar(src string) string {
return strings.TrimLeft(strings.TrimLeft(strings.TrimLeft(src, "\r"), "\n"), "\r\n")
}
func (p *Printer) removeRightSideNewLineChar(src string) string {
return strings.TrimRight(strings.TrimRight(strings.TrimRight(src, "\r"), "\n"), "\r\n")
}
func (p *Printer) removeRightSideWhiteSpaceChar(src string) string {
return p.removeRightSideNewLineChar(strings.TrimRight(src, " "))
}
func (p *Printer) newLineCount(s string) int {
src := []rune(s)
size := len(src)
cnt := 0
for i := 0; i < size; i++ {
c := src[i]
switch c {
case '\r':
if i+1 < size && src[i+1] == '\n' {
i++
}
cnt++
case '\n':
cnt++
}
}
return cnt
}
func (p *Printer) isNewLineLastChar(s string) bool {
for i := len(s) - 1; i > 0; i-- {
c := s[i]
switch c {
case ' ':
continue
case '\n', '\r':
return true
}
break
}
return false
}
func (p *Printer) printBeforeTokens(tk *token.Token, minLine, extLine int) token.Tokens {
for tk.Prev != nil {
if tk.Prev.Position.Line < minLine {
break
}
tk = tk.Prev
}
minTk := tk.Clone()
if minTk.Prev != nil {
// add white spaces to minTk by prev token
prev := minTk.Prev
whiteSpaceLen := len(prev.Origin) - len(strings.TrimRight(prev.Origin, " "))
minTk.Origin = strings.Repeat(" ", whiteSpaceLen) + minTk.Origin
}
minTk.Origin = p.removeLeftSideNewLineChar(minTk.Origin)
tokens := token.Tokens{minTk}
tk = minTk.Next
for tk != nil && tk.Position.Line <= extLine {
clonedTk := tk.Clone()
tokens.Add(clonedTk)
tk = clonedTk.Next
}
lastTk := tokens[len(tokens)-1]
trimmedOrigin := p.removeRightSideWhiteSpaceChar(lastTk.Origin)
suffix := lastTk.Origin[len(trimmedOrigin):]
lastTk.Origin = trimmedOrigin
if lastTk.Next != nil && len(suffix) > 1 {
next := lastTk.Next.Clone()
// add suffix to header of next token
if suffix[0] == '\n' || suffix[0] == '\r' {
suffix = suffix[1:]
}
next.Origin = suffix + next.Origin
lastTk.Next = next
}
return tokens
}
func (p *Printer) printAfterTokens(tk *token.Token, maxLine int) token.Tokens {
tokens := token.Tokens{}
if tk == nil {
return tokens
}
if tk.Position.Line > maxLine {
return tokens
}
minTk := tk.Clone()
minTk.Origin = p.removeLeftSideNewLineChar(minTk.Origin)
tokens.Add(minTk)
tk = minTk.Next
for tk != nil && tk.Position.Line <= maxLine {
clonedTk := tk.Clone()
tokens.Add(clonedTk)
tk = clonedTk.Next
}
return tokens
}
func (p *Printer) setupErrorTokenFormat(annotateLine int, isColored bool) {
prefix := func(annotateLine, num int) string {
if annotateLine == num {
return fmt.Sprintf("> %2d | ", num)
}
return fmt.Sprintf(" %2d | ", num)
}
p.LineNumber = true
p.LineNumberFormat = func(num int) string {
if isColored {
return colorize(prefix(annotateLine, num), ColorBold, ColorFgHiWhite)
}
return prefix(annotateLine, num)
}
if isColored {
p.setDefaultColorSet()
}
}
func (p *Printer) PrintErrorToken(tk *token.Token, isColored bool) string {
errToken := tk
curLine := tk.Position.Line
curExtLine := curLine + p.newLineCount(p.removeLeftSideNewLineChar(tk.Origin))
if p.isNewLineLastChar(tk.Origin) {
// if last character ( exclude white space ) is new line character, ignore it.
curExtLine--
}
minLine := int(math.Max(float64(curLine-3), 1))
maxLine := curExtLine + 3
p.setupErrorTokenFormat(curLine, isColored)
beforeTokens := p.printBeforeTokens(tk, minLine, curExtLine)
lastTk := beforeTokens[len(beforeTokens)-1]
afterTokens := p.printAfterTokens(lastTk.Next, maxLine)
beforeSource := p.PrintTokens(beforeTokens)
prefixSpaceNum := len(fmt.Sprintf(" %2d | ", curLine))
annotateLine := strings.Repeat(" ", prefixSpaceNum+errToken.Position.Column-1) + "^"
afterSource := p.PrintTokens(afterTokens)
return fmt.Sprintf("%s\n%s\n%s", beforeSource, annotateLine, afterSource)
}
goccy-go-yaml-52dacb8/printer/printer_test.go 0000664 0000000 0000000 00000010136 15015766371 0021423 0 ustar 00root root 0000000 0000000 package printer_test
import (
"fmt"
"testing"
"github.com/goccy/go-yaml/lexer"
"github.com/goccy/go-yaml/printer"
)
func Test_Printer(t *testing.T) {
yml := `---
text: aaaa
text2: aaaa
bbbb
cccc
dddd
eeee
text3: ffff
gggg
hhhh
iiii
jjjj
bool: true
number: 10
anchor: &x 1
alias: *x
`
t.Run("print starting from tokens[3]", func(t *testing.T) {
tokens := lexer.Tokenize(yml)
var p printer.Printer
actual := "\n" + p.PrintErrorToken(tokens[3], false)
expect := `
1 | ---
> 2 | text: aaaa
^
3 | text2: aaaa
4 | bbbb
5 | cccc
6 | dddd
7 | eeee
8 | `
if actual != expect {
t.Fatalf("unexpected output: expect:[%s]\n actual:[%s]", expect, actual)
}
})
t.Run("print starting from tokens[4]", func(t *testing.T) {
tokens := lexer.Tokenize(yml)
var p printer.Printer
actual := "\n" + p.PrintErrorToken(tokens[4], false)
expect := `
1 | ---
2 | text: aaaa
> 3 | text2: aaaa
4 | bbbb
5 | cccc
6 | dddd
7 | eeee
^
`
if actual != expect {
t.Fatalf("unexpected output: expect:[%s]\n actual:[%s]", expect, actual)
}
})
t.Run("print starting from tokens[6]", func(t *testing.T) {
tokens := lexer.Tokenize(yml)
var p printer.Printer
actual := "\n" + p.PrintErrorToken(tokens[6], false)
expect := `
1 | ---
2 | text: aaaa
> 3 | text2: aaaa
4 | bbbb
5 | cccc
6 | dddd
7 | eeee
^
8 | text3: ffff
9 | gggg
10 | hhhh
11 | iiii
12 | jjjj
13 | `
if actual != expect {
t.Fatalf("unexpected output: expect:[%s]\n actual:[%s]", expect, actual)
}
})
t.Run("print error token with document header", func(t *testing.T) {
tokens := lexer.Tokenize(`---
a:
b:
c:
d: e
f: g
h: i
---
`)
expect := `
3 | b:
4 | c:
5 | d: e
> 6 | f: g
^
7 | h: i
8 |
9 | ---`
var p printer.Printer
actual := "\n" + p.PrintErrorToken(tokens[12], false)
if actual != expect {
t.Fatalf("unexpected output: expect:[%s]\n actual:[%s]", expect, actual)
}
})
t.Run("output with color", func(t *testing.T) {
t.Run("token6", func(t *testing.T) {
tokens := lexer.Tokenize(yml)
var p printer.Printer
t.Logf("\n%s", p.PrintErrorToken(tokens[6], true))
})
t.Run("token9", func(t *testing.T) {
tokens := lexer.Tokenize(yml)
var p printer.Printer
t.Logf("\n%s", p.PrintErrorToken(tokens[9], true))
})
t.Run("token12", func(t *testing.T) {
tokens := lexer.Tokenize(yml)
var p printer.Printer
t.Logf("\n%s", p.PrintErrorToken(tokens[12], true))
})
})
t.Run("print error message", func(t *testing.T) {
var p printer.Printer
src := "message"
msg := p.PrintErrorMessage(src, false)
if msg != src {
t.Fatal("unexpected result")
}
p.PrintErrorMessage(src, true)
})
}
func TestPrinter_Anchor(t *testing.T) {
expected := `
anchor: &x 1
alias: *x`
tokens := lexer.Tokenize(expected)
var p printer.Printer
got := p.PrintTokens(tokens)
if expected != got {
t.Fatalf("unexpected output: expect:[%s]\n actual:[%s]", expected, got)
}
}
func Test_Printer_Multiline(t *testing.T) {
yml := `
text1: 'aaaa
bbbb
cccc'
text2: "ffff
gggg
hhhh"
text3: hello
`
tc := []struct {
token int
want string
}{
{
token: 2,
want: `
> 2 | text1: 'aaaa
3 | bbbb
4 | cccc'
^
5 | text2: "ffff
6 | gggg
7 | hhhh"`,
},
{token: 3,
want: `
2 | text1: 'aaaa
3 | bbbb
4 | cccc'
> 5 | text2: "ffff
6 | gggg
7 | hhhh"
^
8 | text3: hello`,
},
{token: 5,
want: `
2 | text1: 'aaaa
3 | bbbb
4 | cccc'
> 5 | text2: "ffff
6 | gggg
7 | hhhh"
^
8 | text3: hello`,
},
{token: 6,
want: `
5 | text2: "ffff
6 | gggg
7 | hhhh"
> 8 | text3: hello
^
`,
},
}
for _, tt := range tc {
name := fmt.Sprintf("print starting from tokens[%d]", tt.token)
t.Run(name, func(t *testing.T) {
tokens := lexer.Tokenize(yml)
var p printer.Printer
got := "\n" + p.PrintErrorToken(tokens[tt.token], false)
want := tt.want
if got != want {
t.Fatalf("PrintErrorToken() got: %s\n want:%s\n", want, got)
}
})
}
}
goccy-go-yaml-52dacb8/scanner/ 0000775 0000000 0000000 00000000000 15015766371 0016317 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/scanner/context.go 0000664 0000000 0000000 00000023413 15015766371 0020335 0 ustar 00root root 0000000 0000000 package scanner
import (
"errors"
"strconv"
"strings"
"sync"
"github.com/goccy/go-yaml/token"
)
// Context context at scanning
type Context struct {
idx int
size int
notSpaceCharPos int
notSpaceOrgCharPos int
src []rune
buf []rune
obuf []rune
tokens token.Tokens
mstate *MultiLineState
}
type MultiLineState struct {
opt string
firstLineIndentColumn int
prevLineIndentColumn int
lineIndentColumn int
lastNotSpaceOnlyLineIndentColumn int
spaceOnlyIndentColumn int
foldedNewLine bool
isRawFolded bool
isLiteral bool
isFolded bool
}
var (
ctxPool = sync.Pool{
New: func() interface{} {
return createContext()
},
}
)
func createContext() *Context {
return &Context{
idx: 0,
tokens: token.Tokens{},
}
}
func newContext(src []rune) *Context {
ctx, _ := ctxPool.Get().(*Context)
ctx.reset(src)
return ctx
}
func (c *Context) release() {
ctxPool.Put(c)
}
func (c *Context) clear() {
c.resetBuffer()
c.mstate = nil
}
func (c *Context) reset(src []rune) {
c.idx = 0
c.size = len(src)
c.src = src
c.tokens = c.tokens[:0]
c.resetBuffer()
c.mstate = nil
}
func (c *Context) resetBuffer() {
c.buf = c.buf[:0]
c.obuf = c.obuf[:0]
c.notSpaceCharPos = 0
c.notSpaceOrgCharPos = 0
}
func (c *Context) breakMultiLine() {
c.mstate = nil
}
func (c *Context) getMultiLineState() *MultiLineState {
return c.mstate
}
func (c *Context) setLiteral(lastDelimColumn int, opt string) {
mstate := &MultiLineState{
isLiteral: true,
opt: opt,
}
indent := firstLineIndentColumnByOpt(opt)
if indent > 0 {
mstate.firstLineIndentColumn = lastDelimColumn + indent
}
c.mstate = mstate
}
func (c *Context) setFolded(lastDelimColumn int, opt string) {
mstate := &MultiLineState{
isFolded: true,
opt: opt,
}
indent := firstLineIndentColumnByOpt(opt)
if indent > 0 {
mstate.firstLineIndentColumn = lastDelimColumn + indent
}
c.mstate = mstate
}
func (c *Context) setRawFolded(column int) {
mstate := &MultiLineState{
isRawFolded: true,
}
mstate.updateIndentColumn(column)
c.mstate = mstate
}
func firstLineIndentColumnByOpt(opt string) int {
opt = strings.TrimPrefix(opt, "-")
opt = strings.TrimPrefix(opt, "+")
opt = strings.TrimSuffix(opt, "-")
opt = strings.TrimSuffix(opt, "+")
i, _ := strconv.ParseInt(opt, 10, 64)
return int(i)
}
func (s *MultiLineState) lastDelimColumn() int {
if s.firstLineIndentColumn == 0 {
return 0
}
return s.firstLineIndentColumn - 1
}
func (s *MultiLineState) updateIndentColumn(column int) {
if s.firstLineIndentColumn == 0 {
s.firstLineIndentColumn = column
}
if s.lineIndentColumn == 0 {
s.lineIndentColumn = column
}
}
func (s *MultiLineState) updateSpaceOnlyIndentColumn(column int) {
if s.firstLineIndentColumn != 0 {
return
}
s.spaceOnlyIndentColumn = column
}
func (s *MultiLineState) validateIndentAfterSpaceOnly(column int) error {
if s.firstLineIndentColumn != 0 {
return nil
}
if s.spaceOnlyIndentColumn > column {
return errors.New("invalid number of indent is specified after space only")
}
return nil
}
func (s *MultiLineState) validateIndentColumn() error {
if firstLineIndentColumnByOpt(s.opt) == 0 {
return nil
}
if s.firstLineIndentColumn > s.lineIndentColumn {
return errors.New("invalid number of indent is specified in the multi-line header")
}
return nil
}
func (s *MultiLineState) updateNewLineState() {
s.prevLineIndentColumn = s.lineIndentColumn
if s.lineIndentColumn != 0 {
s.lastNotSpaceOnlyLineIndentColumn = s.lineIndentColumn
}
s.foldedNewLine = true
s.lineIndentColumn = 0
}
func (s *MultiLineState) isIndentColumn(column int) bool {
if s.firstLineIndentColumn == 0 {
return column == 1
}
return s.firstLineIndentColumn > column
}
func (s *MultiLineState) addIndent(ctx *Context, column int) {
if s.firstLineIndentColumn == 0 {
return
}
// If the first line of the document has already been evaluated, the number is treated as the threshold, since the `firstLineIndentColumn` is a positive number.
if column < s.firstLineIndentColumn {
return
}
// `c.foldedNewLine` is a variable that is set to true for every newline.
if !s.isLiteral && s.foldedNewLine {
s.foldedNewLine = false
}
// Since addBuf ignore space character, add to the buffer directly.
ctx.buf = append(ctx.buf, ' ')
ctx.notSpaceCharPos = len(ctx.buf)
}
// updateNewLineInFolded if Folded or RawFolded context and the content on the current line starts at the same column as the previous line,
// treat the new-line-char as a space.
func (s *MultiLineState) updateNewLineInFolded(ctx *Context, column int) {
if s.isLiteral {
return
}
// Folded or RawFolded.
if !s.foldedNewLine {
return
}
var (
lastChar rune
prevLastChar rune
)
if len(ctx.buf) != 0 {
lastChar = ctx.buf[len(ctx.buf)-1]
}
if len(ctx.buf) > 1 {
prevLastChar = ctx.buf[len(ctx.buf)-2]
}
if s.lineIndentColumn == s.prevLineIndentColumn {
// ---
// >
// a
// b
if lastChar == '\n' {
ctx.buf[len(ctx.buf)-1] = ' '
}
} else if s.prevLineIndentColumn == 0 && s.lastNotSpaceOnlyLineIndentColumn == column {
// if previous line is indent-space and new-line-char only, prevLineIndentColumn is zero.
// In this case, last new-line-char is removed.
// ---
// >
// a
//
// b
if lastChar == '\n' && prevLastChar == '\n' {
ctx.buf = ctx.buf[:len(ctx.buf)-1]
ctx.notSpaceCharPos = len(ctx.buf)
}
}
s.foldedNewLine = false
}
func (s *MultiLineState) hasTrimAllEndNewlineOpt() bool {
return strings.HasPrefix(s.opt, "-") || strings.HasSuffix(s.opt, "-") || s.isRawFolded
}
func (s *MultiLineState) hasKeepAllEndNewlineOpt() bool {
return strings.HasPrefix(s.opt, "+") || strings.HasSuffix(s.opt, "+")
}
func (c *Context) addToken(tk *token.Token) {
if tk == nil {
return
}
c.tokens = append(c.tokens, tk)
}
func (c *Context) addBuf(r rune) {
if len(c.buf) == 0 && (r == ' ' || r == '\t') {
return
}
c.buf = append(c.buf, r)
if r != ' ' && r != '\t' {
c.notSpaceCharPos = len(c.buf)
}
}
func (c *Context) addBufWithTab(r rune) {
if len(c.buf) == 0 && r == ' ' {
return
}
c.buf = append(c.buf, r)
if r != ' ' {
c.notSpaceCharPos = len(c.buf)
}
}
func (c *Context) addOriginBuf(r rune) {
c.obuf = append(c.obuf, r)
if r != ' ' && r != '\t' {
c.notSpaceOrgCharPos = len(c.obuf)
}
}
func (c *Context) removeRightSpaceFromBuf() {
trimmedBuf := c.obuf[:c.notSpaceOrgCharPos]
buflen := len(trimmedBuf)
diff := len(c.obuf) - buflen
if diff > 0 {
c.obuf = c.obuf[:buflen]
c.buf = c.bufferedSrc()
}
}
func (c *Context) isEOS() bool {
return len(c.src)-1 <= c.idx
}
func (c *Context) isNextEOS() bool {
return len(c.src) <= c.idx+1
}
func (c *Context) next() bool {
return c.idx < c.size
}
func (c *Context) source(s, e int) string {
return string(c.src[s:e])
}
func (c *Context) previousChar() rune {
if c.idx > 0 {
return c.src[c.idx-1]
}
return rune(0)
}
func (c *Context) currentChar() rune {
if c.size > c.idx {
return c.src[c.idx]
}
return rune(0)
}
func (c *Context) nextChar() rune {
if c.size > c.idx+1 {
return c.src[c.idx+1]
}
return rune(0)
}
func (c *Context) repeatNum(r rune) int {
cnt := 0
for i := c.idx; i < c.size; i++ {
if c.src[i] == r {
cnt++
} else {
break
}
}
return cnt
}
func (c *Context) progress(num int) {
c.idx += num
}
func (c *Context) existsBuffer() bool {
return len(c.bufferedSrc()) != 0
}
func (c *Context) isMultiLine() bool {
return c.mstate != nil
}
func (c *Context) bufferedSrc() []rune {
src := c.buf[:c.notSpaceCharPos]
if c.isMultiLine() {
mstate := c.getMultiLineState()
// remove end '\n' character and trailing empty lines.
// https://yaml.org/spec/1.2.2/#8112-block-chomping-indicator
if mstate.hasTrimAllEndNewlineOpt() {
// If the '-' flag is specified, all trailing newline characters will be removed.
src = []rune(strings.TrimRight(string(src), "\n"))
} else if !mstate.hasKeepAllEndNewlineOpt() {
// Normally, all but one of the trailing newline characters are removed.
var newLineCharCount int
for i := len(src) - 1; i >= 0; i-- {
if src[i] == '\n' {
newLineCharCount++
continue
}
break
}
removedNewLineCharCount := newLineCharCount - 1
for removedNewLineCharCount > 0 {
src = []rune(strings.TrimSuffix(string(src), "\n"))
removedNewLineCharCount--
}
}
// If the text ends with a space character, remove all of them.
if mstate.hasTrimAllEndNewlineOpt() {
src = []rune(strings.TrimRight(string(src), " "))
}
if string(src) == "\n" {
// If the content consists only of a newline,
// it can be considered as the document ending without any specified value,
// so it is treated as an empty string.
src = []rune{}
}
if mstate.hasKeepAllEndNewlineOpt() && len(src) == 0 {
src = []rune{'\n'}
}
}
return src
}
func (c *Context) bufferedToken(pos *token.Position) *token.Token {
if c.idx == 0 {
return nil
}
source := c.bufferedSrc()
if len(source) == 0 {
c.buf = c.buf[:0] // clear value's buffer only.
return nil
}
var tk *token.Token
if c.isMultiLine() {
tk = token.String(string(source), string(c.obuf), pos)
} else {
tk = token.New(string(source), string(c.obuf), pos)
}
c.setTokenTypeByPrevTag(tk)
c.resetBuffer()
return tk
}
func (c *Context) setTokenTypeByPrevTag(tk *token.Token) {
lastTk := c.lastToken()
if lastTk == nil {
return
}
if lastTk.Type != token.TagType {
return
}
tag := token.ReservedTagKeyword(lastTk.Value)
if _, exists := token.ReservedTagKeywordMap[tag]; !exists {
tk.Type = token.StringType
}
}
func (c *Context) lastToken() *token.Token {
if len(c.tokens) != 0 {
return c.tokens[len(c.tokens)-1]
}
return nil
}
goccy-go-yaml-52dacb8/scanner/error.go 0000664 0000000 0000000 00000000440 15015766371 0017775 0 ustar 00root root 0000000 0000000 package scanner
import "github.com/goccy/go-yaml/token"
type InvalidTokenError struct {
Token *token.Token
}
func (e *InvalidTokenError) Error() string {
return e.Token.Error
}
func ErrInvalidToken(tk *token.Token) *InvalidTokenError {
return &InvalidTokenError{
Token: tk,
}
}
goccy-go-yaml-52dacb8/scanner/scanner.go 0000664 0000000 0000000 00000105072 15015766371 0020304 0 ustar 00root root 0000000 0000000 package scanner
import (
"errors"
"fmt"
"io"
"strconv"
"strings"
"github.com/goccy/go-yaml/token"
)
// IndentState state for indent
type IndentState int
const (
// IndentStateEqual equals previous indent
IndentStateEqual IndentState = iota
// IndentStateUp more indent than previous
IndentStateUp
// IndentStateDown less indent than previous
IndentStateDown
// IndentStateKeep uses not indent token
IndentStateKeep
)
// Scanner holds the scanner's internal state while processing a given text.
// It can be allocated as part of another data structure but must be initialized via Init before use.
type Scanner struct {
source []rune
sourcePos int
sourceSize int
// line number. This number starts from 1.
line int
// column number. This number starts from 1.
column int
// offset represents the offset from the beginning of the source.
offset int
// lastDelimColumn is the last column needed to compare indent is retained.
lastDelimColumn int
// indentNum indicates the number of spaces used for indentation.
indentNum int
// prevLineIndentNum indicates the number of spaces used for indentation at previous line.
prevLineIndentNum int
// indentLevel indicates the level of indent depth. This value does not match the column value.
indentLevel int
isFirstCharAtLine bool
isAnchor bool
isAlias bool
isDirective bool
startedFlowSequenceNum int
startedFlowMapNum int
indentState IndentState
savedPos *token.Position
}
func (s *Scanner) pos() *token.Position {
return &token.Position{
Line: s.line,
Column: s.column,
Offset: s.offset,
IndentNum: s.indentNum,
IndentLevel: s.indentLevel,
}
}
func (s *Scanner) bufferedToken(ctx *Context) *token.Token {
if s.savedPos != nil {
tk := ctx.bufferedToken(s.savedPos)
s.savedPos = nil
return tk
}
line := s.line
column := s.column - len(ctx.buf)
level := s.indentLevel
if ctx.isMultiLine() {
line -= s.newLineCount(ctx.buf)
column = strings.Index(string(ctx.obuf), string(ctx.buf)) + 1
// Since we are in a literal, folded or raw folded
// we can use the indent level from the last token.
last := ctx.lastToken()
if last != nil { // The last token should never be nil here.
level = last.Position.IndentLevel + 1
}
}
return ctx.bufferedToken(&token.Position{
Line: line,
Column: column,
Offset: s.offset - len(ctx.buf),
IndentNum: s.indentNum,
IndentLevel: level,
})
}
func (s *Scanner) progressColumn(ctx *Context, num int) {
s.column += num
s.offset += num
s.progress(ctx, num)
}
func (s *Scanner) progressOnly(ctx *Context, num int) {
s.offset += num
s.progress(ctx, num)
}
func (s *Scanner) progressLine(ctx *Context) {
s.prevLineIndentNum = s.indentNum
s.column = 1
s.line++
s.offset++
s.indentNum = 0
s.isFirstCharAtLine = true
s.isAnchor = false
s.isAlias = false
s.isDirective = false
s.progress(ctx, 1)
}
func (s *Scanner) progress(ctx *Context, num int) {
ctx.progress(num)
s.sourcePos += num
}
func (s *Scanner) isNewLineChar(c rune) bool {
if c == '\n' {
return true
}
if c == '\r' {
return true
}
return false
}
func (s *Scanner) newLineCount(src []rune) int {
size := len(src)
cnt := 0
for i := 0; i < size; i++ {
c := src[i]
switch c {
case '\r':
if i+1 < size && src[i+1] == '\n' {
i++
}
cnt++
case '\n':
cnt++
}
}
return cnt
}
func (s *Scanner) updateIndentLevel() {
if s.prevLineIndentNum < s.indentNum {
s.indentLevel++
} else if s.prevLineIndentNum > s.indentNum {
if s.indentLevel > 0 {
s.indentLevel--
}
}
}
func (s *Scanner) updateIndentState(ctx *Context) {
if s.lastDelimColumn == 0 {
return
}
if s.lastDelimColumn < s.column {
s.indentState = IndentStateUp
} else {
// If lastDelimColumn and s.column are the same,
// treat as Down state since it is the same column as delimiter.
s.indentState = IndentStateDown
}
}
func (s *Scanner) updateIndent(ctx *Context, c rune) {
if s.isFirstCharAtLine && s.isNewLineChar(c) {
return
}
if s.isFirstCharAtLine && c == ' ' {
s.indentNum++
return
}
if s.isFirstCharAtLine && c == '\t' {
// found tab indent.
// In this case, scanTab returns error.
return
}
if !s.isFirstCharAtLine {
s.indentState = IndentStateKeep
return
}
s.updateIndentLevel()
s.updateIndentState(ctx)
s.isFirstCharAtLine = false
}
func (s *Scanner) isChangedToIndentStateDown() bool {
return s.indentState == IndentStateDown
}
func (s *Scanner) isChangedToIndentStateUp() bool {
return s.indentState == IndentStateUp
}
func (s *Scanner) addBufferedTokenIfExists(ctx *Context) {
ctx.addToken(s.bufferedToken(ctx))
}
func (s *Scanner) breakMultiLine(ctx *Context) {
ctx.breakMultiLine()
}
func (s *Scanner) scanSingleQuote(ctx *Context) (*token.Token, error) {
ctx.addOriginBuf('\'')
srcpos := s.pos()
startIndex := ctx.idx + 1
src := ctx.src
size := len(src)
value := []rune{}
isFirstLineChar := false
isNewLine := false
for idx := startIndex; idx < size; idx++ {
if !isNewLine {
s.progressColumn(ctx, 1)
} else {
isNewLine = false
}
c := src[idx]
ctx.addOriginBuf(c)
if s.isNewLineChar(c) {
notSpaceIdx := -1
for i := len(value) - 1; i >= 0; i-- {
if value[i] == ' ' {
continue
}
notSpaceIdx = i
break
}
if len(value) > notSpaceIdx {
value = value[:notSpaceIdx+1]
}
if isFirstLineChar {
value = append(value, '\n')
} else {
value = append(value, ' ')
}
isFirstLineChar = true
isNewLine = true
s.progressLine(ctx)
if idx+1 < size {
if err := s.validateDocumentSeparatorMarker(ctx, src[idx+1:]); err != nil {
return nil, err
}
}
continue
} else if isFirstLineChar && c == ' ' {
continue
} else if isFirstLineChar && c == '\t' {
if s.lastDelimColumn >= s.column {
return nil, ErrInvalidToken(
token.Invalid(
"tab character cannot be used for indentation in single-quoted text",
string(ctx.obuf), s.pos(),
),
)
}
continue
} else if c != '\'' {
value = append(value, c)
isFirstLineChar = false
continue
} else if idx+1 < len(ctx.src) && ctx.src[idx+1] == '\'' {
// '' handle as ' character
value = append(value, c)
ctx.addOriginBuf(c)
idx++
s.progressColumn(ctx, 1)
continue
}
s.progressColumn(ctx, 1)
return token.SingleQuote(string(value), string(ctx.obuf), srcpos), nil
}
s.progressColumn(ctx, 1)
return nil, ErrInvalidToken(
token.Invalid(
"could not find end character of single-quoted text",
string(ctx.obuf), srcpos,
),
)
}
func hexToInt(b rune) int {
if b >= 'A' && b <= 'F' {
return int(b) - 'A' + 10
}
if b >= 'a' && b <= 'f' {
return int(b) - 'a' + 10
}
return int(b) - '0'
}
func hexRunesToInt(b []rune) int {
sum := 0
for i := 0; i < len(b); i++ {
sum += hexToInt(b[i]) << (uint(len(b)-i-1) * 4)
}
return sum
}
func (s *Scanner) scanDoubleQuote(ctx *Context) (*token.Token, error) {
ctx.addOriginBuf('"')
srcpos := s.pos()
startIndex := ctx.idx + 1
src := ctx.src
size := len(src)
value := []rune{}
isFirstLineChar := false
isNewLine := false
for idx := startIndex; idx < size; idx++ {
if !isNewLine {
s.progressColumn(ctx, 1)
} else {
isNewLine = false
}
c := src[idx]
ctx.addOriginBuf(c)
if s.isNewLineChar(c) {
notSpaceIdx := -1
for i := len(value) - 1; i >= 0; i-- {
if value[i] == ' ' {
continue
}
notSpaceIdx = i
break
}
if len(value) > notSpaceIdx {
value = value[:notSpaceIdx+1]
}
if isFirstLineChar {
value = append(value, '\n')
} else {
value = append(value, ' ')
}
isFirstLineChar = true
isNewLine = true
s.progressLine(ctx)
if idx+1 < size {
if err := s.validateDocumentSeparatorMarker(ctx, src[idx+1:]); err != nil {
return nil, err
}
}
continue
} else if isFirstLineChar && c == ' ' {
continue
} else if isFirstLineChar && c == '\t' {
if s.lastDelimColumn >= s.column {
return nil, ErrInvalidToken(
token.Invalid(
"tab character cannot be used for indentation in double-quoted text",
string(ctx.obuf), s.pos(),
),
)
}
continue
} else if c == '\\' {
isFirstLineChar = false
if idx+1 >= size {
value = append(value, c)
continue
}
nextChar := src[idx+1]
progress := 0
switch nextChar {
case '0':
progress = 1
ctx.addOriginBuf(nextChar)
value = append(value, 0x00)
case 'a':
progress = 1
ctx.addOriginBuf(nextChar)
value = append(value, 0x07)
case 'b':
progress = 1
ctx.addOriginBuf(nextChar)
value = append(value, 0x08)
case 't':
progress = 1
ctx.addOriginBuf(nextChar)
value = append(value, 0x09)
case 'n':
progress = 1
ctx.addOriginBuf(nextChar)
value = append(value, 0x0A)
case 'v':
progress = 1
ctx.addOriginBuf(nextChar)
value = append(value, 0x0B)
case 'f':
progress = 1
ctx.addOriginBuf(nextChar)
value = append(value, 0x0C)
case 'r':
progress = 1
ctx.addOriginBuf(nextChar)
value = append(value, 0x0D)
case 'e':
progress = 1
ctx.addOriginBuf(nextChar)
value = append(value, 0x1B)
case ' ':
progress = 1
ctx.addOriginBuf(nextChar)
value = append(value, 0x20)
case '"':
progress = 1
ctx.addOriginBuf(nextChar)
value = append(value, 0x22)
case '/':
progress = 1
ctx.addOriginBuf(nextChar)
value = append(value, 0x2F)
case '\\':
progress = 1
ctx.addOriginBuf(nextChar)
value = append(value, 0x5C)
case 'N':
progress = 1
ctx.addOriginBuf(nextChar)
value = append(value, 0x85)
case '_':
progress = 1
ctx.addOriginBuf(nextChar)
value = append(value, 0xA0)
case 'L':
progress = 1
ctx.addOriginBuf(nextChar)
value = append(value, 0x2028)
case 'P':
progress = 1
ctx.addOriginBuf(nextChar)
value = append(value, 0x2029)
case 'x':
if idx+3 >= size {
progress = 1
ctx.addOriginBuf(nextChar)
value = append(value, nextChar)
} else {
progress = 3
codeNum := hexRunesToInt(src[idx+2 : idx+progress+1])
value = append(value, rune(codeNum))
}
case 'u':
// \u0000 style must have 5 characters at least.
if idx+5 >= size {
return nil, ErrInvalidToken(
token.Invalid(
"not enough length for escaped UTF-16 character",
string(ctx.obuf), s.pos(),
),
)
}
progress = 5
codeNum := hexRunesToInt(src[idx+2 : idx+6])
// handle surrogate pairs.
if codeNum >= 0xD800 && codeNum <= 0xDBFF {
high := codeNum
// \u0000\u0000 style must have 11 characters at least.
if idx+11 >= size {
return nil, ErrInvalidToken(
token.Invalid(
"not enough length for escaped UTF-16 surrogate pair",
string(ctx.obuf), s.pos(),
),
)
}
if src[idx+6] != '\\' || src[idx+7] != 'u' {
return nil, ErrInvalidToken(
token.Invalid(
"found unexpected character after high surrogate for UTF-16 surrogate pair",
string(ctx.obuf), s.pos(),
),
)
}
low := hexRunesToInt(src[idx+8 : idx+12])
if low < 0xDC00 || low > 0xDFFF {
return nil, ErrInvalidToken(
token.Invalid(
"found unexpected low surrogate after high surrogate",
string(ctx.obuf), s.pos(),
),
)
}
codeNum = ((high - 0xD800) * 0x400) + (low - 0xDC00) + 0x10000
progress += 6
}
value = append(value, rune(codeNum))
case 'U':
// \U00000000 style must have 9 characters at least.
if idx+9 >= size {
return nil, ErrInvalidToken(
token.Invalid(
"not enough length for escaped UTF-32 character",
string(ctx.obuf), s.pos(),
),
)
}
progress = 9
codeNum := hexRunesToInt(src[idx+2 : idx+10])
value = append(value, rune(codeNum))
case '\n':
isFirstLineChar = true
isNewLine = true
ctx.addOriginBuf(nextChar)
s.progressColumn(ctx, 1)
s.progressLine(ctx)
idx++
continue
case '\r':
isFirstLineChar = true
isNewLine = true
ctx.addOriginBuf(nextChar)
s.progressLine(ctx)
progress = 1
// Skip \n after \r in CRLF sequences
if idx+2 < size && src[idx+2] == '\n' {
ctx.addOriginBuf('\n')
progress = 2
}
case '\t':
progress = 1
ctx.addOriginBuf(nextChar)
value = append(value, nextChar)
default:
s.progressColumn(ctx, 1)
return nil, ErrInvalidToken(
token.Invalid(
fmt.Sprintf("found unknown escape character %q", nextChar),
string(ctx.obuf), s.pos(),
),
)
}
idx += progress
s.progressColumn(ctx, progress)
continue
} else if c == '\t' {
var (
foundNotSpaceChar bool
progress int
)
for i := idx + 1; i < size; i++ {
if src[i] == ' ' || src[i] == '\t' {
progress++
continue
}
if s.isNewLineChar(src[i]) {
break
}
foundNotSpaceChar = true
}
if foundNotSpaceChar {
value = append(value, c)
if src[idx+1] != '"' {
s.progressColumn(ctx, 1)
}
} else {
idx += progress
s.progressColumn(ctx, progress)
}
continue
} else if c != '"' {
value = append(value, c)
isFirstLineChar = false
continue
}
s.progressColumn(ctx, 1)
return token.DoubleQuote(string(value), string(ctx.obuf), srcpos), nil
}
s.progressColumn(ctx, 1)
return nil, ErrInvalidToken(
token.Invalid(
"could not find end character of double-quoted text",
string(ctx.obuf), srcpos,
),
)
}
func (s *Scanner) validateDocumentSeparatorMarker(ctx *Context, src []rune) error {
if s.foundDocumentSeparatorMarker(src) {
return ErrInvalidToken(
token.Invalid("found unexpected document separator", string(ctx.obuf), s.pos()),
)
}
return nil
}
func (s *Scanner) foundDocumentSeparatorMarker(src []rune) bool {
if len(src) < 3 {
return false
}
var marker string
if len(src) == 3 {
marker = string(src)
} else {
marker = strings.TrimRightFunc(string(src[:4]), func(r rune) bool {
return r == ' ' || r == '\t' || r == '\n' || r == '\r'
})
}
return marker == "---" || marker == "..."
}
func (s *Scanner) scanQuote(ctx *Context, ch rune) (bool, error) {
if ctx.existsBuffer() {
return false, nil
}
if ch == '\'' {
tk, err := s.scanSingleQuote(ctx)
if err != nil {
return false, err
}
ctx.addToken(tk)
} else {
tk, err := s.scanDoubleQuote(ctx)
if err != nil {
return false, err
}
ctx.addToken(tk)
}
ctx.clear()
return true, nil
}
func (s *Scanner) scanWhiteSpace(ctx *Context) bool {
if ctx.isMultiLine() {
return false
}
if !s.isAnchor && !s.isDirective && !s.isAlias && !s.isFirstCharAtLine {
return false
}
if s.isFirstCharAtLine {
s.progressColumn(ctx, 1)
ctx.addOriginBuf(' ')
return true
}
if s.isDirective {
s.addBufferedTokenIfExists(ctx)
s.progressColumn(ctx, 1)
ctx.addOriginBuf(' ')
return true
}
s.addBufferedTokenIfExists(ctx)
s.isAnchor = false
s.isAlias = false
return true
}
func (s *Scanner) isMergeKey(ctx *Context) bool {
if ctx.repeatNum('<') != 2 {
return false
}
src := ctx.src
size := len(src)
for idx := ctx.idx + 2; idx < size; idx++ {
c := src[idx]
if c == ' ' {
continue
}
if c != ':' {
return false
}
if idx+1 < size {
nc := src[idx+1]
if nc == ' ' || s.isNewLineChar(nc) {
return true
}
}
}
return false
}
func (s *Scanner) scanTag(ctx *Context) (bool, error) {
if ctx.existsBuffer() || s.isDirective {
return false, nil
}
ctx.addOriginBuf('!')
s.progress(ctx, 1) // skip '!' character
var progress int
for idx, c := range ctx.src[ctx.idx:] {
progress = idx + 1
switch c {
case ' ':
ctx.addOriginBuf(c)
value := ctx.source(ctx.idx-1, ctx.idx+idx)
ctx.addToken(token.Tag(value, string(ctx.obuf), s.pos()))
s.progressColumn(ctx, len([]rune(value)))
ctx.clear()
return true, nil
case ',':
if s.startedFlowSequenceNum > 0 || s.startedFlowMapNum > 0 {
value := ctx.source(ctx.idx-1, ctx.idx+idx)
ctx.addToken(token.Tag(value, string(ctx.obuf), s.pos()))
s.progressColumn(ctx, len([]rune(value))-1) // progress column before collect-entry for scanning it at scanFlowEntry function.
ctx.clear()
return true, nil
} else {
ctx.addOriginBuf(c)
}
case '\n', '\r':
ctx.addOriginBuf(c)
value := ctx.source(ctx.idx-1, ctx.idx+idx)
ctx.addToken(token.Tag(value, string(ctx.obuf), s.pos()))
s.progressColumn(ctx, len([]rune(value))-1) // progress column before new-line-char for scanning new-line-char at scanNewLine function.
ctx.clear()
return true, nil
case '{', '}':
ctx.addOriginBuf(c)
s.progressColumn(ctx, progress)
invalidTk := token.Invalid(fmt.Sprintf("found invalid tag character %q", c), string(ctx.obuf), s.pos())
return false, ErrInvalidToken(invalidTk)
default:
ctx.addOriginBuf(c)
}
}
s.progressColumn(ctx, progress)
ctx.clear()
return true, nil
}
func (s *Scanner) scanComment(ctx *Context) bool {
if ctx.existsBuffer() {
c := ctx.previousChar()
if c != ' ' && c != '\t' && !s.isNewLineChar(c) {
return false
}
}
s.addBufferedTokenIfExists(ctx)
ctx.addOriginBuf('#')
s.progress(ctx, 1) // skip '#' character
for idx, c := range ctx.src[ctx.idx:] {
ctx.addOriginBuf(c)
if !s.isNewLineChar(c) {
continue
}
if ctx.previousChar() == '\\' {
continue
}
value := ctx.source(ctx.idx, ctx.idx+idx)
progress := len([]rune(value))
ctx.addToken(token.Comment(value, string(ctx.obuf), s.pos()))
s.progressColumn(ctx, progress)
s.progressLine(ctx)
ctx.clear()
return true
}
// document ends with comment.
value := string(ctx.src[ctx.idx:])
ctx.addToken(token.Comment(value, string(ctx.obuf), s.pos()))
progress := len([]rune(value))
s.progressColumn(ctx, progress)
s.progressLine(ctx)
ctx.clear()
return true
}
func (s *Scanner) scanMultiLine(ctx *Context, c rune) error {
state := ctx.getMultiLineState()
ctx.addOriginBuf(c)
if ctx.isEOS() {
if s.isFirstCharAtLine && c == ' ' {
state.addIndent(ctx, s.column)
} else {
ctx.addBuf(c)
}
state.updateIndentColumn(s.column)
if err := state.validateIndentColumn(); err != nil {
invalidTk := token.Invalid(err.Error(), string(ctx.obuf), s.pos())
s.progressColumn(ctx, 1)
return ErrInvalidToken(invalidTk)
}
value := ctx.bufferedSrc()
ctx.addToken(token.String(string(value), string(ctx.obuf), s.pos()))
ctx.clear()
s.progressColumn(ctx, 1)
} else if s.isNewLineChar(c) {
ctx.addBuf(c)
state.updateSpaceOnlyIndentColumn(s.column - 1)
state.updateNewLineState()
s.progressLine(ctx)
if ctx.next() {
if s.foundDocumentSeparatorMarker(ctx.src[ctx.idx:]) {
value := ctx.bufferedSrc()
ctx.addToken(token.String(string(value), string(ctx.obuf), s.pos()))
ctx.clear()
s.breakMultiLine(ctx)
}
}
} else if s.isFirstCharAtLine && c == ' ' {
state.addIndent(ctx, s.column)
s.progressColumn(ctx, 1)
} else if s.isFirstCharAtLine && c == '\t' && state.isIndentColumn(s.column) {
err := ErrInvalidToken(
token.Invalid(
"found a tab character where an indentation space is expected",
string(ctx.obuf), s.pos(),
),
)
s.progressColumn(ctx, 1)
return err
} else if c == '\t' && !state.isIndentColumn(s.column) {
ctx.addBufWithTab(c)
s.progressColumn(ctx, 1)
} else {
if err := state.validateIndentAfterSpaceOnly(s.column); err != nil {
invalidTk := token.Invalid(err.Error(), string(ctx.obuf), s.pos())
s.progressColumn(ctx, 1)
return ErrInvalidToken(invalidTk)
}
state.updateIndentColumn(s.column)
if err := state.validateIndentColumn(); err != nil {
invalidTk := token.Invalid(err.Error(), string(ctx.obuf), s.pos())
s.progressColumn(ctx, 1)
return ErrInvalidToken(invalidTk)
}
if col := state.lastDelimColumn(); col > 0 {
s.lastDelimColumn = col
}
state.updateNewLineInFolded(ctx, s.column)
ctx.addBufWithTab(c)
s.progressColumn(ctx, 1)
}
return nil
}
func (s *Scanner) scanNewLine(ctx *Context, c rune) {
if len(ctx.buf) > 0 && s.savedPos == nil {
bufLen := len(ctx.bufferedSrc())
s.savedPos = s.pos()
s.savedPos.Column -= bufLen
s.savedPos.Offset -= bufLen
}
// if the following case, origin buffer has unnecessary two spaces.
// So, `removeRightSpaceFromOriginBuf` remove them, also fix column number too.
// ---
// a:[space][space]
// b: c
ctx.removeRightSpaceFromBuf()
// There is no problem that we ignore CR which followed by LF and normalize it to LF, because of following YAML1.2 spec.
// > Line breaks inside scalar content must be normalized by the YAML processor. Each such line break must be parsed into a single line feed character.
// > Outside scalar content, YAML allows any line break to be used to terminate lines.
// > -- https://yaml.org/spec/1.2/spec.html
if c == '\r' && ctx.nextChar() == '\n' {
ctx.addOriginBuf('\r')
s.progress(ctx, 1)
s.offset++
c = '\n'
}
if ctx.isEOS() {
s.addBufferedTokenIfExists(ctx)
} else if s.isAnchor || s.isAlias || s.isDirective {
s.addBufferedTokenIfExists(ctx)
}
if ctx.existsBuffer() && s.isFirstCharAtLine {
if ctx.buf[len(ctx.buf)-1] == ' ' {
ctx.buf[len(ctx.buf)-1] = '\n'
} else {
ctx.buf = append(ctx.buf, '\n')
}
} else {
ctx.addBuf(' ')
}
ctx.addOriginBuf(c)
s.progressLine(ctx)
}
func (s *Scanner) isFlowMode() bool {
if s.startedFlowSequenceNum > 0 {
return true
}
if s.startedFlowMapNum > 0 {
return true
}
return false
}
func (s *Scanner) scanFlowMapStart(ctx *Context) bool {
if ctx.existsBuffer() && !s.isFlowMode() {
return false
}
s.addBufferedTokenIfExists(ctx)
ctx.addOriginBuf('{')
ctx.addToken(token.MappingStart(string(ctx.obuf), s.pos()))
s.startedFlowMapNum++
s.progressColumn(ctx, 1)
ctx.clear()
return true
}
func (s *Scanner) scanFlowMapEnd(ctx *Context) bool {
if s.startedFlowMapNum <= 0 {
return false
}
s.addBufferedTokenIfExists(ctx)
ctx.addOriginBuf('}')
ctx.addToken(token.MappingEnd(string(ctx.obuf), s.pos()))
s.startedFlowMapNum--
s.progressColumn(ctx, 1)
ctx.clear()
return true
}
func (s *Scanner) scanFlowArrayStart(ctx *Context) bool {
if ctx.existsBuffer() && !s.isFlowMode() {
return false
}
s.addBufferedTokenIfExists(ctx)
ctx.addOriginBuf('[')
ctx.addToken(token.SequenceStart(string(ctx.obuf), s.pos()))
s.startedFlowSequenceNum++
s.progressColumn(ctx, 1)
ctx.clear()
return true
}
func (s *Scanner) scanFlowArrayEnd(ctx *Context) bool {
if ctx.existsBuffer() && s.startedFlowSequenceNum <= 0 {
return false
}
s.addBufferedTokenIfExists(ctx)
ctx.addOriginBuf(']')
ctx.addToken(token.SequenceEnd(string(ctx.obuf), s.pos()))
s.startedFlowSequenceNum--
s.progressColumn(ctx, 1)
ctx.clear()
return true
}
func (s *Scanner) scanFlowEntry(ctx *Context, c rune) bool {
if s.startedFlowSequenceNum <= 0 && s.startedFlowMapNum <= 0 {
return false
}
s.addBufferedTokenIfExists(ctx)
ctx.addOriginBuf(c)
ctx.addToken(token.CollectEntry(string(ctx.obuf), s.pos()))
s.progressColumn(ctx, 1)
ctx.clear()
return true
}
func (s *Scanner) scanMapDelim(ctx *Context) (bool, error) {
nc := ctx.nextChar()
if s.isDirective || s.isAnchor || s.isAlias {
return false, nil
}
if s.startedFlowMapNum <= 0 && nc != ' ' && nc != '\t' && !s.isNewLineChar(nc) && !ctx.isNextEOS() {
return false, nil
}
if s.startedFlowMapNum > 0 && nc == '/' {
// like http://
return false, nil
}
if s.startedFlowMapNum > 0 {
tk := ctx.lastToken()
if tk != nil && tk.Type == token.MappingValueType {
return false, nil
}
}
if strings.HasPrefix(strings.TrimPrefix(string(ctx.obuf), " "), "\t") && !strings.HasPrefix(string(ctx.buf), "\t") {
invalidTk := token.Invalid("tab character cannot use as a map key directly", string(ctx.obuf), s.pos())
s.progressColumn(ctx, 1)
return false, ErrInvalidToken(invalidTk)
}
// mapping value
tk := s.bufferedToken(ctx)
if tk != nil {
s.lastDelimColumn = tk.Position.Column
ctx.addToken(tk)
} else if tk := ctx.lastToken(); tk != nil {
// If the map key is quote, the buffer does not exist because it has already been cut into tokens.
// Therefore, we need to check the last token.
if tk.Indicator == token.QuotedScalarIndicator {
s.lastDelimColumn = tk.Position.Column
}
}
ctx.addToken(token.MappingValue(s.pos()))
s.progressColumn(ctx, 1)
ctx.clear()
return true, nil
}
func (s *Scanner) scanDocumentStart(ctx *Context) bool {
if s.indentNum != 0 {
return false
}
if s.column != 1 {
return false
}
if ctx.repeatNum('-') != 3 {
return false
}
if ctx.size > ctx.idx+3 {
c := ctx.src[ctx.idx+3]
if c != ' ' && c != '\t' && c != '\n' && c != '\r' {
return false
}
}
s.addBufferedTokenIfExists(ctx)
ctx.addToken(token.DocumentHeader(string(ctx.obuf)+"---", s.pos()))
s.progressColumn(ctx, 3)
ctx.clear()
s.clearState()
return true
}
func (s *Scanner) scanDocumentEnd(ctx *Context) bool {
if s.indentNum != 0 {
return false
}
if s.column != 1 {
return false
}
if ctx.repeatNum('.') != 3 {
return false
}
s.addBufferedTokenIfExists(ctx)
ctx.addToken(token.DocumentEnd(string(ctx.obuf)+"...", s.pos()))
s.progressColumn(ctx, 3)
ctx.clear()
return true
}
func (s *Scanner) scanMergeKey(ctx *Context) bool {
if !s.isMergeKey(ctx) {
return false
}
s.lastDelimColumn = s.column
ctx.addToken(token.MergeKey(string(ctx.obuf)+"<<", s.pos()))
s.progressColumn(ctx, 2)
ctx.clear()
return true
}
func (s *Scanner) scanRawFoldedChar(ctx *Context) bool {
if !ctx.existsBuffer() {
return false
}
if !s.isChangedToIndentStateUp() {
return false
}
ctx.setRawFolded(s.column)
ctx.addBuf('-')
ctx.addOriginBuf('-')
s.progressColumn(ctx, 1)
return true
}
func (s *Scanner) scanSequence(ctx *Context) (bool, error) {
if ctx.existsBuffer() {
return false, nil
}
nc := ctx.nextChar()
if nc != 0 && nc != ' ' && nc != '\t' && !s.isNewLineChar(nc) {
return false, nil
}
if strings.HasPrefix(strings.TrimPrefix(string(ctx.obuf), " "), "\t") {
invalidTk := token.Invalid("tab character cannot use as a sequence delimiter", string(ctx.obuf), s.pos())
s.progressColumn(ctx, 1)
return false, ErrInvalidToken(invalidTk)
}
s.addBufferedTokenIfExists(ctx)
ctx.addOriginBuf('-')
tk := token.SequenceEntry(string(ctx.obuf), s.pos())
s.lastDelimColumn = tk.Position.Column
ctx.addToken(tk)
s.progressColumn(ctx, 1)
ctx.clear()
return true, nil
}
func (s *Scanner) scanMultiLineHeader(ctx *Context) (bool, error) {
if ctx.existsBuffer() {
return false, nil
}
if err := s.scanMultiLineHeaderOption(ctx); err != nil {
return false, err
}
s.progressLine(ctx)
return true, nil
}
func (s *Scanner) validateMultiLineHeaderOption(opt string) error {
if len(opt) == 0 {
return nil
}
orgOpt := opt
opt = strings.TrimPrefix(opt, "-")
opt = strings.TrimPrefix(opt, "+")
opt = strings.TrimSuffix(opt, "-")
opt = strings.TrimSuffix(opt, "+")
if len(opt) == 0 {
return nil
}
if opt == "0" {
return fmt.Errorf("invalid header option: %q", orgOpt)
}
i, err := strconv.ParseInt(opt, 10, 64)
if err != nil {
return fmt.Errorf("invalid header option: %q", orgOpt)
}
if i > 9 {
return fmt.Errorf("invalid header option: %q", orgOpt)
}
return nil
}
func (s *Scanner) scanMultiLineHeaderOption(ctx *Context) error {
header := ctx.currentChar()
ctx.addOriginBuf(header)
s.progress(ctx, 1) // skip '|' or '>' character
var progress int
for idx, c := range ctx.src[ctx.idx:] {
progress = idx
ctx.addOriginBuf(c)
if s.isNewLineChar(c) {
break
}
}
value := strings.TrimRight(ctx.source(ctx.idx, ctx.idx+progress), " ")
commentValueIndex := strings.Index(value, "#")
opt := value
if commentValueIndex > 0 {
opt = value[:commentValueIndex]
}
opt = strings.TrimRightFunc(opt, func(r rune) bool {
return r == ' ' || r == '\t'
})
if len(opt) != 0 {
if err := s.validateMultiLineHeaderOption(opt); err != nil {
invalidTk := token.Invalid(err.Error(), string(ctx.obuf), s.pos())
s.progressColumn(ctx, progress)
return ErrInvalidToken(invalidTk)
}
}
if s.column == 1 {
s.lastDelimColumn = 1
}
commentIndex := strings.Index(string(ctx.obuf), "#")
headerBuf := string(ctx.obuf)
if commentIndex > 0 {
headerBuf = headerBuf[:commentIndex]
}
switch header {
case '|':
ctx.addToken(token.Literal("|"+opt, headerBuf, s.pos()))
ctx.setLiteral(s.lastDelimColumn, opt)
case '>':
ctx.addToken(token.Folded(">"+opt, headerBuf, s.pos()))
ctx.setFolded(s.lastDelimColumn, opt)
}
if commentIndex > 0 {
comment := string(value[commentValueIndex+1:])
s.offset += len(headerBuf)
s.column += len(headerBuf)
ctx.addToken(token.Comment(comment, string(ctx.obuf[len(headerBuf):]), s.pos()))
}
s.indentState = IndentStateKeep
ctx.resetBuffer()
s.progressColumn(ctx, progress)
return nil
}
func (s *Scanner) scanMapKey(ctx *Context) bool {
if ctx.existsBuffer() {
return false
}
nc := ctx.nextChar()
if nc != ' ' && nc != '\t' {
return false
}
tk := token.MappingKey(s.pos())
s.lastDelimColumn = tk.Position.Column
ctx.addToken(tk)
s.progressColumn(ctx, 1)
ctx.clear()
return true
}
func (s *Scanner) scanDirective(ctx *Context) bool {
if ctx.existsBuffer() {
return false
}
if s.indentNum != 0 {
return false
}
s.addBufferedTokenIfExists(ctx)
ctx.addOriginBuf('%')
ctx.addToken(token.Directive(string(ctx.obuf), s.pos()))
s.progressColumn(ctx, 1)
ctx.clear()
s.isDirective = true
return true
}
func (s *Scanner) scanAnchor(ctx *Context) bool {
if ctx.existsBuffer() {
return false
}
s.addBufferedTokenIfExists(ctx)
ctx.addOriginBuf('&')
ctx.addToken(token.Anchor(string(ctx.obuf), s.pos()))
s.progressColumn(ctx, 1)
s.isAnchor = true
ctx.clear()
return true
}
func (s *Scanner) scanAlias(ctx *Context) bool {
if ctx.existsBuffer() {
return false
}
s.addBufferedTokenIfExists(ctx)
ctx.addOriginBuf('*')
ctx.addToken(token.Alias(string(ctx.obuf), s.pos()))
s.progressColumn(ctx, 1)
s.isAlias = true
ctx.clear()
return true
}
func (s *Scanner) scanReservedChar(ctx *Context, c rune) error {
if ctx.existsBuffer() {
return nil
}
ctx.addBuf(c)
ctx.addOriginBuf(c)
err := ErrInvalidToken(
token.Invalid(
fmt.Sprintf("%q is a reserved character", c),
string(ctx.obuf), s.pos(),
),
)
s.progressColumn(ctx, 1)
ctx.clear()
return err
}
func (s *Scanner) scanTab(ctx *Context, c rune) error {
if s.startedFlowSequenceNum > 0 || s.startedFlowMapNum > 0 {
// tabs character is allowed in flow mode.
return nil
}
if !s.isFirstCharAtLine {
return nil
}
ctx.addBuf(c)
ctx.addOriginBuf(c)
err := ErrInvalidToken(
token.Invalid("found character '\t' that cannot start any token",
string(ctx.obuf), s.pos(),
),
)
s.progressColumn(ctx, 1)
ctx.clear()
return err
}
func (s *Scanner) scan(ctx *Context) error {
for ctx.next() {
c := ctx.currentChar()
// First, change the IndentState.
// If the target character is the first character in a line, IndentState is Up/Down/Equal state.
// The second and subsequent letters are Keep.
s.updateIndent(ctx, c)
// If IndentState is down, tokens are split, so the buffer accumulated until that point needs to be cutted as a token.
if s.isChangedToIndentStateDown() {
s.addBufferedTokenIfExists(ctx)
}
if ctx.isMultiLine() {
if s.isChangedToIndentStateDown() {
if tk := ctx.lastToken(); tk != nil {
// If literal/folded content is empty, no string token is added.
// Therefore, add an empty string token.
// But if literal/folded token column is 1, it is invalid at down state.
if tk.Position.Column == 1 {
return ErrInvalidToken(
token.Invalid(
"could not find multi-line content",
string(ctx.obuf), s.pos(),
),
)
}
if tk.Type != token.StringType {
ctx.addToken(token.String("", "", s.pos()))
}
}
s.breakMultiLine(ctx)
} else {
if err := s.scanMultiLine(ctx, c); err != nil {
return err
}
continue
}
}
switch c {
case '{':
if s.scanFlowMapStart(ctx) {
continue
}
case '}':
if s.scanFlowMapEnd(ctx) {
continue
}
case '.':
if s.scanDocumentEnd(ctx) {
continue
}
case '<':
if s.scanMergeKey(ctx) {
continue
}
case '-':
if s.scanDocumentStart(ctx) {
continue
}
if s.scanRawFoldedChar(ctx) {
continue
}
scanned, err := s.scanSequence(ctx)
if err != nil {
return err
}
if scanned {
continue
}
case '[':
if s.scanFlowArrayStart(ctx) {
continue
}
case ']':
if s.scanFlowArrayEnd(ctx) {
continue
}
case ',':
if s.scanFlowEntry(ctx, c) {
continue
}
case ':':
scanned, err := s.scanMapDelim(ctx)
if err != nil {
return err
}
if scanned {
continue
}
case '|', '>':
scanned, err := s.scanMultiLineHeader(ctx)
if err != nil {
return err
}
if scanned {
continue
}
case '!':
scanned, err := s.scanTag(ctx)
if err != nil {
return err
}
if scanned {
continue
}
case '%':
if s.scanDirective(ctx) {
continue
}
case '?':
if s.scanMapKey(ctx) {
continue
}
case '&':
if s.scanAnchor(ctx) {
continue
}
case '*':
if s.scanAlias(ctx) {
continue
}
case '#':
if s.scanComment(ctx) {
continue
}
case '\'', '"':
scanned, err := s.scanQuote(ctx, c)
if err != nil {
return err
}
if scanned {
continue
}
case '\r', '\n':
s.scanNewLine(ctx, c)
continue
case ' ':
if s.scanWhiteSpace(ctx) {
continue
}
case '@', '`':
if err := s.scanReservedChar(ctx, c); err != nil {
return err
}
case '\t':
if ctx.existsBuffer() && s.lastDelimColumn == 0 {
// tab indent for plain text (yaml-test-suite's spec-example-7-12-plain-lines).
s.indentNum++
ctx.addOriginBuf(c)
s.progressOnly(ctx, 1)
continue
}
if s.lastDelimColumn < s.column {
s.indentNum++
ctx.addOriginBuf(c)
s.progressOnly(ctx, 1)
continue
}
if err := s.scanTab(ctx, c); err != nil {
return err
}
}
ctx.addBuf(c)
ctx.addOriginBuf(c)
s.progressColumn(ctx, 1)
}
s.addBufferedTokenIfExists(ctx)
return nil
}
// Init prepares the scanner s to tokenize the text src by setting the scanner at the beginning of src.
func (s *Scanner) Init(text string) {
src := []rune(text)
s.source = src
s.sourcePos = 0
s.sourceSize = len(src)
s.line = 1
s.column = 1
s.offset = 1
s.isFirstCharAtLine = true
s.clearState()
}
func (s *Scanner) clearState() {
s.prevLineIndentNum = 0
s.lastDelimColumn = 0
s.indentLevel = 0
s.indentNum = 0
}
// Scan scans the next token and returns the token collection. The source end is indicated by io.EOF.
func (s *Scanner) Scan() (token.Tokens, error) {
if s.sourcePos >= s.sourceSize {
return nil, io.EOF
}
ctx := newContext(s.source[s.sourcePos:])
defer ctx.release()
var tokens token.Tokens
err := s.scan(ctx)
tokens = append(tokens, ctx.tokens...)
if err != nil {
var invalidTokenErr *InvalidTokenError
if errors.As(err, &invalidTokenErr) {
tokens = append(tokens, invalidTokenErr.Token)
}
return tokens, err
}
return tokens, nil
}
goccy-go-yaml-52dacb8/stdlib_quote.go 0000664 0000000 0000000 00000006304 15015766371 0017716 0 ustar 00root root 0000000 0000000 // Copied and trimmed down from https://github.com/golang/go/blob/e3769299cd3484e018e0e2a6e1b95c2b18ce4f41/src/strconv/quote.go
// We want to use the standard library's private "quoteWith" function rather than write our own so that we get robust unicode support.
// Every private function called by quoteWith was copied.
// There are 2 modifications to simplify the code:
// 1. The unicode.IsPrint function was substituted for the custom implementation of IsPrint
// 2. All code paths reachable only when ASCIIonly or grphicOnly are set to true were removed.
// Copyright 2009 The Go 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 yaml
import (
"unicode"
"unicode/utf8"
)
const (
lowerhex = "0123456789abcdef"
)
func quoteWith(s string, quote byte) string {
return string(appendQuotedWith(make([]byte, 0, 3*len(s)/2), s, quote))
}
func appendQuotedWith(buf []byte, s string, quote byte) []byte {
// Often called with big strings, so preallocate. If there's quoting,
// this is conservative but still helps a lot.
if cap(buf)-len(buf) < len(s) {
nBuf := make([]byte, len(buf), len(buf)+1+len(s)+1)
copy(nBuf, buf)
buf = nBuf
}
buf = append(buf, quote)
for width := 0; len(s) > 0; s = s[width:] {
r := rune(s[0])
width = 1
if r >= utf8.RuneSelf {
r, width = utf8.DecodeRuneInString(s)
}
if width == 1 && r == utf8.RuneError {
buf = append(buf, `\x`...)
buf = append(buf, lowerhex[s[0]>>4])
buf = append(buf, lowerhex[s[0]&0xF])
continue
}
buf = appendEscapedRune(buf, r, quote)
}
buf = append(buf, quote)
return buf
}
func appendEscapedRune(buf []byte, r rune, quote byte) []byte {
var runeTmp [utf8.UTFMax]byte
// goccy/go-yaml patch on top of the standard library's appendEscapedRune function.
//
// We use this to implement the YAML single-quoted string, where the only escape sequence is '', which represents a single quote.
// The below snippet from the standard library is for escaping e.g. \ with \\, which is not what we want for the single-quoted string.
//
// if r == rune(quote) || r == '\\' { // always backslashed
// buf = append(buf, '\\')
// buf = append(buf, byte(r))
// return buf
// }
if r == rune(quote) {
buf = append(buf, byte(r))
buf = append(buf, byte(r))
return buf
}
if unicode.IsPrint(r) {
n := utf8.EncodeRune(runeTmp[:], r)
buf = append(buf, runeTmp[:n]...)
return buf
}
switch r {
case '\a':
buf = append(buf, `\a`...)
case '\b':
buf = append(buf, `\b`...)
case '\f':
buf = append(buf, `\f`...)
case '\n':
buf = append(buf, `\n`...)
case '\r':
buf = append(buf, `\r`...)
case '\t':
buf = append(buf, `\t`...)
case '\v':
buf = append(buf, `\v`...)
default:
switch {
case r < ' ':
buf = append(buf, `\x`...)
buf = append(buf, lowerhex[byte(r)>>4])
buf = append(buf, lowerhex[byte(r)&0xF])
case r > utf8.MaxRune:
r = 0xFFFD
fallthrough
case r < 0x10000:
buf = append(buf, `\u`...)
for s := 12; s >= 0; s -= 4 {
buf = append(buf, lowerhex[r>>uint(s)&0xF])
}
default:
buf = append(buf, `\U`...)
for s := 28; s >= 0; s -= 4 {
buf = append(buf, lowerhex[r>>uint(s)&0xF])
}
}
}
return buf
}
goccy-go-yaml-52dacb8/struct.go 0000664 0000000 0000000 00000005336 15015766371 0016550 0 ustar 00root root 0000000 0000000 package yaml
import (
"fmt"
"reflect"
"strings"
)
const (
// StructTagName tag keyword for Marshal/Unmarshal
StructTagName = "yaml"
)
// StructField information for each the field in structure
type StructField struct {
FieldName string
RenderName string
AnchorName string
AliasName string
IsAutoAnchor bool
IsAutoAlias bool
IsOmitEmpty bool
IsOmitZero bool
IsFlow bool
IsInline bool
}
func getTag(field reflect.StructField) string {
// If struct tag `yaml` exist, use that. If no `yaml`
// exists, but `json` does, use that and try the best to
// adhere to its rules
tag := field.Tag.Get(StructTagName)
if tag == "" {
tag = field.Tag.Get(`json`)
}
return tag
}
func structField(field reflect.StructField) *StructField {
tag := getTag(field)
fieldName := strings.ToLower(field.Name)
options := strings.Split(tag, ",")
if len(options) > 0 {
if options[0] != "" {
fieldName = options[0]
}
}
sf := &StructField{
FieldName: field.Name,
RenderName: fieldName,
}
if len(options) > 1 {
for _, opt := range options[1:] {
switch {
case opt == "omitempty":
sf.IsOmitEmpty = true
case opt == "omitzero":
sf.IsOmitZero = true
case opt == "flow":
sf.IsFlow = true
case opt == "inline":
sf.IsInline = true
case strings.HasPrefix(opt, "anchor"):
anchor := strings.Split(opt, "=")
if len(anchor) > 1 {
sf.AnchorName = anchor[1]
} else {
sf.IsAutoAnchor = true
}
case strings.HasPrefix(opt, "alias"):
alias := strings.Split(opt, "=")
if len(alias) > 1 {
sf.AliasName = alias[1]
} else {
sf.IsAutoAlias = true
}
default:
}
}
}
return sf
}
func isIgnoredStructField(field reflect.StructField) bool {
if field.PkgPath != "" && !field.Anonymous {
// private field
return true
}
return getTag(field) == "-"
}
type StructFieldMap map[string]*StructField
func (m StructFieldMap) isIncludedRenderName(name string) bool {
for _, v := range m {
if !v.IsInline && v.RenderName == name {
return true
}
}
return false
}
func (m StructFieldMap) hasMergeProperty() bool {
for _, v := range m {
if v.IsOmitEmpty && v.IsInline && v.IsAutoAlias {
return true
}
}
return false
}
func structFieldMap(structType reflect.Type) (StructFieldMap, error) {
fieldMap := StructFieldMap{}
renderNameMap := map[string]struct{}{}
for i := 0; i < structType.NumField(); i++ {
field := structType.Field(i)
if isIgnoredStructField(field) {
continue
}
sf := structField(field)
if _, exists := renderNameMap[sf.RenderName]; exists {
return nil, fmt.Errorf("duplicated struct field name %s", sf.RenderName)
}
fieldMap[sf.FieldName] = sf
renderNameMap[sf.RenderName] = struct{}{}
}
return fieldMap, nil
}
goccy-go-yaml-52dacb8/testdata/ 0000775 0000000 0000000 00000000000 15015766371 0016477 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/anchor.yml 0000664 0000000 0000000 00000000030 15015766371 0020465 0 ustar 00root root 0000000 0000000 a: &a
b: 1
c: hello
goccy-go-yaml-52dacb8/testdata/go_test.mod 0000664 0000000 0000000 00000001021 15015766371 0020636 0 ustar 00root root 0000000 0000000 module github.com/goccy/go-yaml
go 1.21.0
require (
github.com/go-playground/validator/v10 v10.22.1
github.com/google/go-cmp v0.6.0
)
require (
github.com/gabriel-vasile/mimetype v1.4.3 // indirect
github.com/go-playground/locales v0.14.1 // indirect
github.com/go-playground/universal-translator v0.18.1 // indirect
github.com/leodido/go-urn v1.4.0 // indirect
golang.org/x/crypto v0.28.0 // indirect
golang.org/x/net v0.30.0 // indirect
golang.org/x/sys v0.26.0 // indirect
golang.org/x/text v0.19.0 // indirect
)
goccy-go-yaml-52dacb8/testdata/go_test.sum 0000664 0000000 0000000 00000005045 15015766371 0020675 0 ustar 00root root 0000000 0000000 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/gabriel-vasile/mimetype v1.4.3 h1:in2uUcidCuFcDKtdcBxlR0rJ1+fsokWf+uqxgUFjbI0=
github.com/gabriel-vasile/mimetype v1.4.3/go.mod h1:d8uq/6HKRL6CGdk+aubisF/M5GcPfT7nKyLpA0lbSSk=
github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s=
github.com/go-playground/assert/v2 v2.2.0/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA=
github.com/go-playground/locales v0.14.1/go.mod h1:hxrqLVvrK65+Rwrd5Fc6F2O76J/NuW9t0sjnWqG1slY=
github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJnYK9S473LQFuzCbDbfSFY=
github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY=
github.com/go-playground/validator/v10 v10.22.1 h1:40JcKH+bBNGFczGuoBYgX4I6m/i27HYW8P9FDk5PbgA=
github.com/go-playground/validator/v10 v10.22.1/go.mod h1:dbuPbCMFw/DrkbEynArYaCwl3amGuJotoKCe95atGMM=
github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
github.com/leodido/go-urn v1.4.0 h1:WT9HwE9SGECu3lg4d/dIA+jxlljEa1/ffXKmRjqdmIQ=
github.com/leodido/go-urn v1.4.0/go.mod h1:bvxc+MVxLKB4z00jd1z+Dvzr47oO32F/QSNjSBOlFxI=
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
golang.org/x/crypto v0.28.0 h1:GBDwsMXVQi34v5CCYUm2jkJvu4cbtru2U4TN2PSyQnw=
golang.org/x/crypto v0.28.0/go.mod h1:rmgy+3RHxRZMyY0jjAJShp2zgEdOqj2AO7U0pYmeQ7U=
golang.org/x/net v0.30.0 h1:AcW1SDZMkb8IpzCdQUaIq2sP4sZ4zw+55h6ynffypl4=
golang.org/x/net v0.30.0/go.mod h1:2wGyMJ5iFasEhkwi13ChkO/t1ECNC4X4eBKkVFyYFlU=
golang.org/x/sys v0.26.0 h1:KHjCJyddX0LoSTb3J+vWpupP9p0oznkqVk/IfjymZbo=
golang.org/x/sys v0.26.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
golang.org/x/text v0.19.0 h1:kTxAhCbGbxhK0IwgSKiMO5awPoDQ0RpfiVYBfK860YM=
golang.org/x/text v0.19.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY=
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
goccy-go-yaml-52dacb8/testdata/validate_test.go 0000664 0000000 0000000 00000012411 15015766371 0021655 0 ustar 00root root 0000000 0000000 package yaml_test
import (
"strings"
"testing"
"github.com/go-playground/validator/v10"
"github.com/goccy/go-yaml"
)
func TestStructValidator(t *testing.T) {
type Inner struct {
Required string `validate:"required"`
Lt10 int `validate:"lt=10"`
}
cases := []struct {
TestName string
YAMLContent string
ExpectedErr string
Instance interface{}
}{
{
TestName: "Test Simple Validation",
YAMLContent: `---
- name: john
age: 20
- name: tom
age: -1
- name: ken
age: 10`,
ExpectedErr: `[5:8] Key: 'Age' Error:Field validation for 'Age' failed on the 'gte' tag
2 | - name: john
3 | age: 20
4 | - name: tom
> 5 | age: -1
^
6 | - name: ken
7 | age: 10`,
Instance: &[]struct {
Name string `yaml:"name" validate:"required"`
Age int `yaml:"age" validate:"gte=0,lt=120"`
}{},
},
{
TestName: "Test Missing Required Field",
YAMLContent: `---
- name: john
age: 20
- age: 10`,
ExpectedErr: `[4:1] Key: 'Name' Error:Field validation for 'Name' failed on the 'required' tag
1 | ---
2 | - name: john
3 | age: 20
> 4 | - age: 10
^
`,
Instance: &[]struct {
Name string `yaml:"name" validate:"required"`
Age int `yaml:"age" validate:"gte=0,lt=120"`
}{},
},
{
TestName: "Test Nested Validation Missing Internal Required",
YAMLContent: `---
name: john
age: 10
addr:
number: seven`,
ExpectedErr: `[4:5] Key: 'State' Error:Field validation for 'State' failed on the 'required' tag
1 | ---
2 | name: john
3 | age: 10
> 4 | addr:
^
5 | number: seven`,
Instance: &struct {
Name string `yaml:"name" validate:"required"`
Age int `yaml:"age" validate:"gte=0,lt=120"`
Addr struct {
Number string `yaml:"number" validate:"required"`
State string `yaml:"state" validate:"required"`
} `yaml:"addr"`
}{},
},
{
TestName: "Test nested Validation with unknown field",
YAMLContent: `---
name: john
age: 20
addr:
number: seven
state: washington
error: error
`,
ExpectedErr: `[7:3] unknown field "error"
4 | addr:
5 | number: seven
6 | state: washington
> 7 | error: error
^
`,
Instance: &struct {
Name string `yaml:"name" validate:"required"`
Age int `yaml:"age" validate:"gte=0,lt=120"`
Addr *struct {
Number string `yaml:"number" validate:"required"`
State string `yaml:"state" validate:"required"`
} `yaml:"addr" validate:"required"`
}{},
},
{
TestName: "Test Validation with wrong field type",
YAMLContent: `---
name: myDocument
roles:
name: myRole
permissions:
- hello
- how
- are
- you
`,
ExpectedErr: `[4:7] mapping was used where sequence is expected
1 | ---
2 | name: myDocument
3 | roles:
> 4 | name: myRole
^
5 | permissions:
6 | - hello
7 | - how
8 | `,
Instance: &struct {
Name string `yaml:"name"`
Roles []struct {
Name string `yaml:"name"`
Permissions []string `yaml:"permissions"`
} `yaml:"roles"`
}{},
},
{
TestName: "Test inline validation missing required",
YAMLContent: `---
name: john
age: 20
`,
ExpectedErr: `Key: 'Inner.Required' Error:Field validation for 'Required' failed on the 'required' tag`,
Instance: &struct {
Name string `yaml:"name" validate:"required"`
Age int `yaml:"age" validate:"gte=0,lt=120"`
Inner `yaml:",inline"`
}{},
},
{
TestName: "Test inline validation field error",
YAMLContent: `---
name: john
age: 20
required: present
lt10: 20
`,
ExpectedErr: `[5:7] Key: 'Inner.Lt10' Error:Field validation for 'Lt10' failed on the 'lt' tag
2 | name: john
3 | age: 20
4 | required: present
> 5 | lt10: 20
^
`,
Instance: &struct {
Name string `yaml:"name" validate:"required"`
Age int `yaml:"age" validate:"gte=0,lt=120"`
Inner `yaml:",inline"`
}{},
},
{
TestName: "Test map",
YAMLContent: `
map:
hello: hello
hello2: hello`,
ExpectedErr: `[2:4] Key: 'Map' Error:Field validation for 'Map' failed on the 'eq' tag
> 2 | map:
^
3 | hello: hello
4 | hello2: hello`,
Instance: &struct {
// Make sure that this map is not set
Map map[string]string `yaml:"map" validate:"eq=0"`
}{},
},
{
TestName: "Test sequence",
YAMLContent: `
map:
- value
`,
ExpectedErr: `[2:4] Key: 'Map' Error:Field validation for 'Map' failed on the 'eq' tag
> 2 | map:
^
3 | - value`,
Instance: &struct {
// Make sure that this map is not set
Map []string `yaml:"map" validate:"eq=0"`
}{},
},
}
for _, tc := range cases {
tc := tc // NOTE: https://github.com/golang/go/wiki/CommonMistakes#using-goroutines-on-loop-iterator-variables
t.Run(tc.TestName, func(t *testing.T) {
validate := validator.New()
dec := yaml.NewDecoder(
strings.NewReader(tc.YAMLContent),
yaml.Validator(validate),
yaml.Strict(),
)
err := dec.Decode(tc.Instance)
switch {
case tc.ExpectedErr != "" && err == nil:
t.Fatal("expected error")
case tc.ExpectedErr == "" && err != nil:
t.Fatalf("unexpected error: %v", err)
case tc.ExpectedErr != "" && tc.ExpectedErr != err.Error():
t.Fatalf("expected `%s` but actual `%s`", tc.ExpectedErr, err.Error())
}
})
}
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/ 0000775 0000000 0000000 00000000000 15015766371 0021545 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/aliases-in-block-sequence/ 0000775 0000000 0000000 00000000000 15015766371 0026470 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/aliases-in-block-sequence/in.json 0000664 0000000 0000000 00000000037 15015766371 0027771 0 ustar 00root root 0000000 0000000 [
"a",
"b",
"a",
"b"
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/aliases-in-block-sequence/in.yaml 0000664 0000000 0000000 00000000030 15015766371 0027753 0 ustar 00root root 0000000 0000000 - &a a
- &b b
- *a
- *b
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/aliases-in-explicit-block-mapping/ 0000775 0000000 0000000 00000000000 15015766371 0030132 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/aliases-in-explicit-block-mapping/in.yaml 0000664 0000000 0000000 00000000023 15015766371 0031417 0 ustar 00root root 0000000 0000000 ? &a a
: &b b
: *a
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/aliases-in-explicit-block-mapping/out.yaml 0000664 0000000 0000000 00000000020 15015766371 0031615 0 ustar 00root root 0000000 0000000 &a a: &b b
: *a
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/aliases-in-flow-objects/ 0000775 0000000 0000000 00000000000 15015766371 0026166 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/aliases-in-flow-objects/in.yaml 0000664 0000000 0000000 00000000045 15015766371 0027457 0 ustar 00root root 0000000 0000000 { &a [a, &b b]: *b, *a : [c, *b, d]}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/aliases-in-flow-objects/out.yaml 0000664 0000000 0000000 00000000047 15015766371 0027662 0 ustar 00root root 0000000 0000000 ? &a
- a
- &b b
: *b
*a :
- c
- *b
- d
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/aliases-in-implicit-block-mapping/ 0000775 0000000 0000000 00000000000 15015766371 0030123 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/aliases-in-implicit-block-mapping/in.json 0000664 0000000 0000000 00000000033 15015766371 0031420 0 ustar 00root root 0000000 0000000 {
"a": "b",
"b": "a"
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/aliases-in-implicit-block-mapping/in.yaml 0000664 0000000 0000000 00000000023 15015766371 0031410 0 ustar 00root root 0000000 0000000 &a a: &b b
*b : *a
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/aliases-in-implicit-block-mapping/out.yaml 0000664 0000000 0000000 00000000023 15015766371 0031611 0 ustar 00root root 0000000 0000000 &a a: &b b
*b : *a
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/allowed-characters-in-alias/ 0000775 0000000 0000000 00000000000 15015766371 0027004 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/allowed-characters-in-alias/in.json 0000664 0000000 0000000 00000000051 15015766371 0030301 0 ustar 00root root 0000000 0000000 {
"a": "scalar a",
"b": "scalar a"
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/allowed-characters-in-alias/in.yaml 0000664 0000000 0000000 00000000053 15015766371 0030274 0 ustar 00root root 0000000 0000000 a: &:@*!$": scalar a
b: *:@*!$":
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/allowed-characters-in-keys/ 0000775 0000000 0000000 00000000000 15015766371 0026666 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/allowed-characters-in-keys/in.json 0000664 0000000 0000000 00000000247 15015766371 0030172 0 ustar 00root root 0000000 0000000 {
"a!\"#$%&'()*+,-./09:;<=>?@AZ[\\]^_`az{|}~": "safe",
"?foo": "safe question mark",
":foo": "safe colon",
"-foo": "safe dash",
"this is#not": "a comment"
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/allowed-characters-in-keys/in.yaml 0000664 0000000 0000000 00000000177 15015766371 0030165 0 ustar 00root root 0000000 0000000 a!"#$%&'()*+,-./09:;<=>?@AZ[\]^_`az{|}~: safe
?foo: safe question mark
:foo: safe colon
-foo: safe dash
this is#not: a comment
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/allowed-characters-in-keys/out.yaml 0000664 0000000 0000000 00000000177 15015766371 0030366 0 ustar 00root root 0000000 0000000 a!"#$%&'()*+,-./09:;<=>?@AZ[\]^_`az{|}~: safe
?foo: safe question mark
:foo: safe colon
-foo: safe dash
this is#not: a comment
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/allowed-characters-in-plain-scalars/ 0000775 0000000 0000000 00000000000 15015766371 0030444 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/allowed-characters-in-plain-scalars/in.json 0000664 0000000 0000000 00000000262 15015766371 0031745 0 ustar 00root root 0000000 0000000 {
"safe": "a!\"#$%&'()*+,-./09:;<=>?@AZ[\\]^_`az{|}~ !\"#$%&'()*+,-./09:;<=>?@AZ[\\]^_`az{|}~",
"safe question mark": "?foo",
"safe colon": ":foo",
"safe dash": "-foo"
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/allowed-characters-in-plain-scalars/in.yaml 0000664 0000000 0000000 00000000224 15015766371 0031734 0 ustar 00root root 0000000 0000000 safe: a!"#$%&'()*+,-./09:;<=>?@AZ[\]^_`az{|}~
!"#$%&'()*+,-./09:;<=>?@AZ[\]^_`az{|}~
safe question mark: ?foo
safe colon: :foo
safe dash: -foo
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/allowed-characters-in-plain-scalars/out.yaml 0000664 0000000 0000000 00000000217 15015766371 0032137 0 ustar 00root root 0000000 0000000 safe: a!"#$%&'()*+,-./09:;<=>?@AZ[\]^_`az{|}~ !"#$%&'()*+,-./09:;<=>?@AZ[\]^_`az{|}~
safe question mark: ?foo
safe colon: :foo
safe dash: -foo
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/allowed-characters-in-quoted-mapping-key/ 0000775 0000000 0000000 00000000000 15015766371 0031433 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/allowed-characters-in-quoted-mapping-key/in.json 0000664 0000000 0000000 00000000105 15015766371 0032730 0 ustar 00root root 0000000 0000000 {
"foo\nbar:baz\tx \\$%^&*()x": 23,
"x\\ny:z\\tx $%^&*()x": 24
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/allowed-characters-in-quoted-mapping-key/in.yaml 0000664 0000000 0000000 00000000072 15015766371 0032724 0 ustar 00root root 0000000 0000000 "foo\nbar:baz\tx \\$%^&*()x": 23
'x\ny:z\tx $%^&*()x': 24
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/allowed-characters-in-quoted-mapping-key/out.yaml 0000664 0000000 0000000 00000000075 15015766371 0033130 0 ustar 00root root 0000000 0000000 ? "foo\nbar:baz\tx \\$%^&*()x"
: 23
'x\ny:z\tx $%^&*()x': 24
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/anchor-and-alias-as-mapping-key/ 0000775 0000000 0000000 00000000000 15015766371 0027466 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/anchor-and-alias-as-mapping-key/error 0000664 0000000 0000000 00000000000 15015766371 0030530 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/anchor-and-alias-as-mapping-key/in.yaml 0000664 0000000 0000000 00000000047 15015766371 0030761 0 ustar 00root root 0000000 0000000 key1: &alias value1
&b *alias : value2
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/anchor-before-sequence-entry-on-same-line/ 0000775 0000000 0000000 00000000000 15015766371 0031506 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/anchor-before-sequence-entry-on-same-line/error 0000664 0000000 0000000 00000000000 15015766371 0032550 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/anchor-before-sequence-entry-on-same-line/in.yaml 0000664 0000000 0000000 00000000031 15015766371 0032772 0 ustar 00root root 0000000 0000000 &anchor - sequence entry
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/anchor-before-zero-indented-sequence/ 0000775 0000000 0000000 00000000000 15015766371 0030632 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/anchor-before-zero-indented-sequence/in.json 0000664 0000000 0000000 00000000044 15015766371 0032131 0 ustar 00root root 0000000 0000000 {
"seq": [
"a",
"b"
]
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/anchor-before-zero-indented-sequence/in.yaml 0000664 0000000 0000000 00000000032 15015766371 0032117 0 ustar 00root root 0000000 0000000 ---
seq:
&anchor
- a
- b
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/anchor-before-zero-indented-sequence/out.yaml 0000664 0000000 0000000 00000000031 15015766371 0032317 0 ustar 00root root 0000000 0000000 ---
seq: &anchor
- a
- b
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/anchor-for-empty-node/ 0000775 0000000 0000000 00000000000 15015766371 0025662 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/anchor-for-empty-node/in.json 0000664 0000000 0000000 00000000035 15015766371 0027161 0 ustar 00root root 0000000 0000000 {
"a": null,
"b": null
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/anchor-for-empty-node/in.yaml 0000664 0000000 0000000 00000000032 15015766371 0027147 0 ustar 00root root 0000000 0000000 ---
a: &anchor
b: *anchor
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/anchor-for-empty-node/out.yaml 0000664 0000000 0000000 00000000032 15015766371 0027350 0 ustar 00root root 0000000 0000000 ---
a: &anchor
b: *anchor
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/anchor-plus-alias/ 0000775 0000000 0000000 00000000000 15015766371 0025067 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/anchor-plus-alias/error 0000664 0000000 0000000 00000000000 15015766371 0026131 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/anchor-plus-alias/in.yaml 0000664 0000000 0000000 00000000033 15015766371 0026355 0 ustar 00root root 0000000 0000000 key1: &a value
key2: &b *a
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/anchor-with-colon-in-the-middle/ 0000775 0000000 0000000 00000000000 15015766371 0027516 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/anchor-with-colon-in-the-middle/in.json 0000664 0000000 0000000 00000000025 15015766371 0031014 0 ustar 00root root 0000000 0000000 {
"key": "value"
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/anchor-with-colon-in-the-middle/in.yaml 0000664 0000000 0000000 00000000030 15015766371 0031001 0 ustar 00root root 0000000 0000000 ---
key: &an:chor value
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/anchor-with-colon-in-the-middle/out.yaml 0000664 0000000 0000000 00000000030 15015766371 0031202 0 ustar 00root root 0000000 0000000 ---
key: &an:chor value
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/anchor-with-unicode-character/ 0000775 0000000 0000000 00000000000 15015766371 0027346 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/anchor-with-unicode-character/in.json 0000664 0000000 0000000 00000000027 15015766371 0030646 0 ustar 00root root 0000000 0000000 [
"unicode anchor"
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/anchor-with-unicode-character/in.yaml 0000664 0000000 0000000 00000000033 15015766371 0030634 0 ustar 00root root 0000000 0000000 ---
- &😁 unicode anchor
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/anchor-with-unicode-character/out.yaml 0000664 0000000 0000000 00000000033 15015766371 0031035 0 ustar 00root root 0000000 0000000 ---
- &😁 unicode anchor
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/anchors-and-tags/ 0000775 0000000 0000000 00000000000 15015766371 0024676 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/anchors-and-tags/in.json 0000664 0000000 0000000 00000000033 15015766371 0026173 0 ustar 00root root 0000000 0000000 [
"a",
2,
4,
"d"
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/anchors-and-tags/in.yaml 0000664 0000000 0000000 00000000057 15015766371 0026172 0 ustar 00root root 0000000 0000000 - &a !!str a
- !!int 2
- !!int &c 4
- &d d
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/anchors-and-tags/out.yaml 0000664 0000000 0000000 00000000053 15015766371 0026367 0 ustar 00root root 0000000 0000000 - &a !!str a
- !!int 2
- &c !!int 4
- &d d
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/anchors-in-mapping/ 0000775 0000000 0000000 00000000000 15015766371 0025237 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/anchors-in-mapping/in.json 0000664 0000000 0000000 00000000033 15015766371 0026534 0 ustar 00root root 0000000 0000000 {
"a": "b",
"c": "d"
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/anchors-in-mapping/in.yaml 0000664 0000000 0000000 00000000020 15015766371 0026521 0 ustar 00root root 0000000 0000000 &a a: b
c: &d d
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/anchors-on-empty-scalars/ 0000775 0000000 0000000 00000000000 15015766371 0026376 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/anchors-on-empty-scalars/in.yaml 0000664 0000000 0000000 00000000101 15015766371 0027660 0 ustar 00root root 0000000 0000000 - &a
- a
-
&a : a
b: &b
-
&c : &a
-
? &d
-
? &e
: &a
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/anchors-on-empty-scalars/out.yaml 0000664 0000000 0000000 00000000065 15015766371 0030072 0 ustar 00root root 0000000 0000000 - &a
- a
- &a : a
b: &b
- &c : &a
- &d :
- &e : &a
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/anchors-with-colon-in-name/ 0000775 0000000 0000000 00000000000 15015766371 0026605 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/anchors-with-colon-in-name/in.json 0000664 0000000 0000000 00000000045 15015766371 0030105 0 ustar 00root root 0000000 0000000 {
"key": "value",
"foo": "key"
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/anchors-with-colon-in-name/in.yaml 0000664 0000000 0000000 00000000035 15015766371 0030075 0 ustar 00root root 0000000 0000000 &a: key: &a value
foo:
*a:
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/anchors-with-colon-in-name/out.yaml 0000664 0000000 0000000 00000000033 15015766371 0030274 0 ustar 00root root 0000000 0000000 &a: key: &a value
foo: *a:
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/backslashes-in-singlequotes/ 0000775 0000000 0000000 00000000000 15015766371 0027154 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/backslashes-in-singlequotes/in.json 0000664 0000000 0000000 00000000033 15015766371 0030451 0 ustar 00root root 0000000 0000000 {
"foo: bar\\": "baz'"
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/backslashes-in-singlequotes/in.yaml 0000664 0000000 0000000 00000000022 15015766371 0030440 0 ustar 00root root 0000000 0000000 'foo: bar\': baz'
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/backslashes-in-singlequotes/out.yaml 0000664 0000000 0000000 00000000022 15015766371 0030641 0 ustar 00root root 0000000 0000000 'foo: bar\': baz'
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/bad-indentation-in-mapping-2/ 0000775 0000000 0000000 00000000000 15015766371 0027001 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/bad-indentation-in-mapping-2/error 0000664 0000000 0000000 00000000000 15015766371 0030043 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/bad-indentation-in-mapping-2/in.yaml 0000664 0000000 0000000 00000000062 15015766371 0030271 0 ustar 00root root 0000000 0000000 map:
key1: "quoted1"
key2: "bad indentation"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/bad-indentation-in-mapping/ 0000775 0000000 0000000 00000000000 15015766371 0026642 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/bad-indentation-in-mapping/error 0000664 0000000 0000000 00000000000 15015766371 0027704 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/bad-indentation-in-mapping/in.yaml 0000664 0000000 0000000 00000000060 15015766371 0030130 0 ustar 00root root 0000000 0000000 map:
key1: "quoted1"
key2: "bad indentation"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/bare-document-after-document-end-marker/ 0000775 0000000 0000000 00000000000 15015766371 0031230 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/bare-document-after-document-end-marker/in.json 0000664 0000000 0000000 00000000037 15015766371 0032531 0 ustar 00root root 0000000 0000000 "scalar1"
{
"key": "value"
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/bare-document-after-document-end-marker/in.yaml 0000664 0000000 0000000 00000000033 15015766371 0032516 0 ustar 00root root 0000000 0000000 ---
scalar1
...
key: value
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/bare-document-after-document-end-marker/out.yaml 0000664 0000000 0000000 00000000033 15015766371 0032717 0 ustar 00root root 0000000 0000000 --- scalar1
...
key: value
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/blank-lines/ 0000775 0000000 0000000 00000000000 15015766371 0023744 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/blank-lines/in.json 0000664 0000000 0000000 00000000075 15015766371 0025247 0 ustar 00root root 0000000 0000000 {
"foo": 1,
"bar": 2,
"text": "a\n \nb\n\nc\n\nd\n"
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/blank-lines/in.yaml 0000664 0000000 0000000 00000000064 15015766371 0025236 0 ustar 00root root 0000000 0000000 foo: 1
bar: 2
text: |
a
b
c
d
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/blank-lines/out.yaml 0000664 0000000 0000000 00000000053 15015766371 0025435 0 ustar 00root root 0000000 0000000 foo: 1
bar: 2
text: "a\n \nb\n\nc\n\nd\n"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/block-mapping-with-missing-keys/ 0000775 0000000 0000000 00000000000 15015766371 0027661 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/block-mapping-with-missing-keys/in.yaml 0000664 0000000 0000000 00000000010 15015766371 0031142 0 ustar 00root root 0000000 0000000 : a
: b
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/block-mapping-with-missing-values/ 0000775 0000000 0000000 00000000000 15015766371 0030205 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/block-mapping-with-missing-values/in.json 0000664 0000000 0000000 00000000052 15015766371 0031503 0 ustar 00root root 0000000 0000000 {
"a": null,
"b": null,
"c": null
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/block-mapping-with-missing-values/in.yaml 0000664 0000000 0000000 00000000013 15015766371 0031471 0 ustar 00root root 0000000 0000000 ? a
? b
c:
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/block-mapping-with-missing-values/out.yaml 0000664 0000000 0000000 00000000011 15015766371 0031670 0 ustar 00root root 0000000 0000000 a:
b:
c:
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/block-mapping-with-multiline-scalars/ 0000775 0000000 0000000 00000000000 15015766371 0030667 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/block-mapping-with-multiline-scalars/in.json 0000664 0000000 0000000 00000000051 15015766371 0032164 0 ustar 00root root 0000000 0000000 {
"a true": "null d",
"e 42": null
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/block-mapping-with-multiline-scalars/in.yaml 0000664 0000000 0000000 00000000037 15015766371 0032161 0 ustar 00root root 0000000 0000000 ? a
true
: null
d
? e
42
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/block-mapping-with-multiline-scalars/out.yaml 0000664 0000000 0000000 00000000025 15015766371 0032357 0 ustar 00root root 0000000 0000000 a true: null d
e 42:
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/block-mappings-in-block-sequence/ 0000775 0000000 0000000 00000000000 15015766371 0027755 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/block-mappings-in-block-sequence/in.json 0000664 0000000 0000000 00000000123 15015766371 0031252 0 ustar 00root root 0000000 0000000 [
{
"key": "value",
"key2": "value2"
},
{
"key3": "value3"
}
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/block-mappings-in-block-sequence/in.yaml 0000664 0000000 0000000 00000000061 15015766371 0031244 0 ustar 00root root 0000000 0000000 - key: value
key2: value2
-
key3: value3
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/block-mappings-in-block-sequence/out.yaml 0000664 0000000 0000000 00000000053 15015766371 0031446 0 ustar 00root root 0000000 0000000 - key: value
key2: value2
- key3: value3
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/block-scalar-indicator-order/ 0000775 0000000 0000000 00000000000 15015766371 0027165 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/block-scalar-indicator-order/in.json 0000664 0000000 0000000 00000000101 15015766371 0030456 0 ustar 00root root 0000000 0000000 [
"explicit indent and chomp",
"chomp and explicit indent"
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/block-scalar-indicator-order/in.yaml 0000664 0000000 0000000 00000000104 15015766371 0030452 0 ustar 00root root 0000000 0000000 - |2-
explicit indent and chomp
- |-2
chomp and explicit indent
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/block-scalar-indicator-order/out.yaml 0000664 0000000 0000000 00000000102 15015766371 0030651 0 ustar 00root root 0000000 0000000 - |-
explicit indent and chomp
- |-
chomp and explicit indent
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/block-scalar-keep/ 0000775 0000000 0000000 00000000000 15015766371 0025024 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/block-scalar-keep/in.json 0000664 0000000 0000000 00000000014 15015766371 0026320 0 ustar 00root root 0000000 0000000 "ab\n\n \n"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/block-scalar-keep/in.yaml 0000664 0000000 0000000 00000000024 15015766371 0026312 0 ustar 00root root 0000000 0000000 --- |+
ab
...
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/block-scalar-keep/out.yaml 0000664 0000000 0000000 00000000020 15015766371 0026507 0 ustar 00root root 0000000 0000000 "ab\n\n \n"
...
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/block-scalar-strip-1-3/ 0000775 0000000 0000000 00000000000 15015766371 0025537 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/block-scalar-strip-1-3/in.json 0000664 0000000 0000000 00000000005 15015766371 0027033 0 ustar 00root root 0000000 0000000 "ab"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/block-scalar-strip-1-3/in.yaml 0000664 0000000 0000000 00000000023 15015766371 0027024 0 ustar 00root root 0000000 0000000 --- |-
ab
...
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/block-scalar-strip-1-3/out.yaml 0000664 0000000 0000000 00000000020 15015766371 0027222 0 ustar 00root root 0000000 0000000 --- |-
ab
...
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/block-scalar-strip/ 0000775 0000000 0000000 00000000000 15015766371 0025241 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/block-scalar-strip/in.json 0000664 0000000 0000000 00000000005 15015766371 0026535 0 ustar 00root root 0000000 0000000 "ab"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/block-scalar-strip/in.yaml 0000664 0000000 0000000 00000000017 15015766371 0026531 0 ustar 00root root 0000000 0000000 |-
ab
...
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/block-scalar-strip/out.yaml 0000664 0000000 0000000 00000000014 15015766371 0026727 0 ustar 00root root 0000000 0000000 |-
ab
...
block-scalar-with-more-spaces-than-first-content-line/ 0000775 0000000 0000000 00000000000 15015766371 0033662 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite error 0000664 0000000 0000000 00000000000 15015766371 0034724 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/block-scalar-with-more-spaces-than-first-content-line in.yaml 0000664 0000000 0000000 00000000052 15015766371 0035151 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/block-scalar-with-more-spaces-than-first-content-line empty block scalar: >
# comment
block-scalar-with-wrong-indented-line-after-spaces-only/ 0000775 0000000 0000000 00000000000 15015766371 0034175 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite error 0000664 0000000 0000000 00000000000 15015766371 0035237 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/block-scalar-with-wrong-indented-line-after-spaces-only in.yaml 0000664 0000000 0000000 00000000042 15015766371 0035463 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/block-scalar-with-wrong-indented-line-after-spaces-only block scalar: >
invalid
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/block-sequence-in-block-mapping/ 0000775 0000000 0000000 00000000000 15015766371 0027572 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/block-sequence-in-block-mapping/in.json 0000664 0000000 0000000 00000000054 15015766371 0031072 0 ustar 00root root 0000000 0000000 {
"key": [
"item1",
"item2"
]
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/block-sequence-in-block-mapping/in.yaml 0000664 0000000 0000000 00000000027 15015766371 0031063 0 ustar 00root root 0000000 0000000 key:
- item1
- item2
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/block-sequence-in-block-mapping/out.yaml 0000664 0000000 0000000 00000000025 15015766371 0031262 0 ustar 00root root 0000000 0000000 key:
- item1
- item2
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/block-sequence-in-block-sequence/ 0000775 0000000 0000000 00000000000 15015766371 0027747 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/block-sequence-in-block-sequence/in.json 0000664 0000000 0000000 00000000055 15015766371 0031250 0 ustar 00root root 0000000 0000000 [
[
"s1_i1",
"s1_i2"
],
"s2"
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/block-sequence-in-block-sequence/in.yaml 0000664 0000000 0000000 00000000031 15015766371 0031233 0 ustar 00root root 0000000 0000000 - - s1_i1
- s1_i2
- s2
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/block-sequence-indentation/ 0000775 0000000 0000000 00000000000 15015766371 0026757 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/block-sequence-indentation/in.json 0000664 0000000 0000000 00000000067 15015766371 0030263 0 ustar 00root root 0000000 0000000 [
"x\n",
{
"foo" : "bar"
},
[
42
]
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/block-sequence-indentation/in.yaml 0000664 0000000 0000000 00000000033 15015766371 0030245 0 ustar 00root root 0000000 0000000 - |
x
-
foo: bar
-
- 42
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/block-sequence-indentation/out.yaml 0000664 0000000 0000000 00000000032 15015766371 0030445 0 ustar 00root root 0000000 0000000 - |
x
- foo: bar
- - 42
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/block-submapping/ 0000775 0000000 0000000 00000000000 15015766371 0025002 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/block-submapping/in.json 0000664 0000000 0000000 00000000054 15015766371 0026302 0 ustar 00root root 0000000 0000000 {
"foo": {
"bar": 1
},
"baz": 2
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/block-submapping/in.yaml 0000664 0000000 0000000 00000000025 15015766371 0026271 0 ustar 00root root 0000000 0000000 foo:
bar: 1
baz: 2
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/colon-and-adjacent-value-after-comment-on-next-line/ 0000775 0000000 0000000 00000000000 15015766371 0033352 5 ustar 00root root 0000000 0000000 in.json 0000664 0000000 0000000 00000000023 15015766371 0034567 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/colon-and-adjacent-value-after-comment-on-next-line {
"foo": "bar"
}
in.yaml 0000664 0000000 0000000 00000000037 15015766371 0034565 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/colon-and-adjacent-value-after-comment-on-next-line ---
{ "foo" # comment
:bar }
out.yaml 0000664 0000000 0000000 00000000017 15015766371 0034764 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/colon-and-adjacent-value-after-comment-on-next-line ---
"foo": bar
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/colon-and-adjacent-value-on-next-line/ 0000775 0000000 0000000 00000000000 15015766371 0030613 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/colon-and-adjacent-value-on-next-line/in.json 0000664 0000000 0000000 00000000023 15015766371 0032107 0 ustar 00root root 0000000 0000000 {
"foo": "bar"
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/colon-and-adjacent-value-on-next-line/in.yaml 0000664 0000000 0000000 00000000025 15015766371 0032102 0 ustar 00root root 0000000 0000000 ---
{ "foo"
:bar }
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/colon-and-adjacent-value-on-next-line/out.yaml 0000664 0000000 0000000 00000000017 15015766371 0032304 0 ustar 00root root 0000000 0000000 ---
"foo": bar
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/colon-at-the-beginning-of-adjacent-flow-scalar/ 0000775 0000000 0000000 00000000000 15015766371 0032356 5 ustar 00root root 0000000 0000000 in.json 0000664 0000000 0000000 00000000074 15015766371 0033601 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/colon-at-the-beginning-of-adjacent-flow-scalar [
{
"key": "value"
},
{
"key": ":value"
}
]
in.yaml 0000664 0000000 0000000 00000000045 15015766371 0033570 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/colon-at-the-beginning-of-adjacent-flow-scalar - { "key":value }
- { "key"::value }
out.yaml 0000664 0000000 0000000 00000000033 15015766371 0033766 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/colon-at-the-beginning-of-adjacent-flow-scalar - key: value
- key: :value
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/colon-followed-by-comma/ 0000775 0000000 0000000 00000000000 15015766371 0026172 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/colon-followed-by-comma/in.json 0000664 0000000 0000000 00000000013 15015766371 0027465 0 ustar 00root root 0000000 0000000 [
":,"
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/colon-followed-by-comma/in.yaml 0000664 0000000 0000000 00000000011 15015766371 0027454 0 ustar 00root root 0000000 0000000 ---
- :,
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/colon-followed-by-comma/out.yaml 0000664 0000000 0000000 00000000011 15015766371 0027655 0 ustar 00root root 0000000 0000000 ---
- :,
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/colon-in-double-quoted-string/ 0000775 0000000 0000000 00000000000 15015766371 0027336 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/colon-in-double-quoted-string/in.json 0000664 0000000 0000000 00000000022 15015766371 0030631 0 ustar 00root root 0000000 0000000 "foo: bar\": baz"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/colon-in-double-quoted-string/in.yaml 0000664 0000000 0000000 00000000022 15015766371 0030622 0 ustar 00root root 0000000 0000000 "foo: bar\": baz"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/comment-and-document-end-marker/ 0000775 0000000 0000000 00000000000 15015766371 0027606 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/comment-and-document-end-marker/in.json 0000664 0000000 0000000 00000000000 15015766371 0031075 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/comment-and-document-end-marker/in.yaml 0000664 0000000 0000000 00000000016 15015766371 0031075 0 ustar 00root root 0000000 0000000 # comment
...
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/comment-and-document-end-marker/out.yaml 0000664 0000000 0000000 00000000000 15015766371 0031267 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/comment-between-plain-scalar-lines/ 0000775 0000000 0000000 00000000000 15015766371 0030312 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/comment-between-plain-scalar-lines/error 0000664 0000000 0000000 00000000000 15015766371 0031354 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/comment-between-plain-scalar-lines/in.yaml 0000664 0000000 0000000 00000000027 15015766371 0031603 0 ustar 00root root 0000000 0000000 word1 # comment
word2
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/comment-in-flow-sequence-before-comma/ 0000775 0000000 0000000 00000000000 15015766371 0030720 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/comment-in-flow-sequence-before-comma/in.json 0000664 0000000 0000000 00000000031 15015766371 0032213 0 ustar 00root root 0000000 0000000 [
"word1",
"word2"
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/comment-in-flow-sequence-before-comma/in.yaml 0000664 0000000 0000000 00000000037 15015766371 0032212 0 ustar 00root root 0000000 0000000 ---
[ word1
# comment
, word2]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/comment-in-flow-sequence-before-comma/out.yaml 0000664 0000000 0000000 00000000024 15015766371 0032407 0 ustar 00root root 0000000 0000000 ---
- word1
- word2
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/comment-in-plain-multiline-value/ 0000775 0000000 0000000 00000000000 15015766371 0030026 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/comment-in-plain-multiline-value/error 0000664 0000000 0000000 00000000000 15015766371 0031070 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/comment-in-plain-multiline-value/in.yaml 0000664 0000000 0000000 00000000032 15015766371 0031313 0 ustar 00root root 0000000 0000000 key: word1
# xxx
word2
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/comment-that-looks-like-a-mapping-key/ 0000775 0000000 0000000 00000000000 15015766371 0030651 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/comment-that-looks-like-a-mapping-key/error 0000664 0000000 0000000 00000000000 15015766371 0031713 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/comment-that-looks-like-a-mapping-key/in.yaml 0000664 0000000 0000000 00000000037 15015766371 0032143 0 ustar 00root root 0000000 0000000 key: value
this is #not a: key
comment-without-whitespace-after-block-scalar-indicator/ 0000775 0000000 0000000 00000000000 15015766371 0034367 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite error 0000664 0000000 0000000 00000000000 15015766371 0035431 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/comment-without-whitespace-after-block-scalar-indicator in.yaml 0000664 0000000 0000000 00000000033 15015766371 0035655 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/comment-without-whitespace-after-block-scalar-indicator block: ># comment
scalar
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/comment-without-whitespace-after-doublequoted-scalar/0000775 0000000 0000000 00000000000 15015766371 0034076 5 ustar 00root root 0000000 0000000 error 0000664 0000000 0000000 00000000000 15015766371 0035061 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/comment-without-whitespace-after-doublequoted-scalar in.yaml 0000664 0000000 0000000 00000000036 15015766371 0035310 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/comment-without-whitespace-after-doublequoted-scalar key: "value"# invalid comment
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/construct-binary/ 0000775 0000000 0000000 00000000000 15015766371 0025053 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/construct-binary/in.json 0000664 0000000 0000000 00000001162 15015766371 0026354 0 ustar 00root root 0000000 0000000 {
"canonical": "R0lGODlhDAAMAIQAAP//9/X17unp5WZmZgAAAOfn515eXvPz7Y6OjuDg4J+fn5OTk6enp56enmlpaWNjY6Ojo4SEhP/++f/++f/++f/++f/++f/++f/++f/++f/++f/++f/++f/++f/++f/++SH+Dk1hZGUgd2l0aCBHSU1QACwAAAAADAAMAAAFLCAgjoEwnuNAFOhpEMTRiggcz4BNJHrv/zCFcLiwMWYNG84BwwEeECcgggoBADs=",
"generic": "R0lGODlhDAAMAIQAAP//9/X17unp5WZmZgAAAOfn515eXvPz7Y6OjuDg4J+fn5\nOTk6enp56enmlpaWNjY6Ojo4SEhP/++f/++f/++f/++f/++f/++f/++f/++f/+\n+f/++f/++f/++f/++f/++SH+Dk1hZGUgd2l0aCBHSU1QACwAAAAADAAMAAAFLC\nAgjoEwnuNAFOhpEMTRiggcz4BNJHrv/zCFcLiwMWYNG84BwwEeECcgggoBADs=\n",
"description": "The binary value above is a tiny arrow encoded as a gif image."
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/construct-binary/in.yaml 0000664 0000000 0000000 00000001174 15015766371 0026350 0 ustar 00root root 0000000 0000000 canonical: !!binary "\
R0lGODlhDAAMAIQAAP//9/X17unp5WZmZgAAAOfn515eXvPz7Y6OjuDg4J+fn5\
OTk6enp56enmlpaWNjY6Ojo4SEhP/++f/++f/++f/++f/++f/++f/++f/++f/+\
+f/++f/++f/++f/++f/++SH+Dk1hZGUgd2l0aCBHSU1QACwAAAAADAAMAAAFLC\
AgjoEwnuNAFOhpEMTRiggcz4BNJHrv/zCFcLiwMWYNG84BwwEeECcgggoBADs="
generic: !!binary |
R0lGODlhDAAMAIQAAP//9/X17unp5WZmZgAAAOfn515eXvPz7Y6OjuDg4J+fn5
OTk6enp56enmlpaWNjY6Ojo4SEhP/++f/++f/++f/++f/++f/++f/++f/++f/+
+f/++f/++f/++f/++f/++SH+Dk1hZGUgd2l0aCBHSU1QACwAAAAADAAMAAAFLC
AgjoEwnuNAFOhpEMTRiggcz4BNJHrv/zCFcLiwMWYNG84BwwEeECcgggoBADs=
description:
The binary value above is a tiny arrow encoded as a gif image.
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/dash-in-flow-sequence/ 0000775 0000000 0000000 00000000000 15015766371 0025643 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/dash-in-flow-sequence/error 0000664 0000000 0000000 00000000000 15015766371 0026705 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/dash-in-flow-sequence/in.yaml 0000664 0000000 0000000 00000000004 15015766371 0027127 0 ustar 00root root 0000000 0000000 [-]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/directive-by-itself-with-no-document/ 0000775 0000000 0000000 00000000000 15015766371 0030616 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/directive-by-itself-with-no-document/error 0000664 0000000 0000000 00000000000 15015766371 0031660 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/directive-by-itself-with-no-document/in.yaml 0000664 0000000 0000000 00000000012 15015766371 0032101 0 ustar 00root root 0000000 0000000 %YAML 1.2
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/directive-variants/ 0000775 0000000 0000000 00000000000 15015766371 0025350 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/directive-variants/00/ 0000775 0000000 0000000 00000000000 15015766371 0025567 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/directive-variants/00/error 0000664 0000000 0000000 00000000000 15015766371 0026631 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/directive-variants/00/in.yaml 0000664 0000000 0000000 00000000022 15015766371 0027053 0 ustar 00root root 0000000 0000000 %YAML 1.1#...
---
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/directive-variants/01/ 0000775 0000000 0000000 00000000000 15015766371 0025570 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/directive-variants/01/error 0000664 0000000 0000000 00000000000 15015766371 0026632 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/directive-variants/01/in.yaml 0000664 0000000 0000000 00000000034 15015766371 0027057 0 ustar 00root root 0000000 0000000 %YAML 1.2
---
%YAML 1.2
---
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/directive-variants/02/ 0000775 0000000 0000000 00000000000 15015766371 0025571 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/directive-variants/02/in.json 0000664 0000000 0000000 00000000005 15015766371 0027065 0 ustar 00root root 0000000 0000000 null
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/directive-variants/02/in.yaml 0000664 0000000 0000000 00000000017 15015766371 0027061 0 ustar 00root root 0000000 0000000 %YAML 1.1
---
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/directive-variants/02/out.yaml 0000664 0000000 0000000 00000000004 15015766371 0027256 0 ustar 00root root 0000000 0000000 ---
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/directive-variants/03/ 0000775 0000000 0000000 00000000000 15015766371 0025572 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/directive-variants/03/in.json 0000664 0000000 0000000 00000000005 15015766371 0027066 0 ustar 00root root 0000000 0000000 null
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/directive-variants/03/in.yaml 0000664 0000000 0000000 00000000020 15015766371 0027054 0 ustar 00root root 0000000 0000000 %YAML 1.1
---
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/directive-variants/03/out.yaml 0000664 0000000 0000000 00000000004 15015766371 0027257 0 ustar 00root root 0000000 0000000 ---
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/directive-variants/04/ 0000775 0000000 0000000 00000000000 15015766371 0025573 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/directive-variants/04/in.json 0000664 0000000 0000000 00000000005 15015766371 0027067 0 ustar 00root root 0000000 0000000 null
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/directive-variants/04/in.yaml 0000664 0000000 0000000 00000000031 15015766371 0027057 0 ustar 00root root 0000000 0000000 %YAML 1.1 # comment
---
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/directive-variants/04/out.yaml 0000664 0000000 0000000 00000000004 15015766371 0027260 0 ustar 00root root 0000000 0000000 ---
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/directive-variants/05/ 0000775 0000000 0000000 00000000000 15015766371 0025574 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/directive-variants/05/in.json 0000664 0000000 0000000 00000000005 15015766371 0027070 0 ustar 00root root 0000000 0000000 null
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/directive-variants/05/in.yaml 0000664 0000000 0000000 00000000015 15015766371 0027062 0 ustar 00root root 0000000 0000000 %YAM 1.1
---
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/directive-variants/05/out.yaml 0000664 0000000 0000000 00000000004 15015766371 0027261 0 ustar 00root root 0000000 0000000 ---
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/directive-variants/06/ 0000775 0000000 0000000 00000000000 15015766371 0025575 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/directive-variants/06/in.json 0000664 0000000 0000000 00000000005 15015766371 0027071 0 ustar 00root root 0000000 0000000 null
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/directive-variants/06/in.yaml 0000664 0000000 0000000 00000000017 15015766371 0027065 0 ustar 00root root 0000000 0000000 %YAMLL 1.1
---
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/directive-variants/06/out.yaml 0000664 0000000 0000000 00000000004 15015766371 0027262 0 ustar 00root root 0000000 0000000 ---
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/directive-without-document/ 0000775 0000000 0000000 00000000000 15015766371 0027040 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/directive-without-document/error 0000664 0000000 0000000 00000000000 15015766371 0030102 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/directive-without-document/in.yaml 0000664 0000000 0000000 00000000016 15015766371 0030327 0 ustar 00root root 0000000 0000000 %YAML 1.2
...
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/document-end-marker/ 0000775 0000000 0000000 00000000000 15015766371 0025406 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/document-end-marker/in.json 0000664 0000000 0000000 00000000000 15015766371 0026675 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/document-end-marker/in.yaml 0000664 0000000 0000000 00000000004 15015766371 0026672 0 ustar 00root root 0000000 0000000 ...
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/document-end-marker/out.yaml 0000664 0000000 0000000 00000000000 15015766371 0027067 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/document-start-on-last-line/ 0000775 0000000 0000000 00000000000 15015766371 0027016 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/document-start-on-last-line/in.json 0000664 0000000 0000000 00000000024 15015766371 0030313 0 ustar 00root root 0000000 0000000 {
"a": "b"
}
null
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/document-start-on-last-line/in.yaml 0000664 0000000 0000000 00000000015 15015766371 0030304 0 ustar 00root root 0000000 0000000 ---
a: b
---
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/document-start-on-last-line/out.yaml 0000664 0000000 0000000 00000000021 15015766371 0030502 0 ustar 00root root 0000000 0000000 ---
a: b
---
...
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/document-with-footer/ 0000775 0000000 0000000 00000000000 15015766371 0025630 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/document-with-footer/in.json 0000664 0000000 0000000 00000000023 15015766371 0027124 0 ustar 00root root 0000000 0000000 {
"aaa": "bbb"
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/document-with-footer/in.yaml 0000664 0000000 0000000 00000000015 15015766371 0027116 0 ustar 00root root 0000000 0000000 aaa: bbb
...
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/double-quoted-scalar-with-escaped-single-quote/ 0000775 0000000 0000000 00000000000 15015766371 0032546 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/double-quoted-scalar-with-escaped-single-quote/error 0000664 0000000 0000000 00000000000 15015766371 0033610 0 ustar 00root root 0000000 0000000 in.yaml 0000664 0000000 0000000 00000000037 15015766371 0033761 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/double-quoted-scalar-with-escaped-single-quote ---
double: "quoted \' scalar"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/double-quoted-string-without-closing-quote/ 0000775 0000000 0000000 00000000000 15015766371 0032112 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/double-quoted-string-without-closing-quote/error 0000664 0000000 0000000 00000000000 15015766371 0033154 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/double-quoted-string-without-closing-quote/in.yaml 0000664 0000000 0000000 00000000040 15015766371 0033376 0 ustar 00root root 0000000 0000000 ---
key: "missing closing quote
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/doublequoted-scalar-starting-with-a-tab/ 0000775 0000000 0000000 00000000000 15015766371 0031270 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/doublequoted-scalar-starting-with-a-tab/in.json 0000664 0000000 0000000 00000000030 15015766371 0032562 0 ustar 00root root 0000000 0000000 {
"tab": "\tstring"
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/doublequoted-scalar-starting-with-a-tab/in.yaml 0000664 0000000 0000000 00000000024 15015766371 0032556 0 ustar 00root root 0000000 0000000 ---
tab: "\tstring"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/doublequoted-scalar-starting-with-a-tab/out.yaml 0000664 0000000 0000000 00000000024 15015766371 0032757 0 ustar 00root root 0000000 0000000 ---
tab: "\tstring"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/duplicate-yaml-directive/ 0000775 0000000 0000000 00000000000 15015766371 0026433 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/duplicate-yaml-directive/error 0000664 0000000 0000000 00000000000 15015766371 0027475 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/duplicate-yaml-directive/in.yaml 0000664 0000000 0000000 00000000030 15015766371 0027716 0 ustar 00root root 0000000 0000000 %YAML 1.2
%YAML 1.2
---
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/empty-flow-collections/ 0000775 0000000 0000000 00000000000 15015766371 0026164 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/empty-flow-collections/in.json 0000664 0000000 0000000 00000000213 15015766371 0027461 0 ustar 00root root 0000000 0000000 {
"nested sequences": [
[
[
[]
]
],
[
[
{}
]
]
],
"key1": [],
"key2": {}
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/empty-flow-collections/in.yaml 0000664 0000000 0000000 00000000072 15015766371 0027455 0 ustar 00root root 0000000 0000000 ---
nested sequences:
- - - []
- - - {}
key1: []
key2: {}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/empty-flow-collections/out.yaml 0000664 0000000 0000000 00000000072 15015766371 0027656 0 ustar 00root root 0000000 0000000 ---
nested sequences:
- - - []
- - - {}
key1: []
key2: {}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/empty-implicit-key-in-single-pair-flow-sequences/ 0000775 0000000 0000000 00000000000 15015766371 0033053 5 ustar 00root root 0000000 0000000 in.yaml 0000664 0000000 0000000 00000000052 15015766371 0034263 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/empty-implicit-key-in-single-pair-flow-sequences - [ : empty key ]
- [: another empty key]
out.yaml 0000664 0000000 0000000 00000000050 15015766371 0034462 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/empty-implicit-key-in-single-pair-flow-sequences - - : empty key
- - : another empty key
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/empty-keys-in-block-and-flow-mapping/ 0000775 0000000 0000000 00000000000 15015766371 0030506 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/empty-keys-in-block-and-flow-mapping/in.yaml 0000664 0000000 0000000 00000000170 15015766371 0031776 0 ustar 00root root 0000000 0000000 ---
key: value
: empty key
---
{
key: value, : empty key
}
---
# empty key and value
:
---
# empty key and value
{ : }
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/empty-lines-at-end-of-document/ 0000775 0000000 0000000 00000000000 15015766371 0027377 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/empty-lines-at-end-of-document/in.yaml 0000664 0000000 0000000 00000000004 15015766371 0030663 0 ustar 00root root 0000000 0000000 :
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/empty-lines-between-mapping-elements/ 0000775 0000000 0000000 00000000000 15015766371 0030705 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/empty-lines-between-mapping-elements/in.json 0000664 0000000 0000000 00000000035 15015766371 0032204 0 ustar 00root root 0000000 0000000 {
"one": 2,
"three": 4
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/empty-lines-between-mapping-elements/in.yaml 0000664 0000000 0000000 00000000022 15015766371 0032171 0 ustar 00root root 0000000 0000000 one: 2
three: 4
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/empty-lines-between-mapping-elements/out.yaml 0000664 0000000 0000000 00000000020 15015766371 0032370 0 ustar 00root root 0000000 0000000 one: 2
three: 4
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/empty-stream/ 0000775 0000000 0000000 00000000000 15015766371 0024174 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/empty-stream/in.json 0000664 0000000 0000000 00000000000 15015766371 0025463 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/empty-stream/in.yaml 0000664 0000000 0000000 00000000000 15015766371 0025454 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/escaped-slash-in-double-quotes/ 0000775 0000000 0000000 00000000000 15015766371 0027453 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/escaped-slash-in-double-quotes/in.json 0000664 0000000 0000000 00000000035 15015766371 0030752 0 ustar 00root root 0000000 0000000 {
"escaped slash": "a/b"
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/escaped-slash-in-double-quotes/in.yaml 0000664 0000000 0000000 00000000026 15015766371 0030743 0 ustar 00root root 0000000 0000000 escaped slash: "a\/b"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/escaped-slash-in-double-quotes/out.yaml 0000664 0000000 0000000 00000000025 15015766371 0031143 0 ustar 00root root 0000000 0000000 escaped slash: "a/b"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/explicit-key-and-value-seperated-by-comment/ 0000775 0000000 0000000 00000000000 15015766371 0032050 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/explicit-key-and-value-seperated-by-comment/in.json 0000664 0000000 0000000 00000000025 15015766371 0033346 0 ustar 00root root 0000000 0000000 {
"key": "value"
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/explicit-key-and-value-seperated-by-comment/in.yaml 0000664 0000000 0000000 00000000034 15015766371 0033337 0 ustar 00root root 0000000 0000000 ---
? key
# comment
: value
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/explicit-key-and-value-seperated-by-comment/out.yaml 0000664 0000000 0000000 00000000017 15015766371 0033541 0 ustar 00root root 0000000 0000000 ---
key: value
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/explicit-non-specific-tag-1-3/ 0000775 0000000 0000000 00000000000 15015766371 0027010 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/explicit-non-specific-tag-1-3/in.json 0000664 0000000 0000000 00000000004 15015766371 0030303 0 ustar 00root root 0000000 0000000 "a"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/explicit-non-specific-tag-1-3/in.yaml 0000664 0000000 0000000 00000000010 15015766371 0030271 0 ustar 00root root 0000000 0000000 ---
! a
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/explicit-non-specific-tag-1-3/out.yaml 0000664 0000000 0000000 00000000010 15015766371 0030472 0 ustar 00root root 0000000 0000000 --- ! a
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/explicit-non-specific-tag/ 0000775 0000000 0000000 00000000000 15015766371 0026512 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/explicit-non-specific-tag/in.json 0000664 0000000 0000000 00000000004 15015766371 0030005 0 ustar 00root root 0000000 0000000 "a"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/explicit-non-specific-tag/in.yaml 0000664 0000000 0000000 00000000004 15015766371 0027776 0 ustar 00root root 0000000 0000000 ! a
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/extra-words-on-yaml-directive/ 0000775 0000000 0000000 00000000000 15015766371 0027352 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/extra-words-on-yaml-directive/error 0000664 0000000 0000000 00000000000 15015766371 0030414 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/extra-words-on-yaml-directive/in.yaml 0000664 0000000 0000000 00000000022 15015766371 0030636 0 ustar 00root root 0000000 0000000 %YAML 1.2 foo
---
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-collections-over-many-lines/ 0000775 0000000 0000000 00000000000 15015766371 0030053 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-collections-over-many-lines/00/ 0000775 0000000 0000000 00000000000 15015766371 0030272 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-collections-over-many-lines/00/error 0000664 0000000 0000000 00000000000 15015766371 0031334 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-collections-over-many-lines/00/in.yaml 0000664 0000000 0000000 00000000015 15015766371 0031560 0 ustar 00root root 0000000 0000000 k: {
k
:
v
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-collections-over-many-lines/01/ 0000775 0000000 0000000 00000000000 15015766371 0030273 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-collections-over-many-lines/01/in.json 0000664 0000000 0000000 00000000040 15015766371 0031566 0 ustar 00root root 0000000 0000000 {
"k" : {
"k" : "v"
}
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-collections-over-many-lines/01/in.yaml 0000664 0000000 0000000 00000000021 15015766371 0031556 0 ustar 00root root 0000000 0000000 k: {
k
:
v
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-collections-over-many-lines/01/out.yaml 0000664 0000000 0000000 00000000016 15015766371 0031763 0 ustar 00root root 0000000 0000000 ---
k:
k: v
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-mapping-colon-on-line-after-key/ 0000775 0000000 0000000 00000000000 15015766371 0030501 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-mapping-colon-on-line-after-key/00/ 0000775 0000000 0000000 00000000000 15015766371 0030720 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-mapping-colon-on-line-after-key/00/in.json 0000664 0000000 0000000 00000000023 15015766371 0032214 0 ustar 00root root 0000000 0000000 {
"foo": "bar"
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-mapping-colon-on-line-after-key/00/in.yaml 0000664 0000000 0000000 00000000020 15015766371 0032202 0 ustar 00root root 0000000 0000000 {"foo"
: "bar"}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-mapping-colon-on-line-after-key/01/ 0000775 0000000 0000000 00000000000 15015766371 0030721 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-mapping-colon-on-line-after-key/01/in.json 0000664 0000000 0000000 00000000023 15015766371 0032215 0 ustar 00root root 0000000 0000000 {
"foo": "bar"
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-mapping-colon-on-line-after-key/01/in.yaml 0000664 0000000 0000000 00000000016 15015766371 0032210 0 ustar 00root root 0000000 0000000 {"foo"
: bar}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-mapping-colon-on-line-after-key/02/ 0000775 0000000 0000000 00000000000 15015766371 0030722 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-mapping-colon-on-line-after-key/02/in.json 0000664 0000000 0000000 00000000023 15015766371 0032216 0 ustar 00root root 0000000 0000000 {
"foo": "bar"
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-mapping-colon-on-line-after-key/02/in.yaml 0000664 0000000 0000000 00000000014 15015766371 0032207 0 ustar 00root root 0000000 0000000 {foo
: bar}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-mapping-edge-cases/ 0000775 0000000 0000000 00000000000 15015766371 0026143 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-mapping-edge-cases/in.json 0000664 0000000 0000000 00000000020 15015766371 0027434 0 ustar 00root root 0000000 0000000 {
"x": ":x"
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-mapping-edge-cases/in.yaml 0000664 0000000 0000000 00000000010 15015766371 0027424 0 ustar 00root root 0000000 0000000 {x: :x}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-mapping-edge-cases/out.yaml 0000664 0000000 0000000 00000000006 15015766371 0027632 0 ustar 00root root 0000000 0000000 x: :x
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-mapping-in-block-sequence/ 0000775 0000000 0000000 00000000000 15015766371 0027447 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-mapping-in-block-sequence/in.json 0000664 0000000 0000000 00000000031 15015766371 0030742 0 ustar 00root root 0000000 0000000 [
{
"a": "b"
}
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-mapping-in-block-sequence/in.yaml 0000664 0000000 0000000 00000000011 15015766371 0030731 0 ustar 00root root 0000000 0000000 - {a: b}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-mapping-in-block-sequence/out.yaml 0000664 0000000 0000000 00000000007 15015766371 0031137 0 ustar 00root root 0000000 0000000 - a: b
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-mapping-key-on-two-lines/ 0000775 0000000 0000000 00000000000 15015766371 0027264 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-mapping-key-on-two-lines/error 0000664 0000000 0000000 00000000000 15015766371 0030326 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-mapping-key-on-two-lines/in.yaml 0000664 0000000 0000000 00000000012 15015766371 0030547 0 ustar 00root root 0000000 0000000 [23
]: 42
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-mapping-missing-a-separating-comma/ 0000775 0000000 0000000 00000000000 15015766371 0031257 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-mapping-missing-a-separating-comma/error 0000664 0000000 0000000 00000000000 15015766371 0032321 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-mapping-missing-a-separating-comma/in.yaml 0000664 0000000 0000000 00000000030 15015766371 0032542 0 ustar 00root root 0000000 0000000 ---
{
foo: 1
bar: 2 }
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-mapping-separate-values/ 0000775 0000000 0000000 00000000000 15015766371 0027244 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-mapping-separate-values/in.yaml 0000664 0000000 0000000 00000000073 15015766371 0030536 0 ustar 00root root 0000000 0000000 {
unquoted : "separate",
http://foo.com,
omitted value:,
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-mapping-separate-values/out.yaml 0000664 0000000 0000000 00000000076 15015766371 0030742 0 ustar 00root root 0000000 0000000 unquoted: "separate"
http://foo.com: null
omitted value: null
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-mapping/ 0000775 0000000 0000000 00000000000 15015766371 0024145 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-mapping/in.json 0000664 0000000 0000000 00000000043 15015766371 0025443 0 ustar 00root root 0000000 0000000 {
"foo": "you",
"bar": "far"
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-mapping/in.yaml 0000664 0000000 0000000 00000000025 15015766371 0025434 0 ustar 00root root 0000000 0000000 {foo: you, bar: far}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-mapping/out.yaml 0000664 0000000 0000000 00000000022 15015766371 0025632 0 ustar 00root root 0000000 0000000 foo: you
bar: far
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-sequence-in-block-mapping/ 0000775 0000000 0000000 00000000000 15015766371 0027447 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-sequence-in-block-mapping/in.json 0000664 0000000 0000000 00000000042 15015766371 0030744 0 ustar 00root root 0000000 0000000 {
"a": [
"b",
"c"
]
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-sequence-in-block-mapping/in.yaml 0000664 0000000 0000000 00000000012 15015766371 0030732 0 ustar 00root root 0000000 0000000 a: [b, c]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-sequence-in-block-mapping/out.yaml 0000664 0000000 0000000 00000000013 15015766371 0031134 0 ustar 00root root 0000000 0000000 a:
- b
- c
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-sequence-in-flow-mapping/ 0000775 0000000 0000000 00000000000 15015766371 0027324 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-sequence-in-flow-mapping/in.yaml 0000664 0000000 0000000 00000000027 15015766371 0030615 0 ustar 00root root 0000000 0000000 {a: [b, c], [d, e]: f}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-sequence-in-flow-mapping/out.yaml 0000664 0000000 0000000 00000000033 15015766371 0031013 0 ustar 00root root 0000000 0000000 a:
- b
- c
? - d
- e
: f
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-sequence-in-flow-sequence/ 0000775 0000000 0000000 00000000000 15015766371 0027501 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-sequence-in-flow-sequence/in.json 0000664 0000000 0000000 00000000044 15015766371 0031000 0 ustar 00root root 0000000 0000000 [
"a",
[
"b",
"c"
]
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-sequence-in-flow-sequence/in.yaml 0000664 0000000 0000000 00000000014 15015766371 0030766 0 ustar 00root root 0000000 0000000 [a, [b, c]]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-sequence-in-flow-sequence/out.yaml 0000664 0000000 0000000 00000000020 15015766371 0031164 0 ustar 00root root 0000000 0000000 - a
- - b
- c
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-sequence-with-invalid-comma-at-the-beginning/ 0000775 0000000 0000000 00000000000 15015766371 0033127 5 ustar 00root root 0000000 0000000 error 0000664 0000000 0000000 00000000000 15015766371 0034112 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-sequence-with-invalid-comma-at-the-beginning in.yaml 0000664 0000000 0000000 00000000022 15015766371 0034334 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-sequence-with-invalid-comma-at-the-beginning ---
[ , a, b, c ]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-sequence-with-invalid-extra-closing-bracket/ 0000775 0000000 0000000 00000000000 15015766371 0033105 5 ustar 00root root 0000000 0000000 error 0000664 0000000 0000000 00000000000 15015766371 0034070 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-sequence-with-invalid-extra-closing-bracket in.yaml 0000664 0000000 0000000 00000000022 15015766371 0034312 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-sequence-with-invalid-extra-closing-bracket ---
[ a, b, c ] ]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-sequence-with-invalid-extra-comma/ 0000775 0000000 0000000 00000000000 15015766371 0031132 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-sequence-with-invalid-extra-comma/error 0000664 0000000 0000000 00000000000 15015766371 0032174 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-sequence-with-invalid-extra-comma/in.yaml 0000664 0000000 0000000 00000000023 15015766371 0032417 0 ustar 00root root 0000000 0000000 ---
[ a, b, c, , ]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-sequence-without-closing-bracket/ 0000775 0000000 0000000 00000000000 15015766371 0031070 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-sequence-without-closing-bracket/error 0000664 0000000 0000000 00000000000 15015766371 0032132 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-sequence-without-closing-bracket/in.yaml 0000664 0000000 0000000 00000000022 15015766371 0032354 0 ustar 00root root 0000000 0000000 ---
[ [ a, b, c ]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-sequence/ 0000775 0000000 0000000 00000000000 15015766371 0024322 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-sequence/in.json 0000664 0000000 0000000 00000000033 15015766371 0025617 0 ustar 00root root 0000000 0000000 [
"foo",
"bar",
42
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-sequence/in.yaml 0000664 0000000 0000000 00000000017 15015766371 0025612 0 ustar 00root root 0000000 0000000 [foo, bar, 42]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/flow-sequence/out.yaml 0000664 0000000 0000000 00000000021 15015766371 0026006 0 ustar 00root root 0000000 0000000 - foo
- bar
- 42
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/folded-block-scalar-1-3/ 0000775 0000000 0000000 00000000000 15015766371 0025633 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/folded-block-scalar-1-3/in.json 0000664 0000000 0000000 00000000024 15015766371 0027130 0 ustar 00root root 0000000 0000000 "ab cd\nef\n\ngh\n"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/folded-block-scalar-1-3/in.yaml 0000664 0000000 0000000 00000000032 15015766371 0027120 0 ustar 00root root 0000000 0000000 --- >
ab
cd
ef
gh
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/folded-block-scalar-1-3/out.yaml 0000664 0000000 0000000 00000000033 15015766371 0027322 0 ustar 00root root 0000000 0000000 --- >
ab cd
ef
gh
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/folded-block-scalar/ 0000775 0000000 0000000 00000000000 15015766371 0025335 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/folded-block-scalar/in.json 0000664 0000000 0000000 00000000024 15015766371 0026632 0 ustar 00root root 0000000 0000000 "ab cd\nef\n\ngh\n"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/folded-block-scalar/in.yaml 0000664 0000000 0000000 00000000026 15015766371 0026625 0 ustar 00root root 0000000 0000000 >
ab
cd
ef
gh
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/folded-block-scalar/out.yaml 0000664 0000000 0000000 00000000027 15015766371 0027027 0 ustar 00root root 0000000 0000000 >
ab cd
ef
gh
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/implicit-flow-mapping-key-on-one-line/ 0000775 0000000 0000000 00000000000 15015766371 0030661 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/implicit-flow-mapping-key-on-one-line/in.yaml 0000664 0000000 0000000 00000000016 15015766371 0032150 0 ustar 00root root 0000000 0000000 [flow]: block
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/implicit-flow-mapping-key-on-one-line/out.yaml 0000664 0000000 0000000 00000000021 15015766371 0032345 0 ustar 00root root 0000000 0000000 ? - flow
: block
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/implicit-key-followed-by-newline-and-adjacent-value/ 0000775 0000000 0000000 00000000000 15015766371 0033446 5 ustar 00root root 0000000 0000000 error 0000664 0000000 0000000 00000000000 15015766371 0034431 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/implicit-key-followed-by-newline-and-adjacent-value in.yaml 0000664 0000000 0000000 00000000023 15015766371 0034654 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/implicit-key-followed-by-newline-and-adjacent-value [ "key"
:value ]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/implicit-key-followed-by-newline/ 0000775 0000000 0000000 00000000000 15015766371 0030025 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/implicit-key-followed-by-newline/error 0000664 0000000 0000000 00000000000 15015766371 0031067 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/implicit-key-followed-by-newline/in.yaml 0000664 0000000 0000000 00000000026 15015766371 0031315 0 ustar 00root root 0000000 0000000 ---
[ key
: value ]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/inline-tabs-in-double-quoted/ 0000775 0000000 0000000 00000000000 15015766371 0027125 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/inline-tabs-in-double-quoted/00/ 0000775 0000000 0000000 00000000000 15015766371 0027344 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/inline-tabs-in-double-quoted/00/in.json 0000664 0000000 0000000 00000000020 15015766371 0030635 0 ustar 00root root 0000000 0000000 "1 inline\ttab"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/inline-tabs-in-double-quoted/00/in.yaml 0000664 0000000 0000000 00000000020 15015766371 0030626 0 ustar 00root root 0000000 0000000 "1 inline\ttab"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/inline-tabs-in-double-quoted/01/ 0000775 0000000 0000000 00000000000 15015766371 0027345 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/inline-tabs-in-double-quoted/01/in.json 0000664 0000000 0000000 00000000020 15015766371 0030636 0 ustar 00root root 0000000 0000000 "2 inline\ttab"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/inline-tabs-in-double-quoted/01/in.yaml 0000664 0000000 0000000 00000000020 15015766371 0030627 0 ustar 00root root 0000000 0000000 "2 inline\ tab"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/inline-tabs-in-double-quoted/01/out.yaml 0000664 0000000 0000000 00000000020 15015766371 0031030 0 ustar 00root root 0000000 0000000 "2 inline\ttab"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/inline-tabs-in-double-quoted/02/ 0000775 0000000 0000000 00000000000 15015766371 0027346 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/inline-tabs-in-double-quoted/02/in.json 0000664 0000000 0000000 00000000020 15015766371 0030637 0 ustar 00root root 0000000 0000000 "3 inline\ttab"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/inline-tabs-in-double-quoted/02/in.yaml 0000664 0000000 0000000 00000000017 15015766371 0030636 0 ustar 00root root 0000000 0000000 "3 inline tab"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/inline-tabs-in-double-quoted/02/out.yaml 0000664 0000000 0000000 00000000020 15015766371 0031031 0 ustar 00root root 0000000 0000000 "3 inline\ttab"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-anchor-in-zero-indented-sequence/ 0000775 0000000 0000000 00000000000 15015766371 0031422 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-anchor-in-zero-indented-sequence/error 0000664 0000000 0000000 00000000000 15015766371 0032464 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-anchor-in-zero-indented-sequence/in.yaml 0000664 0000000 0000000 00000000031 15015766371 0032706 0 ustar 00root root 0000000 0000000 ---
seq:
&anchor
- a
- b
invalid-block-mapping-key-on-same-line-as-previous-key/ 0000775 0000000 0000000 00000000000 15015766371 0033746 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite error 0000664 0000000 0000000 00000000000 15015766371 0035010 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-block-mapping-key-on-same-line-as-previous-key in.yaml 0000664 0000000 0000000 00000000031 15015766371 0035232 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-block-mapping-key-on-same-line-as-previous-key ---
x: { y: z }in: valid
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-comma-in-tag/ 0000775 0000000 0000000 00000000000 15015766371 0025442 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-comma-in-tag/error 0000664 0000000 0000000 00000000000 15015766371 0026504 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-comma-in-tag/in.yaml 0000664 0000000 0000000 00000000015 15015766371 0026730 0 ustar 00root root 0000000 0000000 - !!str, xxx
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-comment-after-comma/ 0000775 0000000 0000000 00000000000 15015766371 0027024 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-comment-after-comma/error 0000664 0000000 0000000 00000000000 15015766371 0030066 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-comment-after-comma/in.yaml 0000664 0000000 0000000 00000000031 15015766371 0030310 0 ustar 00root root 0000000 0000000 ---
[ a, b, c,#invalid
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-comment-after-end-of-flow-sequence/ 0000775 0000000 0000000 00000000000 15015766371 0031653 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-comment-after-end-of-flow-sequence/error 0000664 0000000 0000000 00000000000 15015766371 0032715 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-comment-after-end-of-flow-sequence/in.yaml 0000664 0000000 0000000 00000000031 15015766371 0033137 0 ustar 00root root 0000000 0000000 ---
[ a, b, c, ]#invalid
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-content-after-document-end-marker/ 0000775 0000000 0000000 00000000000 15015766371 0031601 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-content-after-document-end-marker/error 0000664 0000000 0000000 00000000000 15015766371 0032643 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-content-after-document-end-marker/in.yaml 0000664 0000000 0000000 00000000033 15015766371 0033067 0 ustar 00root root 0000000 0000000 ---
key: value
... invalid
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-document-end-marker-in-single-quoted-string/ 0000775 0000000 0000000 00000000000 15015766371 0033520 5 ustar 00root root 0000000 0000000 error 0000664 0000000 0000000 00000000000 15015766371 0034503 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-document-end-marker-in-single-quoted-string in.yaml 0000664 0000000 0000000 00000000014 15015766371 0034726 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-document-end-marker-in-single-quoted-string ---
'
...
'
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-document-markers-in-flow-style/ 0000775 0000000 0000000 00000000000 15015766371 0031160 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-document-markers-in-flow-style/error 0000664 0000000 0000000 00000000000 15015766371 0032222 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-document-markers-in-flow-style/in.yaml 0000664 0000000 0000000 00000000016 15015766371 0032447 0 ustar 00root root 0000000 0000000 [
--- ,
...
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-document-start-marker-in-doublequoted-tring/ 0000775 0000000 0000000 00000000000 15015766371 0033640 5 ustar 00root root 0000000 0000000 error 0000664 0000000 0000000 00000000000 15015766371 0034623 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-document-start-marker-in-doublequoted-tring in.yaml 0000664 0000000 0000000 00000000014 15015766371 0035046 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-document-start-marker-in-doublequoted-tring ---
"
---
"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-escape-in-double-quoted-string/ 0000775 0000000 0000000 00000000000 15015766371 0031110 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-escape-in-double-quoted-string/error 0000664 0000000 0000000 00000000000 15015766371 0032152 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-escape-in-double-quoted-string/in.yaml 0000664 0000000 0000000 00000000011 15015766371 0032372 0 ustar 00root root 0000000 0000000 ---
"\."
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-item-after-end-of-flow-sequence/ 0000775 0000000 0000000 00000000000 15015766371 0031147 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-item-after-end-of-flow-sequence/error 0000664 0000000 0000000 00000000000 15015766371 0032211 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-item-after-end-of-flow-sequence/in.yaml 0000664 0000000 0000000 00000000043 15015766371 0032436 0 ustar 00root root 0000000 0000000 ---
[
sequence item
]
invalid item
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-mapping-after-sequence/ 0000775 0000000 0000000 00000000000 15015766371 0027531 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-mapping-after-sequence/error 0000664 0000000 0000000 00000000000 15015766371 0030573 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-mapping-after-sequence/in.yaml 0000664 0000000 0000000 00000000033 15015766371 0031017 0 ustar 00root root 0000000 0000000 - item1
- item2
invalid: x
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-mapping-in-plain-multiline/ 0000775 0000000 0000000 00000000000 15015766371 0030331 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-mapping-in-plain-multiline/error 0000664 0000000 0000000 00000000000 15015766371 0031373 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-mapping-in-plain-multiline/in.yaml 0000664 0000000 0000000 00000000026 15015766371 0031621 0 ustar 00root root 0000000 0000000 this
is
invalid: x
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-mapping-in-plain-scalar/ 0000775 0000000 0000000 00000000000 15015766371 0027574 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-mapping-in-plain-scalar/error 0000664 0000000 0000000 00000000000 15015766371 0030636 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-mapping-in-plain-scalar/in.yaml 0000664 0000000 0000000 00000000035 15015766371 0031064 0 ustar 00root root 0000000 0000000 key:
word1 word2
no: key
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-mapping-in-plain-single-line-value/ 0000775 0000000 0000000 00000000000 15015766371 0031647 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-mapping-in-plain-single-line-value/error 0000664 0000000 0000000 00000000000 15015766371 0032711 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-mapping-in-plain-single-line-value/in.yaml 0000664 0000000 0000000 00000000013 15015766371 0033133 0 ustar 00root root 0000000 0000000 a: b: c: d
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-nested-mapping/ 0000775 0000000 0000000 00000000000 15015766371 0026104 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-nested-mapping/error 0000664 0000000 0000000 00000000000 15015766371 0027146 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-nested-mapping/in.yaml 0000664 0000000 0000000 00000000016 15015766371 0027373 0 ustar 00root root 0000000 0000000 ---
a: 'b': c
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-scalar-after-sequence/ 0000775 0000000 0000000 00000000000 15015766371 0027343 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-scalar-after-sequence/error 0000664 0000000 0000000 00000000000 15015766371 0030405 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-scalar-after-sequence/in.yaml 0000664 0000000 0000000 00000000030 15015766371 0030626 0 ustar 00root root 0000000 0000000 - item1
- item2
invalid
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-scalar-at-the-end-of-mapping/ 0000775 0000000 0000000 00000000000 15015766371 0030415 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-scalar-at-the-end-of-mapping/error 0000664 0000000 0000000 00000000000 15015766371 0031457 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-scalar-at-the-end-of-mapping/in.yaml 0000664 0000000 0000000 00000000037 15015766371 0031707 0 ustar 00root root 0000000 0000000 key:
- item1
- item2
invalid
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-scalar-at-the-end-of-sequence/ 0000775 0000000 0000000 00000000000 15015766371 0030572 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-scalar-at-the-end-of-sequence/error 0000664 0000000 0000000 00000000000 15015766371 0031634 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-scalar-at-the-end-of-sequence/in.yaml 0000664 0000000 0000000 00000000034 15015766371 0032061 0 ustar 00root root 0000000 0000000 key:
- bar
- baz
invalid
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-sequene-item-on-same-line-as-previous-item/ 0000775 0000000 0000000 00000000000 15015766371 0033263 5 ustar 00root root 0000000 0000000 error 0000664 0000000 0000000 00000000000 15015766371 0034246 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-sequene-item-on-same-line-as-previous-item in.yaml 0000664 0000000 0000000 00000000030 15015766371 0034467 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-sequene-item-on-same-line-as-previous-item ---
- { y: z }- invalid
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-tabs-as-indendation-in-a-mapping/ 0000775 0000000 0000000 00000000000 15015766371 0031270 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-tabs-as-indendation-in-a-mapping/error 0000664 0000000 0000000 00000000000 15015766371 0032332 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-tabs-as-indendation-in-a-mapping/in.yaml 0000664 0000000 0000000 00000000026 15015766371 0032560 0 ustar 00root root 0000000 0000000 ---
a:
b:
c: value
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-tag/ 0000775 0000000 0000000 00000000000 15015766371 0023744 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-tag/error 0000664 0000000 0000000 00000000000 15015766371 0025006 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-tag/in.yaml 0000664 0000000 0000000 00000000031 15015766371 0025230 0 ustar 00root root 0000000 0000000 ---
!invalid{}tag scalar
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-text-after-block-scalar-indicator/ 0000775 0000000 0000000 00000000000 15015766371 0031561 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-text-after-block-scalar-indicator/error 0000664 0000000 0000000 00000000000 15015766371 0032623 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-text-after-block-scalar-indicator/in.yaml 0000664 0000000 0000000 00000000047 15015766371 0033054 0 ustar 00root root 0000000 0000000 ---
folded: > first line
second line
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-value-after-mapping/ 0000775 0000000 0000000 00000000000 15015766371 0027035 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-value-after-mapping/error 0000664 0000000 0000000 00000000000 15015766371 0030077 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/invalid-value-after-mapping/in.yaml 0000664 0000000 0000000 00000000023 15015766371 0030322 0 ustar 00root root 0000000 0000000 foo:
bar
invalid
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/key-with-anchor-after-missing-explicit-mapping-value/0000775 0000000 0000000 00000000000 15015766371 0033706 5 ustar 00root root 0000000 0000000 in.json 0000664 0000000 0000000 00000000044 15015766371 0035126 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/key-with-anchor-after-missing-explicit-mapping-value {
"a": 1,
"b": null,
"c": 3
}
in.yaml 0000664 0000000 0000000 00000000032 15015766371 0035114 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/key-with-anchor-after-missing-explicit-mapping-value ---
a: 1
? b
&anchor c: 3
out.yaml 0000664 0000000 0000000 00000000031 15015766371 0035314 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/key-with-anchor-after-missing-explicit-mapping-value ---
a: 1
b:
&anchor c: 3
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/leading-tab-content-in-literals/ 0000775 0000000 0000000 00000000000 15015766371 0027605 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/leading-tab-content-in-literals/00/ 0000775 0000000 0000000 00000000000 15015766371 0030024 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/leading-tab-content-in-literals/00/in.json 0000664 0000000 0000000 00000000020 15015766371 0031315 0 ustar 00root root 0000000 0000000 {"foo":"\tbar"}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/leading-tab-content-in-literals/00/in.yaml 0000664 0000000 0000000 00000000016 15015766371 0031313 0 ustar 00root root 0000000 0000000 foo: |-
bar
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/leading-tab-content-in-literals/00/out.yaml 0000664 0000000 0000000 00000000017 15015766371 0031515 0 ustar 00root root 0000000 0000000 foo: |-
bar
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/leading-tab-content-in-literals/01/ 0000775 0000000 0000000 00000000000 15015766371 0030025 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/leading-tab-content-in-literals/01/in.json 0000664 0000000 0000000 00000000020 15015766371 0031316 0 ustar 00root root 0000000 0000000 {"foo":"\tbar"}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/leading-tab-content-in-literals/01/in.yaml 0000664 0000000 0000000 00000000015 15015766371 0031313 0 ustar 00root root 0000000 0000000 foo: |-
bar goccy-go-yaml-52dacb8/testdata/yaml-test-suite/leading-tab-content-in-literals/01/out.yaml 0000664 0000000 0000000 00000000017 15015766371 0031516 0 ustar 00root root 0000000 0000000 foo: |-
bar
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/leading-tabs-in-double-quoted/ 0000775 0000000 0000000 00000000000 15015766371 0027252 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/leading-tabs-in-double-quoted/00/ 0000775 0000000 0000000 00000000000 15015766371 0027471 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/leading-tabs-in-double-quoted/00/in.json 0000664 0000000 0000000 00000000022 15015766371 0030764 0 ustar 00root root 0000000 0000000 "1 leading \ttab"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/leading-tabs-in-double-quoted/00/in.yaml 0000664 0000000 0000000 00000000026 15015766371 0030761 0 ustar 00root root 0000000 0000000 "1 leading
\ttab"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/leading-tabs-in-double-quoted/01/ 0000775 0000000 0000000 00000000000 15015766371 0027472 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/leading-tabs-in-double-quoted/01/in.json 0000664 0000000 0000000 00000000022 15015766371 0030765 0 ustar 00root root 0000000 0000000 "2 leading \ttab"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/leading-tabs-in-double-quoted/01/in.yaml 0000664 0000000 0000000 00000000026 15015766371 0030762 0 ustar 00root root 0000000 0000000 "2 leading
\ tab"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/leading-tabs-in-double-quoted/02/ 0000775 0000000 0000000 00000000000 15015766371 0027473 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/leading-tabs-in-double-quoted/02/in.json 0000664 0000000 0000000 00000000020 15015766371 0030764 0 ustar 00root root 0000000 0000000 "3 leading tab"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/leading-tabs-in-double-quoted/02/in.yaml 0000664 0000000 0000000 00000000025 15015766371 0030762 0 ustar 00root root 0000000 0000000 "3 leading
tab"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/leading-tabs-in-double-quoted/03/ 0000775 0000000 0000000 00000000000 15015766371 0027474 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/leading-tabs-in-double-quoted/03/in.json 0000664 0000000 0000000 00000000024 15015766371 0030771 0 ustar 00root root 0000000 0000000 "4 leading \t tab"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/leading-tabs-in-double-quoted/03/in.yaml 0000664 0000000 0000000 00000000030 15015766371 0030757 0 ustar 00root root 0000000 0000000 "4 leading
\t tab"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/leading-tabs-in-double-quoted/04/ 0000775 0000000 0000000 00000000000 15015766371 0027475 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/leading-tabs-in-double-quoted/04/in.json 0000664 0000000 0000000 00000000024 15015766371 0030772 0 ustar 00root root 0000000 0000000 "5 leading \t tab"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/leading-tabs-in-double-quoted/04/in.yaml 0000664 0000000 0000000 00000000030 15015766371 0030760 0 ustar 00root root 0000000 0000000 "5 leading
\ tab"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/leading-tabs-in-double-quoted/05/ 0000775 0000000 0000000 00000000000 15015766371 0027476 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/leading-tabs-in-double-quoted/05/in.json 0000664 0000000 0000000 00000000020 15015766371 0030767 0 ustar 00root root 0000000 0000000 "6 leading tab"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/leading-tabs-in-double-quoted/05/in.yaml 0000664 0000000 0000000 00000000027 15015766371 0030767 0 ustar 00root root 0000000 0000000 "6 leading
tab"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/legal-tab-after-indentation/ 0000775 0000000 0000000 00000000000 15015766371 0027006 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/legal-tab-after-indentation/in.json 0000664 0000000 0000000 00000000033 15015766371 0030303 0 ustar 00root root 0000000 0000000 {
"x": [
"x x"
]
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/legal-tab-after-indentation/in.yaml 0000664 0000000 0000000 00000000015 15015766371 0030274 0 ustar 00root root 0000000 0000000 x:
- x
x
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/legal-tab-after-indentation/out.yaml 0000664 0000000 0000000 00000000011 15015766371 0030471 0 ustar 00root root 0000000 0000000 x:
- x x
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/literal-block-scalar-with-more-spaces-in-first-line/ 0000775 0000000 0000000 00000000000 15015766371 0033377 5 ustar 00root root 0000000 0000000 error 0000664 0000000 0000000 00000000000 15015766371 0034362 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/literal-block-scalar-with-more-spaces-in-first-line in.yaml 0000664 0000000 0000000 00000000107 15015766371 0034610 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/literal-block-scalar-with-more-spaces-in-first-line ---
block scalar: |
more spaces at the beginning
are invalid
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/literal-block-scalar/ 0000775 0000000 0000000 00000000000 15015766371 0025534 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/literal-block-scalar/in.json 0000664 0000000 0000000 00000000034 15015766371 0027032 0 ustar 00root root 0000000 0000000 {
"a": "ab\n\ncd\nef\n"
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/literal-block-scalar/in.yaml 0000664 0000000 0000000 00000000032 15015766371 0027021 0 ustar 00root root 0000000 0000000 a: |
ab
cd
ef
...
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/literal-block-scalar/out.yaml 0000664 0000000 0000000 00000000031 15015766371 0027221 0 ustar 00root root 0000000 0000000 a: |
ab
cd
ef
...
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/literal-modifers/ 0000775 0000000 0000000 00000000000 15015766371 0025007 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/literal-modifers/00/ 0000775 0000000 0000000 00000000000 15015766371 0025226 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/literal-modifers/00/error 0000664 0000000 0000000 00000000000 15015766371 0026270 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/literal-modifers/00/in.yaml 0000664 0000000 0000000 00000000007 15015766371 0026515 0 ustar 00root root 0000000 0000000 --- |0
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/literal-modifers/01/ 0000775 0000000 0000000 00000000000 15015766371 0025227 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/literal-modifers/01/error 0000664 0000000 0000000 00000000000 15015766371 0026271 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/literal-modifers/01/in.yaml 0000664 0000000 0000000 00000000010 15015766371 0026510 0 ustar 00root root 0000000 0000000 --- |10
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/literal-modifers/02/ 0000775 0000000 0000000 00000000000 15015766371 0025230 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/literal-modifers/02/in.json 0000664 0000000 0000000 00000000003 15015766371 0026522 0 ustar 00root root 0000000 0000000 ""
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/literal-modifers/02/in.yaml 0000664 0000000 0000000 00000000007 15015766371 0026517 0 ustar 00root root 0000000 0000000 --- |1- goccy-go-yaml-52dacb8/testdata/yaml-test-suite/literal-modifers/03/ 0000775 0000000 0000000 00000000000 15015766371 0025231 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/literal-modifers/03/in.json 0000664 0000000 0000000 00000000003 15015766371 0026523 0 ustar 00root root 0000000 0000000 ""
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/literal-modifers/03/in.yaml 0000664 0000000 0000000 00000000007 15015766371 0026520 0 ustar 00root root 0000000 0000000 --- |1+ goccy-go-yaml-52dacb8/testdata/yaml-test-suite/literal-scalars/ 0000775 0000000 0000000 00000000000 15015766371 0024627 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/literal-scalars/in.json 0000664 0000000 0000000 00000000065 15015766371 0026131 0 ustar 00root root 0000000 0000000 [
{
"aaa" : "xxx\n",
"bbb" : "xxx\n"
}
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/literal-scalars/in.yaml 0000664 0000000 0000000 00000000043 15015766371 0026116 0 ustar 00root root 0000000 0000000 - aaa: |2
xxx
bbb: |
xxx
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/literal-scalars/out.yaml 0000664 0000000 0000000 00000000046 15015766371 0026322 0 ustar 00root root 0000000 0000000 ---
- aaa: |
xxx
bbb: |
xxx
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/literal-unicode/ 0000775 0000000 0000000 00000000000 15015766371 0024625 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/literal-unicode/in.json 0000664 0000000 0000000 00000000051 15015766371 0026122 0 ustar 00root root 0000000 0000000 {
"wanted": "love ♥ and peace ☮"
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/literal-unicode/in.yaml 0000664 0000000 0000000 00000000043 15015766371 0026114 0 ustar 00root root 0000000 0000000 ---
wanted: love ♥ and peace ☮
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/literal-unicode/out.yaml 0000664 0000000 0000000 00000000053 15015766371 0026316 0 ustar 00root root 0000000 0000000 ---
wanted: "love \u2665 and peace \u262E"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/lookahead-test-cases/ 0000775 0000000 0000000 00000000000 15015766371 0025545 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/lookahead-test-cases/in.json 0000664 0000000 0000000 00000000102 15015766371 0027037 0 ustar 00root root 0000000 0000000 [
{
"bla\"keks": "foo"
},
{
"bla]keks": "foo"
}
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/lookahead-test-cases/in.yaml 0000664 0000000 0000000 00000000040 15015766371 0027031 0 ustar 00root root 0000000 0000000 - bla"keks: foo
- bla]keks: foo
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/mapping-key-and-flow-sequence-item-anchors/ 0000775 0000000 0000000 00000000000 15015766371 0031670 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/mapping-key-and-flow-sequence-item-anchors/in.yaml 0000664 0000000 0000000 00000000053 15015766371 0033160 0 ustar 00root root 0000000 0000000 ---
&mapping
&key [ &item a, b, c ]: value
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/mapping-key-and-flow-sequence-item-anchors/out.yaml 0000664 0000000 0000000 00000000056 15015766371 0033364 0 ustar 00root root 0000000 0000000 --- &mapping
? &key
- &item a
- b
- c
: value
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/mapping-starting-at-line/ 0000775 0000000 0000000 00000000000 15015766371 0026360 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/mapping-starting-at-line/error 0000664 0000000 0000000 00000000000 15015766371 0027422 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/mapping-starting-at-line/in.yaml 0000664 0000000 0000000 00000000042 15015766371 0027646 0 ustar 00root root 0000000 0000000 --- key1: value1
key2: value2
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/mapping-with-anchor-on-document-start-line/ 0000775 0000000 0000000 00000000000 15015766371 0031727 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/mapping-with-anchor-on-document-start-line/error 0000664 0000000 0000000 00000000000 15015766371 0032771 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/mapping-with-anchor-on-document-start-line/in.yaml 0000664 0000000 0000000 00000000021 15015766371 0033212 0 ustar 00root root 0000000 0000000 --- &anchor a: b
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/missing-colon/ 0000775 0000000 0000000 00000000000 15015766371 0024326 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/missing-colon/error 0000664 0000000 0000000 00000000000 15015766371 0025370 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/missing-colon/in.yaml 0000664 0000000 0000000 00000000030 15015766371 0025611 0 ustar 00root root 0000000 0000000 top1:
key1: val1
top2
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/missing-comma-in-flow/ 0000775 0000000 0000000 00000000000 15015766371 0025661 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/missing-comma-in-flow/error 0000664 0000000 0000000 00000000000 15015766371 0026723 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/missing-comma-in-flow/in.yaml 0000664 0000000 0000000 00000000036 15015766371 0027152 0 ustar 00root root 0000000 0000000 key: [ word1
# xxx
word2 ]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/missing-document-end-marker-before-directive/ 0000775 0000000 0000000 00000000000 15015766371 0032271 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/missing-document-end-marker-before-directive/error 0000664 0000000 0000000 00000000000 15015766371 0033333 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/missing-document-end-marker-before-directive/in.yaml 0000664 0000000 0000000 00000000054 15015766371 0033562 0 ustar 00root root 0000000 0000000 ---
scalar1 # comment
%YAML 1.2
---
scalar2
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/mixed-block-mapping-explicit-to-implicit/ 0000775 0000000 0000000 00000000000 15015766371 0031443 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/mixed-block-mapping-explicit-to-implicit/in.json 0000664 0000000 0000000 00000000041 15015766371 0032737 0 ustar 00root root 0000000 0000000 {
"a": 1.3,
"fifteen": "d"
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/mixed-block-mapping-explicit-to-implicit/in.yaml 0000664 0000000 0000000 00000000025 15015766371 0032732 0 ustar 00root root 0000000 0000000 ? a
: 1.3
fifteen: d
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/mixed-block-mapping-explicit-to-implicit/out.yaml 0000664 0000000 0000000 00000000022 15015766371 0033130 0 ustar 00root root 0000000 0000000 a: 1.3
fifteen: d
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/mixed-block-mapping-implicit-to-explicit/ 0000775 0000000 0000000 00000000000 15015766371 0031443 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/mixed-block-mapping-implicit-to-explicit/in.json 0000664 0000000 0000000 00000000032 15015766371 0032737 0 ustar 00root root 0000000 0000000 {
"d": 23,
"a": 4.2
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/mixed-block-mapping-implicit-to-explicit/in.yaml 0000664 0000000 0000000 00000000020 15015766371 0032725 0 ustar 00root root 0000000 0000000 a: 4.2
? d
: 23
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/mixed-block-mapping-implicit-to-explicit/out.yaml 0000664 0000000 0000000 00000000015 15015766371 0033132 0 ustar 00root root 0000000 0000000 a: 4.2
d: 23
more-indented-lines-at-the-beginning-of-folded-block-scalars/ 0000775 0000000 0000000 00000000000 15015766371 0035021 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite in.json 0000664 0000000 0000000 00000000117 15015766371 0036321 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/more-indented-lines-at-the-beginning-of-folded-block-scalars {
"a": " more indented\nregular\n",
"b": "\n\n more indented\nregular\n"
}
in.yaml 0000664 0000000 0000000 00000000110 15015766371 0036303 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/more-indented-lines-at-the-beginning-of-folded-block-scalars ---
a: >2
more indented
regular
b: >2
more indented
regular
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/multi-level-mapping-indent/ 0000775 0000000 0000000 00000000000 15015766371 0026714 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/multi-level-mapping-indent/in.json 0000664 0000000 0000000 00000000136 15015766371 0030215 0 ustar 00root root 0000000 0000000 {
"a": {
"b": {
"c": "d"
},
"e": {
"f": "g"
}
},
"h": "i"
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/multi-level-mapping-indent/in.yaml 0000664 0000000 0000000 00000000044 15015766371 0030204 0 ustar 00root root 0000000 0000000 a:
b:
c: d
e:
f: g
h: i
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/multiline-double-quoted-flow-mapping-key/ 0000775 0000000 0000000 00000000000 15015766371 0031502 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/multiline-double-quoted-flow-mapping-key/in.json 0000664 0000000 0000000 00000000112 15015766371 0032775 0 ustar 00root root 0000000 0000000 [
{
"single line": "value"
},
{
"multi line": "value"
}
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/multiline-double-quoted-flow-mapping-key/in.yaml 0000664 0000000 0000000 00000000071 15015766371 0032772 0 ustar 00root root 0000000 0000000 ---
- { "single line": value}
- { "multi
line": value}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/multiline-double-quoted-flow-mapping-key/out.yaml 0000664 0000000 0000000 00000000061 15015766371 0033172 0 ustar 00root root 0000000 0000000 ---
- "single line": value
- "multi line": value
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/multiline-double-quoted-implicit-keys/ 0000775 0000000 0000000 00000000000 15015766371 0031077 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/multiline-double-quoted-implicit-keys/error 0000664 0000000 0000000 00000000000 15015766371 0032141 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/multiline-double-quoted-implicit-keys/in.yaml 0000664 0000000 0000000 00000000024 15015766371 0032365 0 ustar 00root root 0000000 0000000 "a\nb": 1
"c
d": 1
multiline-doublequoted-flow-mapping-key-without-value/ 0000775 0000000 0000000 00000000000 15015766371 0034161 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite in.json 0000664 0000000 0000000 00000000140 15015766371 0035455 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/multiline-doublequoted-flow-mapping-key-without-value [
{
"single line": null,
"a": "b"
},
{
"multi line": null,
"a": "b"
}
]
in.yaml 0000664 0000000 0000000 00000000067 15015766371 0035456 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/multiline-doublequoted-flow-mapping-key-without-value ---
- { "single line", a: b}
- { "multi
line", a: b}
out.yaml 0000664 0000000 0000000 00000000063 15015766371 0035653 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/multiline-doublequoted-flow-mapping-key-without-value ---
- "single line":
a: b
- "multi line":
a: b
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/multiline-implicit-keys/ 0000775 0000000 0000000 00000000000 15015766371 0026330 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/multiline-implicit-keys/error 0000664 0000000 0000000 00000000000 15015766371 0027372 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/multiline-implicit-keys/in.yaml 0000664 0000000 0000000 00000000020 15015766371 0027612 0 ustar 00root root 0000000 0000000 a\nb: 1
c
d: 1
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/multiline-plain-flow-mapping-key-without-value/ 0000775 0000000 0000000 00000000000 15015766371 0032647 5 ustar 00root root 0000000 0000000 in.json 0000664 0000000 0000000 00000000140 15015766371 0034064 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/multiline-plain-flow-mapping-key-without-value [
{
"single line": null,
"a": "b"
},
{
"multi line": null,
"a": "b"
}
]
in.yaml 0000664 0000000 0000000 00000000063 15015766371 0034061 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/multiline-plain-flow-mapping-key-without-value ---
- { single line, a: b}
- { multi
line, a: b}
out.yaml 0000664 0000000 0000000 00000000057 15015766371 0034265 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/multiline-plain-flow-mapping-key-without-value ---
- single line:
a: b
- multi line:
a: b
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/multiline-plain-flow-mapping-key/ 0000775 0000000 0000000 00000000000 15015766371 0030034 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/multiline-plain-flow-mapping-key/in.json 0000664 0000000 0000000 00000000112 15015766371 0031327 0 ustar 00root root 0000000 0000000 [
{
"single line": "value"
},
{
"multi line": "value"
}
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/multiline-plain-flow-mapping-key/in.yaml 0000664 0000000 0000000 00000000065 15015766371 0031327 0 ustar 00root root 0000000 0000000 ---
- { single line: value}
- { multi
line: value}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/multiline-plain-flow-mapping-key/out.yaml 0000664 0000000 0000000 00000000055 15015766371 0031527 0 ustar 00root root 0000000 0000000 ---
- single line: value
- multi line: value
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/multiline-plain-scalar-with-empty-line/ 0000775 0000000 0000000 00000000000 15015766371 0031145 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/multiline-plain-scalar-with-empty-line/in.json 0000664 0000000 0000000 00000000030 15015766371 0032437 0 ustar 00root root 0000000 0000000 {
"plain": "a b\nc"
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/multiline-plain-scalar-with-empty-line/in.yaml 0000664 0000000 0000000 00000000024 15015766371 0032433 0 ustar 00root root 0000000 0000000 ---
plain: a
b
c
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/multiline-plain-scalar-with-empty-line/out.yaml 0000664 0000000 0000000 00000000026 15015766371 0032636 0 ustar 00root root 0000000 0000000 ---
plain: 'a b
c'
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/multiline-plain-value-with-tabs-on-empty-lines/ 0000775 0000000 0000000 00000000000 15015766371 0032540 5 ustar 00root root 0000000 0000000 in.json 0000664 0000000 0000000 00000000040 15015766371 0033754 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/multiline-plain-value-with-tabs-on-empty-lines {
"key": "value with\ntabs"
}
in.yaml 0000664 0000000 0000000 00000000037 15015766371 0033753 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/multiline-plain-value-with-tabs-on-empty-lines key:
value
with
tabs
out.yaml 0000664 0000000 0000000 00000000032 15015766371 0034147 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/multiline-plain-value-with-tabs-on-empty-lines key: 'value with
tabs'
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/multiline-scalar-at-top-level-1-3/ 0000775 0000000 0000000 00000000000 15015766371 0027617 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/multiline-scalar-at-top-level-1-3/in.json 0000664 0000000 0000000 00000000015 15015766371 0031114 0 ustar 00root root 0000000 0000000 "a b c d\ne"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/multiline-scalar-at-top-level-1-3/in.yaml 0000664 0000000 0000000 00000000023 15015766371 0031104 0 ustar 00root root 0000000 0000000 ---
a
b
c
d
e
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/multiline-scalar-at-top-level-1-3/out.yaml 0000664 0000000 0000000 00000000017 15015766371 0031310 0 ustar 00root root 0000000 0000000 'a b c d
e'
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/multiline-scalar-at-top-level/ 0000775 0000000 0000000 00000000000 15015766371 0027321 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/multiline-scalar-at-top-level/in.json 0000664 0000000 0000000 00000000015 15015766371 0030616 0 ustar 00root root 0000000 0000000 "a b c d\ne"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/multiline-scalar-at-top-level/in.yaml 0000664 0000000 0000000 00000000017 15015766371 0030611 0 ustar 00root root 0000000 0000000 a
b
c
d
e
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/multiline-scalar-at-top-level/out.yaml 0000664 0000000 0000000 00000000017 15015766371 0031012 0 ustar 00root root 0000000 0000000 'a b c d
e'
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/multiline-scalar-in-mapping/ 0000775 0000000 0000000 00000000000 15015766371 0027047 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/multiline-scalar-in-mapping/in.json 0000664 0000000 0000000 00000000037 15015766371 0030350 0 ustar 00root root 0000000 0000000 {
"a": "b c",
"d": "e f"
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/multiline-scalar-in-mapping/in.yaml 0000664 0000000 0000000 00000000022 15015766371 0030333 0 ustar 00root root 0000000 0000000 a: b
c
d:
e
f
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/multiline-scalar-in-mapping/out.yaml 0000664 0000000 0000000 00000000016 15015766371 0030537 0 ustar 00root root 0000000 0000000 a: b c
d: e f
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/multiline-scalar-that-looks-like-a-yaml-directive/ 0000775 0000000 0000000 00000000000 15015766371 0033151 5 ustar 00root root 0000000 0000000 in.json 0000664 0000000 0000000 00000000023 15015766371 0034366 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/multiline-scalar-that-looks-like-a-yaml-directive "scalar %YAML 1.2"
in.yaml 0000664 0000000 0000000 00000000025 15015766371 0034361 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/multiline-scalar-that-looks-like-a-yaml-directive ---
scalar
%YAML 1.2
out.yaml 0000664 0000000 0000000 00000000031 15015766371 0034557 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/multiline-scalar-that-looks-like-a-yaml-directive --- scalar %YAML 1.2
...
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/multiline-single-quoted-implicit-keys/ 0000775 0000000 0000000 00000000000 15015766371 0031106 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/multiline-single-quoted-implicit-keys/error 0000664 0000000 0000000 00000000000 15015766371 0032150 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/multiline-single-quoted-implicit-keys/in.yaml 0000664 0000000 0000000 00000000024 15015766371 0032374 0 ustar 00root root 0000000 0000000 'a\nb': 1
'c
d': 1
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/multiline-unidented-double-quoted-block-key/ 0000775 0000000 0000000 00000000000 15015766371 0032151 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/multiline-unidented-double-quoted-block-key/error 0000664 0000000 0000000 00000000000 15015766371 0033213 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/multiline-unidented-double-quoted-block-key/in.yaml 0000664 0000000 0000000 00000000021 15015766371 0033434 0 ustar 00root root 0000000 0000000 - - "bar
bar": x
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/multiple-entry-block-sequence/ 0000775 0000000 0000000 00000000000 15015766371 0027435 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/multiple-entry-block-sequence/in.json 0000664 0000000 0000000 00000000033 15015766371 0030732 0 ustar 00root root 0000000 0000000 [
"foo",
"bar",
42
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/multiple-entry-block-sequence/in.yaml 0000664 0000000 0000000 00000000021 15015766371 0030720 0 ustar 00root root 0000000 0000000 - foo
- bar
- 42
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/multiple-pair-block-mapping/ 0000775 0000000 0000000 00000000000 15015766371 0027052 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/multiple-pair-block-mapping/in.json 0000664 0000000 0000000 00000000066 15015766371 0030355 0 ustar 00root root 0000000 0000000 {
"foo": "blue",
"bar": "arrr",
"baz": "jazz"
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/multiple-pair-block-mapping/in.yaml 0000664 0000000 0000000 00000000036 15015766371 0030343 0 ustar 00root root 0000000 0000000 foo: blue
bar: arrr
baz: jazz
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/need-document-footer-before-directives/ 0000775 0000000 0000000 00000000000 15015766371 0031167 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/need-document-footer-before-directives/error 0000664 0000000 0000000 00000000000 15015766371 0032231 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/need-document-footer-before-directives/in.yaml 0000664 0000000 0000000 00000000073 15015766371 0032461 0 ustar 00root root 0000000 0000000 !foo "bar"
%TAG ! tag:example.com,2000:app/
---
!foo "bar"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/nested-flow-collections-on-one-line/ 0000775 0000000 0000000 00000000000 15015766371 0030426 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/nested-flow-collections-on-one-line/in.json 0000664 0000000 0000000 00000000135 15015766371 0031726 0 ustar 00root root 0000000 0000000 {
"a": [
"b",
"c",
{
"d": [
"e",
"f"
]
}
]
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/nested-flow-collections-on-one-line/in.yaml 0000664 0000000 0000000 00000000042 15015766371 0031714 0 ustar 00root root 0000000 0000000 ---
{ a: [b, c, { d: [e, f] } ] }
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/nested-flow-collections-on-one-line/out.yaml 0000664 0000000 0000000 00000000040 15015766371 0032113 0 ustar 00root root 0000000 0000000 ---
a:
- b
- c
- d:
- e
- f
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/nested-flow-collections/ 0000775 0000000 0000000 00000000000 15015766371 0026310 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/nested-flow-collections/in.json 0000664 0000000 0000000 00000000135 15015766371 0027610 0 ustar 00root root 0000000 0000000 {
"a": [
"b",
"c",
{
"d": [
"e",
"f"
]
}
]
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/nested-flow-collections/in.yaml 0000664 0000000 0000000 00000000054 15015766371 0027601 0 ustar 00root root 0000000 0000000 ---
{
a: [
b, c, {
d: [e, f]
}
]
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/nested-flow-collections/out.yaml 0000664 0000000 0000000 00000000040 15015766371 0027775 0 ustar 00root root 0000000 0000000 ---
a:
- b
- c
- d:
- e
- f
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/nested-flow-mapping-sequence-and-mappings/ 0000775 0000000 0000000 00000000000 15015766371 0031607 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/nested-flow-mapping-sequence-and-mappings/in.json 0000664 0000000 0000000 00000000145 15015766371 0033110 0 ustar 00root root 0000000 0000000 {
"top1": [
"item1",
{
"key2": "value2"
},
"item3"
],
"top2": "value2"
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/nested-flow-mapping-sequence-and-mappings/in.yaml 0000664 0000000 0000000 00000000073 15015766371 0033101 0 ustar 00root root 0000000 0000000 ---
{ top1: [item1, {key2: value2}, item3], top2: value2 }
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/nested-flow-mapping-sequence-and-mappings/out.yaml 0000664 0000000 0000000 00000000066 15015766371 0033304 0 ustar 00root root 0000000 0000000 ---
top1:
- item1
- key2: value2
- item3
top2: value2
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/nested-implicit-complex-keys/ 0000775 0000000 0000000 00000000000 15015766371 0027255 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/nested-implicit-complex-keys/in.yaml 0000664 0000000 0000000 00000000045 15015766371 0030546 0 ustar 00root root 0000000 0000000 ---
[
[ a, [ [[b,c]]: d, e]]: 23
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/nested-implicit-complex-keys/out.yaml 0000664 0000000 0000000 00000000111 15015766371 0030741 0 ustar 00root root 0000000 0000000 ---
- ? - a
- - ? - - b
- c
: d
- e
: 23
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/nested-top-level-flow-mapping/ 0000775 0000000 0000000 00000000000 15015766371 0027332 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/nested-top-level-flow-mapping/in.json 0000664 0000000 0000000 00000000077 15015766371 0030637 0 ustar 00root root 0000000 0000000 {
"key": [
[
[
"value"
]
]
]
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/nested-top-level-flow-mapping/in.yaml 0000664 0000000 0000000 00000000032 15015766371 0030617 0 ustar 00root root 0000000 0000000 { key: [[[
value
]]]
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/nested-top-level-flow-mapping/out.yaml 0000664 0000000 0000000 00000000021 15015766371 0031016 0 ustar 00root root 0000000 0000000 key:
- - - value
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/node-anchor-and-tag-on-seperate-lines/ 0000775 0000000 0000000 00000000000 15015766371 0030603 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/node-anchor-and-tag-on-seperate-lines/in.json 0000664 0000000 0000000 00000000040 15015766371 0032076 0 ustar 00root root 0000000 0000000 {
"key": {
"a": "b"
}
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/node-anchor-and-tag-on-seperate-lines/in.yaml 0000664 0000000 0000000 00000000033 15015766371 0032071 0 ustar 00root root 0000000 0000000 key: &anchor
!!map
a: b
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/node-anchor-and-tag-on-seperate-lines/out.yaml 0000664 0000000 0000000 00000000032 15015766371 0032271 0 ustar 00root root 0000000 0000000 key: &anchor !!map
a: b
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/node-anchor-in-sequence/ 0000775 0000000 0000000 00000000000 15015766371 0026154 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/node-anchor-in-sequence/error 0000664 0000000 0000000 00000000000 15015766371 0027216 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/node-anchor-in-sequence/in.yaml 0000664 0000000 0000000 00000000026 15015766371 0027444 0 ustar 00root root 0000000 0000000 - item1
&node
- item2
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/node-anchor-not-indented/ 0000775 0000000 0000000 00000000000 15015766371 0026330 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/node-anchor-not-indented/error 0000664 0000000 0000000 00000000000 15015766371 0027372 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/node-anchor-not-indented/in.yaml 0000664 0000000 0000000 00000000025 15015766371 0027617 0 ustar 00root root 0000000 0000000 key: &x
!!map
a: b
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/node-and-mapping-key-anchors-1-3/ 0000775 0000000 0000000 00000000000 15015766371 0027402 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/node-and-mapping-key-anchors-1-3/in.json 0000664 0000000 0000000 00000000332 15015766371 0030701 0 ustar 00root root 0000000 0000000 {
"top1": {
"key1": "one"
},
"top2": {
"key2": "two"
},
"top3": {
"key3": "three"
},
"top4": {
"key4": "four"
},
"top5": {
"key5": "five"
},
"top6": "six",
"top7": "seven"
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/node-and-mapping-key-anchors-1-3/in.yaml 0000664 0000000 0000000 00000000272 15015766371 0030675 0 ustar 00root root 0000000 0000000 ---
top1: &node1
&k1 key1: one
top2: &node2 # comment
key2: two
top3:
&k3 key3: three
top4: &node4
&k4 key4: four
top5: &node5
key5: five
top6: &val6
six
top7:
&val7 seven
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/node-and-mapping-key-anchors-1-3/out.yaml 0000664 0000000 0000000 00000000254 15015766371 0031076 0 ustar 00root root 0000000 0000000 ---
top1: &node1
&k1 key1: one
top2: &node2
key2: two
top3:
&k3 key3: three
top4: &node4
&k4 key4: four
top5: &node5
key5: five
top6: &val6 six
top7: &val7 seven
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/node-and-mapping-key-anchors/ 0000775 0000000 0000000 00000000000 15015766371 0027104 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/node-and-mapping-key-anchors/in.json 0000664 0000000 0000000 00000000332 15015766371 0030403 0 ustar 00root root 0000000 0000000 {
"top1": {
"key1": "one"
},
"top2": {
"key2": "two"
},
"top3": {
"key3": "three"
},
"top4": {
"key4": "four"
},
"top5": {
"key5": "five"
},
"top6": "six",
"top7": "seven"
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/node-and-mapping-key-anchors/in.yaml 0000664 0000000 0000000 00000000276 15015766371 0030403 0 ustar 00root root 0000000 0000000 ---
top1: &node1
&k1 key1: one
top2: &node2 # comment
key2: two
top3:
&k3 key3: three
top4:
&node4
&k4 key4: four
top5:
&node5
key5: five
top6: &val6
six
top7:
&val7 seven
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/node-and-mapping-key-anchors/out.yaml 0000664 0000000 0000000 00000000254 15015766371 0030600 0 ustar 00root root 0000000 0000000 ---
top1: &node1
&k1 key1: one
top2: &node2
key2: two
top3:
&k3 key3: three
top4: &node4
&k4 key4: four
top5: &node5
key5: five
top6: &val6 six
top7: &val7 seven
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/non-specific-tags-on-scalars/ 0000775 0000000 0000000 00000000000 15015766371 0027116 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/non-specific-tags-on-scalars/in.json 0000664 0000000 0000000 00000000122 15015766371 0030412 0 ustar 00root root 0000000 0000000 [
"plain",
"double quoted",
"single quoted",
"block\n",
"plain again"
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/non-specific-tags-on-scalars/in.yaml 0000664 0000000 0000000 00000000106 15015766371 0030405 0 ustar 00root root 0000000 0000000 - plain
- "double quoted"
- 'single quoted'
- >
block
- plain again
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/plain-dashes-in-flow-sequence/ 0000775 0000000 0000000 00000000000 15015766371 0027274 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/plain-dashes-in-flow-sequence/error 0000664 0000000 0000000 00000000000 15015766371 0030336 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/plain-dashes-in-flow-sequence/in.yaml 0000664 0000000 0000000 00000000015 15015766371 0030562 0 ustar 00root root 0000000 0000000 ---
- [-, -]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/plain-mapping-key-ending-with-colon/ 0000775 0000000 0000000 00000000000 15015766371 0030412 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/plain-mapping-key-ending-with-colon/in.json 0000664 0000000 0000000 00000000054 15015766371 0031712 0 ustar 00root root 0000000 0000000 {
"key ends with two colons::": "value"
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/plain-mapping-key-ending-with-colon/in.yaml 0000664 0000000 0000000 00000000046 15015766371 0031704 0 ustar 00root root 0000000 0000000 ---
key ends with two colons::: value
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/plain-mapping-key-ending-with-colon/out.yaml 0000664 0000000 0000000 00000000050 15015766371 0032100 0 ustar 00root root 0000000 0000000 ---
'key ends with two colons::': value
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/plain-scalar-looking-like-key-comment-anchor-and-tag/0000775 0000000 0000000 00000000000 15015766371 0033504 5 ustar 00root root 0000000 0000000 in.json 0000664 0000000 0000000 00000000021 15015766371 0034717 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/plain-scalar-looking-like-key-comment-anchor-and-tag "k:#foo &a !t s"
in.yaml 0000664 0000000 0000000 00000000024 15015766371 0034713 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/plain-scalar-looking-like-key-comment-anchor-and-tag ---
k:#foo
&a !t s
out.yaml 0000664 0000000 0000000 00000000023 15015766371 0035113 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/plain-scalar-looking-like-key-comment-anchor-and-tag --- k:#foo &a !t s
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/plain-scalar-with-backslashes/ 0000775 0000000 0000000 00000000000 15015766371 0027345 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/plain-scalar-with-backslashes/in.json 0000664 0000000 0000000 00000000042 15015766371 0030642 0 ustar 00root root 0000000 0000000 "plain\\value\\with\\backslashes"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/plain-scalar-with-backslashes/in.yaml 0000664 0000000 0000000 00000000041 15015766371 0030632 0 ustar 00root root 0000000 0000000 ---
plain\value\with\backslashes
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/plain-scalar-with-backslashes/out.yaml 0000664 0000000 0000000 00000000041 15015766371 0031033 0 ustar 00root root 0000000 0000000 --- plain\value\with\backslashes
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/plain-url-in-flow-mapping/ 0000775 0000000 0000000 00000000000 15015766371 0026452 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/plain-url-in-flow-mapping/in.json 0000664 0000000 0000000 00000000054 15015766371 0027752 0 ustar 00root root 0000000 0000000 [
{
"url": "http://example.org"
}
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/plain-url-in-flow-mapping/in.yaml 0000664 0000000 0000000 00000000036 15015766371 0027743 0 ustar 00root root 0000000 0000000 - { url: http://example.org }
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/plain-url-in-flow-mapping/out.yaml 0000664 0000000 0000000 00000000032 15015766371 0030140 0 ustar 00root root 0000000 0000000 - url: http://example.org
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/question-mark-at-start-of-flow-key/ 0000775 0000000 0000000 00000000000 15015766371 0030236 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/question-mark-at-start-of-flow-key/in.json 0000664 0000000 0000000 00000000043 15015766371 0031534 0 ustar 00root root 0000000 0000000 {
"?foo" : "bar",
"bar" : 42
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/question-mark-at-start-of-flow-key/in.yaml 0000664 0000000 0000000 00000000027 15015766371 0031527 0 ustar 00root root 0000000 0000000 { ?foo: bar,
bar: 42
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/question-mark-at-start-of-flow-key/out.yaml 0000664 0000000 0000000 00000000026 15015766371 0031727 0 ustar 00root root 0000000 0000000 ---
?foo: bar
bar: 42
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/question-mark-edge-cases/ 0000775 0000000 0000000 00000000000 15015766371 0026342 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/question-mark-edge-cases/00/ 0000775 0000000 0000000 00000000000 15015766371 0026561 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/question-mark-edge-cases/00/in.yaml 0000664 0000000 0000000 00000000010 15015766371 0030042 0 ustar 00root root 0000000 0000000 - ? : x
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/question-mark-edge-cases/00/out.yaml 0000664 0000000 0000000 00000000014 15015766371 0030247 0 ustar 00root root 0000000 0000000 - ? : x
:
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/question-mark-edge-cases/01/ 0000775 0000000 0000000 00000000000 15015766371 0026562 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/question-mark-edge-cases/01/in.yaml 0000664 0000000 0000000 00000000010 15015766371 0030043 0 ustar 00root root 0000000 0000000 ? []: x
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/question-mark-edge-cases/01/out.yaml 0000664 0000000 0000000 00000000012 15015766371 0030246 0 ustar 00root root 0000000 0000000 ? []: x
:
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/question-marks-in-scalars/ 0000775 0000000 0000000 00000000000 15015766371 0026561 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/question-marks-in-scalars/in.json 0000664 0000000 0000000 00000000323 15015766371 0030060 0 ustar 00root root 0000000 0000000 [
"a?string",
"another ? string",
{
"key": "value?"
},
[
"a?string"
],
[
"another ? string"
],
{
"key": "value?"
},
{
"key": "value?"
},
{
"key?": "value"
}
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/question-marks-in-scalars/in.yaml 0000664 0000000 0000000 00000000200 15015766371 0030043 0 ustar 00root root 0000000 0000000 - a?string
- another ? string
- key: value?
- [a?string]
- [another ? string]
- {key: value? }
- {key: value?}
- {key?: value }
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/question-marks-in-scalars/out.yaml 0000664 0000000 0000000 00000000170 15015766371 0030252 0 ustar 00root root 0000000 0000000 - a?string
- another ? string
- key: value?
- - a?string
- - another ? string
- key: value?
- key: value?
- key?: value
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/scalar-doc-with-in-content/ 0000775 0000000 0000000 00000000000 15015766371 0026602 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/scalar-doc-with-in-content/00/ 0000775 0000000 0000000 00000000000 15015766371 0027021 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/scalar-doc-with-in-content/00/in.json 0000664 0000000 0000000 00000000013 15015766371 0030314 0 ustar 00root root 0000000 0000000 "a ...x b"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/scalar-doc-with-in-content/00/in.yaml 0000664 0000000 0000000 00000000017 15015766371 0030311 0 ustar 00root root 0000000 0000000 --- "a
...x
b"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/scalar-doc-with-in-content/00/out.yaml 0000664 0000000 0000000 00000000015 15015766371 0030510 0 ustar 00root root 0000000 0000000 --- a ...x b
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/scalar-doc-with-in-content/01/ 0000775 0000000 0000000 00000000000 15015766371 0027022 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/scalar-doc-with-in-content/01/error 0000664 0000000 0000000 00000000000 15015766371 0030064 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/scalar-doc-with-in-content/01/in.json 0000664 0000000 0000000 00000000013 15015766371 0030315 0 ustar 00root root 0000000 0000000 "a ...x b"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/scalar-doc-with-in-content/01/in.yaml 0000664 0000000 0000000 00000000020 15015766371 0030304 0 ustar 00root root 0000000 0000000 --- "a
... x
b"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/scalar-value-with-two-anchors/ 0000775 0000000 0000000 00000000000 15015766371 0027337 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/scalar-value-with-two-anchors/error 0000664 0000000 0000000 00000000000 15015766371 0030401 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/scalar-value-with-two-anchors/in.yaml 0000664 0000000 0000000 00000000066 15015766371 0030633 0 ustar 00root root 0000000 0000000 top1: &node1
&k1 key1: val1
top2: &node2
&v2 val2
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/scalars-in-flow-start-with-syntax-char/ 0000775 0000000 0000000 00000000000 15015766371 0031111 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/scalars-in-flow-start-with-syntax-char/00/ 0000775 0000000 0000000 00000000000 15015766371 0031330 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/scalars-in-flow-start-with-syntax-char/00/in.json 0000664 0000000 0000000 00000000013 15015766371 0032623 0 ustar 00root root 0000000 0000000 [
":x"
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/scalars-in-flow-start-with-syntax-char/00/in.yaml 0000664 0000000 0000000 00000000005 15015766371 0032615 0 ustar 00root root 0000000 0000000 [:x]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/scalars-in-flow-start-with-syntax-char/00/out.yaml 0000664 0000000 0000000 00000000005 15015766371 0033016 0 ustar 00root root 0000000 0000000 - :x
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/scalars-in-flow-start-with-syntax-char/01/ 0000775 0000000 0000000 00000000000 15015766371 0031331 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/scalars-in-flow-start-with-syntax-char/01/in.json 0000664 0000000 0000000 00000000013 15015766371 0032624 0 ustar 00root root 0000000 0000000 [
"?x"
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/scalars-in-flow-start-with-syntax-char/01/in.yaml 0000664 0000000 0000000 00000000005 15015766371 0032616 0 ustar 00root root 0000000 0000000 [?x]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/scalars-in-flow-start-with-syntax-char/01/out.yaml 0000664 0000000 0000000 00000000005 15015766371 0033017 0 ustar 00root root 0000000 0000000 - ?x
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/scalars-on-line/ 0000775 0000000 0000000 00000000000 15015766371 0024534 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/scalars-on-line/in.json 0000664 0000000 0000000 00000000026 15015766371 0026033 0 ustar 00root root 0000000 0000000 "quoted string"
"foo"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/scalars-on-line/in.yaml 0000664 0000000 0000000 00000000042 15015766371 0026022 0 ustar 00root root 0000000 0000000 --- "quoted
string"
--- &node foo
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/scalars-on-line/out.yaml 0000664 0000000 0000000 00000000046 15015766371 0026227 0 ustar 00root root 0000000 0000000 --- "quoted string"
--- &node foo
...
sequence-entry-that-looks-like-two-with-wrong-indentation/ 0000775 0000000 0000000 00000000000 15015766371 0034666 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite in.json 0000664 0000000 0000000 00000000052 15015766371 0036164 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/sequence-entry-that-looks-like-two-with-wrong-indentation [
"single multiline - sequence entry"
]
in.yaml 0000664 0000000 0000000 00000000045 15015766371 0036157 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/sequence-entry-that-looks-like-two-with-wrong-indentation - single multiline
- sequence entry
out.yaml 0000664 0000000 0000000 00000000044 15015766371 0036357 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/sequence-entry-that-looks-like-two-with-wrong-indentation - single multiline - sequence entry
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/sequence-indent/ 0000775 0000000 0000000 00000000000 15015766371 0024634 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/sequence-indent/in.json 0000664 0000000 0000000 00000000061 15015766371 0026132 0 ustar 00root root 0000000 0000000 {
"foo": [
42
],
"bar": [
44
]
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/sequence-indent/in.yaml 0000664 0000000 0000000 00000000026 15015766371 0026124 0 ustar 00root root 0000000 0000000 foo:
- 42
bar:
- 44
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/sequence-indent/out.yaml 0000664 0000000 0000000 00000000024 15015766371 0026323 0 ustar 00root root 0000000 0000000 foo:
- 42
bar:
- 44
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/sequence-on-same-line-as-mapping-key/ 0000775 0000000 0000000 00000000000 15015766371 0030457 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/sequence-on-same-line-as-mapping-key/error 0000664 0000000 0000000 00000000000 15015766371 0031521 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/sequence-on-same-line-as-mapping-key/in.yaml 0000664 0000000 0000000 00000000022 15015766371 0031743 0 ustar 00root root 0000000 0000000 key: - a
- b
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/sequence-with-same-indentation-as-parent-mapping/ 0000775 0000000 0000000 00000000000 15015766371 0033104 5 ustar 00root root 0000000 0000000 in.json 0000664 0000000 0000000 00000000055 15015766371 0034326 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/sequence-with-same-indentation-as-parent-mapping {
"one": [
2,
3
],
"four": 5
}
in.yaml 0000664 0000000 0000000 00000000025 15015766371 0034314 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/sequence-with-same-indentation-as-parent-mapping one:
- 2
- 3
four: 5
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/simple-mapping-indent/ 0000775 0000000 0000000 00000000000 15015766371 0025746 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/simple-mapping-indent/in.json 0000664 0000000 0000000 00000000044 15015766371 0027245 0 ustar 00root root 0000000 0000000 {
"foo": {
"bar": "baz"
}
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/simple-mapping-indent/in.yaml 0000664 0000000 0000000 00000000020 15015766371 0027230 0 ustar 00root root 0000000 0000000 foo:
bar: baz
single-block-sequence-with-anchor-and-explicit-document-start/ 0000775 0000000 0000000 00000000000 15015766371 0035414 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite in.json 0000664 0000000 0000000 00000000012 15015766371 0036706 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/single-block-sequence-with-anchor-and-explicit-document-start [
"a"
]
in.yaml 0000664 0000000 0000000 00000000022 15015766371 0036700 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/single-block-sequence-with-anchor-and-explicit-document-start --- &sequence
- a
out.yaml 0000664 0000000 0000000 00000000022 15015766371 0037101 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/single-block-sequence-with-anchor-and-explicit-document-start --- &sequence
- a
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/single-block-sequence-with-anchor/ 0000775 0000000 0000000 00000000000 15015766371 0030145 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/single-block-sequence-with-anchor/in.json 0000664 0000000 0000000 00000000012 15015766371 0031437 0 ustar 00root root 0000000 0000000 [
"a"
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/single-block-sequence-with-anchor/in.yaml 0000664 0000000 0000000 00000000016 15015766371 0031434 0 ustar 00root root 0000000 0000000 &sequence
- a
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/single-block-sequence-with-anchor/out.yaml 0000664 0000000 0000000 00000000016 15015766371 0031635 0 ustar 00root root 0000000 0000000 &sequence
- a
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/single-character-streams/ 0000775 0000000 0000000 00000000000 15015766371 0026434 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/single-character-streams/00/ 0000775 0000000 0000000 00000000000 15015766371 0026653 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/single-character-streams/00/in.json 0000664 0000000 0000000 00000000007 15015766371 0030151 0 ustar 00root root 0000000 0000000 [null]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/single-character-streams/00/in.yaml 0000664 0000000 0000000 00000000001 15015766371 0030134 0 ustar 00root root 0000000 0000000 - goccy-go-yaml-52dacb8/testdata/yaml-test-suite/single-character-streams/00/out.yaml 0000664 0000000 0000000 00000000002 15015766371 0030336 0 ustar 00root root 0000000 0000000 -
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/single-character-streams/01/ 0000775 0000000 0000000 00000000000 15015766371 0026654 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/single-character-streams/01/in.yaml 0000664 0000000 0000000 00000000001 15015766371 0030135 0 ustar 00root root 0000000 0000000 : goccy-go-yaml-52dacb8/testdata/yaml-test-suite/single-character-streams/01/out.yaml 0000664 0000000 0000000 00000000002 15015766371 0030337 0 ustar 00root root 0000000 0000000 :
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/single-entry-block-sequence/ 0000775 0000000 0000000 00000000000 15015766371 0027063 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/single-entry-block-sequence/in.json 0000664 0000000 0000000 00000000014 15015766371 0030357 0 ustar 00root root 0000000 0000000 [
"foo"
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/single-entry-block-sequence/in.yaml 0000664 0000000 0000000 00000000006 15015766371 0030351 0 ustar 00root root 0000000 0000000 - foo
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/single-pair-block-mapping/ 0000775 0000000 0000000 00000000000 15015766371 0026500 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/single-pair-block-mapping/in.json 0000664 0000000 0000000 00000000023 15015766371 0027774 0 ustar 00root root 0000000 0000000 {
"foo": "bar"
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/single-pair-block-mapping/in.yaml 0000664 0000000 0000000 00000000011 15015766371 0027762 0 ustar 00root root 0000000 0000000 foo: bar
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/single-pair-implicit-entries/ 0000775 0000000 0000000 00000000000 15015766371 0027236 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/single-pair-implicit-entries/in.yaml 0000664 0000000 0000000 00000000115 15015766371 0030525 0 ustar 00root root 0000000 0000000 - [ YAML : separate ]
- [ "JSON like":adjacent ]
- [ {JSON: like}:adjacent ]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/single-pair-implicit-entries/out.yaml 0000664 0000000 0000000 00000000115 15015766371 0030726 0 ustar 00root root 0000000 0000000 - - YAML: separate
- - "JSON like": adjacent
- - ? JSON: like
: adjacent
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-1-sequence-of-scalars/ 0000775 0000000 0000000 00000000000 15015766371 0030263 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-1-sequence-of-scalars/in.json 0000664 0000000 0000000 00000000066 15015766371 0031566 0 ustar 00root root 0000000 0000000 [
"Mark McGwire",
"Sammy Sosa",
"Ken Griffey"
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-1-sequence-of-scalars/in.yaml 0000664 0000000 0000000 00000000052 15015766371 0031552 0 ustar 00root root 0000000 0000000 - Mark McGwire
- Sammy Sosa
- Ken Griffey
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-1-sequence-of-scalars/lex.token 0000664 0000000 0000000 00000000251 15015766371 0032113 0 ustar 00root root 0000000 0000000 SEQ-MARK 0 1 1 1
WS-SPACE 1 1 1 2
TEXT-VAL 2 12 1 3 :Mark McGwire
WS-NEWLN 14 1 1 15
SEQ-MARK 15 1 2 1
WS-SPACE 1 1 1 2
TEXT-VAL 2 12 1 3 :Sammy Sosa
WS-NEWLN 14 1 1 15
spec-example-2-10-node-for-sammy-sosa-appears-twice-in-this-document/ 0000775 0000000 0000000 00000000000 15015766371 0036153 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite in.json 0000664 0000000 0000000 00000000153 15015766371 0037453 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-10-node-for-sammy-sosa-appears-twice-in-this-document {
"hr": [
"Mark McGwire",
"Sammy Sosa"
],
"rbi": [
"Sammy Sosa",
"Ken Griffey"
]
}
in.yaml 0000664 0000000 0000000 00000000177 15015766371 0037452 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-10-node-for-sammy-sosa-appears-twice-in-this-document ---
hr:
- Mark McGwire
# Following node labeled SS
- &SS Sammy Sosa
rbi:
- *SS # Subsequent occurrence
- Ken Griffey
out.yaml 0000664 0000000 0000000 00000000101 15015766371 0037636 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-10-node-for-sammy-sosa-appears-twice-in-this-document ---
hr:
- Mark McGwire
- &SS Sammy Sosa
rbi:
- *SS
- Ken Griffey
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-11-mapping-between-sequences/ 0000775 0000000 0000000 00000000000 15015766371 0031557 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-11-mapping-between-sequences/in.yaml 0000664 0000000 0000000 00000000216 15015766371 0033050 0 ustar 00root root 0000000 0000000 ? - Detroit Tigers
- Chicago cubs
:
- 2001-07-23
? [ New York Yankees,
Atlanta Braves ]
: [ 2001-07-02, 2001-08-12,
2001-08-14 ]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-11-mapping-between-sequences/out.yaml 0000664 0000000 0000000 00000000210 15015766371 0033243 0 ustar 00root root 0000000 0000000 ? - Detroit Tigers
- Chicago cubs
: - 2001-07-23
? - New York Yankees
- Atlanta Braves
: - 2001-07-02
- 2001-08-12
- 2001-08-14
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-12-compact-nested-mapping/ 0000775 0000000 0000000 00000000000 15015766371 0031044 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-12-compact-nested-mapping/in.json 0000664 0000000 0000000 00000000241 15015766371 0032342 0 ustar 00root root 0000000 0000000 [
{
"item": "Super Hoop",
"quantity": 1
},
{
"item": "Basketball",
"quantity": 4
},
{
"item": "Big Shoes",
"quantity": 1
}
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-12-compact-nested-mapping/in.yaml 0000664 0000000 0000000 00000000207 15015766371 0032335 0 ustar 00root root 0000000 0000000 ---
# Products purchased
- item : Super Hoop
quantity: 1
- item : Basketball
quantity: 4
- item : Big Shoes
quantity: 1
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-12-compact-nested-mapping/out.yaml 0000664 0000000 0000000 00000000146 15015766371 0032540 0 ustar 00root root 0000000 0000000 ---
- item: Super Hoop
quantity: 1
- item: Basketball
quantity: 4
- item: Big Shoes
quantity: 1
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-13-in-literals-newlines-are-preserved/0000775 0000000 0000000 00000000000 15015766371 0033315 5 ustar 00root root 0000000 0000000 in.json 0000664 0000000 0000000 00000000035 15015766371 0034535 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-13-in-literals-newlines-are-preserved "\\//||\\/||\n// || ||__\n"
in.yaml 0000664 0000000 0000000 00000000054 15015766371 0034527 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-13-in-literals-newlines-are-preserved # ASCII Art
--- |
\//||\/||
// || ||__
out.yaml 0000664 0000000 0000000 00000000040 15015766371 0034723 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-13-in-literals-newlines-are-preserved --- |
\//||\/||
// || ||__
spec-example-2-14-in-the-folded-scalars-newlines-become-spaces/ 0000775 0000000 0000000 00000000000 15015766371 0035023 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite in.json 0000664 0000000 0000000 00000000067 15015766371 0036327 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-14-in-the-folded-scalars-newlines-become-spaces "Mark McGwire's year was crippled by a knee injury.\n"
in.yaml 0000664 0000000 0000000 00000000077 15015766371 0036321 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-14-in-the-folded-scalars-newlines-become-spaces --- >
Mark McGwire's
year was crippled
by a knee injury.
out.yaml 0000664 0000000 0000000 00000000073 15015766371 0036516 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-14-in-the-folded-scalars-newlines-become-spaces --- >
Mark McGwire's year was crippled by a knee injury.
spec-example-2-15-folded-newlines-are-preserved-for-more-indented-and-blank-lines/ 0000775 0000000 0000000 00000000000 15015766371 0040523 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite in.json 0000664 0000000 0000000 00000000172 15015766371 0042024 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-15-folded-newlines-are-preserved-for-more-indented-and-blank-lines "Sammy Sosa completed another fine season with great stats.\n\n 63 Home Runs\n 0.288 Batting Average\n\nWhat a year!\n"
in.yaml 0000664 0000000 0000000 00000000170 15015766371 0042013 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-15-folded-newlines-are-preserved-for-more-indented-and-blank-lines >
Sammy Sosa completed another
fine season with great stats.
63 Home Runs
0.288 Batting Average
What a year!
out.yaml 0000664 0000000 0000000 00000000173 15015766371 0042217 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-15-folded-newlines-are-preserved-for-more-indented-and-blank-lines >
Sammy Sosa completed another fine season with great stats.
63 Home Runs
0.288 Batting Average
What a year!
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-16-indentation-determines-scope/ 0000775 0000000 0000000 00000000000 15015766371 0032271 5 ustar 00root root 0000000 0000000 in.json 0000664 0000000 0000000 00000000233 15015766371 0033511 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-16-indentation-determines-scope {
"name": "Mark McGwire",
"accomplishment": "Mark set a major league home run record in 1998.\n",
"stats": "65 Home Runs\n0.278 Batting Average\n"
}
in.yaml 0000664 0000000 0000000 00000000212 15015766371 0033477 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-16-indentation-determines-scope name: Mark McGwire
accomplishment: >
Mark set a major league
home run record in 1998.
stats: |
65 Home Runs
0.278 Batting Average
out.yaml 0000664 0000000 0000000 00000000210 15015766371 0033676 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-16-indentation-determines-scope name: Mark McGwire
accomplishment: >
Mark set a major league home run record in 1998.
stats: |
65 Home Runs
0.278 Batting Average
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-17-quoted-scalars/ 0000775 0000000 0000000 00000000000 15015766371 0027441 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-17-quoted-scalars/in.json 0000664 0000000 0000000 00000000313 15015766371 0030737 0 ustar 00root root 0000000 0000000 {
"unicode": "Sosa did fine.☺",
"control": "\b1998\t1999\t2000\n",
"hex esc": "\r\n is \r\n",
"single": "\"Howdy!\" he cried.",
"quoted": " # Not a 'comment'.",
"tie-fighter": "|\\-*-/|"
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-17-quoted-scalars/in.yaml 0000664 0000000 0000000 00000000261 15015766371 0030732 0 ustar 00root root 0000000 0000000 unicode: "Sosa did fine.\u263A"
control: "\b1998\t1999\t2000\n"
hex esc: "\x0d\x0a is \r\n"
single: '"Howdy!" he cried.'
quoted: ' # Not a ''comment''.'
tie-fighter: '|\-*-/|'
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-17-quoted-scalars/out.yaml 0000664 0000000 0000000 00000000254 15015766371 0031135 0 ustar 00root root 0000000 0000000 unicode: "Sosa did fine.\u263A"
control: "\b1998\t1999\t2000\n"
hex esc: "\r\n is \r\n"
single: '"Howdy!" he cried.'
quoted: ' # Not a ''comment''.'
tie-fighter: '|\-*-/|'
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-18-multi-line-flow-scalars/ 0000775 0000000 0000000 00000000000 15015766371 0031165 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-18-multi-line-flow-scalars/in.json 0000664 0000000 0000000 00000000145 15015766371 0032466 0 ustar 00root root 0000000 0000000 {
"plain": "This unquoted scalar spans many lines.",
"quoted": "So does this quoted scalar.\n"
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-18-multi-line-flow-scalars/in.yaml 0000664 0000000 0000000 00000000135 15015766371 0032456 0 ustar 00root root 0000000 0000000 plain:
This unquoted scalar
spans many lines.
quoted: "So does this
quoted scalar.\n"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-18-multi-line-flow-scalars/out.yaml 0000664 0000000 0000000 00000000126 15015766371 0032657 0 ustar 00root root 0000000 0000000 plain: This unquoted scalar spans many lines.
quoted: "So does this quoted scalar.\n"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-2-mapping-scalars-to-scalars/ 0000775 0000000 0000000 00000000000 15015766371 0031553 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-2-mapping-scalars-to-scalars/in.json 0000664 0000000 0000000 00000000055 15015766371 0033054 0 ustar 00root root 0000000 0000000 {
"hr": 65,
"avg": 0.278,
"rbi": 147
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-2-mapping-scalars-to-scalars/in.yaml 0000664 0000000 0000000 00000000120 15015766371 0033036 0 ustar 00root root 0000000 0000000 hr: 65 # Home runs
avg: 0.278 # Batting average
rbi: 147 # Runs Batted In
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-2-mapping-scalars-to-scalars/out.yaml 0000664 0000000 0000000 00000000033 15015766371 0033242 0 ustar 00root root 0000000 0000000 hr: 65
avg: 0.278
rbi: 147
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-24-global-tags/ 0000775 0000000 0000000 00000000000 15015766371 0026704 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-24-global-tags/in.json 0000664 0000000 0000000 00000000473 15015766371 0030211 0 ustar 00root root 0000000 0000000 [
{
"center": {
"x": 73,
"y": 129
},
"radius": 7
},
{
"start": {
"x": 73,
"y": 129
},
"finish": {
"x": 89,
"y": 102
}
},
{
"start": {
"x": 73,
"y": 129
},
"color": 16772795,
"text": "Pretty vector drawing."
}
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-24-global-tags/in.yaml 0000664 0000000 0000000 00000000452 15015766371 0030177 0 ustar 00root root 0000000 0000000 %TAG ! tag:clarkevans.com,2002:
--- !shape
# Use the ! handle for presenting
# tag:clarkevans.com,2002:circle
- !circle
center: &ORIGIN {x: 73, y: 129}
radius: 7
- !line
start: *ORIGIN
finish: { x: 89, y: 102 }
- !label
start: *ORIGIN
color: 0xFFEEBB
text: Pretty vector drawing.
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-24-global-tags/out.yaml 0000664 0000000 0000000 00000000463 15015766371 0030402 0 ustar 00root root 0000000 0000000 --- !
- !
center: &ORIGIN
x: 73
y: 129
radius: 7
- !
start: *ORIGIN
finish:
x: 89
y: 102
- !
start: *ORIGIN
color: 0xFFEEBB
text: Pretty vector drawing.
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-25-unordered-sets/ 0000775 0000000 0000000 00000000000 15015766371 0027454 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-25-unordered-sets/in.json 0000664 0000000 0000000 00000000106 15015766371 0030752 0 ustar 00root root 0000000 0000000 {
"Mark McGwire": null,
"Sammy Sosa": null,
"Ken Griff": null
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-25-unordered-sets/in.yaml 0000664 0000000 0000000 00000000211 15015766371 0030740 0 ustar 00root root 0000000 0000000 # Sets are represented as a
# Mapping where each key is
# associated with a null value
--- !!set
? Mark McGwire
? Sammy Sosa
? Ken Griff
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-25-unordered-sets/out.yaml 0000664 0000000 0000000 00000000057 15015766371 0031151 0 ustar 00root root 0000000 0000000 --- !!set
Mark McGwire:
Sammy Sosa:
Ken Griff:
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-26-ordered-mappings/ 0000775 0000000 0000000 00000000000 15015766371 0027752 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-26-ordered-mappings/in.json 0000664 0000000 0000000 00000000137 15015766371 0031254 0 ustar 00root root 0000000 0000000 [
{
"Mark McGwire": 65
},
{
"Sammy Sosa": 63
},
{
"Ken Griffy": 58
}
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-26-ordered-mappings/in.yaml 0000664 0000000 0000000 00000000476 15015766371 0031253 0 ustar 00root root 0000000 0000000 # The !!omap tag is one of the optional types
# introduced for YAML 1.1. In 1.2, it is not
# part of the standard tags and should not be
# enabled by default.
# Ordered maps are represented as
# A sequence of mappings, with
# each mapping having one key
--- !!omap
- Mark McGwire: 65
- Sammy Sosa: 63
- Ken Griffy: 58
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-26-ordered-mappings/out.yaml 0000664 0000000 0000000 00000000100 15015766371 0031434 0 ustar 00root root 0000000 0000000 --- !!omap
- Mark McGwire: 65
- Sammy Sosa: 63
- Ken Griffy: 58
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-27-invoice/ 0000775 0000000 0000000 00000000000 15015766371 0026147 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-27-invoice/in.json 0000664 0000000 0000000 00000001473 15015766371 0027455 0 ustar 00root root 0000000 0000000 {
"invoice": 34843,
"date": "2001-01-23",
"bill-to": {
"given": "Chris",
"family": "Dumars",
"address": {
"lines": "458 Walkman Dr.\nSuite #292\n",
"city": "Royal Oak",
"state": "MI",
"postal": 48046
}
},
"ship-to": {
"given": "Chris",
"family": "Dumars",
"address": {
"lines": "458 Walkman Dr.\nSuite #292\n",
"city": "Royal Oak",
"state": "MI",
"postal": 48046
}
},
"product": [
{
"sku": "BL394D",
"quantity": 4,
"description": "Basketball",
"price": 450
},
{
"sku": "BL4438H",
"quantity": 1,
"description": "Super Hoop",
"price": 2392
}
],
"tax": 251.42,
"total": 4443.52,
"comments": "Late afternoon is best. Backup contact is Nancy Billsmer @ 338-4338."
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-27-invoice/in.yaml 0000664 0000000 0000000 00000001204 15015766371 0027436 0 ustar 00root root 0000000 0000000 --- !
invoice: 34843
date : 2001-01-23
bill-to: &id001
given : Chris
family : Dumars
address:
lines: |
458 Walkman Dr.
Suite #292
city : Royal Oak
state : MI
postal : 48046
ship-to: *id001
product:
- sku : BL394D
quantity : 4
description : Basketball
price : 450.00
- sku : BL4438H
quantity : 1
description : Super Hoop
price : 2392.00
tax : 251.42
total: 4443.52
comments:
Late afternoon is best.
Backup contact is Nancy
Billsmer @ 338-4338.
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-27-invoice/out.yaml 0000664 0000000 0000000 00000000773 15015766371 0027651 0 ustar 00root root 0000000 0000000 --- !
invoice: 34843
date: 2001-01-23
bill-to: &id001
given: Chris
family: Dumars
address:
lines: |
458 Walkman Dr.
Suite #292
city: Royal Oak
state: MI
postal: 48046
ship-to: *id001
product:
- sku: BL394D
quantity: 4
description: Basketball
price: 450.00
- sku: BL4438H
quantity: 1
description: Super Hoop
price: 2392.00
tax: 251.42
total: 4443.52
comments: Late afternoon is best. Backup contact is Nancy Billsmer @ 338-4338.
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-28-log-file/ 0000775 0000000 0000000 00000000000 15015766371 0026212 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-28-log-file/in.json 0000664 0000000 0000000 00000001013 15015766371 0027506 0 ustar 00root root 0000000 0000000 {
"Time": "2001-11-23 15:01:42 -5",
"User": "ed",
"Warning": "This is an error message for the log file"
}
{
"Time": "2001-11-23 15:02:31 -5",
"User": "ed",
"Warning": "A slightly different error message."
}
{
"Date": "2001-11-23 15:03:17 -5",
"User": "ed",
"Fatal": "Unknown variable \"bar\"",
"Stack": [
{
"file": "TopClass.py",
"line": 23,
"code": "x = MoreObject(\"345\\n\")\n"
},
{
"file": "MoreClass.py",
"line": 58,
"code": "foo = bar"
}
]
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-28-log-file/in.yaml 0000664 0000000 0000000 00000000633 15015766371 0027506 0 ustar 00root root 0000000 0000000 ---
Time: 2001-11-23 15:01:42 -5
User: ed
Warning:
This is an error message
for the log file
---
Time: 2001-11-23 15:02:31 -5
User: ed
Warning:
A slightly different error
message.
---
Date: 2001-11-23 15:03:17 -5
User: ed
Fatal:
Unknown variable "bar"
Stack:
- file: TopClass.py
line: 23
code: |
x = MoreObject("345\n")
- file: MoreClass.py
line: 58
code: |-
foo = bar
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-28-log-file/out.yaml 0000664 0000000 0000000 00000000601 15015766371 0027702 0 ustar 00root root 0000000 0000000 ---
Time: 2001-11-23 15:01:42 -5
User: ed
Warning: This is an error message for the log file
---
Time: 2001-11-23 15:02:31 -5
User: ed
Warning: A slightly different error message.
---
Date: 2001-11-23 15:03:17 -5
User: ed
Fatal: Unknown variable "bar"
Stack:
- file: TopClass.py
line: 23
code: |
x = MoreObject("345\n")
- file: MoreClass.py
line: 58
code: |-
foo = bar
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-3-mapping-scalars-to-sequences/ 0000775 0000000 0000000 00000000000 15015766371 0032117 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-3-mapping-scalars-to-sequences/in.json0000664 0000000 0000000 00000000256 15015766371 0033423 0 ustar 00root root 0000000 0000000 {
"american": [
"Boston Red Sox",
"Detroit Tigers",
"New York Yankees"
],
"national": [
"New York Mets",
"Chicago Cubs",
"Atlanta Braves"
]
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-3-mapping-scalars-to-sequences/in.yaml0000664 0000000 0000000 00000000205 15015766371 0033406 0 ustar 00root root 0000000 0000000 american:
- Boston Red Sox
- Detroit Tigers
- New York Yankees
national:
- New York Mets
- Chicago Cubs
- Atlanta Braves
out.yaml 0000664 0000000 0000000 00000000171 15015766371 0033532 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-3-mapping-scalars-to-sequences american:
- Boston Red Sox
- Detroit Tigers
- New York Yankees
national:
- New York Mets
- Chicago Cubs
- Atlanta Braves
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-4-sequence-of-mappings/ 0000775 0000000 0000000 00000000000 15015766371 0030454 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-4-sequence-of-mappings/in.json 0000664 0000000 0000000 00000000211 15015766371 0031747 0 ustar 00root root 0000000 0000000 [
{
"name": "Mark McGwire",
"hr": 65,
"avg": 0.278
},
{
"name": "Sammy Sosa",
"hr": 63,
"avg": 0.288
}
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-4-sequence-of-mappings/in.yaml 0000664 0000000 0000000 00000000136 15015766371 0031746 0 ustar 00root root 0000000 0000000 -
name: Mark McGwire
hr: 65
avg: 0.278
-
name: Sammy Sosa
hr: 63
avg: 0.288
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-4-sequence-of-mappings/out.yaml 0000664 0000000 0000000 00000000124 15015766371 0032144 0 ustar 00root root 0000000 0000000 - name: Mark McGwire
hr: 65
avg: 0.278
- name: Sammy Sosa
hr: 63
avg: 0.288
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-5-sequence-of-sequences/ 0000775 0000000 0000000 00000000000 15015766371 0030632 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-5-sequence-of-sequences/in.json 0000664 0000000 0000000 00000000210 15015766371 0032124 0 ustar 00root root 0000000 0000000 [
[
"name",
"hr",
"avg"
],
[
"Mark McGwire",
65,
0.278
],
[
"Sammy Sosa",
63,
0.288
]
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-5-sequence-of-sequences/in.yaml 0000664 0000000 0000000 00000000124 15015766371 0032121 0 ustar 00root root 0000000 0000000 - [name , hr, avg ]
- [Mark McGwire, 65, 0.278]
- [Sammy Sosa , 63, 0.288]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-5-sequence-of-sequences/out.yaml 0000664 0000000 0000000 00000000132 15015766371 0032321 0 ustar 00root root 0000000 0000000 - - name
- hr
- avg
- - Mark McGwire
- 65
- 0.278
- - Sammy Sosa
- 63
- 0.288
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-6-mapping-of-mappings/ 0000775 0000000 0000000 00000000000 15015766371 0030301 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-6-mapping-of-mappings/in.json 0000664 0000000 0000000 00000000161 15015766371 0031600 0 ustar 00root root 0000000 0000000 {
"Mark McGwire": {
"hr": 65,
"avg": 0.278
},
"Sammy Sosa": {
"hr": 63,
"avg": 0.288
}
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-6-mapping-of-mappings/in.yaml 0000664 0000000 0000000 00000000120 15015766371 0031564 0 ustar 00root root 0000000 0000000 Mark McGwire: {hr: 65, avg: 0.278}
Sammy Sosa: {
hr: 63,
avg: 0.288
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-6-mapping-of-mappings/out.yaml 0000664 0000000 0000000 00000000106 15015766371 0031771 0 ustar 00root root 0000000 0000000 Mark McGwire:
hr: 65
avg: 0.278
Sammy Sosa:
hr: 63
avg: 0.288
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-7-two-documents-in-a-stream/ 0000775 0000000 0000000 00000000000 15015766371 0031354 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-7-two-documents-in-a-stream/in.json 0000664 0000000 0000000 00000000143 15015766371 0032653 0 ustar 00root root 0000000 0000000 [
"Mark McGwire",
"Sammy Sosa",
"Ken Griffey"
]
[
"Chicago Cubs",
"St Louis Cardinals"
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-7-two-documents-in-a-stream/in.yaml 0000664 0000000 0000000 00000000202 15015766371 0032640 0 ustar 00root root 0000000 0000000 # Ranking of 1998 home runs
---
- Mark McGwire
- Sammy Sosa
- Ken Griffey
# Team ranking
---
- Chicago Cubs
- St Louis Cardinals
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-7-two-documents-in-a-stream/out.yaml 0000664 0000000 0000000 00000000126 15015766371 0033046 0 ustar 00root root 0000000 0000000 ---
- Mark McGwire
- Sammy Sosa
- Ken Griffey
---
- Chicago Cubs
- St Louis Cardinals
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-8-play-by-play-feed-from-a-game/ 0000775 0000000 0000000 00000000000 15015766371 0031741 5 ustar 00root root 0000000 0000000 in.json 0000664 0000000 0000000 00000000235 15015766371 0033163 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-8-play-by-play-feed-from-a-game {
"time": "20:03:20",
"player": "Sammy Sosa",
"action": "strike (miss)"
}
{
"time": "20:03:47",
"player": "Sammy Sosa",
"action": "grand slam"
}
in.yaml 0000664 0000000 0000000 00000000175 15015766371 0033157 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-8-play-by-play-feed-from-a-game ---
time: 20:03:20
player: Sammy Sosa
action: strike (miss)
...
---
time: 20:03:47
player: Sammy Sosa
action: grand slam
...
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-9-single-document-with-two-comments/ 0000775 0000000 0000000 00000000000 15015766371 0033133 5 ustar 00root root 0000000 0000000 in.json 0000664 0000000 0000000 00000000153 15015766371 0034354 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-9-single-document-with-two-comments {
"hr": [
"Mark McGwire",
"Sammy Sosa"
],
"rbi": [
"Sammy Sosa",
"Ken Griffey"
]
}
in.yaml 0000664 0000000 0000000 00000000163 15015766371 0034346 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-9-single-document-with-two-comments ---
hr: # 1998 hr ranking
- Mark McGwire
- Sammy Sosa
rbi:
# 1998 rbi ranking
- Sammy Sosa
- Ken Griffey
out.yaml 0000664 0000000 0000000 00000000104 15015766371 0034542 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-2-9-single-document-with-two-comments ---
hr:
- Mark McGwire
- Sammy Sosa
rbi:
- Sammy Sosa
- Ken Griffey
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-5-12-tabs-and-spaces/ 0000775 0000000 0000000 00000000000 15015766371 0027455 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-5-12-tabs-and-spaces/in.json 0000664 0000000 0000000 00000000136 15015766371 0030756 0 ustar 00root root 0000000 0000000 {
"quoted": "Quoted \t",
"block": "void main() {\n\tprintf(\"Hello, world!\\n\");\n}\n"
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-5-12-tabs-and-spaces/in.yaml 0000664 0000000 0000000 00000000140 15015766371 0030742 0 ustar 00root root 0000000 0000000 # Tabs and spaces
quoted: "Quoted "
block: |
void main() {
printf("Hello, world!\n");
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-5-12-tabs-and-spaces/out.yaml 0000664 0000000 0000000 00000000117 15015766371 0031147 0 ustar 00root root 0000000 0000000 quoted: "Quoted \t"
block: |
void main() {
printf("Hello, world!\n");
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-5-3-block-structure-indicators/ 0000775 0000000 0000000 00000000000 15015766371 0031715 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-5-3-block-structure-indicators/in.json 0000664 0000000 0000000 00000000147 15015766371 0033220 0 ustar 00root root 0000000 0000000 {
"sequence": [
"one",
"two"
],
"mapping": {
"sky": "blue",
"sea": "green"
}
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-5-3-block-structure-indicators/in.yaml 0000664 0000000 0000000 00000000076 15015766371 0033212 0 ustar 00root root 0000000 0000000 sequence:
- one
- two
mapping:
? sky
: blue
sea : green
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-5-3-block-structure-indicators/out.yaml 0000664 0000000 0000000 00000000070 15015766371 0033405 0 ustar 00root root 0000000 0000000 sequence:
- one
- two
mapping:
sky: blue
sea: green
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-5-4-flow-collection-indicators/ 0000775 0000000 0000000 00000000000 15015766371 0031666 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-5-4-flow-collection-indicators/in.json 0000664 0000000 0000000 00000000147 15015766371 0033171 0 ustar 00root root 0000000 0000000 {
"sequence": [
"one",
"two"
],
"mapping": {
"sky": "blue",
"sea": "green"
}
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-5-4-flow-collection-indicators/in.yaml 0000664 0000000 0000000 00000000073 15015766371 0033160 0 ustar 00root root 0000000 0000000 sequence: [ one, two, ]
mapping: { sky: blue, sea: green }
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-5-4-flow-collection-indicators/out.yaml 0000664 0000000 0000000 00000000070 15015766371 0033356 0 ustar 00root root 0000000 0000000 sequence:
- one
- two
mapping:
sky: blue
sea: green
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-5-5-comment-indicator/ 0000775 0000000 0000000 00000000000 15015766371 0030046 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-5-5-comment-indicator/in.json 0000664 0000000 0000000 00000000000 15015766371 0031335 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-5-5-comment-indicator/in.yaml 0000664 0000000 0000000 00000000020 15015766371 0031330 0 ustar 00root root 0000000 0000000 # Comment only.
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-5-5-comment-indicator/out.yaml 0000664 0000000 0000000 00000000000 15015766371 0031527 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-5-6-node-property-indicators/ 0000775 0000000 0000000 00000000000 15015766371 0031377 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-5-6-node-property-indicators/in.json 0000664 0000000 0000000 00000000056 15015766371 0032701 0 ustar 00root root 0000000 0000000 {
"anchored": "value",
"alias": "value"
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-5-6-node-property-indicators/in.yaml 0000664 0000000 0000000 00000000056 15015766371 0032672 0 ustar 00root root 0000000 0000000 anchored: !local &anchor value
alias: *anchor
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-5-6-node-property-indicators/out.yaml 0000664 0000000 0000000 00000000056 15015766371 0033073 0 ustar 00root root 0000000 0000000 anchored: &anchor !local value
alias: *anchor
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-5-7-block-scalar-indicators/ 0000775 0000000 0000000 00000000000 15015766371 0031126 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-5-7-block-scalar-indicators/in.json 0000664 0000000 0000000 00000000073 15015766371 0032427 0 ustar 00root root 0000000 0000000 {
"literal": "some\ntext\n",
"folded": "some text\n"
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-5-7-block-scalar-indicators/in.yaml 0000664 0000000 0000000 00000000061 15015766371 0032415 0 ustar 00root root 0000000 0000000 literal: |
some
text
folded: >
some
text
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-5-7-block-scalar-indicators/out.yaml 0000664 0000000 0000000 00000000057 15015766371 0032623 0 ustar 00root root 0000000 0000000 literal: |
some
text
folded: >
some text
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-5-8-quoted-scalar-indicators/ 0000775 0000000 0000000 00000000000 15015766371 0031336 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-5-8-quoted-scalar-indicators/in.json 0000664 0000000 0000000 00000000053 15015766371 0032635 0 ustar 00root root 0000000 0000000 {
"single": "text",
"double": "text"
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-5-8-quoted-scalar-indicators/in.yaml 0000664 0000000 0000000 00000000036 15015766371 0032627 0 ustar 00root root 0000000 0000000 single: 'text'
double: "text"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-5-9-directive-indicator/ 0000775 0000000 0000000 00000000000 15015766371 0030366 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-5-9-directive-indicator/in.json 0000664 0000000 0000000 00000000007 15015766371 0031664 0 ustar 00root root 0000000 0000000 "text"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-5-9-directive-indicator/in.yaml 0000664 0000000 0000000 00000000023 15015766371 0031653 0 ustar 00root root 0000000 0000000 %YAML 1.2
--- text
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-5-9-directive-indicator/out.yaml 0000664 0000000 0000000 00000000011 15015766371 0032051 0 ustar 00root root 0000000 0000000 --- text
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-1-indentation-spaces/ 0000775 0000000 0000000 00000000000 15015766371 0030217 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-1-indentation-spaces/in.json 0000664 0000000 0000000 00000000233 15015766371 0031516 0 ustar 00root root 0000000 0000000 {
"Not indented": {
"By one space": "By four\n spaces\n",
"Flow style": [
"By two",
"Also by two",
"Still by two"
]
}
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-1-indentation-spaces/in.yaml 0000664 0000000 0000000 00000000455 15015766371 0031515 0 ustar 00root root 0000000 0000000 # Leading comment line spaces are
# neither content nor indentation.
Not indented:
By one space: |
By four
spaces
Flow style: [ # Leading spaces
By two, # in flow style
Also by two, # are neither
Still by two # content nor
] # indentation.
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-1-indentation-spaces/out.yaml 0000664 0000000 0000000 00000000163 15015766371 0031712 0 ustar 00root root 0000000 0000000 Not indented:
By one space: |
By four
spaces
Flow style:
- By two
- Also by two
- Still by two
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-10-comment-lines/ 0000775 0000000 0000000 00000000000 15015766371 0027261 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-10-comment-lines/in.json 0000664 0000000 0000000 00000000000 15015766371 0030550 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-10-comment-lines/in.yaml 0000664 0000000 0000000 00000000022 15015766371 0030545 0 ustar 00root root 0000000 0000000 # Comment
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-10-comment-lines/out.yaml 0000664 0000000 0000000 00000000000 15015766371 0030742 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-11-multi-line-comments/ 0000775 0000000 0000000 00000000000 15015766371 0030412 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-11-multi-line-comments/in.json 0000664 0000000 0000000 00000000025 15015766371 0031710 0 ustar 00root root 0000000 0000000 {
"key": "value"
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-11-multi-line-comments/in.yaml 0000664 0000000 0000000 00000000054 15015766371 0031703 0 ustar 00root root 0000000 0000000 key: # Comment
# lines
value
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-11-multi-line-comments/out.yaml 0000664 0000000 0000000 00000000013 15015766371 0032077 0 ustar 00root root 0000000 0000000 key: value
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-12-separation-spaces/ 0000775 0000000 0000000 00000000000 15015766371 0030132 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-12-separation-spaces/in.yaml 0000664 0000000 0000000 00000000141 15015766371 0031420 0 ustar 00root root 0000000 0000000 { first: Sammy, last: Sosa }:
# Statistics:
hr: # Home runs
65
avg: # Average
0.278
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-12-separation-spaces/out.yaml 0000664 0000000 0000000 00000000062 15015766371 0031623 0 ustar 00root root 0000000 0000000 ? first: Sammy
last: Sosa
: hr: 65
avg: 0.278
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-13-reserved-directives-1-3/ 0000775 0000000 0000000 00000000000 15015766371 0030766 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-13-reserved-directives-1-3/in.json 0000664 0000000 0000000 00000000006 15015766371 0032263 0 ustar 00root root 0000000 0000000 "foo"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-13-reserved-directives-1-3/in.yaml 0000664 0000000 0000000 00000000114 15015766371 0032254 0 ustar 00root root 0000000 0000000 %FOO bar baz # Should be ignored
# with a warning.
---
"foo"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-13-reserved-directives-1-3/out.yaml 0000664 0000000 0000000 00000000012 15015766371 0032452 0 ustar 00root root 0000000 0000000 ---
"foo"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-13-reserved-directives/ 0000775 0000000 0000000 00000000000 15015766371 0030470 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-13-reserved-directives/in.json 0000664 0000000 0000000 00000000006 15015766371 0031765 0 ustar 00root root 0000000 0000000 "foo"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-13-reserved-directives/in.yaml 0000664 0000000 0000000 00000000114 15015766371 0031756 0 ustar 00root root 0000000 0000000 %FOO bar baz # Should be ignored
# with a warning.
--- "foo"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-13-reserved-directives/out.yaml 0000664 0000000 0000000 00000000012 15015766371 0032154 0 ustar 00root root 0000000 0000000 --- "foo"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-14-yaml-directive/ 0000775 0000000 0000000 00000000000 15015766371 0027431 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-14-yaml-directive/in.json 0000664 0000000 0000000 00000000006 15015766371 0030726 0 ustar 00root root 0000000 0000000 "foo"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-14-yaml-directive/in.yaml 0000664 0000000 0000000 00000000101 15015766371 0030713 0 ustar 00root root 0000000 0000000 %YAML 1.3 # Attempt parsing
# with a warning
---
"foo"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-14-yaml-directive/out.yaml 0000664 0000000 0000000 00000000012 15015766371 0031115 0 ustar 00root root 0000000 0000000 --- "foo"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-16-tag-directive/ 0000775 0000000 0000000 00000000000 15015766371 0027244 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-16-tag-directive/in.json 0000664 0000000 0000000 00000000006 15015766371 0030541 0 ustar 00root root 0000000 0000000 "foo"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-16-tag-directive/in.yaml 0000664 0000000 0000000 00000000063 15015766371 0030535 0 ustar 00root root 0000000 0000000 %TAG !yaml! tag:yaml.org,2002:
---
!yaml!str "foo"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-16-tag-directive/out.yaml 0000664 0000000 0000000 00000000020 15015766371 0030727 0 ustar 00root root 0000000 0000000 --- !!str "foo"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-18-primary-tag-handle-1-3/ 0000775 0000000 0000000 00000000000 15015766371 0030502 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-18-primary-tag-handle-1-3/in.json 0000664 0000000 0000000 00000000014 15015766371 0031776 0 ustar 00root root 0000000 0000000 "bar"
"bar"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-18-primary-tag-handle-1-3/in.yaml 0000664 0000000 0000000 00000000126 15015766371 0031773 0 ustar 00root root 0000000 0000000 # Private
---
!foo "bar"
...
# Global
%TAG ! tag:example.com,2000:app/
---
!foo "bar"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-18-primary-tag-handle-1-3/out.yaml 0000664 0000000 0000000 00000000075 15015766371 0032177 0 ustar 00root root 0000000 0000000 ---
!foo "bar"
...
--- !
"bar"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-18-primary-tag-handle/ 0000775 0000000 0000000 00000000000 15015766371 0030204 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-18-primary-tag-handle/in.json 0000664 0000000 0000000 00000000014 15015766371 0031500 0 ustar 00root root 0000000 0000000 "bar"
"bar"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-18-primary-tag-handle/in.yaml 0000664 0000000 0000000 00000000122 15015766371 0031471 0 ustar 00root root 0000000 0000000 # Private
!foo "bar"
...
# Global
%TAG ! tag:example.com,2000:app/
---
!foo "bar"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-18-primary-tag-handle/out.yaml 0000664 0000000 0000000 00000000071 15015766371 0031675 0 ustar 00root root 0000000 0000000 !foo "bar"
...
--- ! "bar"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-19-secondary-tag-handle/ 0000775 0000000 0000000 00000000000 15015766371 0030511 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-19-secondary-tag-handle/in.json 0000664 0000000 0000000 00000000010 15015766371 0032001 0 ustar 00root root 0000000 0000000 "1 - 3"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-19-secondary-tag-handle/in.yaml 0000664 0000000 0000000 00000000112 15015766371 0031775 0 ustar 00root root 0000000 0000000 %TAG !! tag:example.com,2000:app/
---
!!int 1 - 3 # Interval, not integer
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-19-secondary-tag-handle/out.yaml 0000664 0000000 0000000 00000000052 15015766371 0032201 0 ustar 00root root 0000000 0000000 --- ! 1 - 3
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-2-indentation-indicators/ 0000775 0000000 0000000 00000000000 15015766371 0031101 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-2-indentation-indicators/in.json 0000664 0000000 0000000 00000000073 15015766371 0032402 0 ustar 00root root 0000000 0000000 {
"a": [
"b",
[
"c",
"d"
]
]
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-2-indentation-indicators/in.yaml 0000664 0000000 0000000 00000000034 15015766371 0032370 0 ustar 00root root 0000000 0000000 ? a
: - b
- - c
- d
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-2-indentation-indicators/out.yaml 0000664 0000000 0000000 00000000023 15015766371 0032567 0 ustar 00root root 0000000 0000000 a:
- b
- - c
- d
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-20-tag-handles/ 0000775 0000000 0000000 00000000000 15015766371 0026677 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-20-tag-handles/in.json 0000664 0000000 0000000 00000000006 15015766371 0030174 0 ustar 00root root 0000000 0000000 "bar"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-20-tag-handles/in.yaml 0000664 0000000 0000000 00000000064 15015766371 0030171 0 ustar 00root root 0000000 0000000 %TAG !e! tag:example.com,2000:app/
---
!e!foo "bar"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-20-tag-handles/out.yaml 0000664 0000000 0000000 00000000052 15015766371 0030367 0 ustar 00root root 0000000 0000000 --- ! "bar"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-21-local-tag-prefix/ 0000775 0000000 0000000 00000000000 15015766371 0027647 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-21-local-tag-prefix/in.json 0000664 0000000 0000000 00000000026 15015766371 0031146 0 ustar 00root root 0000000 0000000 "fluorescent"
"green"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-21-local-tag-prefix/in.yaml 0000664 0000000 0000000 00000000145 15015766371 0031141 0 ustar 00root root 0000000 0000000 %TAG !m! !my-
--- # Bulb here
!m!light fluorescent
...
%TAG !m! !my-
--- # Color here
!m!light green
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-22-global-tag-prefix/ 0000775 0000000 0000000 00000000000 15015766371 0030016 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-22-global-tag-prefix/in.json 0000664 0000000 0000000 00000000014 15015766371 0031312 0 ustar 00root root 0000000 0000000 [
"bar"
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-22-global-tag-prefix/in.yaml 0000664 0000000 0000000 00000000066 15015766371 0031312 0 ustar 00root root 0000000 0000000 %TAG !e! tag:example.com,2000:app/
---
- !e!foo "bar"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-22-global-tag-prefix/out.yaml 0000664 0000000 0000000 00000000054 15015766371 0031510 0 ustar 00root root 0000000 0000000 ---
- ! "bar"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-23-node-properties/ 0000775 0000000 0000000 00000000000 15015766371 0027632 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-23-node-properties/in.json 0000664 0000000 0000000 00000000043 15015766371 0031130 0 ustar 00root root 0000000 0000000 {
"foo": "bar",
"baz": "foo"
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-23-node-properties/in.yaml 0000664 0000000 0000000 00000000053 15015766371 0031122 0 ustar 00root root 0000000 0000000 !!str &a1 "foo":
!!str bar
&a2 baz : *a1
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-23-node-properties/out.yaml 0000664 0000000 0000000 00000000050 15015766371 0031320 0 ustar 00root root 0000000 0000000 &a1 !!str "foo": !!str bar
&a2 baz: *a1
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-24-verbatim-tags/ 0000775 0000000 0000000 00000000000 15015766371 0027261 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-24-verbatim-tags/in.json 0000664 0000000 0000000 00000000023 15015766371 0030555 0 ustar 00root root 0000000 0000000 {
"foo": "baz"
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-24-verbatim-tags/in.yaml 0000664 0000000 0000000 00000000055 15015766371 0030553 0 ustar 00root root 0000000 0000000 ! foo :
! baz
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-24-verbatim-tags/out.yaml 0000664 0000000 0000000 00000000024 15015766371 0030750 0 ustar 00root root 0000000 0000000 !!str foo: !bar baz
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-26-tag-shorthands/ 0000775 0000000 0000000 00000000000 15015766371 0027444 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-26-tag-shorthands/in.json 0000664 0000000 0000000 00000000036 15015766371 0030744 0 ustar 00root root 0000000 0000000 [
"foo",
"bar",
"baz"
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-26-tag-shorthands/in.yaml 0000664 0000000 0000000 00000000120 15015766371 0030727 0 ustar 00root root 0000000 0000000 %TAG !e! tag:example.com,2000:app/
---
- !local foo
- !!str bar
- !e!tag%21 baz
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-28-non-specific-tags/ 0000775 0000000 0000000 00000000000 15015766371 0030031 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-28-non-specific-tags/in.json 0000664 0000000 0000000 00000000031 15015766371 0031324 0 ustar 00root root 0000000 0000000 [
"12",
12,
"12"
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-28-non-specific-tags/in.yaml 0000664 0000000 0000000 00000000067 15015766371 0031326 0 ustar 00root root 0000000 0000000 # Assuming conventional resolution:
- "12"
- 12
- ! 12
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-28-non-specific-tags/out.yaml 0000664 0000000 0000000 00000000023 15015766371 0031517 0 ustar 00root root 0000000 0000000 - "12"
- 12
- ! 12
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-29-node-anchors/ 0000775 0000000 0000000 00000000000 15015766371 0027101 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-29-node-anchors/in.json 0000664 0000000 0000000 00000000102 15015766371 0030373 0 ustar 00root root 0000000 0000000 {
"First occurrence": "Value",
"Second occurrence": "Value"
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-29-node-anchors/in.yaml 0000664 0000000 0000000 00000000073 15015766371 0030373 0 ustar 00root root 0000000 0000000 First occurrence: &anchor Value
Second occurrence: *anchor
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-3-separation-spaces/ 0000775 0000000 0000000 00000000000 15015766371 0030052 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-3-separation-spaces/in.json 0000664 0000000 0000000 00000000073 15015766371 0031353 0 ustar 00root root 0000000 0000000 [
{
"foo": "bar"
},
[
"baz",
"baz"
]
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-3-separation-spaces/in.yaml 0000664 0000000 0000000 00000000034 15015766371 0031341 0 ustar 00root root 0000000 0000000 - foo: bar
- - baz
- baz
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-3-separation-spaces/out.yaml 0000664 0000000 0000000 00000000033 15015766371 0031541 0 ustar 00root root 0000000 0000000 - foo: bar
- - baz
- baz
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-4-line-prefixes/ 0000775 0000000 0000000 00000000000 15015766371 0027204 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-4-line-prefixes/in.json 0000664 0000000 0000000 00000000125 15015766371 0030503 0 ustar 00root root 0000000 0000000 {
"plain": "text lines",
"quoted": "text lines",
"block": "text\n \tlines\n"
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-4-line-prefixes/in.yaml 0000664 0000000 0000000 00000000106 15015766371 0030473 0 ustar 00root root 0000000 0000000 plain: text
lines
quoted: "text
lines"
block: |
text
lines
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-4-line-prefixes/out.yaml 0000664 0000000 0000000 00000000101 15015766371 0030667 0 ustar 00root root 0000000 0000000 plain: text lines
quoted: "text lines"
block: "text\n \tlines\n"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-5-empty-lines-1-3/ 0000775 0000000 0000000 00000000000 15015766371 0027177 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-5-empty-lines-1-3/in.json 0000664 0000000 0000000 00000000125 15015766371 0030476 0 ustar 00root root 0000000 0000000 {
"Folding": "Empty line\nas a line feed",
"Chomping": "Clipped empty lines\n"
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-5-empty-lines-1-3/in.yaml 0000664 0000000 0000000 00000000117 15015766371 0030470 0 ustar 00root root 0000000 0000000 Folding:
"Empty line
as a line feed"
Chomping: |
Clipped empty lines
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-5-empty-lines-1-3/out.yaml 0000664 0000000 0000000 00000000110 15015766371 0030662 0 ustar 00root root 0000000 0000000 Folding: "Empty line\nas a line feed"
Chomping: |
Clipped empty lines
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-5-empty-lines/ 0000775 0000000 0000000 00000000000 15015766371 0026701 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-5-empty-lines/in.json 0000664 0000000 0000000 00000000125 15015766371 0030200 0 ustar 00root root 0000000 0000000 {
"Folding": "Empty line\nas a line feed",
"Chomping": "Clipped empty lines\n"
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-5-empty-lines/in.yaml 0000664 0000000 0000000 00000000123 15015766371 0030167 0 ustar 00root root 0000000 0000000 Folding:
"Empty line
as a line feed"
Chomping: |
Clipped empty lines
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-5-empty-lines/out.yaml 0000664 0000000 0000000 00000000110 15015766371 0030364 0 ustar 00root root 0000000 0000000 Folding: "Empty line\nas a line feed"
Chomping: |
Clipped empty lines
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-6-line-folding-1-3/ 0000775 0000000 0000000 00000000000 15015766371 0027301 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-6-line-folding-1-3/in.json 0000664 0000000 0000000 00000000030 15015766371 0030573 0 ustar 00root root 0000000 0000000 "trimmed\n\n\nas space"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-6-line-folding-1-3/in.yaml 0000664 0000000 0000000 00000000044 15015766371 0030571 0 ustar 00root root 0000000 0000000 --- >-
trimmed
as
space
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-6-line-folding-1-3/out.yaml 0000664 0000000 0000000 00000000037 15015766371 0030774 0 ustar 00root root 0000000 0000000 --- >-
trimmed
as space
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-6-line-folding/ 0000775 0000000 0000000 00000000000 15015766371 0027003 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-6-line-folding/in.json 0000664 0000000 0000000 00000000030 15015766371 0030275 0 ustar 00root root 0000000 0000000 "trimmed\n\n\nas space"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-6-line-folding/in.yaml 0000664 0000000 0000000 00000000040 15015766371 0030267 0 ustar 00root root 0000000 0000000 >-
trimmed
as
space
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-6-line-folding/out.yaml 0000664 0000000 0000000 00000000033 15015766371 0030472 0 ustar 00root root 0000000 0000000 >-
trimmed
as space
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-7-block-folding/ 0000775 0000000 0000000 00000000000 15015766371 0027147 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-7-block-folding/in.json 0000664 0000000 0000000 00000000032 15015766371 0030443 0 ustar 00root root 0000000 0000000 "foo \n\n\t bar\n\nbaz\n"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-7-block-folding/in.yaml 0000664 0000000 0000000 00000000032 15015766371 0030434 0 ustar 00root root 0000000 0000000 >
foo
bar
baz
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-7-block-folding/out.yaml 0000664 0000000 0000000 00000000032 15015766371 0030635 0 ustar 00root root 0000000 0000000 "foo \n\n\t bar\n\nbaz\n"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-8-flow-folding-1-3/ 0000775 0000000 0000000 00000000000 15015766371 0027323 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-8-flow-folding-1-3/in.json 0000664 0000000 0000000 00000000022 15015766371 0030616 0 ustar 00root root 0000000 0000000 " foo\nbar\nbaz "
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-8-flow-folding-1-3/in.yaml 0000664 0000000 0000000 00000000040 15015766371 0030607 0 ustar 00root root 0000000 0000000 ---
"
foo
bar
baz
"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-8-flow-folding-1-3/out.yaml 0000664 0000000 0000000 00000000022 15015766371 0031010 0 ustar 00root root 0000000 0000000 " foo\nbar\nbaz "
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-8-flow-folding/ 0000775 0000000 0000000 00000000000 15015766371 0027025 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-8-flow-folding/in.json 0000664 0000000 0000000 00000000022 15015766371 0030320 0 ustar 00root root 0000000 0000000 " foo\nbar\nbaz "
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-8-flow-folding/in.yaml 0000664 0000000 0000000 00000000034 15015766371 0030314 0 ustar 00root root 0000000 0000000 "
foo
bar
baz
"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-8-flow-folding/out.yaml 0000664 0000000 0000000 00000000022 15015766371 0030512 0 ustar 00root root 0000000 0000000 " foo\nbar\nbaz "
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-9-separated-comment/ 0000775 0000000 0000000 00000000000 15015766371 0030047 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-9-separated-comment/in.json 0000664 0000000 0000000 00000000025 15015766371 0031345 0 ustar 00root root 0000000 0000000 {
"key": "value"
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-9-separated-comment/in.yaml 0000664 0000000 0000000 00000000032 15015766371 0031334 0 ustar 00root root 0000000 0000000 key: # Comment
value
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-6-9-separated-comment/out.yaml 0000664 0000000 0000000 00000000013 15015766371 0031534 0 ustar 00root root 0000000 0000000 key: value
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-1-alias-nodes/ 0000775 0000000 0000000 00000000000 15015766371 0026627 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-1-alias-nodes/in.json 0000664 0000000 0000000 00000000163 15015766371 0030130 0 ustar 00root root 0000000 0000000 {
"First occurrence": "Foo",
"Second occurrence": "Foo",
"Override anchor": "Bar",
"Reuse anchor": "Bar"
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-1-alias-nodes/in.yaml 0000664 0000000 0000000 00000000154 15015766371 0030121 0 ustar 00root root 0000000 0000000 First occurrence: &anchor Foo
Second occurrence: *anchor
Override anchor: &anchor Bar
Reuse anchor: *anchor
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-10-plain-characters/ 0000775 0000000 0000000 00000000000 15015766371 0027730 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-10-plain-characters/in.json 0000664 0000000 0000000 00000000306 15015766371 0031230 0 ustar 00root root 0000000 0000000 [
"::vector",
": - ()",
"Up, up, and away!",
-123,
"http://example.com/foo#bar",
[
"::vector",
": - ()",
"Up, up and away!",
-123,
"http://example.com/foo#bar"
]
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-10-plain-characters/in.yaml 0000664 0000000 0000000 00000000332 15015766371 0031220 0 ustar 00root root 0000000 0000000 # Outside flow collection:
- ::vector
- ": - ()"
- Up, up, and away!
- -123
- http://example.com/foo#bar
# Inside flow collection:
- [ ::vector,
": - ()",
"Up, up and away!",
-123,
http://example.com/foo#bar ]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-10-plain-characters/out.yaml 0000664 0000000 0000000 00000000247 15015766371 0031426 0 ustar 00root root 0000000 0000000 - ::vector
- ": - ()"
- Up, up, and away!
- -123
- http://example.com/foo#bar
- - ::vector
- ": - ()"
- "Up, up and away!"
- -123
- http://example.com/foo#bar
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-11-plain-implicit-keys/ 0000775 0000000 0000000 00000000000 15015766371 0030375 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-11-plain-implicit-keys/in.json 0000664 0000000 0000000 00000000121 15015766371 0031670 0 ustar 00root root 0000000 0000000 {
"implicit block key": [
{
"implicit flow key": "value"
}
]
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-11-plain-implicit-keys/in.yaml 0000664 0000000 0000000 00000000067 15015766371 0031672 0 ustar 00root root 0000000 0000000 implicit block key : [
implicit flow key : value,
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-11-plain-implicit-keys/out.yaml 0000664 0000000 0000000 00000000057 15015766371 0032072 0 ustar 00root root 0000000 0000000 implicit block key:
- implicit flow key: value
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-12-plain-lines/ 0000775 0000000 0000000 00000000000 15015766371 0026725 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-12-plain-lines/in.json 0000664 0000000 0000000 00000000055 15015766371 0030226 0 ustar 00root root 0000000 0000000 "1st non-empty\n2nd non-empty 3rd non-empty"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-12-plain-lines/in.yaml 0000664 0000000 0000000 00000000056 15015766371 0030220 0 ustar 00root root 0000000 0000000 1st non-empty
2nd non-empty
3rd non-empty
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-12-plain-lines/out.yaml 0000664 0000000 0000000 00000000057 15015766371 0030422 0 ustar 00root root 0000000 0000000 '1st non-empty
2nd non-empty 3rd non-empty'
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-13-flow-sequence/ 0000775 0000000 0000000 00000000000 15015766371 0027270 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-13-flow-sequence/in.json 0000664 0000000 0000000 00000000102 15015766371 0030562 0 ustar 00root root 0000000 0000000 [
[
"one",
"two"
],
[
"three",
"four"
]
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-13-flow-sequence/in.yaml 0000664 0000000 0000000 00000000040 15015766371 0030554 0 ustar 00root root 0000000 0000000 - [ one, two, ]
- [three ,four]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-13-flow-sequence/out.yaml 0000664 0000000 0000000 00000000043 15015766371 0030760 0 ustar 00root root 0000000 0000000 - - one
- two
- - three
- four
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-14-flow-sequence-entries/ 0000775 0000000 0000000 00000000000 15015766371 0030740 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-14-flow-sequence-entries/in.json 0000664 0000000 0000000 00000000155 15015766371 0032242 0 ustar 00root root 0000000 0000000 [
"double quoted",
"single quoted",
"plain text",
[
"nested"
],
{
"single": "pair"
}
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-14-flow-sequence-entries/in.yaml 0000664 0000000 0000000 00000000131 15015766371 0032225 0 ustar 00root root 0000000 0000000 [
"double
quoted", 'single
quoted',
plain
text, [ nested ],
single: pair,
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-14-flow-sequence-entries/out.yaml 0000664 0000000 0000000 00000000113 15015766371 0032426 0 ustar 00root root 0000000 0000000 - "double quoted"
- 'single quoted'
- plain text
- - nested
- single: pair
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-15-flow-mappings/ 0000775 0000000 0000000 00000000000 15015766371 0027300 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-15-flow-mappings/in.json 0000664 0000000 0000000 00000000143 15015766371 0030577 0 ustar 00root root 0000000 0000000 [
{
"one": "two",
"three": "four"
},
{
"five": "six",
"seven": "eight"
}
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-15-flow-mappings/in.yaml 0000664 0000000 0000000 00000000074 15015766371 0030573 0 ustar 00root root 0000000 0000000 - { one : two , three: four , }
- {five: six,seven : eight}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-15-flow-mappings/out.yaml 0000664 0000000 0000000 00000000064 15015766371 0030773 0 ustar 00root root 0000000 0000000 - one: two
three: four
- five: six
seven: eight
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-16-flow-mapping-entries/ 0000775 0000000 0000000 00000000000 15015766371 0030565 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-16-flow-mapping-entries/in.yaml 0000664 0000000 0000000 00000000052 15015766371 0032054 0 ustar 00root root 0000000 0000000 {
? explicit: entry,
implicit: entry,
?
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-16-flow-mapping-entries/out.yaml 0000664 0000000 0000000 00000000042 15015766371 0032254 0 ustar 00root root 0000000 0000000 explicit: entry
implicit: entry
:
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-18-flow-mapping-adjacent-values/ 0000775 0000000 0000000 00000000000 15015766371 0032164 5 ustar 00root root 0000000 0000000 in.json 0000664 0000000 0000000 00000000102 15015766371 0033377 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-18-flow-mapping-adjacent-values {
"adjacent": "value",
"readable": "value",
"empty": null
}
in.yaml 0000664 0000000 0000000 00000000062 15015766371 0033375 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-18-flow-mapping-adjacent-values {
"adjacent":value,
"readable": value,
"empty":
}
out.yaml 0000664 0000000 0000000 00000000055 15015766371 0033600 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-18-flow-mapping-adjacent-values "adjacent": value
"readable": value
"empty":
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-19-single-pair-flow-mappings/ 0000775 0000000 0000000 00000000000 15015766371 0031514 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-19-single-pair-flow-mappings/in.json 0000664 0000000 0000000 00000000035 15015766371 0033013 0 ustar 00root root 0000000 0000000 [
{
"foo": "bar"
}
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-19-single-pair-flow-mappings/in.yaml 0000664 0000000 0000000 00000000015 15015766371 0033002 0 ustar 00root root 0000000 0000000 [
foo: bar
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-19-single-pair-flow-mappings/out.yaml 0000664 0000000 0000000 00000000013 15015766371 0033201 0 ustar 00root root 0000000 0000000 - foo: bar
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-2-empty-content/ 0000775 0000000 0000000 00000000000 15015766371 0027237 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-2-empty-content/in.json 0000664 0000000 0000000 00000000035 15015766371 0030536 0 ustar 00root root 0000000 0000000 {
"foo": "",
"": "bar"
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-2-empty-content/in.yaml 0000664 0000000 0000000 00000000042 15015766371 0030525 0 ustar 00root root 0000000 0000000 {
foo : !!str,
!!str : bar,
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-2-empty-content/out.yaml 0000664 0000000 0000000 00000000027 15015766371 0030731 0 ustar 00root root 0000000 0000000 foo: !!str
!!str : bar
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-20-single-pair-explicit-entry/ 0000775 0000000 0000000 00000000000 15015766371 0031701 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-20-single-pair-explicit-entry/in.json 0000664 0000000 0000000 00000000041 15015766371 0033175 0 ustar 00root root 0000000 0000000 [
{
"foo bar": "baz"
}
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-20-single-pair-explicit-entry/in.yaml 0000664 0000000 0000000 00000000025 15015766371 0033170 0 ustar 00root root 0000000 0000000 [
? foo
bar : baz
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-20-single-pair-explicit-entry/out.yaml0000664 0000000 0000000 00000000017 15015766371 0033372 0 ustar 00root root 0000000 0000000 - foo bar: baz
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-23-flow-content/ 0000775 0000000 0000000 00000000000 15015766371 0027133 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-23-flow-content/in.json 0000664 0000000 0000000 00000000110 15015766371 0030424 0 ustar 00root root 0000000 0000000 [
[
"a",
"b"
],
{
"a": "b"
},
"a",
"b",
"c"
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-23-flow-content/in.yaml 0000664 0000000 0000000 00000000046 15015766371 0030425 0 ustar 00root root 0000000 0000000 - [ a, b ]
- { a: b }
- "a"
- 'b'
- c
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-23-flow-content/out.yaml 0000664 0000000 0000000 00000000043 15015766371 0030623 0 ustar 00root root 0000000 0000000 - - a
- b
- a: b
- "a"
- 'b'
- c
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-24-flow-nodes/ 0000775 0000000 0000000 00000000000 15015766371 0026572 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-24-flow-nodes/in.json 0000664 0000000 0000000 00000000045 15015766371 0030072 0 ustar 00root root 0000000 0000000 [
"a",
"b",
"c",
"c",
""
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-24-flow-nodes/in.yaml 0000664 0000000 0000000 00000000062 15015766371 0030062 0 ustar 00root root 0000000 0000000 - !!str "a"
- 'b'
- &anchor "c"
- *anchor
- !!str
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-3-completely-empty-flow-nodes/ 0000775 0000000 0000000 00000000000 15015766371 0032016 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-3-completely-empty-flow-nodes/in.yaml 0000664 0000000 0000000 00000000030 15015766371 0033301 0 ustar 00root root 0000000 0000000 {
? foo :,
: bar,
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-4-double-quoted-implicit-keys/ 0000775 0000000 0000000 00000000000 15015766371 0031765 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-4-double-quoted-implicit-keys/in.json 0000664 0000000 0000000 00000000121 15015766371 0033260 0 ustar 00root root 0000000 0000000 {
"implicit block key": [
{
"implicit flow key": "value"
}
]
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-4-double-quoted-implicit-keys/in.yaml 0000664 0000000 0000000 00000000073 15015766371 0033257 0 ustar 00root root 0000000 0000000 "implicit block key" : [
"implicit flow key" : value,
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-4-double-quoted-implicit-keys/out.yaml0000664 0000000 0000000 00000000063 15015766371 0033457 0 ustar 00root root 0000000 0000000 "implicit block key":
- "implicit flow key": value
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-5-double-quoted-line-breaks-1-3/ 0000775 0000000 0000000 00000000000 15015766371 0031675 5 ustar 00root root 0000000 0000000 in.json 0000664 0000000 0000000 00000000072 15015766371 0033116 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-5-double-quoted-line-breaks-1-3 "folded to a space,\nto a line feed, or \t \tnon-content"
in.yaml 0000664 0000000 0000000 00000000102 15015766371 0033101 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-5-double-quoted-line-breaks-1-3 ---
"folded
to a space,
to a line feed, or \
\ non-content"
out.yaml 0000664 0000000 0000000 00000000072 15015766371 0033310 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-5-double-quoted-line-breaks-1-3 "folded to a space,\nto a line feed, or \t \tnon-content"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-5-double-quoted-line-breaks/ 0000775 0000000 0000000 00000000000 15015766371 0031377 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-5-double-quoted-line-breaks/in.json 0000664 0000000 0000000 00000000072 15015766371 0032677 0 ustar 00root root 0000000 0000000 "folded to a space,\nto a line feed, or \t \tnon-content"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-5-double-quoted-line-breaks/in.yaml 0000664 0000000 0000000 00000000077 15015766371 0032675 0 ustar 00root root 0000000 0000000 "folded
to a space,
to a line feed, or \
\ non-content"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-5-double-quoted-line-breaks/out.yaml 0000664 0000000 0000000 00000000072 15015766371 0033071 0 ustar 00root root 0000000 0000000 "folded to a space,\nto a line feed, or \t \tnon-content"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-6-double-quoted-lines-1-3/ 0000775 0000000 0000000 00000000000 15015766371 0030614 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-6-double-quoted-lines-1-3/in.json 0000664 0000000 0000000 00000000057 15015766371 0032117 0 ustar 00root root 0000000 0000000 " 1st non-empty\n2nd non-empty 3rd non-empty "
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-6-double-quoted-lines-1-3/in.yaml 0000664 0000000 0000000 00000000066 15015766371 0032110 0 ustar 00root root 0000000 0000000 ---
" 1st non-empty
2nd non-empty
3rd non-empty "
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-6-double-quoted-lines-1-3/out.yaml 0000664 0000000 0000000 00000000057 15015766371 0032311 0 ustar 00root root 0000000 0000000 " 1st non-empty\n2nd non-empty 3rd non-empty "
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-6-double-quoted-lines/ 0000775 0000000 0000000 00000000000 15015766371 0030316 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-6-double-quoted-lines/in.json 0000664 0000000 0000000 00000000057 15015766371 0031621 0 ustar 00root root 0000000 0000000 " 1st non-empty\n2nd non-empty 3rd non-empty "
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-6-double-quoted-lines/in.yaml 0000664 0000000 0000000 00000000062 15015766371 0031606 0 ustar 00root root 0000000 0000000 " 1st non-empty
2nd non-empty
3rd non-empty "
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-6-double-quoted-lines/out.yaml 0000664 0000000 0000000 00000000057 15015766371 0032013 0 ustar 00root root 0000000 0000000 " 1st non-empty\n2nd non-empty 3rd non-empty "
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-7-single-quoted-characters-1-3/ 0000775 0000000 0000000 00000000000 15015766371 0031631 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-7-single-quoted-characters-1-3/in.json0000664 0000000 0000000 00000000027 15015766371 0033131 0 ustar 00root root 0000000 0000000 "here's to \"quotes\""
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-7-single-quoted-characters-1-3/in.yaml0000664 0000000 0000000 00000000032 15015766371 0033116 0 ustar 00root root 0000000 0000000 ---
'here''s to "quotes"'
out.yaml 0000664 0000000 0000000 00000000032 15015766371 0033240 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-7-single-quoted-characters-1-3 --- 'here''s to "quotes"'
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-7-single-quoted-characters/ 0000775 0000000 0000000 00000000000 15015766371 0031333 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-7-single-quoted-characters/in.json 0000664 0000000 0000000 00000000027 15015766371 0032633 0 ustar 00root root 0000000 0000000 "here's to \"quotes\""
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-7-single-quoted-characters/in.yaml 0000664 0000000 0000000 00000000026 15015766371 0032623 0 ustar 00root root 0000000 0000000 'here''s to "quotes"'
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-8-single-quoted-implicit-keys/ 0000775 0000000 0000000 00000000000 15015766371 0032000 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-8-single-quoted-implicit-keys/in.json 0000664 0000000 0000000 00000000121 15015766371 0033273 0 ustar 00root root 0000000 0000000 {
"implicit block key": [
{
"implicit flow key": "value"
}
]
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-8-single-quoted-implicit-keys/in.yaml 0000664 0000000 0000000 00000000073 15015766371 0033272 0 ustar 00root root 0000000 0000000 'implicit block key' : [
'implicit flow key' : value,
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-8-single-quoted-implicit-keys/out.yaml0000664 0000000 0000000 00000000063 15015766371 0033472 0 ustar 00root root 0000000 0000000 'implicit block key':
- 'implicit flow key': value
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-9-single-quoted-lines-1-3/ 0000775 0000000 0000000 00000000000 15015766371 0030626 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-9-single-quoted-lines-1-3/in.json 0000664 0000000 0000000 00000000057 15015766371 0032131 0 ustar 00root root 0000000 0000000 " 1st non-empty\n2nd non-empty 3rd non-empty "
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-9-single-quoted-lines-1-3/in.yaml 0000664 0000000 0000000 00000000066 15015766371 0032122 0 ustar 00root root 0000000 0000000 ---
' 1st non-empty
2nd non-empty
3rd non-empty '
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-9-single-quoted-lines-1-3/out.yaml 0000664 0000000 0000000 00000000061 15015766371 0032316 0 ustar 00root root 0000000 0000000 ' 1st non-empty
2nd non-empty 3rd non-empty '
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-9-single-quoted-lines/ 0000775 0000000 0000000 00000000000 15015766371 0030330 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-9-single-quoted-lines/in.json 0000664 0000000 0000000 00000000057 15015766371 0031633 0 ustar 00root root 0000000 0000000 " 1st non-empty\n2nd non-empty 3rd non-empty "
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-9-single-quoted-lines/in.yaml 0000664 0000000 0000000 00000000062 15015766371 0031620 0 ustar 00root root 0000000 0000000 ' 1st non-empty
2nd non-empty
3rd non-empty '
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-7-9-single-quoted-lines/out.yaml 0000664 0000000 0000000 00000000061 15015766371 0032020 0 ustar 00root root 0000000 0000000 ' 1st non-empty
2nd non-empty 3rd non-empty '
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-1-block-scalar-header/ 0000775 0000000 0000000 00000000000 15015766371 0030214 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-1-block-scalar-header/in.json 0000664 0000000 0000000 00000000073 15015766371 0031515 0 ustar 00root root 0000000 0000000 [
"literal\n",
" folded\n",
"keep\n\n",
" strip"
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-1-block-scalar-header/in.yaml 0000664 0000000 0000000 00000000217 15015766371 0031506 0 ustar 00root root 0000000 0000000 - | # Empty header↓
literal
- >1 # Indentation indicator↓
folded
- |+ # Chomping indicator↓
keep
- >1- # Both indicators↓
strip
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-1-block-scalar-header/out.yaml 0000664 0000000 0000000 00000000071 15015766371 0031705 0 ustar 00root root 0000000 0000000 - |
literal
- >2
folded
- |+
keep
- >2-
strip
spec-example-8-10-folded-lines-8-13-final-empty-lines/ 0000775 0000000 0000000 00000000000 15015766371 0032720 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite in.json 0000664 0000000 0000000 00000000115 15015766371 0034216 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-10-folded-lines-8-13-final-empty-lines "\nfolded line\nnext line\n * bullet\n\n * list\n * lines\n\nlast line\n"
in.yaml 0000664 0000000 0000000 00000000130 15015766371 0034204 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-10-folded-lines-8-13-final-empty-lines >
folded
line
next
line
* bullet
* list
* lines
last
line
# Comment
out.yaml 0000664 0000000 0000000 00000000120 15015766371 0034404 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-10-folded-lines-8-13-final-empty-lines >
folded line
next line
* bullet
* list
* lines
last line
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-14-block-sequence/ 0000775 0000000 0000000 00000000000 15015766371 0027415 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-14-block-sequence/in.json 0000664 0000000 0000000 00000000112 15015766371 0030710 0 ustar 00root root 0000000 0000000 {
"block sequence": [
"one",
{
"two": "three"
}
]
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-14-block-sequence/in.yaml 0000664 0000000 0000000 00000000050 15015766371 0030702 0 ustar 00root root 0000000 0000000 block sequence:
- one
- two : three
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-14-block-sequence/out.yaml 0000664 0000000 0000000 00000000043 15015766371 0031105 0 ustar 00root root 0000000 0000000 block sequence:
- one
- two: three
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-15-block-sequence-entry-types/ 0000775 0000000 0000000 00000000000 15015766371 0031717 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-15-block-sequence-entry-types/in.json 0000664 0000000 0000000 00000000125 15015766371 0033216 0 ustar 00root root 0000000 0000000 [
null,
"block node\n",
[
"one",
"two"
],
{
"one": "two"
}
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-15-block-sequence-entry-types/in.yaml 0000664 0000000 0000000 00000000134 15015766371 0033207 0 ustar 00root root 0000000 0000000 - # Empty
- |
block node
- - one # Compact
- two # sequence
- one: two # Compact mapping
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-15-block-sequence-entry-types/out.yaml0000664 0000000 0000000 00000000056 15015766371 0033413 0 ustar 00root root 0000000 0000000 -
- |
block node
- - one
- two
- one: two
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-16-block-mappings/ 0000775 0000000 0000000 00000000000 15015766371 0027425 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-16-block-mappings/in.json 0000664 0000000 0000000 00000000060 15015766371 0030722 0 ustar 00root root 0000000 0000000 {
"block mapping": {
"key": "value"
}
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-16-block-mappings/in.yaml 0000664 0000000 0000000 00000000033 15015766371 0030713 0 ustar 00root root 0000000 0000000 block mapping:
key: value
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-16-block-mappings/out.yaml 0000664 0000000 0000000 00000000034 15015766371 0031115 0 ustar 00root root 0000000 0000000 block mapping:
key: value
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-17-explicit-block-mapping-entries/ 0000775 0000000 0000000 00000000000 15015766371 0032531 5 ustar 00root root 0000000 0000000 in.json 0000664 0000000 0000000 00000000110 15015766371 0033743 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-17-explicit-block-mapping-entries {
"explicit key": null,
"block key\n": [
"one",
"two"
]
}
in.yaml 0000664 0000000 0000000 00000000136 15015766371 0033744 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-17-explicit-block-mapping-entries ? explicit key # Empty value
? |
block key
: - one # Explicit compact
- two # block value
out.yaml 0000664 0000000 0000000 00000000056 15015766371 0034146 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-17-explicit-block-mapping-entries explicit key:
? |
block key
: - one
- two
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-18-implicit-block-mapping-entries/ 0000775 0000000 0000000 00000000000 15015766371 0032523 5 ustar 00root root 0000000 0000000 in.yaml 0000664 0000000 0000000 00000000076 15015766371 0033741 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-18-implicit-block-mapping-entries plain key: in-line value
: # Both empty
"quoted key":
- entry
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-19-compact-block-mappings/ 0000775 0000000 0000000 00000000000 15015766371 0031054 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-19-compact-block-mappings/in.yaml 0000664 0000000 0000000 00000000056 15015766371 0032347 0 ustar 00root root 0000000 0000000 - sun: yellow
- ? earth: blue
: moon: white
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-2-block-indentation-indicator-1-3/ 0000775 0000000 0000000 00000000000 15015766371 0032306 5 ustar 00root root 0000000 0000000 in.json 0000664 0000000 0000000 00000000112 15015766371 0033522 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-2-block-indentation-indicator-1-3 [
"detected\n",
"\n\n# detected\n",
" explicit\n",
"detected\n"
]
in.yaml 0000664 0000000 0000000 00000000102 15015766371 0033512 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-2-block-indentation-indicator-1-3 - |
detected
- >
# detected
- |1
explicit
- >
detected
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-2-block-indentation-indicator/ 0000775 0000000 0000000 00000000000 15015766371 0032010 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-2-block-indentation-indicator/in.json 0000664 0000000 0000000 00000000116 15015766371 0033307 0 ustar 00root root 0000000 0000000 [
"detected\n",
"\n\n# detected\n",
" explicit\n",
"\t\ndetected\n"
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-2-block-indentation-indicator/in.yaml 0000664 0000000 0000000 00000000105 15015766371 0033276 0 ustar 00root root 0000000 0000000 - |
detected
- >
# detected
- |1
explicit
- >
detected
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-2-block-indentation-indicator/out.yaml0000664 0000000 0000000 00000000107 15015766371 0033501 0 ustar 00root root 0000000 0000000 - |
detected
- >2
# detected
- |2
explicit
- "\t\ndetected\n"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-20-block-node-types/ 0000775 0000000 0000000 00000000000 15015766371 0027671 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-20-block-node-types/in.json 0000664 0000000 0000000 00000000104 15015766371 0031165 0 ustar 00root root 0000000 0000000 [
"flow in block",
"Block scalar\n",
{
"foo": "bar"
}
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-20-block-node-types/in.yaml 0000664 0000000 0000000 00000000115 15015766371 0031160 0 ustar 00root root 0000000 0000000 -
"flow in block"
- >
Block scalar
- !!map # Block collection
foo : bar
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-20-block-node-types/out.yaml 0000664 0000000 0000000 00000000070 15015766371 0031361 0 ustar 00root root 0000000 0000000 - "flow in block"
- >
Block scalar
- !!map
foo: bar
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-21-block-scalar-nodes-1-3/ 0000775 0000000 0000000 00000000000 15015766371 0030454 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-21-block-scalar-nodes-1-3/in.json 0000664 0000000 0000000 00000000062 15015766371 0031753 0 ustar 00root root 0000000 0000000 {
"literal": "value\n",
"folded": "value\n"
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-21-block-scalar-nodes-1-3/in.yaml 0000664 0000000 0000000 00000000053 15015766371 0031744 0 ustar 00root root 0000000 0000000 literal: |2
value
folded: !foo >1
value
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-21-block-scalar-nodes-1-3/out.yaml 0000664 0000000 0000000 00000000052 15015766371 0032144 0 ustar 00root root 0000000 0000000 literal: |
value
folded: !foo >
value
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-21-block-scalar-nodes/ 0000775 0000000 0000000 00000000000 15015766371 0030156 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-21-block-scalar-nodes/in.json 0000664 0000000 0000000 00000000062 15015766371 0031455 0 ustar 00root root 0000000 0000000 {
"literal": "value\n",
"folded": "value\n"
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-21-block-scalar-nodes/in.yaml 0000664 0000000 0000000 00000000060 15015766371 0031444 0 ustar 00root root 0000000 0000000 literal: |2
value
folded:
!foo
>1
value
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-21-block-scalar-nodes/out.yaml 0000664 0000000 0000000 00000000052 15015766371 0031646 0 ustar 00root root 0000000 0000000 literal: |
value
folded: !foo >
value
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-22-block-collection-nodes/ 0000775 0000000 0000000 00000000000 15015766371 0031045 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-22-block-collection-nodes/in.json 0000664 0000000 0000000 00000000145 15015766371 0032346 0 ustar 00root root 0000000 0000000 {
"sequence": [
"entry",
[
"nested"
]
],
"mapping": {
"foo": "bar"
}
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-22-block-collection-nodes/in.yaml 0000664 0000000 0000000 00000000103 15015766371 0032331 0 ustar 00root root 0000000 0000000 sequence: !!seq
- entry
- !!seq
- nested
mapping: !!map
foo: bar
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-22-block-collection-nodes/out.yaml 0000664 0000000 0000000 00000000105 15015766371 0032534 0 ustar 00root root 0000000 0000000 sequence: !!seq
- entry
- !!seq
- nested
mapping: !!map
foo: bar
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-4-chomping-final-line-break/ 0000775 0000000 0000000 00000000000 15015766371 0031336 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-4-chomping-final-line-break/in.json 0000664 0000000 0000000 00000000076 15015766371 0032642 0 ustar 00root root 0000000 0000000 {
"strip": "text",
"clip": "text\n",
"keep": "text\n"
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-4-chomping-final-line-break/in.yaml 0000664 0000000 0000000 00000000060 15015766371 0032624 0 ustar 00root root 0000000 0000000 strip: |-
text
clip: |
text
keep: |+
text
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-4-chomping-final-line-break/out.yaml 0000664 0000000 0000000 00000000057 15015766371 0033033 0 ustar 00root root 0000000 0000000 strip: |-
text
clip: |
text
keep: |
text
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-5-chomping-trailing-lines/ 0000775 0000000 0000000 00000000000 15015766371 0031160 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-5-chomping-trailing-lines/in.json 0000664 0000000 0000000 00000000106 15015766371 0032456 0 ustar 00root root 0000000 0000000 {
"strip": "# text",
"clip": "# text\n",
"keep": "# text\n\n"
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-5-chomping-trailing-lines/in.yaml 0000664 0000000 0000000 00000000230 15015766371 0032445 0 ustar 00root root 0000000 0000000 # Strip
# Comments:
strip: |-
# text
# Clip
# comments:
clip: |
# text
# Keep
# comments:
keep: |+
# text
# Trail
# comments.
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-5-chomping-trailing-lines/out.yaml 0000664 0000000 0000000 00000000073 15015766371 0032653 0 ustar 00root root 0000000 0000000 strip: |-
# text
clip: |
# text
keep: |+
# text
...
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-6-empty-scalar-chomping/ 0000775 0000000 0000000 00000000000 15015766371 0030641 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-6-empty-scalar-chomping/in.json 0000664 0000000 0000000 00000000060 15015766371 0032136 0 ustar 00root root 0000000 0000000 {
"strip": "",
"clip": "",
"keep": "\n"
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-6-empty-scalar-chomping/in.yaml 0000664 0000000 0000000 00000000036 15015766371 0032132 0 ustar 00root root 0000000 0000000 strip: >-
clip: >
keep: |+
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-6-empty-scalar-chomping/out.yaml 0000664 0000000 0000000 00000000042 15015766371 0032330 0 ustar 00root root 0000000 0000000 strip: ""
clip: ""
keep: |2+
...
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-7-literal-scalar-1-3/ 0000775 0000000 0000000 00000000000 15015766371 0027634 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-7-literal-scalar-1-3/in.json 0000664 0000000 0000000 00000000024 15015766371 0031131 0 ustar 00root root 0000000 0000000 "literal\n\ttext\n"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-7-literal-scalar-1-3/in.yaml 0000664 0000000 0000000 00000000030 15015766371 0031117 0 ustar 00root root 0000000 0000000 --- |
literal
text
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-7-literal-scalar-1-3/out.yaml 0000664 0000000 0000000 00000000024 15015766371 0031323 0 ustar 00root root 0000000 0000000 "literal\n\ttext\n"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-7-literal-scalar/ 0000775 0000000 0000000 00000000000 15015766371 0027336 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-7-literal-scalar/in.json 0000664 0000000 0000000 00000000024 15015766371 0030633 0 ustar 00root root 0000000 0000000 "literal\n\ttext\n"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-7-literal-scalar/in.yaml 0000664 0000000 0000000 00000000024 15015766371 0030624 0 ustar 00root root 0000000 0000000 |
literal
text
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-7-literal-scalar/out.yaml 0000664 0000000 0000000 00000000024 15015766371 0031025 0 ustar 00root root 0000000 0000000 |
literal
text
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-8-literal-content-1-3/ 0000775 0000000 0000000 00000000000 15015766371 0030042 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-8-literal-content-1-3/in.json 0000664 0000000 0000000 00000000033 15015766371 0031337 0 ustar 00root root 0000000 0000000 "\n\nliteral\n \n\ntext\n"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-8-literal-content-1-3/in.yaml 0000664 0000000 0000000 00000000057 15015766371 0031336 0 ustar 00root root 0000000 0000000 --- |
literal
text
# Comment
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-8-literal-content-1-3/out.yaml 0000664 0000000 0000000 00000000033 15015766371 0031531 0 ustar 00root root 0000000 0000000 "\n\nliteral\n \n\ntext\n"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-8-literal-content/ 0000775 0000000 0000000 00000000000 15015766371 0027544 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-8-literal-content/in.json 0000664 0000000 0000000 00000000033 15015766371 0031041 0 ustar 00root root 0000000 0000000 "\n\nliteral\n \n\ntext\n"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-8-literal-content/in.yaml 0000664 0000000 0000000 00000000053 15015766371 0031034 0 ustar 00root root 0000000 0000000 |
literal
text
# Comment
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-8-literal-content/out.yaml 0000664 0000000 0000000 00000000033 15015766371 0031233 0 ustar 00root root 0000000 0000000 "\n\nliteral\n \n\ntext\n"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-9-folded-scalar-1-3/ 0000775 0000000 0000000 00000000000 15015766371 0027437 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-9-folded-scalar-1-3/in.json 0000664 0000000 0000000 00000000020 15015766371 0030730 0 ustar 00root root 0000000 0000000 "folded text\n"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-9-folded-scalar-1-3/in.yaml 0000664 0000000 0000000 00000000026 15015766371 0030727 0 ustar 00root root 0000000 0000000 --- >
folded
text
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-9-folded-scalar-1-3/out.yaml 0000664 0000000 0000000 00000000020 15015766371 0031122 0 ustar 00root root 0000000 0000000 >
folded text
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-9-folded-scalar/ 0000775 0000000 0000000 00000000000 15015766371 0027141 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-9-folded-scalar/in.json 0000664 0000000 0000000 00000000020 15015766371 0030432 0 ustar 00root root 0000000 0000000 "folded text\n"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-9-folded-scalar/in.yaml 0000664 0000000 0000000 00000000022 15015766371 0030425 0 ustar 00root root 0000000 0000000 >
folded
text
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-8-9-folded-scalar/out.yaml 0000664 0000000 0000000 00000000020 15015766371 0030624 0 ustar 00root root 0000000 0000000 >
folded text
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-9-2-document-markers/ 0000775 0000000 0000000 00000000000 15015766371 0027713 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-9-2-document-markers/in.json 0000664 0000000 0000000 00000000013 15015766371 0031206 0 ustar 00root root 0000000 0000000 "Document"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-9-2-document-markers/in.yaml 0000664 0000000 0000000 00000000044 15015766371 0031203 0 ustar 00root root 0000000 0000000 %YAML 1.2
---
Document
... # Suffix
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-9-2-document-markers/out.yaml 0000664 0000000 0000000 00000000021 15015766371 0031377 0 ustar 00root root 0000000 0000000 --- Document
...
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-9-3-bare-documents/ 0000775 0000000 0000000 00000000000 15015766371 0027344 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-9-3-bare-documents/in.json 0000664 0000000 0000000 00000000070 15015766371 0030642 0 ustar 00root root 0000000 0000000 "Bare document"
"%!PS-Adobe-2.0 # Not the first line\n"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-9-3-bare-documents/in.yaml 0000664 0000000 0000000 00000000112 15015766371 0030630 0 ustar 00root root 0000000 0000000 Bare
document
...
# No document
...
|
%!PS-Adobe-2.0 # Not the first line
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-9-4-explicit-documents/ 0000775 0000000 0000000 00000000000 15015766371 0030255 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-9-4-explicit-documents/in.json 0000664 0000000 0000000 00000000033 15015766371 0031552 0 ustar 00root root 0000000 0000000 {
"matches %": 20
}
null
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-9-4-explicit-documents/in.yaml 0000664 0000000 0000000 00000000053 15015766371 0031545 0 ustar 00root root 0000000 0000000 ---
{ matches
% : 20 }
...
---
# Empty
...
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-9-4-explicit-documents/out.yaml 0000664 0000000 0000000 00000000036 15015766371 0031747 0 ustar 00root root 0000000 0000000 ---
matches %: 20
...
---
...
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-9-5-directives-documents/ 0000775 0000000 0000000 00000000000 15015766371 0030576 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-9-5-directives-documents/in.json 0000664 0000000 0000000 00000000030 15015766371 0032070 0 ustar 00root root 0000000 0000000 "%!PS-Adobe-2.0\n"
null
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-9-5-directives-documents/in.yaml 0000664 0000000 0000000 00000000075 15015766371 0032072 0 ustar 00root root 0000000 0000000 %YAML 1.2
--- |
%!PS-Adobe-2.0
...
%YAML 1.2
---
# Empty
...
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-9-5-directives-documents/out.yaml 0000664 0000000 0000000 00000000043 15015766371 0032266 0 ustar 00root root 0000000 0000000 --- |
%!PS-Adobe-2.0
...
---
...
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-9-6-stream-1-3/ 0000775 0000000 0000000 00000000000 15015766371 0026230 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-9-6-stream-1-3/in.json 0000664 0000000 0000000 00000000067 15015766371 0027534 0 ustar 00root root 0000000 0000000 {
"Mapping": "Document"
}
null
{
"matches %": 20
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-9-6-stream-1-3/in.yaml 0000664 0000000 0000000 00000000076 15015766371 0027525 0 ustar 00root root 0000000 0000000 Mapping: Document
---
# Empty
...
%YAML 1.2
---
matches %: 20
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-9-6-stream/ 0000775 0000000 0000000 00000000000 15015766371 0025732 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-9-6-stream/in.json 0000664 0000000 0000000 00000000046 15015766371 0027233 0 ustar 00root root 0000000 0000000 "Document"
null
{
"matches %": 20
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/spec-example-9-6-stream/in.yaml 0000664 0000000 0000000 00000000065 15015766371 0027225 0 ustar 00root root 0000000 0000000 Document
---
# Empty
...
%YAML 1.2
---
matches %: 20
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/syntax-character-edge-cases/ 0000775 0000000 0000000 00000000000 15015766371 0027023 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/syntax-character-edge-cases/00/ 0000775 0000000 0000000 00000000000 15015766371 0027242 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/syntax-character-edge-cases/00/in.yaml 0000664 0000000 0000000 00000000004 15015766371 0030526 0 ustar 00root root 0000000 0000000 - :
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/syntax-character-edge-cases/01/ 0000775 0000000 0000000 00000000000 15015766371 0027243 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/syntax-character-edge-cases/01/in.json 0000664 0000000 0000000 00000000020 15015766371 0030534 0 ustar 00root root 0000000 0000000 {
":": null
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/syntax-character-edge-cases/01/in.yaml 0000664 0000000 0000000 00000000003 15015766371 0030526 0 ustar 00root root 0000000 0000000 ::
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/syntax-character-edge-cases/02/ 0000775 0000000 0000000 00000000000 15015766371 0027244 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/syntax-character-edge-cases/02/in.yaml 0000664 0000000 0000000 00000000002 15015766371 0030526 0 ustar 00root root 0000000 0000000 !
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tab-after-document-header/ 0000775 0000000 0000000 00000000000 15015766371 0026454 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tab-after-document-header/in.json 0000664 0000000 0000000 00000000011 15015766371 0027745 0 ustar 00root root 0000000 0000000 "scalar"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tab-after-document-header/in.yaml 0000664 0000000 0000000 00000000013 15015766371 0027740 0 ustar 00root root 0000000 0000000 --- scalar
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tab-after-document-header/out.yaml 0000664 0000000 0000000 00000000017 15015766371 0030145 0 ustar 00root root 0000000 0000000 --- scalar
...
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tab-at-beginning-of-line-followed-by-a-flow-mapping/ 0000775 0000000 0000000 00000000000 15015766371 0033237 5 ustar 00root root 0000000 0000000 in.json 0000664 0000000 0000000 00000000003 15015766371 0034452 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tab-at-beginning-of-line-followed-by-a-flow-mapping {}
in.yaml 0000664 0000000 0000000 00000000004 15015766371 0034444 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tab-at-beginning-of-line-followed-by-a-flow-mapping {}
out.yaml 0000664 0000000 0000000 00000000003 15015766371 0034644 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tab-at-beginning-of-line-followed-by-a-flow-mapping {}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tab-indented-top-flow/ 0000775 0000000 0000000 00000000000 15015766371 0025650 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tab-indented-top-flow/in.json 0000664 0000000 0000000 00000000003 15015766371 0027142 0 ustar 00root root 0000000 0000000 []
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tab-indented-top-flow/in.yaml 0000664 0000000 0000000 00000000006 15015766371 0027136 0 ustar 00root root 0000000 0000000 [
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-in-various-contexts/ 0000775 0000000 0000000 00000000000 15015766371 0026435 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-in-various-contexts/000/ 0000775 0000000 0000000 00000000000 15015766371 0026734 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-in-various-contexts/000/error 0000664 0000000 0000000 00000000000 15015766371 0027776 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-in-various-contexts/000/in.yaml 0000664 0000000 0000000 00000000020 15015766371 0030216 0 ustar 00root root 0000000 0000000 foo: |
bar: 1
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-in-various-contexts/001/ 0000775 0000000 0000000 00000000000 15015766371 0026735 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-in-various-contexts/001/in.json 0000664 0000000 0000000 00000000040 15015766371 0030230 0 ustar 00root root 0000000 0000000 {
"foo": "\t\n",
"bar": 1
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-in-various-contexts/001/in.yaml 0000664 0000000 0000000 00000000021 15015766371 0030220 0 ustar 00root root 0000000 0000000 foo: |
bar: 1
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-in-various-contexts/001/out.yaml 0000664 0000000 0000000 00000000022 15015766371 0030422 0 ustar 00root root 0000000 0000000 foo: |
bar: 1
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-in-various-contexts/002/ 0000775 0000000 0000000 00000000000 15015766371 0026736 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-in-various-contexts/002/in.json 0000664 0000000 0000000 00000000026 15015766371 0030235 0 ustar 00root root 0000000 0000000 [
[
"foo"
]
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-in-various-contexts/002/in.yaml 0000664 0000000 0000000 00000000016 15015766371 0030225 0 ustar 00root root 0000000 0000000 - [
foo
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-in-various-contexts/002/out.yaml 0000664 0000000 0000000 00000000010 15015766371 0030420 0 ustar 00root root 0000000 0000000 - - foo
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-in-various-contexts/003/ 0000775 0000000 0000000 00000000000 15015766371 0026737 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-in-various-contexts/003/error 0000664 0000000 0000000 00000000000 15015766371 0030001 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-in-various-contexts/003/in.yaml 0000664 0000000 0000000 00000000022 15015766371 0030223 0 ustar 00root root 0000000 0000000 - [
foo,
foo
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-in-various-contexts/003/out.yaml 0000664 0000000 0000000 00000000010 15015766371 0030421 0 ustar 00root root 0000000 0000000 - - foo
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-in-various-contexts/004/ 0000775 0000000 0000000 00000000000 15015766371 0026740 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-in-various-contexts/004/error 0000664 0000000 0000000 00000000000 15015766371 0030002 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-in-various-contexts/004/in.yaml 0000664 0000000 0000000 00000000004 15015766371 0030224 0 ustar 00root root 0000000 0000000 - -
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-in-various-contexts/004/out.yaml 0000664 0000000 0000000 00000000010 15015766371 0030422 0 ustar 00root root 0000000 0000000 - - foo
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-in-various-contexts/005/ 0000775 0000000 0000000 00000000000 15015766371 0026741 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-in-various-contexts/005/error 0000664 0000000 0000000 00000000000 15015766371 0030003 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-in-various-contexts/005/in.yaml 0000664 0000000 0000000 00000000005 15015766371 0030226 0 ustar 00root root 0000000 0000000 - -
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-in-various-contexts/005/out.yaml 0000664 0000000 0000000 00000000010 15015766371 0030423 0 ustar 00root root 0000000 0000000 - - foo
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-in-various-contexts/006/ 0000775 0000000 0000000 00000000000 15015766371 0026742 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-in-various-contexts/006/error 0000664 0000000 0000000 00000000000 15015766371 0030004 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-in-various-contexts/006/in.yaml 0000664 0000000 0000000 00000000004 15015766371 0030226 0 ustar 00root root 0000000 0000000 ? -
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-in-various-contexts/006/out.yaml 0000664 0000000 0000000 00000000010 15015766371 0030424 0 ustar 00root root 0000000 0000000 - - foo
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-in-various-contexts/007/ 0000775 0000000 0000000 00000000000 15015766371 0026743 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-in-various-contexts/007/error 0000664 0000000 0000000 00000000000 15015766371 0030005 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-in-various-contexts/007/in.yaml 0000664 0000000 0000000 00000000010 15015766371 0030224 0 ustar 00root root 0000000 0000000 ? -
: -
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-in-various-contexts/007/out.yaml 0000664 0000000 0000000 00000000010 15015766371 0030425 0 ustar 00root root 0000000 0000000 - - foo
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-in-various-contexts/008/ 0000775 0000000 0000000 00000000000 15015766371 0026744 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-in-various-contexts/008/error 0000664 0000000 0000000 00000000000 15015766371 0030006 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-in-various-contexts/008/in.yaml 0000664 0000000 0000000 00000000007 15015766371 0030233 0 ustar 00root root 0000000 0000000 ? key:
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-in-various-contexts/008/out.yaml 0000664 0000000 0000000 00000000010 15015766371 0030426 0 ustar 00root root 0000000 0000000 - - foo
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-in-various-contexts/009/ 0000775 0000000 0000000 00000000000 15015766371 0026745 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-in-various-contexts/009/error 0000664 0000000 0000000 00000000000 15015766371 0030007 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-in-various-contexts/009/in.yaml 0000664 0000000 0000000 00000000016 15015766371 0030234 0 ustar 00root root 0000000 0000000 ? key:
: key:
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-in-various-contexts/009/out.yaml 0000664 0000000 0000000 00000000010 15015766371 0030427 0 ustar 00root root 0000000 0000000 - - foo
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-in-various-contexts/010/ 0000775 0000000 0000000 00000000000 15015766371 0026735 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-in-various-contexts/010/in.json 0000664 0000000 0000000 00000000011 15015766371 0030226 0 ustar 00root root 0000000 0000000 [
-1
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-in-various-contexts/010/in.yaml 0000664 0000000 0000000 00000000005 15015766371 0030222 0 ustar 00root root 0000000 0000000 - -1
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-in-various-contexts/010/out.yaml 0000664 0000000 0000000 00000000005 15015766371 0030423 0 ustar 00root root 0000000 0000000 - -1
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-that-look-like-indentation/ 0000775 0000000 0000000 00000000000 15015766371 0027632 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-that-look-like-indentation/00/ 0000775 0000000 0000000 00000000000 15015766371 0030051 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-that-look-like-indentation/00/in.json 0000664 0000000 0000000 00000000024 15015766371 0031346 0 ustar 00root root 0000000 0000000 {
"foo" : "bar"
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-that-look-like-indentation/00/in.yaml 0000664 0000000 0000000 00000000013 15015766371 0031335 0 ustar 00root root 0000000 0000000 foo:
bar
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-that-look-like-indentation/01/ 0000775 0000000 0000000 00000000000 15015766371 0030052 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-that-look-like-indentation/01/error 0000664 0000000 0000000 00000000000 15015766371 0031114 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-that-look-like-indentation/01/in.json 0000664 0000000 0000000 00000000024 15015766371 0031347 0 ustar 00root root 0000000 0000000 {
"foo" : "bar"
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-that-look-like-indentation/01/in.yaml 0000664 0000000 0000000 00000000020 15015766371 0031334 0 ustar 00root root 0000000 0000000 foo: "bar
baz"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-that-look-like-indentation/02/ 0000775 0000000 0000000 00000000000 15015766371 0030053 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-that-look-like-indentation/02/in.json 0000664 0000000 0000000 00000000030 15015766371 0031345 0 ustar 00root root 0000000 0000000 {
"foo" : "bar baz"
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-that-look-like-indentation/02/in.yaml 0000664 0000000 0000000 00000000022 15015766371 0031337 0 ustar 00root root 0000000 0000000 foo: "bar
baz"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-that-look-like-indentation/03/ 0000775 0000000 0000000 00000000000 15015766371 0030054 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-that-look-like-indentation/03/in.json 0000664 0000000 0000000 00000000020 15015766371 0031345 0 ustar 00root root 0000000 0000000 {
"foo" : 1
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-that-look-like-indentation/03/in.yaml 0000664 0000000 0000000 00000000012 15015766371 0031337 0 ustar 00root root 0000000 0000000
foo: 1
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-that-look-like-indentation/04/ 0000775 0000000 0000000 00000000000 15015766371 0030055 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-that-look-like-indentation/04/in.json 0000664 0000000 0000000 00000000035 15015766371 0031354 0 ustar 00root root 0000000 0000000 {
"foo" : 1,
"bar" : 2
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-that-look-like-indentation/04/in.yaml 0000664 0000000 0000000 00000000020 15015766371 0031337 0 ustar 00root root 0000000 0000000 foo: 1
bar: 2
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-that-look-like-indentation/05/ 0000775 0000000 0000000 00000000000 15015766371 0030056 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-that-look-like-indentation/05/in.json 0000664 0000000 0000000 00000000035 15015766371 0031355 0 ustar 00root root 0000000 0000000 {
"foo" : 1,
"bar" : 2
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-that-look-like-indentation/05/in.yaml 0000664 0000000 0000000 00000000021 15015766371 0031341 0 ustar 00root root 0000000 0000000 foo: 1
bar: 2
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-that-look-like-indentation/06/ 0000775 0000000 0000000 00000000000 15015766371 0030057 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-that-look-like-indentation/06/error 0000664 0000000 0000000 00000000000 15015766371 0031121 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-that-look-like-indentation/06/in.json 0000664 0000000 0000000 00000000035 15015766371 0031356 0 ustar 00root root 0000000 0000000 {
"foo" : 1,
"bar" : 2
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-that-look-like-indentation/06/in.yaml 0000664 0000000 0000000 00000000024 15015766371 0031345 0 ustar 00root root 0000000 0000000 foo:
a: 1
b: 2
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-that-look-like-indentation/07/ 0000775 0000000 0000000 00000000000 15015766371 0030060 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-that-look-like-indentation/07/in.json 0000664 0000000 0000000 00000000005 15015766371 0031354 0 ustar 00root root 0000000 0000000 null
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-that-look-like-indentation/07/in.yaml 0000664 0000000 0000000 00000000020 15015766371 0031342 0 ustar 00root root 0000000 0000000 %YAML 1.2
---
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-that-look-like-indentation/08/ 0000775 0000000 0000000 00000000000 15015766371 0030061 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-that-look-like-indentation/08/in.json 0000664 0000000 0000000 00000000037 15015766371 0031362 0 ustar 00root root 0000000 0000000 {
"foo" : "bar baz \t \t "
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tabs-that-look-like-indentation/08/in.yaml 0000664 0000000 0000000 00000000031 15015766371 0031345 0 ustar 00root root 0000000 0000000 foo: "bar
baz "
tag-shorthand-used-in-documents-but-only-defined-in-the-first/ 0000775 0000000 0000000 00000000000 15015766371 0035244 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite error 0000664 0000000 0000000 00000000000 15015766371 0036306 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tag-shorthand-used-in-documents-but-only-defined-in-the-first in.yaml 0000664 0000000 0000000 00000000135 15015766371 0036535 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tag-shorthand-used-in-documents-but-only-defined-in-the-first %TAG !prefix! tag:example.com,2011:
--- !prefix!A
a: b
--- !prefix!B
c: d
--- !prefix!C
e: f
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tags-for-block-objects/ 0000775 0000000 0000000 00000000000 15015766371 0026006 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tags-for-block-objects/in.json 0000664 0000000 0000000 00000000075 15015766371 0027311 0 ustar 00root root 0000000 0000000 {
"foo": [
"a",
{
"key": "value"
}
]
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tags-for-block-objects/in.yaml 0000664 0000000 0000000 00000000066 15015766371 0027302 0 ustar 00root root 0000000 0000000 foo: !!seq
- !!str a
- !!map
key: !!str value
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tags-for-block-objects/out.yaml 0000664 0000000 0000000 00000000060 15015766371 0027475 0 ustar 00root root 0000000 0000000 foo: !!seq
- !!str a
- !!map
key: !!str value
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tags-for-flow-objects/ 0000775 0000000 0000000 00000000000 15015766371 0025663 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tags-for-flow-objects/in.json 0000664 0000000 0000000 00000000042 15015766371 0027160 0 ustar 00root root 0000000 0000000 {
"k": [
"a",
"b"
]
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tags-for-flow-objects/in.yaml 0000664 0000000 0000000 00000000045 15015766371 0027154 0 ustar 00root root 0000000 0000000 !!map {
k: !!seq
[ a, !!str b]
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tags-for-flow-objects/out.yaml 0000664 0000000 0000000 00000000035 15015766371 0027354 0 ustar 00root root 0000000 0000000 !!map
k: !!seq
- a
- !!str b
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tags-for-root-objects/ 0000775 0000000 0000000 00000000000 15015766371 0025677 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tags-for-root-objects/in.json 0000664 0000000 0000000 00000000037 15015766371 0027200 0 ustar 00root root 0000000 0000000 {
"a": "b"
}
[
"c"
]
"d e"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tags-for-root-objects/in.yaml 0000664 0000000 0000000 00000000064 15015766371 0027171 0 ustar 00root root 0000000 0000000 --- !!map
? a
: b
--- !!seq
- !!str c
--- !!str
d
e
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tags-for-root-objects/out.yaml 0000664 0000000 0000000 00000000061 15015766371 0027367 0 ustar 00root root 0000000 0000000 --- !!map
a: b
--- !!seq
- !!str c
--- !!str d e
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tags-in-block-sequence/ 0000775 0000000 0000000 00000000000 15015766371 0026005 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tags-in-block-sequence/in.json 0000664 0000000 0000000 00000000036 15015766371 0027305 0 ustar 00root root 0000000 0000000 [
"a",
"b",
42,
"d"
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tags-in-block-sequence/in.yaml 0000664 0000000 0000000 00000000041 15015766371 0027272 0 ustar 00root root 0000000 0000000 - !!str a
- b
- !!int 42
- d
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tags-in-block-sequence/out.yaml 0000664 0000000 0000000 00000000035 15015766371 0027476 0 ustar 00root root 0000000 0000000 - !!str a
- b
- !!int 42
- d
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tags-in-explicit-mapping/ 0000775 0000000 0000000 00000000000 15015766371 0026357 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tags-in-explicit-mapping/in.json 0000664 0000000 0000000 00000000032 15015766371 0027653 0 ustar 00root root 0000000 0000000 {
"a": 47,
"c": "d"
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tags-in-explicit-mapping/in.yaml 0000664 0000000 0000000 00000000043 15015766371 0027646 0 ustar 00root root 0000000 0000000 ? !!str a
: !!int 47
? c
: !!str d
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tags-in-explicit-mapping/out.yaml 0000664 0000000 0000000 00000000035 15015766371 0030050 0 ustar 00root root 0000000 0000000 !!str a: !!int 47
c: !!str d
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tags-in-implicit-mapping/ 0000775 0000000 0000000 00000000000 15015766371 0026350 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tags-in-implicit-mapping/in.json 0000664 0000000 0000000 00000000101 15015766371 0027641 0 ustar 00root root 0000000 0000000 {
"a": "b",
"c": 42,
"e": "f",
"g": "h",
"23": false
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tags-in-implicit-mapping/in.yaml 0000664 0000000 0000000 00000000076 15015766371 0027645 0 ustar 00root root 0000000 0000000 !!str a: b
c: !!int 42
e: !!str f
g: h
!!str 23: !!bool false
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tags-in-implicit-mapping/out.yaml 0000664 0000000 0000000 00000000076 15015766371 0030046 0 ustar 00root root 0000000 0000000 !!str a: b
c: !!int 42
e: !!str f
g: h
!!str 23: !!bool false
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tags-on-empty-scalars/ 0000775 0000000 0000000 00000000000 15015766371 0025677 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tags-on-empty-scalars/in.yaml 0000664 0000000 0000000 00000000063 15015766371 0027170 0 ustar 00root root 0000000 0000000 - !!str
-
!!null : a
b: !!str
- !!str : !!null
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/tags-on-empty-scalars/out.yaml 0000664 0000000 0000000 00000000061 15015766371 0027367 0 ustar 00root root 0000000 0000000 - !!str
- !!null : a
b: !!str
- !!str : !!null
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/three-dashes-and-content-without-space-1-3/ 0000775 0000000 0000000 00000000000 15015766371 0031421 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/three-dashes-and-content-without-space-1-3/in.json 0000664 0000000 0000000 00000000021 15015766371 0032713 0 ustar 00root root 0000000 0000000 "---word1 word2"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/three-dashes-and-content-without-space-1-3/in.yaml 0000664 0000000 0000000 00000000023 15015766371 0032706 0 ustar 00root root 0000000 0000000 ---
---word1
word2
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/three-dashes-and-content-without-space-1-3/out.yaml 0000664 0000000 0000000 00000000021 15015766371 0033105 0 ustar 00root root 0000000 0000000 '---word1 word2'
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/three-dashes-and-content-without-space/ 0000775 0000000 0000000 00000000000 15015766371 0031123 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/three-dashes-and-content-without-space/in.json 0000664 0000000 0000000 00000000021 15015766371 0032415 0 ustar 00root root 0000000 0000000 "---word1 word2"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/three-dashes-and-content-without-space/in.yaml 0000664 0000000 0000000 00000000017 15015766371 0032413 0 ustar 00root root 0000000 0000000 ---word1
word2
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/three-dashes-and-content-without-space/out.yaml 0000664 0000000 0000000 00000000021 15015766371 0032607 0 ustar 00root root 0000000 0000000 '---word1 word2'
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/three-explicit-integers-in-a-block-sequence/ 0000775 0000000 0000000 00000000000 15015766371 0032031 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/three-explicit-integers-in-a-block-sequence/in.json 0000664 0000000 0000000 00000000024 15015766371 0033326 0 ustar 00root root 0000000 0000000 [
1,
-2,
33
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/three-explicit-integers-in-a-block-sequence/in.yaml 0000664 0000000 0000000 00000000044 15015766371 0033321 0 ustar 00root root 0000000 0000000 ---
- !!int 1
- !!int -2
- !!int 33
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/three-explicit-integers-in-a-block-sequence/out.yaml 0000664 0000000 0000000 00000000044 15015766371 0033522 0 ustar 00root root 0000000 0000000 ---
- !!int 1
- !!int -2
- !!int 33
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/trailing-comment-in-multiline-plain-scalar/ 0000775 0000000 0000000 00000000000 15015766371 0031766 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/trailing-comment-in-multiline-plain-scalar/error 0000664 0000000 0000000 00000000000 15015766371 0033030 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/trailing-comment-in-multiline-plain-scalar/in.yaml 0000664 0000000 0000000 00000000057 15015766371 0033262 0 ustar 00root root 0000000 0000000 ---
plain: a
b # end of scalar
c
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/trailing-content-after-quoted-value/ 0000775 0000000 0000000 00000000000 15015766371 0030536 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/trailing-content-after-quoted-value/error 0000664 0000000 0000000 00000000000 15015766371 0031600 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/trailing-content-after-quoted-value/in.yaml 0000664 0000000 0000000 00000000101 15015766371 0032020 0 ustar 00root root 0000000 0000000 key1: "quoted1"
key2: "quoted2" trailing content
key3: "quoted3"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/trailing-content-that-looks-like-a-mapping/ 0000775 0000000 0000000 00000000000 15015766371 0031702 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/trailing-content-that-looks-like-a-mapping/error 0000664 0000000 0000000 00000000000 15015766371 0032744 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/trailing-content-that-looks-like-a-mapping/in.yaml 0000664 0000000 0000000 00000000102 15015766371 0033165 0 ustar 00root root 0000000 0000000 key1: "quoted1"
key2: "quoted2" no key: nor value
key3: "quoted3"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/trailing-line-of-spaces/ 0000775 0000000 0000000 00000000000 15015766371 0026161 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/trailing-line-of-spaces/00/ 0000775 0000000 0000000 00000000000 15015766371 0026400 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/trailing-line-of-spaces/00/in.json 0000664 0000000 0000000 00000000027 15015766371 0027700 0 ustar 00root root 0000000 0000000 {
"foo" : "x\n \n"
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/trailing-line-of-spaces/00/in.yaml 0000664 0000000 0000000 00000000017 15015766371 0027670 0 ustar 00root root 0000000 0000000 foo: |
x
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/trailing-line-of-spaces/01/ 0000775 0000000 0000000 00000000000 15015766371 0026401 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/trailing-line-of-spaces/01/in.json 0000664 0000000 0000000 00000000027 15015766371 0027701 0 ustar 00root root 0000000 0000000 {
"foo" : "x\n \n"
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/trailing-line-of-spaces/01/in.yaml 0000664 0000000 0000000 00000000016 15015766371 0027670 0 ustar 00root root 0000000 0000000 foo: |
x
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/trailing-spaces-after-flow-collection/ 0000775 0000000 0000000 00000000000 15015766371 0031027 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/trailing-spaces-after-flow-collection/in.json 0000664 0000000 0000000 00000000022 15015766371 0032322 0 ustar 00root root 0000000 0000000 [
1,
2,
3
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/trailing-spaces-after-flow-collection/in.yaml 0000664 0000000 0000000 00000000020 15015766371 0032311 0 ustar 00root root 0000000 0000000 [1, 2, 3]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/trailing-spaces-after-flow-collection/out.yaml 0000664 0000000 0000000 00000000014 15015766371 0032515 0 ustar 00root root 0000000 0000000 - 1
- 2
- 3
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/trailing-tabs-in-double-quoted/ 0000775 0000000 0000000 00000000000 15015766371 0027460 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/trailing-tabs-in-double-quoted/00/ 0000775 0000000 0000000 00000000000 15015766371 0027677 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/trailing-tabs-in-double-quoted/00/in.json 0000664 0000000 0000000 00000000023 15015766371 0031173 0 ustar 00root root 0000000 0000000 "1 trailing\t tab"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/trailing-tabs-in-double-quoted/00/in.yaml 0000664 0000000 0000000 00000000027 15015766371 0031170 0 ustar 00root root 0000000 0000000 "1 trailing\t
tab"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/trailing-tabs-in-double-quoted/00/out.yaml 0000664 0000000 0000000 00000000023 15015766371 0031365 0 ustar 00root root 0000000 0000000 "1 trailing\t tab"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/trailing-tabs-in-double-quoted/01/ 0000775 0000000 0000000 00000000000 15015766371 0027700 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/trailing-tabs-in-double-quoted/01/in.json 0000664 0000000 0000000 00000000023 15015766371 0031174 0 ustar 00root root 0000000 0000000 "2 trailing\t tab"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/trailing-tabs-in-double-quoted/01/in.yaml 0000664 0000000 0000000 00000000031 15015766371 0031164 0 ustar 00root root 0000000 0000000 "2 trailing\t
tab"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/trailing-tabs-in-double-quoted/01/out.yaml 0000664 0000000 0000000 00000000023 15015766371 0031366 0 ustar 00root root 0000000 0000000 "2 trailing\t tab"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/trailing-tabs-in-double-quoted/02/ 0000775 0000000 0000000 00000000000 15015766371 0027701 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/trailing-tabs-in-double-quoted/02/in.json 0000664 0000000 0000000 00000000023 15015766371 0031175 0 ustar 00root root 0000000 0000000 "3 trailing\t tab"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/trailing-tabs-in-double-quoted/02/in.yaml 0000664 0000000 0000000 00000000027 15015766371 0031172 0 ustar 00root root 0000000 0000000 "3 trailing\
tab"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/trailing-tabs-in-double-quoted/02/out.yaml 0000664 0000000 0000000 00000000023 15015766371 0031367 0 ustar 00root root 0000000 0000000 "3 trailing\t tab"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/trailing-tabs-in-double-quoted/03/ 0000775 0000000 0000000 00000000000 15015766371 0027702 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/trailing-tabs-in-double-quoted/03/in.json 0000664 0000000 0000000 00000000023 15015766371 0031176 0 ustar 00root root 0000000 0000000 "4 trailing\t tab"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/trailing-tabs-in-double-quoted/03/in.yaml 0000664 0000000 0000000 00000000031 15015766371 0031166 0 ustar 00root root 0000000 0000000 "4 trailing\
tab"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/trailing-tabs-in-double-quoted/03/out.yaml 0000664 0000000 0000000 00000000023 15015766371 0031370 0 ustar 00root root 0000000 0000000 "4 trailing\t tab"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/trailing-tabs-in-double-quoted/04/ 0000775 0000000 0000000 00000000000 15015766371 0027703 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/trailing-tabs-in-double-quoted/04/in.json 0000664 0000000 0000000 00000000021 15015766371 0031175 0 ustar 00root root 0000000 0000000 "5 trailing tab"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/trailing-tabs-in-double-quoted/04/in.yaml 0000664 0000000 0000000 00000000026 15015766371 0031173 0 ustar 00root root 0000000 0000000 "5 trailing
tab"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/trailing-tabs-in-double-quoted/04/out.yaml 0000664 0000000 0000000 00000000021 15015766371 0031367 0 ustar 00root root 0000000 0000000 "5 trailing tab"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/trailing-tabs-in-double-quoted/05/ 0000775 0000000 0000000 00000000000 15015766371 0027704 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/trailing-tabs-in-double-quoted/05/in.json 0000664 0000000 0000000 00000000021 15015766371 0031176 0 ustar 00root root 0000000 0000000 "6 trailing tab"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/trailing-tabs-in-double-quoted/05/in.yaml 0000664 0000000 0000000 00000000030 15015766371 0031167 0 ustar 00root root 0000000 0000000 "6 trailing
tab"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/trailing-tabs-in-double-quoted/05/out.yaml 0000664 0000000 0000000 00000000021 15015766371 0031370 0 ustar 00root root 0000000 0000000 "6 trailing tab"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/trailing-whitespace-in-streams/ 0000775 0000000 0000000 00000000000 15015766371 0027570 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/trailing-whitespace-in-streams/00/ 0000775 0000000 0000000 00000000000 15015766371 0030007 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/trailing-whitespace-in-streams/00/in.json 0000664 0000000 0000000 00000000015 15015766371 0031304 0 ustar 00root root 0000000 0000000 [
"\n\n"
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/trailing-whitespace-in-streams/00/in.yaml 0000664 0000000 0000000 00000000007 15015766371 0031276 0 ustar 00root root 0000000 0000000 - |+
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/trailing-whitespace-in-streams/00/out.yaml 0000664 0000000 0000000 00000000013 15015766371 0031474 0 ustar 00root root 0000000 0000000 - |+
...
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/trailing-whitespace-in-streams/01/ 0000775 0000000 0000000 00000000000 15015766371 0030010 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/trailing-whitespace-in-streams/01/in.json 0000664 0000000 0000000 00000000013 15015766371 0031303 0 ustar 00root root 0000000 0000000 [
"\n"
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/trailing-whitespace-in-streams/01/in.yaml 0000664 0000000 0000000 00000000011 15015766371 0031272 0 ustar 00root root 0000000 0000000 - |+
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/trailing-whitespace-in-streams/01/out.yaml 0000664 0000000 0000000 00000000012 15015766371 0031474 0 ustar 00root root 0000000 0000000 - |+
...
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/trailing-whitespace-in-streams/02/ 0000775 0000000 0000000 00000000000 15015766371 0030011 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/trailing-whitespace-in-streams/02/in.json 0000664 0000000 0000000 00000000013 15015766371 0031304 0 ustar 00root root 0000000 0000000 [
"\n"
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/trailing-whitespace-in-streams/02/in.yaml 0000664 0000000 0000000 00000000010 15015766371 0031272 0 ustar 00root root 0000000 0000000 - |+
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/trailing-whitespace-in-streams/02/out.yaml 0000664 0000000 0000000 00000000012 15015766371 0031475 0 ustar 00root root 0000000 0000000 - |+
...
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/two-document-start-markers/ 0000775 0000000 0000000 00000000000 15015766371 0026767 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/two-document-start-markers/in.json 0000664 0000000 0000000 00000000012 15015766371 0030261 0 ustar 00root root 0000000 0000000 null
null
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/two-document-start-markers/in.yaml 0000664 0000000 0000000 00000000010 15015766371 0030250 0 ustar 00root root 0000000 0000000 ---
---
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/two-document-start-markers/out.yaml 0000664 0000000 0000000 00000000010 15015766371 0030451 0 ustar 00root root 0000000 0000000 ---
---
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/two-scalar-docs-with-trailing-comments/ 0000775 0000000 0000000 00000000000 15015766371 0031152 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/two-scalar-docs-with-trailing-comments/in.json 0000664 0000000 0000000 00000000014 15015766371 0032446 0 ustar 00root root 0000000 0000000 "foo"
"foo"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/two-scalar-docs-with-trailing-comments/in.yaml 0000664 0000000 0000000 00000000046 15015766371 0032444 0 ustar 00root root 0000000 0000000 --- foo # comment
--- foo # comment
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/two-scalar-docs-with-trailing-comments/out.yaml 0000664 0000000 0000000 00000000020 15015766371 0032635 0 ustar 00root root 0000000 0000000 --- foo
--- foo
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/various-combinations-of-explicit-block-mappings/ 0000775 0000000 0000000 00000000000 15015766371 0033045 5 ustar 00root root 0000000 0000000 in.yaml 0000664 0000000 0000000 00000000174 15015766371 0034262 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/various-combinations-of-explicit-block-mappings complex1:
? - a
complex2:
? - a
: b
complex3:
? - a
: >
b
complex4:
? >
a
:
complex5:
? - a
: - b
out.yaml 0000664 0000000 0000000 00000000200 15015766371 0034451 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/various-combinations-of-explicit-block-mappings complex1:
? - a
:
complex2:
? - a
: b
complex3:
? - a
: >
b
complex4:
? >
a
:
complex5:
? - a
: - b
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/various-combinations-of-tags-and-anchors/ 0000775 0000000 0000000 00000000000 15015766371 0031451 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/various-combinations-of-tags-and-anchors/in.json 0000664 0000000 0000000 00000000207 15015766371 0032751 0 ustar 00root root 0000000 0000000 "scalar1"
"scalar2"
"scalar3"
{
"key5": "value4"
}
{
"a6": 1,
"b6": 2
}
{
"key8": "value7"
}
{
"key10": "value9"
}
"value11"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/various-combinations-of-tags-and-anchors/in.yaml 0000664 0000000 0000000 00000000333 15015766371 0032742 0 ustar 00root root 0000000 0000000 ---
&a1
!!str
scalar1
---
!!str
&a2
scalar2
---
&a3
!!str scalar3
---
&a4 !!map
&a5 !!str key5: value4
---
a6: 1
&anchor6 b6: 2
---
!!map
&a8 !!str key8: value7
---
!!map
!!str &a10 key10: value9
---
!!str &a11
value11
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/various-combinations-of-tags-and-anchors/out.yaml 0000664 0000000 0000000 00000000333 15015766371 0033143 0 ustar 00root root 0000000 0000000 --- &a1 !!str scalar1
--- &a2 !!str scalar2
--- &a3 !!str scalar3
--- &a4 !!map
&a5 !!str key5: value4
---
a6: 1
&anchor6 b6: 2
--- !!map
&a8 !!str key8: value7
--- !!map
&a10 !!str key10: value9
--- &a11 !!str value11
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/various-empty-or-newline-only-quoted-strings/ 0000775 0000000 0000000 00000000000 15015766371 0032413 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/various-empty-or-newline-only-quoted-strings/in.json 0000664 0000000 0000000 00000000153 15015766371 0033713 0 ustar 00root root 0000000 0000000 {
"a": " ",
"b": " ",
"c": " ",
"d": " ",
"e": "\n",
"f": "\n",
"g": "\n\n",
"h": "\n\n"
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/various-empty-or-newline-only-quoted-strings/in.yaml 0000664 0000000 0000000 00000000126 15015766371 0033704 0 ustar 00root root 0000000 0000000 ---
a: '
'
b: '
'
c: "
"
d: "
"
e: '
'
f: "
"
g: '
'
h: "
"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/various-location-of-anchors-in-flow-sequence/ 0000775 0000000 0000000 00000000000 15015766371 0032257 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/various-location-of-anchors-in-flow-sequence/in.json 0000664 0000000 0000000 00000000133 15015766371 0033555 0 ustar 00root root 0000000 0000000 [
{
"a": "b"
},
{
"c": "d"
},
{
"e": "f"
},
{
"g": "h"
}
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/various-location-of-anchors-in-flow-sequence/in.yaml 0000664 0000000 0000000 00000000071 15015766371 0033547 0 ustar 00root root 0000000 0000000 &flowseq [
a: b,
&c c: d,
{ &e e: f },
&g { g: h }
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/various-location-of-anchors-in-flow-sequence/out.yaml0000664 0000000 0000000 00000000060 15015766371 0033746 0 ustar 00root root 0000000 0000000 &flowseq
- a: b
- &c c: d
- &e e: f
- &g
g: h
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/various-trailing-comments-1-3/ 0000775 0000000 0000000 00000000000 15015766371 0027165 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/various-trailing-comments-1-3/in.yaml 0000664 0000000 0000000 00000000235 15015766371 0030457 0 ustar 00root root 0000000 0000000 a: "double
quotes" # lala
b: plain
value # lala
c : #lala
d
? # lala
- seq1
: # lala
- #lala
seq2
e: &node # lala
- x: y
block: > # lala
abcde
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/various-trailing-comments-1-3/out.yaml 0000664 0000000 0000000 00000000132 15015766371 0030654 0 ustar 00root root 0000000 0000000 a: "double quotes"
b: plain value
c: d
? - seq1
: - seq2
e: &node
- x: y
block: >
abcde
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/various-trailing-comments/ 0000775 0000000 0000000 00000000000 15015766371 0026667 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/various-trailing-comments/in.yaml 0000664 0000000 0000000 00000000236 15015766371 0030162 0 ustar 00root root 0000000 0000000 a: "double
quotes" # lala
b: plain
value # lala
c : #lala
d
? # lala
- seq1
: # lala
- #lala
seq2
e:
&node # lala
- x: y
block: > # lala
abcde
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/various-trailing-comments/out.yaml 0000664 0000000 0000000 00000000132 15015766371 0030356 0 ustar 00root root 0000000 0000000 a: "double quotes"
b: plain value
c: d
? - seq1
: - seq2
e: &node
- x: y
block: >
abcde
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/various-trailing-tabs/ 0000775 0000000 0000000 00000000000 15015766371 0025773 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/various-trailing-tabs/in.json 0000664 0000000 0000000 00000000063 15015766371 0027273 0 ustar 00root root 0000000 0000000 {
"a": "b",
"seq": [
"a"
],
"c": "d"
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/various-trailing-tabs/in.yaml 0000664 0000000 0000000 00000000032 15015766371 0027260 0 ustar 00root root 0000000 0000000 a: b
seq:
- a
c: d #X
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/various-trailing-tabs/out.yaml 0000664 0000000 0000000 00000000023 15015766371 0027461 0 ustar 00root root 0000000 0000000 a: b
seq:
- a
c: d
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/whitespace-after-scalars-in-flow/ 0000775 0000000 0000000 00000000000 15015766371 0027777 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/whitespace-after-scalars-in-flow/in.json 0000664 0000000 0000000 00000000136 15015766371 0031300 0 ustar 00root root 0000000 0000000 [
[
"a",
"b",
"c"
],
{
"a": "b",
"c": "d",
"e": "f"
},
[]
]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/whitespace-after-scalars-in-flow/in.yaml 0000664 0000000 0000000 00000000106 15015766371 0031266 0 ustar 00root root 0000000 0000000 - [a, b , c ]
- { "a" : b
, c : 'd' ,
e : "f"
}
- [ ]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/whitespace-after-scalars-in-flow/out.yaml 0000664 0000000 0000000 00000000062 15015766371 0031470 0 ustar 00root root 0000000 0000000 - - a
- b
- c
- "a": b
c: 'd'
e: "f"
- []
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/whitespace-around-colon-in-mappings/ 0000775 0000000 0000000 00000000000 15015766371 0030517 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/whitespace-around-colon-in-mappings/in.json 0000664 0000000 0000000 00000000341 15015766371 0032016 0 ustar 00root root 0000000 0000000 {
"top1": {
"key1": "scalar1"
},
"top2": {
"key2": "scalar2"
},
"top3": {
"scalar1": "scalar3"
},
"top4": {
"scalar2": "scalar4"
},
"top5": "scalar5",
"top6": {
"key6": "scalar6"
}
}
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/whitespace-around-colon-in-mappings/in.yaml 0000664 0000000 0000000 00000000301 15015766371 0032003 0 ustar 00root root 0000000 0000000 "top1" :
"key1" : &alias1 scalar1
'top2' :
'key2' : &alias2 scalar2
top3: &node3
*alias1 : scalar3
top4:
*alias2 : scalar4
top5 :
scalar5
top6:
&anchor6 'key6' : scalar6
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/whitespace-around-colon-in-mappings/out.yaml 0000664 0000000 0000000 00000000256 15015766371 0032215 0 ustar 00root root 0000000 0000000 "top1":
"key1": &alias1 scalar1
'top2':
'key2': &alias2 scalar2
top3: &node3
*alias1 : scalar3
top4:
*alias2 : scalar4
top5: scalar5
top6:
&anchor6 'key6': scalar6
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/wrong-indendation-in-map/ 0000775 0000000 0000000 00000000000 15015766371 0026352 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/wrong-indendation-in-map/error 0000664 0000000 0000000 00000000000 15015766371 0027414 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/wrong-indendation-in-map/in.yaml 0000664 0000000 0000000 00000000027 15015766371 0027643 0 ustar 00root root 0000000 0000000 key:
ok: 1
wrong: 2
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/wrong-indendation-in-mapping/ 0000775 0000000 0000000 00000000000 15015766371 0027230 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/wrong-indendation-in-mapping/error 0000664 0000000 0000000 00000000000 15015766371 0030272 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/wrong-indendation-in-mapping/in.yaml 0000664 0000000 0000000 00000000017 15015766371 0030520 0 ustar 00root root 0000000 0000000 k1: v1
k2: v2
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/wrong-indendation-in-sequence/ 0000775 0000000 0000000 00000000000 15015766371 0027405 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/wrong-indendation-in-sequence/error 0000664 0000000 0000000 00000000000 15015766371 0030447 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/wrong-indendation-in-sequence/in.yaml 0000664 0000000 0000000 00000000044 15015766371 0030675 0 ustar 00root root 0000000 0000000 key:
- ok
- also ok
- wrong
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/wrong-indented-flow-sequence/ 0000775 0000000 0000000 00000000000 15015766371 0027244 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/wrong-indented-flow-sequence/error 0000664 0000000 0000000 00000000000 15015766371 0030306 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/wrong-indented-flow-sequence/in.yaml 0000664 0000000 0000000 00000000024 15015766371 0030532 0 ustar 00root root 0000000 0000000 ---
flow: [a,
b,
c]
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/wrong-indented-multiline-quoted-scalar/ 0000775 0000000 0000000 00000000000 15015766371 0031233 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/wrong-indented-multiline-quoted-scalar/error 0000664 0000000 0000000 00000000000 15015766371 0032275 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/wrong-indented-multiline-quoted-scalar/in.yaml 0000664 0000000 0000000 00000000024 15015766371 0032521 0 ustar 00root root 0000000 0000000 ---
quoted: "a
b
c"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/wrong-indented-sequence-item/ 0000775 0000000 0000000 00000000000 15015766371 0027233 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/wrong-indented-sequence-item/error 0000664 0000000 0000000 00000000000 15015766371 0030275 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/wrong-indented-sequence-item/in.yaml 0000664 0000000 0000000 00000000026 15015766371 0030523 0 ustar 00root root 0000000 0000000 - key: value
- item1
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/yaml-directive-without-document-end-marker/ 0000775 0000000 0000000 00000000000 15015766371 0032023 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/yaml-directive-without-document-end-marker/error 0000664 0000000 0000000 00000000000 15015766371 0033065 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/yaml-directive-without-document-end-marker/in.yaml 0000664 0000000 0000000 00000000035 15015766371 0033313 0 ustar 00root root 0000000 0000000 ---
key: value
%YAML 1.2
---
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/yaml.go 0000664 0000000 0000000 00000003424 15015766371 0023041 0 ustar 00root root 0000000 0000000 package yamltestsuite
import (
"bytes"
"encoding/json"
"fmt"
"io"
"io/fs"
"os"
"path/filepath"
"runtime"
"sort"
"strings"
)
type TestSuite struct {
Name string
InYAML []byte
InJSON []any
OutYAML []byte
Error bool
}
func curDir() string {
_, file, _, _ := runtime.Caller(0) //nolint:dogsled
return filepath.Dir(file)
}
func TestSuites() ([]*TestSuite, error) {
dir := curDir()
testMap := make(map[string]*TestSuite)
if err := filepath.Walk(dir, func(path string, info fs.FileInfo, err error) error {
if strings.HasSuffix(path, ".go") {
// this file.
return nil
}
if info.IsDir() {
return nil
}
if err != nil {
return err
}
name := strings.TrimPrefix(path, dir+"/")
name = strings.TrimSuffix(name, "/"+filepath.Base(name))
if _, exists := testMap[name]; !exists {
testMap[name] = &TestSuite{}
}
f, err := os.ReadFile(path)
if err != nil {
return err
}
fileName := filepath.Base(path)
switch fileName {
case "in.yaml":
testMap[name].InYAML = f
case "in.json":
dec := json.NewDecoder(bytes.NewReader(f))
var inJSON []any
for {
var v any
if err := dec.Decode(&v); err != nil {
if err == io.EOF {
break
}
return fmt.Errorf("failed to decode json: %s: %s: %w", name, string(f), err)
}
inJSON = append(inJSON, v)
}
testMap[name].InJSON = inJSON
case "out.yaml":
testMap[name].OutYAML = f
case "error":
testMap[name].Error = true
}
testMap[name].Name = name
return nil
}); err != nil {
return nil, err
}
tests := make([]*TestSuite, 0, len(testMap))
for _, test := range testMap {
if test.InYAML == nil {
continue
}
tests = append(tests, test)
}
sort.Slice(tests, func(i, j int) bool {
return tests[i].Name < tests[j].Name
})
return tests, nil
}
zero-indented-block-scalar-with-line-that-looks-like-a-comment/ 0000775 0000000 0000000 00000000000 15015766371 0035351 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite in.json 0000664 0000000 0000000 00000000035 15015766371 0036650 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/zero-indented-block-scalar-with-line-that-looks-like-a-comment "line1 # no comment line3\n"
in.yaml 0000664 0000000 0000000 00000000037 15015766371 0036643 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/zero-indented-block-scalar-with-line-that-looks-like-a-comment --- >
line1
# no comment
line3
out.yaml 0000664 0000000 0000000 00000000041 15015766371 0037037 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/zero-indented-block-scalar-with-line-that-looks-like-a-comment --- >
line1 # no comment line3
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/zero-indented-block-scalar/ 0000775 0000000 0000000 00000000000 15015766371 0026647 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/zero-indented-block-scalar/in.json 0000664 0000000 0000000 00000000026 15015766371 0030146 0 ustar 00root root 0000000 0000000 "line1 line2 line3\n"
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/zero-indented-block-scalar/in.yaml 0000664 0000000 0000000 00000000030 15015766371 0030132 0 ustar 00root root 0000000 0000000 --- >
line1
line2
line3
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/zero-indented-block-scalar/out.yaml 0000664 0000000 0000000 00000000032 15015766371 0030335 0 ustar 00root root 0000000 0000000 --- >
line1 line2 line3
goccy-go-yaml-52dacb8/testdata/yaml-test-suite/zero-indented-sequences-in-explicit-mapping-keys/ 0000775 0000000 0000000 00000000000 15015766371 0033132 5 ustar 00root root 0000000 0000000 in.yaml 0000664 0000000 0000000 00000000030 15015766371 0034336 0 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/testdata/yaml-test-suite/zero-indented-sequences-in-explicit-mapping-keys ---
?
- a
- b
:
- c
- d
goccy-go-yaml-52dacb8/testdata/yaml_test.go 0000664 0000000 0000000 00000063036 15015766371 0021037 0 ustar 00root root 0000000 0000000 package yaml_test
import (
"bytes"
"context"
"errors"
"strings"
"testing"
"github.com/google/go-cmp/cmp"
"github.com/goccy/go-yaml"
"github.com/goccy/go-yaml/ast"
)
func TestMarshal(t *testing.T) {
var v struct {
A int
B string
}
v.A = 1
v.B = "hello"
bytes, err := yaml.Marshal(v)
if err != nil {
t.Fatalf("%+v", err)
}
if string(bytes) != "a: 1\nb: hello\n" {
t.Fatal("failed to marshal")
}
}
func TestUnmarshal(t *testing.T) {
yml := `
%YAML 1.2
---
a: 1
b: c
`
var v struct {
A int
B string
}
if err := yaml.Unmarshal([]byte(yml), &v); err != nil {
t.Fatalf("%+v", err)
}
}
type marshalTest struct{}
func (t *marshalTest) MarshalYAML() ([]byte, error) {
return yaml.Marshal(yaml.MapSlice{
{
"a", 1,
},
{
"b", "hello",
},
{
"c", true,
},
{
"d", map[string]string{"x": "y"},
},
})
}
type marshalTest2 struct{}
func (t *marshalTest2) MarshalYAML() (interface{}, error) {
return yaml.MapSlice{
{
"a", 2,
},
{
"b", "world",
},
{
"c", true,
},
}, nil
}
func TestMarshalYAML(t *testing.T) {
var v struct {
A *marshalTest
B *marshalTest2
}
v.A = &marshalTest{}
v.B = &marshalTest2{}
bytes, err := yaml.Marshal(v)
if err != nil {
t.Fatalf("failed to Marshal: %+v", err)
}
expect := `
a:
a: 1
b: hello
c: true
d:
x: "y"
b:
a: 2
b: world
c: true
`
actual := "\n" + string(bytes)
if expect != actual {
t.Fatalf("failed to MarshalYAML expect:[%s], actual:[%s]", expect, actual)
}
}
type unmarshalTest struct {
a int
b string
c bool
}
func (t *unmarshalTest) UnmarshalYAML(b []byte) error {
if t.a != 0 {
return errors.New("unexpected field value to a")
}
if t.b != "" {
return errors.New("unexpected field value to b")
}
if t.c {
return errors.New("unexpected field value to c")
}
var v struct {
A int
B string
C bool
}
if err := yaml.Unmarshal(b, &v); err != nil {
return err
}
t.a = v.A
t.b = v.B
t.c = v.C
return nil
}
type unmarshalTest2 struct {
a int
b string
c bool
}
func (t *unmarshalTest2) UnmarshalYAML(unmarshal func(interface{}) error) error {
var v struct {
A int
B string
C bool
}
if t.a != 0 {
return errors.New("unexpected field value to a")
}
if t.b != "" {
return errors.New("unexpected field value to b")
}
if t.c {
return errors.New("unexpected field value to c")
}
if err := unmarshal(&v); err != nil {
return err
}
t.a = v.A
t.b = v.B
t.c = v.C
return nil
}
func TestUnmarshalYAML(t *testing.T) {
yml := `
a:
a: 1
b: hello
c: true
b:
a: 2
b: world
c: true
`
var v struct {
A *unmarshalTest
B *unmarshalTest2
}
if err := yaml.Unmarshal([]byte(yml), &v); err != nil {
t.Fatalf("failed to Unmarshal: %+v", err)
}
if v.A == nil {
t.Fatal("failed to UnmarshalYAML")
}
if v.A.a != 1 {
t.Fatal("failed to UnmarshalYAML")
}
if v.A.b != "hello" {
t.Fatal("failed to UnmarshalYAML")
}
if !v.A.c {
t.Fatal("failed to UnmarshalYAML")
}
if v.B == nil {
t.Fatal("failed to UnmarshalYAML")
}
if v.B.a != 2 {
t.Fatal("failed to UnmarshalYAML")
}
if v.B.b != "world" {
t.Fatal("failed to UnmarshalYAML")
}
if !v.B.c {
t.Fatal("failed to UnmarshalYAML")
}
}
type ObjectMap map[string]*Object
type ObjectDecl struct {
Name string `yaml:"-"`
*Object `yaml:",inline,anchor"`
}
func (m ObjectMap) MarshalYAML() (interface{}, error) {
newMap := map[string]*ObjectDecl{}
for k, v := range m {
newMap[k] = &ObjectDecl{Name: k, Object: v}
}
return newMap, nil
}
type rootObject struct {
Single ObjectMap `yaml:"single"`
Collection map[string][]*Object `yaml:"collection"`
}
type Object struct {
*Object `yaml:",omitempty,inline,alias"`
MapValue map[string]interface{} `yaml:",omitempty,inline"`
}
func TestInlineAnchorAndAlias(t *testing.T) {
yml := `---
single:
default: &default
id: 1
name: john
user_1: &user_1
id: 1
name: ken
user_2: &user_2
<<: *default
id: 2
collection:
defaults:
- *default
- <<: *default
- <<: *default
id: 2
users:
- <<: *user_1
- <<: *user_2
- <<: *user_1
id: 3
- <<: *user_1
id: 4
- <<: *user_1
id: 5
`
var v rootObject
if err := yaml.Unmarshal([]byte(yml), &v); err != nil {
t.Fatal(err)
}
opt := yaml.MarshalAnchor(func(anchor *ast.AnchorNode, value interface{}) error {
if o, ok := value.(*ObjectDecl); ok {
return anchor.SetName(o.Name)
}
return nil
})
var buf bytes.Buffer
if err := yaml.NewEncoder(&buf, opt).Encode(v); err != nil {
t.Fatalf("%+v", err)
}
actual := "---\n" + buf.String()
if yml != actual {
t.Fatalf("failed to marshal: expected:[%s] actual:[%s]", yml, actual)
}
}
func TestMapSlice_Map(t *testing.T) {
yml := `
a: b
c: d
`
var v yaml.MapSlice
if err := yaml.Unmarshal([]byte(yml), &v); err != nil {
t.Fatal(err)
}
m := v.ToMap()
if len(m) != 2 {
t.Fatal("failed to convert MapSlice to map")
}
if m["a"] != "b" {
t.Fatal("failed to convert MapSlice to map")
}
if m["c"] != "d" {
t.Fatal("failed to convert MapSlice to map")
}
}
func TestMarshalWithModifiedAnchorAlias(t *testing.T) {
yml := `
a: &a 1
b: *a
`
var v struct {
A *int `yaml:"a,anchor"`
B *int `yaml:"b"`
}
if err := yaml.Unmarshal([]byte(yml), &v); err != nil {
t.Fatal(err)
}
node, err := yaml.ValueToNode(v)
if err != nil {
t.Fatal(err)
}
anchors := ast.Filter(ast.AnchorType, node)
if len(anchors) != 1 {
t.Fatal("failed to filter node")
}
anchor, _ := anchors[0].(*ast.AnchorNode)
if err := anchor.SetName("b"); err != nil {
t.Fatal(err)
}
aliases := ast.Filter(ast.AliasType, node)
if len(anchors) != 1 {
t.Fatal("failed to filter node")
}
alias, _ := aliases[0].(*ast.AliasNode)
if err := alias.SetName("b"); err != nil {
t.Fatal(err)
}
expected := `
a: &b 1
b: *b`
actual := "\n" + node.String()
if expected != actual {
t.Fatalf("failed to marshal: expected:[%q] but got [%q]", expected, actual)
}
}
func Test_YAMLToJSON(t *testing.T) {
yml := `
foo:
bar:
- a
- b
- c
a: 1
`
actual, err := yaml.YAMLToJSON([]byte(yml))
if err != nil {
t.Fatal(err)
}
expected := `{"foo": {"bar": ["a", "b", "c"]}, "a": 1}`
if expected+"\n" != string(actual) {
t.Fatalf("failed to convert yaml to json: expected [%q] but got [%q]", expected, actual)
}
}
func Test_JSONToYAML(t *testing.T) {
json := `{"foo": {"bar": ["a", "b", "c"]}, "a": 1}`
expected := `
foo:
bar:
- a
- b
- c
a: 1
`
actual, err := yaml.JSONToYAML([]byte(json))
if err != nil {
t.Fatal(err)
}
if expected != "\n"+string(actual) {
t.Fatalf("failed to convert json to yaml: expected [%q] but got [%q]", expected, actual)
}
}
func Test_WithCommentOption(t *testing.T) {
t.Run("line comment", func(t *testing.T) {
v := struct {
Foo string `yaml:"foo"`
Bar map[string]interface{} `yaml:"bar"`
Baz struct {
X int `yaml:"x"`
} `yaml:"baz"`
}{
Foo: "aaa",
Bar: map[string]interface{}{"bbb": "ccc"},
Baz: struct {
X int `yaml:"x"`
}{X: 10},
}
b, err := yaml.MarshalWithOptions(v, yaml.WithComment(
yaml.CommentMap{
"$.foo": []*yaml.Comment{yaml.LineComment("foo comment")},
"$.bar": []*yaml.Comment{yaml.LineComment("bar comment")},
"$.bar.bbb": []*yaml.Comment{yaml.LineComment("bbb comment")},
"$.baz.x": []*yaml.Comment{yaml.LineComment("x comment")},
},
))
if err != nil {
t.Fatal(err)
}
expected := `
foo: aaa #foo comment
bar: #bar comment
bbb: ccc #bbb comment
baz:
x: 10 #x comment
`
actual := "\n" + string(b)
if expected != actual {
t.Fatalf("expected:%s but got %s", expected, actual)
}
})
t.Run("line comment2", func(t *testing.T) {
v := struct {
Foo map[string]interface{} `yaml:"foo"`
}{
Foo: map[string]interface{}{
"bar": map[string]interface{}{
"baz": true,
},
},
}
b, err := yaml.MarshalWithOptions(v, yaml.WithComment(
yaml.CommentMap{
"$.foo.bar": []*yaml.Comment{yaml.HeadComment(" bar head comment"), yaml.LineComment(" bar line comment")},
"$.foo.bar.baz": []*yaml.Comment{yaml.LineComment(" baz line comment")},
},
))
if err != nil {
t.Fatal(err)
}
expected := `
foo:
# bar head comment
bar: # bar line comment
baz: true # baz line comment
`
actual := "\n" + string(b)
if expected != actual {
t.Fatalf("expected:%s but got %s", expected, actual)
}
})
t.Run("single head comment", func(t *testing.T) {
v := struct {
Foo string `yaml:"foo"`
Bar map[string]interface{} `yaml:"bar"`
Baz struct {
X int `yaml:"x"`
} `yaml:"baz"`
}{
Foo: "aaa",
Bar: map[string]interface{}{"bbb": "ccc"},
Baz: struct {
X int `yaml:"x"`
}{X: 10},
}
b, err := yaml.MarshalWithOptions(v, yaml.WithComment(
yaml.CommentMap{
"$.foo": []*yaml.Comment{yaml.HeadComment("foo comment")},
"$.bar": []*yaml.Comment{yaml.HeadComment("bar comment")},
"$.bar.bbb": []*yaml.Comment{yaml.HeadComment("bbb comment")},
"$.baz.x": []*yaml.Comment{yaml.HeadComment("x comment")},
},
))
if err != nil {
t.Fatal(err)
}
expected := `
#foo comment
foo: aaa
#bar comment
bar:
#bbb comment
bbb: ccc
baz:
#x comment
x: 10
`
actual := "\n" + string(b)
if expected != actual {
t.Fatalf("expected:%s but got %s", expected, actual)
}
})
t.Run("multiple head comment", func(t *testing.T) {
v := struct {
Foo string `yaml:"foo"`
Bar map[string]interface{} `yaml:"bar"`
Baz struct {
X int `yaml:"x"`
} `yaml:"baz"`
}{
Foo: "aaa",
Bar: map[string]interface{}{"bbb": "ccc"},
Baz: struct {
X int `yaml:"x"`
}{X: 10},
}
b, err := yaml.MarshalWithOptions(v, yaml.WithComment(
yaml.CommentMap{
"$.foo": []*yaml.Comment{
yaml.HeadComment(
"foo comment",
"foo comment2",
),
},
"$.bar": []*yaml.Comment{
yaml.HeadComment(
"bar comment",
"bar comment2",
),
},
"$.bar.bbb": []*yaml.Comment{
yaml.HeadComment(
"bbb comment",
"bbb comment2",
),
},
"$.baz.x": []*yaml.Comment{
yaml.HeadComment(
"x comment",
"x comment2",
),
},
},
))
if err != nil {
t.Fatal(err)
}
expected := `
#foo comment
#foo comment2
foo: aaa
#bar comment
#bar comment2
bar:
#bbb comment
#bbb comment2
bbb: ccc
baz:
#x comment
#x comment2
x: 10
`
actual := "\n" + string(b)
if expected != actual {
t.Fatalf("expected:%s but got %s", expected, actual)
}
})
t.Run("foot comment", func(t *testing.T) {
v := struct {
Bar map[string]interface{} `yaml:"bar"`
Baz []int `yaml:"baz"`
}{
Bar: map[string]interface{}{"bbb": "ccc"},
Baz: []int{1, 2},
}
b, err := yaml.MarshalWithOptions(v, yaml.IndentSequence(true), yaml.WithComment(
yaml.CommentMap{
"$.bar.bbb": []*yaml.Comment{yaml.FootComment("ccc: ddd")},
"$.baz[1]": []*yaml.Comment{yaml.FootComment("- 3")},
"$.baz": []*yaml.Comment{yaml.FootComment(" foot comment", "foot comment2")},
},
))
if err != nil {
t.Fatal(err)
}
expected := `
bar:
bbb: ccc
#ccc: ddd
baz:
- 1
- 2
#- 3
# foot comment
#foot comment2
`
actual := "\n" + string(b)
if expected != actual {
t.Fatalf("expected:%s but got %s", expected, actual)
}
})
t.Run("combination", func(t *testing.T) {
v := struct {
Foo map[string]interface{} `yaml:"foo"`
O map[string]interface{} `yaml:"o"`
T map[string]bool `yaml:"t"`
Bar map[string]interface{} `yaml:"bar"`
Baz []int `yaml:"baz"`
Hoge map[string]interface{} `yaml:"hoge"`
}{
Foo: map[string]interface{}{
"a": map[string]interface{}{
"b": map[string]interface{}{
"c": "d",
},
},
},
O: map[string]interface{}{
"p": map[string]interface{}{
"q": map[string]interface{}{
"r": "s",
},
},
},
T: map[string]bool{
"u": true,
},
Bar: map[string]interface{}{"bbb": "ccc"},
Baz: []int{1, 2},
Hoge: map[string]interface{}{
"moga": true,
},
}
b, err := yaml.MarshalWithOptions(v, yaml.IndentSequence(true), yaml.WithComment(
yaml.CommentMap{
"$.foo": []*yaml.Comment{
yaml.HeadComment(" foo head comment", " foo head comment2"),
yaml.LineComment(" foo line comment"),
},
"$.foo.a": []*yaml.Comment{
yaml.HeadComment(" a head comment"),
yaml.LineComment(" a line comment"),
},
"$.foo.a.b": []*yaml.Comment{
yaml.HeadComment(" b head comment"),
yaml.LineComment(" b line comment"),
},
"$.foo.a.b.c": []*yaml.Comment{
yaml.LineComment(" c line comment"),
},
"$.o": []*yaml.Comment{
yaml.LineComment(" o line comment"),
},
"$.o.p": []*yaml.Comment{
yaml.HeadComment(" p head comment", " p head comment2"),
yaml.LineComment(" p line comment"),
},
"$.o.p.q": []*yaml.Comment{
yaml.HeadComment(" q head comment", " q head comment2"),
yaml.LineComment(" q line comment"),
},
"$.o.p.q.r": []*yaml.Comment{
yaml.LineComment(" r line comment"),
},
"$.t.u": []*yaml.Comment{
yaml.LineComment(" u line comment"),
},
"$.bar": []*yaml.Comment{
yaml.HeadComment(" bar head comment"),
yaml.LineComment(" bar line comment"),
},
"$.bar.bbb": []*yaml.Comment{
yaml.HeadComment(" bbb head comment"),
yaml.LineComment(" bbb line comment"),
yaml.FootComment(" bbb foot comment"),
},
"$.baz[0]": []*yaml.Comment{
yaml.HeadComment(" sequence head comment"),
yaml.LineComment(" sequence line comment"),
},
"$.baz[1]": []*yaml.Comment{
yaml.HeadComment(" sequence head comment2"),
yaml.LineComment(" sequence line comment2"),
yaml.FootComment(" sequence foot comment"),
},
"$.baz": []*yaml.Comment{
yaml.HeadComment(" baz head comment", " baz head comment2"),
yaml.LineComment(" baz line comment"),
yaml.FootComment(" baz foot comment"),
},
"$.hoge.moga": []*yaml.Comment{
yaml.LineComment(" moga line comment"),
yaml.FootComment(" moga foot comment"),
},
},
))
if err != nil {
t.Fatal(err)
}
expected := `
# foo head comment
# foo head comment2
foo: # foo line comment
# a head comment
a: # a line comment
# b head comment
b: # b line comment
c: d # c line comment
o: # o line comment
# p head comment
# p head comment2
p: # p line comment
# q head comment
# q head comment2
q: # q line comment
r: s # r line comment
t:
u: true # u line comment
# bar head comment
bar: # bar line comment
# bbb head comment
bbb: ccc # bbb line comment
# bbb foot comment
# baz head comment
# baz head comment2
baz: # baz line comment
# sequence head comment
- 1 # sequence line comment
# sequence head comment2
- 2 # sequence line comment2
# sequence foot comment
# baz foot comment
hoge:
moga: true # moga line comment
# moga foot comment
`
actual := "\n" + string(b)
if expected != actual {
t.Fatalf("expected:%s but got %s", expected, actual)
}
})
}
func Test_CommentToMapOption(t *testing.T) {
type testCase struct {
name string
yml string
options []yaml.DecodeOption
expected []struct {
path string
comments []*yaml.Comment
}
}
tests := []testCase{
{
name: "line comment",
yml: `
foo: aaa #foo comment
bar: #bar comment
bbb: ccc #bbb comment
baz:
x: 10 #x comment
`,
expected: []struct {
path string
comments []*yaml.Comment
}{
{"$.foo", []*yaml.Comment{yaml.LineComment("foo comment")}},
{"$.bar", []*yaml.Comment{yaml.LineComment("bar comment")}},
{"$.bar.bbb", []*yaml.Comment{yaml.LineComment("bbb comment")}},
{"$.baz.x", []*yaml.Comment{yaml.LineComment("x comment")}},
},
},
{
name: "line comment2",
yml: `
foo:
bar: baz # comment`,
expected: []struct {
path string
comments []*yaml.Comment
}{
{"$.foo.bar", []*yaml.Comment{yaml.LineComment(" comment")}},
},
},
{
name: "single head comment",
yml: `
#foo comment
foo: aaa
#bar comment
bar:
#bbb comment
bbb: ccc
baz:
#x comment
x: 10
`,
expected: []struct {
path string
comments []*yaml.Comment
}{
{"$.foo", []*yaml.Comment{yaml.HeadComment("foo comment")}},
{"$.bar", []*yaml.Comment{yaml.HeadComment("bar comment")}},
{"$.bar.bbb", []*yaml.Comment{yaml.HeadComment("bbb comment")}},
{"$.baz.x", []*yaml.Comment{yaml.HeadComment("x comment")}},
},
},
{
name: "single head comment ordered map",
yml: `
#first comment
first: value
#second comment
second:
#third comment
third: value
#forth comment
forth: value
#fifth comment
fifth:
#sixth comment
sixth: value
#seventh comment
seventh: value
`,
expected: []struct {
path string
comments []*yaml.Comment
}{
{"$.first", []*yaml.Comment{yaml.HeadComment("first comment")}},
{"$.second", []*yaml.Comment{yaml.HeadComment("second comment")}},
{"$.second.third", []*yaml.Comment{yaml.HeadComment("third comment")}},
{"$.second.forth", []*yaml.Comment{yaml.HeadComment("forth comment")}},
{"$.fifth", []*yaml.Comment{yaml.HeadComment("fifth comment")}},
{"$.fifth.sixth", []*yaml.Comment{yaml.HeadComment("sixth comment")}},
{"$.fifth.seventh", []*yaml.Comment{yaml.HeadComment("seventh comment")}},
},
options: []yaml.DecodeOption{yaml.UseOrderedMap()},
},
{
name: "multiple head comments",
yml: `
#foo comment
#foo comment2
foo: aaa
#bar comment
#bar comment2
bar:
#bbb comment
#bbb comment2
bbb: ccc
baz:
#x comment
#x comment2
x: 10
`,
expected: []struct {
path string
comments []*yaml.Comment
}{
{"$.foo", []*yaml.Comment{yaml.HeadComment("foo comment", "foo comment2")}},
{"$.bar", []*yaml.Comment{yaml.HeadComment("bar comment", "bar comment2")}},
{"$.bar.bbb", []*yaml.Comment{yaml.HeadComment("bbb comment", "bbb comment2")}},
{"$.baz.x", []*yaml.Comment{yaml.HeadComment("x comment", "x comment2")}},
},
},
{
name: "foot comment",
yml: `
bar:
bbb: ccc
#ccc: ddd
baz:
- 1
- 2
#- 3
# foot comment
#foot comment2
`,
expected: []struct {
path string
comments []*yaml.Comment
}{
{"$.bar.bbb", []*yaml.Comment{yaml.FootComment("ccc: ddd")}},
{"$.baz[1]", []*yaml.Comment{yaml.FootComment("- 3")}},
{"$.baz", []*yaml.Comment{yaml.FootComment(" foot comment", "foot comment2")}},
},
},
{
name: "combination",
yml: `
# foo head comment
# foo head comment2
foo: # foo line comment
# a head comment
a: # a line comment
# b head comment
b: # b line comment
c: d # c line comment
o: # o line comment
# p head comment
# p head comment2
p: # p line comment
# q head comment
# q head comment2
q: # q line comment
r: s # r line comment
t:
u: true # u line comment
# bar head comment
bar: # bar line comment
# bbb head comment
bbb: ccc # bbb line comment
# bbb foot comment
# baz head comment
# baz head comment2
baz: # baz line comment
# sequence head comment
- 1 # sequence line comment
# sequence head comment2
- 2 # sequence line comment2
# sequence foot comment
hoge:
moga: true # moga line comment
# moga foot comment
# hoge foot comment
`,
expected: []struct {
path string
comments []*yaml.Comment
}{
{"$.foo", []*yaml.Comment{yaml.HeadComment(" foo head comment", " foo head comment2"), yaml.LineComment(" foo line comment")}},
{"$.foo.a", []*yaml.Comment{yaml.HeadComment(" a head comment"), yaml.LineComment(" a line comment")}},
{"$.foo.a.b", []*yaml.Comment{yaml.HeadComment(" b head comment"), yaml.LineComment(" b line comment")}},
{"$.foo.a.b.c", []*yaml.Comment{yaml.LineComment(" c line comment")}},
{"$.o", []*yaml.Comment{yaml.LineComment(" o line comment")}},
{"$.o.p", []*yaml.Comment{yaml.HeadComment(" p head comment", " p head comment2"), yaml.LineComment(" p line comment")}},
{"$.o.p.q", []*yaml.Comment{yaml.HeadComment(" q head comment", " q head comment2"), yaml.LineComment(" q line comment")}},
{"$.o.p.q.r", []*yaml.Comment{yaml.LineComment(" r line comment")}},
{"$.t.u", []*yaml.Comment{yaml.LineComment(" u line comment")}},
{"$.bar", []*yaml.Comment{yaml.HeadComment(" bar head comment"), yaml.LineComment(" bar line comment")}},
{"$.bar.bbb", []*yaml.Comment{yaml.HeadComment(" bbb head comment"), yaml.LineComment(" bbb line comment"), yaml.FootComment(" bbb foot comment")}},
{"$.baz[0]", []*yaml.Comment{yaml.HeadComment(" sequence head comment"), yaml.LineComment(" sequence line comment")}},
{"$.baz[1]", []*yaml.Comment{yaml.HeadComment(" sequence head comment2"), yaml.LineComment(" sequence line comment2"), yaml.FootComment(" sequence foot comment")}},
{"$.baz", []*yaml.Comment{yaml.HeadComment(" baz head comment", " baz head comment2"), yaml.LineComment(" baz line comment")}},
{"$.hoge", []*yaml.Comment{yaml.FootComment(" hoge foot comment")}},
{"$.hoge.moga", []*yaml.Comment{yaml.LineComment(" moga line comment"), yaml.FootComment(" moga foot comment")}},
},
},
}
for _, tc := range tests {
t.Run(tc.name, func(t *testing.T) {
cm := yaml.CommentMap{}
opts := []yaml.DecodeOption{yaml.CommentToMap(cm)}
opts = append(opts, tc.options...)
var v interface{}
if err := yaml.UnmarshalWithOptions([]byte(tc.yml), &v, opts...); err != nil {
t.Fatal(err)
}
if len(cm) != len(tc.expected) {
t.Fatalf("comment size does not match: got: %d, expected: %d", len(cm), len(tc.expected))
}
for _, exp := range tc.expected {
comments := cm[exp.path]
if comments == nil {
t.Fatalf("failed to get path %s", exp.path)
}
if diff := cmp.Diff(exp.comments, comments); diff != "" {
t.Errorf("(-got, +want)\n%s", diff)
}
}
})
}
}
func TestCommentMapRoundTrip(t *testing.T) {
// test that an unmarshal and marshal round trip retains comments.
// if expect is empty, the test will use the input as the expected result.
tests := []struct {
name string
source string
expect string
encodeOptions []yaml.EncodeOption
}{
{
name: "simple map",
source: `
# head
a: 1 # line
# foot
`,
},
{
name: "nesting",
source: `
- 1 # one
- foo:
a: b
# c comment
c: d # d comment
"e#f": g # g comment
h.i: j # j comment
"k.#l": m # m comment
`,
},
{
name: "single quotes",
source: `'a#b': c # c comment`,
encodeOptions: []yaml.EncodeOption{yaml.UseSingleQuote(true)},
},
{
name: "single quotes added in encode",
source: `a#b: c # c comment`,
encodeOptions: []yaml.EncodeOption{yaml.UseSingleQuote(true)},
expect: `'a#b': c # c comment`,
},
{
name: "double quotes quotes transformed to single quotes",
source: `"a#b": c # c comment`,
encodeOptions: []yaml.EncodeOption{yaml.UseSingleQuote(true)},
expect: `'a#b': c # c comment`,
},
{
name: "single quotes quotes transformed to double quotes",
source: `'a#b': c # c comment`,
expect: `"a#b": c # c comment`,
},
{
name: "single quotes removed",
source: `'a': b # b comment`,
expect: `a: b # b comment`,
},
{
name: "double quotes removed",
source: `"a": b # b comment`,
expect: `a: b # b comment`,
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
var val any
cm := yaml.CommentMap{}
source := strings.TrimSpace(test.source)
if err := yaml.UnmarshalWithOptions([]byte(source), &val, yaml.CommentToMap(cm)); err != nil {
t.Fatalf("%+v", err)
}
marshaled, err := yaml.MarshalWithOptions(val, append(test.encodeOptions, yaml.WithComment(cm))...)
if err != nil {
t.Fatalf("%+v", err)
}
got := strings.TrimSpace(string(marshaled))
expect := strings.TrimSpace(test.expect)
if expect == "" {
expect = source
}
if got != expect {
t.Fatalf("expected:\n%s\ngot:\n%s\n", expect, got)
}
})
}
}
func TestRegisterCustomMarshaler(t *testing.T) {
type T struct {
Foo []byte `yaml:"foo"`
}
yaml.RegisterCustomMarshaler[T](func(_ T) ([]byte, error) {
return []byte(`"override"`), nil
})
b, err := yaml.Marshal(&T{Foo: []byte("bar")})
if err != nil {
t.Fatal(err)
}
if !bytes.Equal(b, []byte("\"override\"\n")) {
t.Fatalf("failed to register custom marshaler. got: %q", b)
}
}
func TestRegisterCustomMarshalerContext(t *testing.T) {
type T struct {
Foo []byte `yaml:"foo"`
}
yaml.RegisterCustomMarshalerContext[T](func(ctx context.Context, _ T) ([]byte, error) {
if ctx.Value("plop") != uint(42) {
t.Fatalf("context value is not correct")
}
return []byte(`"override"`), nil
})
ctx := context.WithValue(context.Background(), "plop", uint(42))
b, err := yaml.MarshalContext(ctx, &T{Foo: []byte("bar")})
if err != nil {
t.Fatal(err)
}
if !bytes.Equal(b, []byte("\"override\"\n")) {
t.Fatalf("failed to register custom marshaler. got: %q", b)
}
}
func TestRegisterCustomUnmarshaler(t *testing.T) {
type T struct {
Foo []byte `yaml:"foo"`
}
yaml.RegisterCustomUnmarshaler[T](func(v *T, _ []byte) error {
v.Foo = []byte("override")
return nil
})
var v T
if err := yaml.Unmarshal([]byte(`"foo": "bar"`), &v); err != nil {
t.Fatal(err)
}
if !bytes.Equal(v.Foo, []byte("override")) {
t.Fatalf("failed to decode. got %q", v.Foo)
}
}
func TestRegisterCustomUnmarshalerContext(t *testing.T) {
type T struct {
Foo []byte `yaml:"foo"`
}
yaml.RegisterCustomUnmarshalerContext[T](func(ctx context.Context, v *T, _ []byte) error {
if ctx.Value("plop") != uint(42) {
t.Fatalf("context value is not correct")
}
v.Foo = []byte("override")
return nil
})
var v T
ctx := context.WithValue(context.Background(), "plop", uint(42))
if err := yaml.UnmarshalContext(ctx, []byte(`"foo": "bar"`), &v); err != nil {
t.Fatal(err)
}
if !bytes.Equal(v.Foo, []byte("override")) {
t.Fatalf("failed to decode. got %q", v.Foo)
}
}
goccy-go-yaml-52dacb8/token/ 0000775 0000000 0000000 00000000000 15015766371 0016006 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/token/token.go 0000664 0000000 0000000 00000071507 15015766371 0017467 0 ustar 00root root 0000000 0000000 package token
import (
"errors"
"fmt"
"strconv"
"strings"
"time"
)
// Character type for character
type Character byte
const (
// SequenceEntryCharacter character for sequence entry
SequenceEntryCharacter Character = '-'
// MappingKeyCharacter character for mapping key
MappingKeyCharacter Character = '?'
// MappingValueCharacter character for mapping value
MappingValueCharacter Character = ':'
// CollectEntryCharacter character for collect entry
CollectEntryCharacter Character = ','
// SequenceStartCharacter character for sequence start
SequenceStartCharacter Character = '['
// SequenceEndCharacter character for sequence end
SequenceEndCharacter Character = ']'
// MappingStartCharacter character for mapping start
MappingStartCharacter Character = '{'
// MappingEndCharacter character for mapping end
MappingEndCharacter Character = '}'
// CommentCharacter character for comment
CommentCharacter Character = '#'
// AnchorCharacter character for anchor
AnchorCharacter Character = '&'
// AliasCharacter character for alias
AliasCharacter Character = '*'
// TagCharacter character for tag
TagCharacter Character = '!'
// LiteralCharacter character for literal
LiteralCharacter Character = '|'
// FoldedCharacter character for folded
FoldedCharacter Character = '>'
// SingleQuoteCharacter character for single quote
SingleQuoteCharacter Character = '\''
// DoubleQuoteCharacter character for double quote
DoubleQuoteCharacter Character = '"'
// DirectiveCharacter character for directive
DirectiveCharacter Character = '%'
// SpaceCharacter character for space
SpaceCharacter Character = ' '
// LineBreakCharacter character for line break
LineBreakCharacter Character = '\n'
)
// Type type identifier for token
type Type int
const (
// UnknownType reserve for invalid type
UnknownType Type = iota
// DocumentHeaderType type for DocumentHeader token
DocumentHeaderType
// DocumentEndType type for DocumentEnd token
DocumentEndType
// SequenceEntryType type for SequenceEntry token
SequenceEntryType
// MappingKeyType type for MappingKey token
MappingKeyType
// MappingValueType type for MappingValue token
MappingValueType
// MergeKeyType type for MergeKey token
MergeKeyType
// CollectEntryType type for CollectEntry token
CollectEntryType
// SequenceStartType type for SequenceStart token
SequenceStartType
// SequenceEndType type for SequenceEnd token
SequenceEndType
// MappingStartType type for MappingStart token
MappingStartType
// MappingEndType type for MappingEnd token
MappingEndType
// CommentType type for Comment token
CommentType
// AnchorType type for Anchor token
AnchorType
// AliasType type for Alias token
AliasType
// TagType type for Tag token
TagType
// LiteralType type for Literal token
LiteralType
// FoldedType type for Folded token
FoldedType
// SingleQuoteType type for SingleQuote token
SingleQuoteType
// DoubleQuoteType type for DoubleQuote token
DoubleQuoteType
// DirectiveType type for Directive token
DirectiveType
// SpaceType type for Space token
SpaceType
// NullType type for Null token
NullType
// ImplicitNullType type for implicit Null token.
// This is used when explicit keywords such as null or ~ are not specified.
// It is distinguished during encoding and output as an empty string.
ImplicitNullType
// InfinityType type for Infinity token
InfinityType
// NanType type for Nan token
NanType
// IntegerType type for Integer token
IntegerType
// BinaryIntegerType type for BinaryInteger token
BinaryIntegerType
// OctetIntegerType type for OctetInteger token
OctetIntegerType
// HexIntegerType type for HexInteger token
HexIntegerType
// FloatType type for Float token
FloatType
// StringType type for String token
StringType
// BoolType type for Bool token
BoolType
// InvalidType type for invalid token
InvalidType
)
// String type identifier to text
func (t Type) String() string {
switch t {
case UnknownType:
return "Unknown"
case DocumentHeaderType:
return "DocumentHeader"
case DocumentEndType:
return "DocumentEnd"
case SequenceEntryType:
return "SequenceEntry"
case MappingKeyType:
return "MappingKey"
case MappingValueType:
return "MappingValue"
case MergeKeyType:
return "MergeKey"
case CollectEntryType:
return "CollectEntry"
case SequenceStartType:
return "SequenceStart"
case SequenceEndType:
return "SequenceEnd"
case MappingStartType:
return "MappingStart"
case MappingEndType:
return "MappingEnd"
case CommentType:
return "Comment"
case AnchorType:
return "Anchor"
case AliasType:
return "Alias"
case TagType:
return "Tag"
case LiteralType:
return "Literal"
case FoldedType:
return "Folded"
case SingleQuoteType:
return "SingleQuote"
case DoubleQuoteType:
return "DoubleQuote"
case DirectiveType:
return "Directive"
case SpaceType:
return "Space"
case StringType:
return "String"
case BoolType:
return "Bool"
case IntegerType:
return "Integer"
case BinaryIntegerType:
return "BinaryInteger"
case OctetIntegerType:
return "OctetInteger"
case HexIntegerType:
return "HexInteger"
case FloatType:
return "Float"
case NullType:
return "Null"
case ImplicitNullType:
return "ImplicitNull"
case InfinityType:
return "Infinity"
case NanType:
return "Nan"
case InvalidType:
return "Invalid"
}
return ""
}
// CharacterType type for character category
type CharacterType int
const (
// CharacterTypeIndicator type of indicator character
CharacterTypeIndicator CharacterType = iota
// CharacterTypeWhiteSpace type of white space character
CharacterTypeWhiteSpace
// CharacterTypeMiscellaneous type of miscellaneous character
CharacterTypeMiscellaneous
// CharacterTypeEscaped type of escaped character
CharacterTypeEscaped
// CharacterTypeInvalid type for a invalid token.
CharacterTypeInvalid
)
// String character type identifier to text
func (c CharacterType) String() string {
switch c {
case CharacterTypeIndicator:
return "Indicator"
case CharacterTypeWhiteSpace:
return "WhiteSpace"
case CharacterTypeMiscellaneous:
return "Miscellaneous"
case CharacterTypeEscaped:
return "Escaped"
}
return ""
}
// Indicator type for indicator
type Indicator int
const (
// NotIndicator not indicator
NotIndicator Indicator = iota
// BlockStructureIndicator indicator for block structure ( '-', '?', ':' )
BlockStructureIndicator
// FlowCollectionIndicator indicator for flow collection ( '[', ']', '{', '}', ',' )
FlowCollectionIndicator
// CommentIndicator indicator for comment ( '#' )
CommentIndicator
// NodePropertyIndicator indicator for node property ( '!', '&', '*' )
NodePropertyIndicator
// BlockScalarIndicator indicator for block scalar ( '|', '>' )
BlockScalarIndicator
// QuotedScalarIndicator indicator for quoted scalar ( ''', '"' )
QuotedScalarIndicator
// DirectiveIndicator indicator for directive ( '%' )
DirectiveIndicator
// InvalidUseOfReservedIndicator indicator for invalid use of reserved keyword ( '@', '`' )
InvalidUseOfReservedIndicator
)
// String indicator to text
func (i Indicator) String() string {
switch i {
case NotIndicator:
return "NotIndicator"
case BlockStructureIndicator:
return "BlockStructure"
case FlowCollectionIndicator:
return "FlowCollection"
case CommentIndicator:
return "Comment"
case NodePropertyIndicator:
return "NodeProperty"
case BlockScalarIndicator:
return "BlockScalar"
case QuotedScalarIndicator:
return "QuotedScalar"
case DirectiveIndicator:
return "Directive"
case InvalidUseOfReservedIndicator:
return "InvalidUseOfReserved"
}
return ""
}
var (
reservedNullKeywords = []string{
"null",
"Null",
"NULL",
"~",
}
reservedBoolKeywords = []string{
"true",
"True",
"TRUE",
"false",
"False",
"FALSE",
}
// For compatibility with other YAML 1.1 parsers
// Note that we use these solely for encoding the bool value with quotes.
// go-yaml should not treat these as reserved keywords at parsing time.
// as go-yaml is supposed to be compliant only with YAML 1.2.
reservedLegacyBoolKeywords = []string{
"y",
"Y",
"yes",
"Yes",
"YES",
"n",
"N",
"no",
"No",
"NO",
"on",
"On",
"ON",
"off",
"Off",
"OFF",
}
reservedInfKeywords = []string{
".inf",
".Inf",
".INF",
"-.inf",
"-.Inf",
"-.INF",
}
reservedNanKeywords = []string{
".nan",
".NaN",
".NAN",
}
reservedKeywordMap = map[string]func(string, string, *Position) *Token{}
// reservedEncKeywordMap contains is the keyword map used at encoding time.
// This is supposed to be a superset of reservedKeywordMap,
// and used to quote legacy keywords present in YAML 1.1 or lesser for compatibility reasons,
// even though this library is supposed to be YAML 1.2-compliant.
reservedEncKeywordMap = map[string]func(string, string, *Position) *Token{}
)
func reservedKeywordToken(typ Type, value, org string, pos *Position) *Token {
return &Token{
Type: typ,
CharacterType: CharacterTypeMiscellaneous,
Indicator: NotIndicator,
Value: value,
Origin: org,
Position: pos,
}
}
func init() {
for _, keyword := range reservedNullKeywords {
f := func(value, org string, pos *Position) *Token {
return reservedKeywordToken(NullType, value, org, pos)
}
reservedKeywordMap[keyword] = f
reservedEncKeywordMap[keyword] = f
}
for _, keyword := range reservedBoolKeywords {
f := func(value, org string, pos *Position) *Token {
return reservedKeywordToken(BoolType, value, org, pos)
}
reservedKeywordMap[keyword] = f
reservedEncKeywordMap[keyword] = f
}
for _, keyword := range reservedLegacyBoolKeywords {
reservedEncKeywordMap[keyword] = func(value, org string, pos *Position) *Token {
return reservedKeywordToken(BoolType, value, org, pos)
}
}
for _, keyword := range reservedInfKeywords {
reservedKeywordMap[keyword] = func(value, org string, pos *Position) *Token {
return reservedKeywordToken(InfinityType, value, org, pos)
}
}
for _, keyword := range reservedNanKeywords {
reservedKeywordMap[keyword] = func(value, org string, pos *Position) *Token {
return reservedKeywordToken(NanType, value, org, pos)
}
}
}
// ReservedTagKeyword type of reserved tag keyword
type ReservedTagKeyword string
const (
// IntegerTag `!!int` tag
IntegerTag ReservedTagKeyword = "!!int"
// FloatTag `!!float` tag
FloatTag ReservedTagKeyword = "!!float"
// NullTag `!!null` tag
NullTag ReservedTagKeyword = "!!null"
// SequenceTag `!!seq` tag
SequenceTag ReservedTagKeyword = "!!seq"
// MappingTag `!!map` tag
MappingTag ReservedTagKeyword = "!!map"
// StringTag `!!str` tag
StringTag ReservedTagKeyword = "!!str"
// BinaryTag `!!binary` tag
BinaryTag ReservedTagKeyword = "!!binary"
// OrderedMapTag `!!omap` tag
OrderedMapTag ReservedTagKeyword = "!!omap"
// SetTag `!!set` tag
SetTag ReservedTagKeyword = "!!set"
// TimestampTag `!!timestamp` tag
TimestampTag ReservedTagKeyword = "!!timestamp"
// BooleanTag `!!bool` tag
BooleanTag ReservedTagKeyword = "!!bool"
// MergeTag `!!merge` tag
MergeTag ReservedTagKeyword = "!!merge"
)
var (
// ReservedTagKeywordMap map for reserved tag keywords
ReservedTagKeywordMap = map[ReservedTagKeyword]func(string, string, *Position) *Token{
IntegerTag: func(value, org string, pos *Position) *Token {
return &Token{
Type: TagType,
CharacterType: CharacterTypeIndicator,
Indicator: NodePropertyIndicator,
Value: value,
Origin: org,
Position: pos,
}
},
FloatTag: func(value, org string, pos *Position) *Token {
return &Token{
Type: TagType,
CharacterType: CharacterTypeIndicator,
Indicator: NodePropertyIndicator,
Value: value,
Origin: org,
Position: pos,
}
},
NullTag: func(value, org string, pos *Position) *Token {
return &Token{
Type: TagType,
CharacterType: CharacterTypeIndicator,
Indicator: NodePropertyIndicator,
Value: value,
Origin: org,
Position: pos,
}
},
SequenceTag: func(value, org string, pos *Position) *Token {
return &Token{
Type: TagType,
CharacterType: CharacterTypeIndicator,
Indicator: NodePropertyIndicator,
Value: value,
Origin: org,
Position: pos,
}
},
MappingTag: func(value, org string, pos *Position) *Token {
return &Token{
Type: TagType,
CharacterType: CharacterTypeIndicator,
Indicator: NodePropertyIndicator,
Value: value,
Origin: org,
Position: pos,
}
},
StringTag: func(value, org string, pos *Position) *Token {
return &Token{
Type: TagType,
CharacterType: CharacterTypeIndicator,
Indicator: NodePropertyIndicator,
Value: value,
Origin: org,
Position: pos,
}
},
BinaryTag: func(value, org string, pos *Position) *Token {
return &Token{
Type: TagType,
CharacterType: CharacterTypeIndicator,
Indicator: NodePropertyIndicator,
Value: value,
Origin: org,
Position: pos,
}
},
OrderedMapTag: func(value, org string, pos *Position) *Token {
return &Token{
Type: TagType,
CharacterType: CharacterTypeIndicator,
Indicator: NodePropertyIndicator,
Value: value,
Origin: org,
Position: pos,
}
},
SetTag: func(value, org string, pos *Position) *Token {
return &Token{
Type: TagType,
CharacterType: CharacterTypeIndicator,
Indicator: NodePropertyIndicator,
Value: value,
Origin: org,
Position: pos,
}
},
TimestampTag: func(value, org string, pos *Position) *Token {
return &Token{
Type: TagType,
CharacterType: CharacterTypeIndicator,
Indicator: NodePropertyIndicator,
Value: value,
Origin: org,
Position: pos,
}
},
BooleanTag: func(value, org string, pos *Position) *Token {
return &Token{
Type: TagType,
CharacterType: CharacterTypeIndicator,
Indicator: NodePropertyIndicator,
Value: value,
Origin: org,
Position: pos,
}
},
MergeTag: func(value, org string, pos *Position) *Token {
return &Token{
Type: TagType,
CharacterType: CharacterTypeIndicator,
Indicator: NodePropertyIndicator,
Value: value,
Origin: org,
Position: pos,
}
},
}
)
type NumberType string
const (
NumberTypeDecimal NumberType = "decimal"
NumberTypeBinary NumberType = "binary"
NumberTypeOctet NumberType = "octet"
NumberTypeHex NumberType = "hex"
NumberTypeFloat NumberType = "float"
)
type NumberValue struct {
Type NumberType
Value any
Text string
}
func ToNumber(value string) *NumberValue {
num, err := toNumber(value)
if err != nil {
return nil
}
return num
}
func isNumber(value string) bool {
num, err := toNumber(value)
if err != nil {
var numErr *strconv.NumError
if errors.As(err, &numErr) && errors.Is(numErr.Err, strconv.ErrRange) {
return true
}
return false
}
return num != nil
}
func toNumber(value string) (*NumberValue, error) {
if len(value) == 0 {
return nil, nil
}
if strings.HasPrefix(value, "_") {
return nil, nil
}
dotCount := strings.Count(value, ".")
if dotCount > 1 {
return nil, nil
}
isNegative := strings.HasPrefix(value, "-")
normalized := strings.ReplaceAll(strings.TrimPrefix(strings.TrimPrefix(value, "+"), "-"), "_", "")
var (
typ NumberType
base int
)
switch {
case strings.HasPrefix(normalized, "0x"):
normalized = strings.TrimPrefix(normalized, "0x")
base = 16
typ = NumberTypeHex
case strings.HasPrefix(normalized, "0o"):
normalized = strings.TrimPrefix(normalized, "0o")
base = 8
typ = NumberTypeOctet
case strings.HasPrefix(normalized, "0b"):
normalized = strings.TrimPrefix(normalized, "0b")
base = 2
typ = NumberTypeBinary
case strings.HasPrefix(normalized, "0") && len(normalized) > 1 && dotCount == 0:
base = 8
typ = NumberTypeOctet
case dotCount == 1:
typ = NumberTypeFloat
default:
typ = NumberTypeDecimal
base = 10
}
text := normalized
if isNegative {
text = "-" + text
}
var v any
if typ == NumberTypeFloat {
f, err := strconv.ParseFloat(text, 64)
if err != nil {
return nil, err
}
v = f
} else if isNegative {
i, err := strconv.ParseInt(text, base, 64)
if err != nil {
return nil, err
}
v = i
} else {
u, err := strconv.ParseUint(text, base, 64)
if err != nil {
return nil, err
}
v = u
}
return &NumberValue{
Type: typ,
Value: v,
Text: text,
}, nil
}
// This is a subset of the formats permitted by the regular expression
// defined at http://yaml.org/type/timestamp.html. Note that time.Parse
// cannot handle: "2001-12-14 21:59:43.10 -5" from the examples.
var timestampFormats = []string{
time.RFC3339Nano,
"2006-01-02t15:04:05.999999999Z07:00", // RFC3339Nano with lower-case "t".
time.DateTime,
time.DateOnly,
// Not in examples, but to preserve backward compatibility by quoting time values.
"15:4",
}
func isTimestamp(value string) bool {
for _, format := range timestampFormats {
if _, err := time.Parse(format, value); err == nil {
return true
}
}
return false
}
// IsNeedQuoted checks whether the value needs quote for passed string or not
func IsNeedQuoted(value string) bool {
if value == "" {
return true
}
if _, exists := reservedEncKeywordMap[value]; exists {
return true
}
if isNumber(value) {
return true
}
if value == "-" {
return true
}
first := value[0]
switch first {
case '*', '&', '[', '{', '}', ']', ',', '!', '|', '>', '%', '\'', '"', '@', ' ', '`':
return true
}
last := value[len(value)-1]
switch last {
case ':', ' ':
return true
}
if isTimestamp(value) {
return true
}
for i, c := range value {
switch c {
case '#', '\\':
return true
case ':', '-':
if i+1 < len(value) && value[i+1] == ' ' {
return true
}
}
}
return false
}
// LiteralBlockHeader detect literal block scalar header
func LiteralBlockHeader(value string) string {
lbc := DetectLineBreakCharacter(value)
switch {
case !strings.Contains(value, lbc):
return ""
case strings.HasSuffix(value, fmt.Sprintf("%s%s", lbc, lbc)):
return "|+"
case strings.HasSuffix(value, lbc):
return "|"
default:
return "|-"
}
}
// New create reserved keyword token or number token and other string token.
func New(value string, org string, pos *Position) *Token {
fn := reservedKeywordMap[value]
if fn != nil {
return fn(value, org, pos)
}
if num := ToNumber(value); num != nil {
tk := &Token{
Type: IntegerType,
CharacterType: CharacterTypeMiscellaneous,
Indicator: NotIndicator,
Value: value,
Origin: org,
Position: pos,
}
switch num.Type {
case NumberTypeFloat:
tk.Type = FloatType
case NumberTypeBinary:
tk.Type = BinaryIntegerType
case NumberTypeOctet:
tk.Type = OctetIntegerType
case NumberTypeHex:
tk.Type = HexIntegerType
}
return tk
}
return String(value, org, pos)
}
// Position type for position in YAML document
type Position struct {
Line int
Column int
Offset int
IndentNum int
IndentLevel int
}
// String position to text
func (p *Position) String() string {
return fmt.Sprintf("[level:%d,line:%d,column:%d,offset:%d]", p.IndentLevel, p.Line, p.Column, p.Offset)
}
// Token type for token
type Token struct {
// Type is a token type.
Type Type
// CharacterType is a character type.
CharacterType CharacterType
// Indicator is a indicator type.
Indicator Indicator
// Value is a string extracted with only meaningful characters, with spaces and such removed.
Value string
// Origin is a string that stores the original text as-is.
Origin string
// Error keeps error message for InvalidToken.
Error string
// Position is a token position.
Position *Position
// Next is a next token reference.
Next *Token
// Prev is a previous token reference.
Prev *Token
}
// PreviousType previous token type
func (t *Token) PreviousType() Type {
if t.Prev != nil {
return t.Prev.Type
}
return UnknownType
}
// NextType next token type
func (t *Token) NextType() Type {
if t.Next != nil {
return t.Next.Type
}
return UnknownType
}
// AddColumn append column number to current position of column
func (t *Token) AddColumn(col int) {
if t == nil {
return
}
t.Position.Column += col
}
// Clone copy token ( preserve Prev/Next reference )
func (t *Token) Clone() *Token {
if t == nil {
return nil
}
copied := *t
if t.Position != nil {
pos := *(t.Position)
copied.Position = &pos
}
return &copied
}
// Dump outputs token information to stdout for debugging.
func (t *Token) Dump() {
fmt.Printf(
"[TYPE]:%q [CHARTYPE]:%q [INDICATOR]:%q [VALUE]:%q [ORG]:%q [POS(line:column:level:offset)]: %d:%d:%d:%d\n",
t.Type, t.CharacterType, t.Indicator, t.Value, t.Origin, t.Position.Line, t.Position.Column, t.Position.IndentLevel, t.Position.Offset,
)
}
// Tokens type of token collection
type Tokens []*Token
func (t Tokens) InvalidToken() *Token {
for _, tt := range t {
if tt.Type == InvalidType {
return tt
}
}
return nil
}
func (t *Tokens) add(tk *Token) {
tokens := *t
if len(tokens) == 0 {
tokens = append(tokens, tk)
} else {
last := tokens[len(tokens)-1]
last.Next = tk
tk.Prev = last
tokens = append(tokens, tk)
}
*t = tokens
}
// Add append new some tokens
func (t *Tokens) Add(tks ...*Token) {
for _, tk := range tks {
t.add(tk)
}
}
// Dump dump all token structures for debugging
func (t Tokens) Dump() {
for _, tk := range t {
fmt.Print("- ")
tk.Dump()
}
}
// String create token for String
func String(value string, org string, pos *Position) *Token {
return &Token{
Type: StringType,
CharacterType: CharacterTypeMiscellaneous,
Indicator: NotIndicator,
Value: value,
Origin: org,
Position: pos,
}
}
// SequenceEntry create token for SequenceEntry
func SequenceEntry(org string, pos *Position) *Token {
return &Token{
Type: SequenceEntryType,
CharacterType: CharacterTypeIndicator,
Indicator: BlockStructureIndicator,
Value: string(SequenceEntryCharacter),
Origin: org,
Position: pos,
}
}
// MappingKey create token for MappingKey
func MappingKey(pos *Position) *Token {
return &Token{
Type: MappingKeyType,
CharacterType: CharacterTypeIndicator,
Indicator: BlockStructureIndicator,
Value: string(MappingKeyCharacter),
Origin: string(MappingKeyCharacter),
Position: pos,
}
}
// MappingValue create token for MappingValue
func MappingValue(pos *Position) *Token {
return &Token{
Type: MappingValueType,
CharacterType: CharacterTypeIndicator,
Indicator: BlockStructureIndicator,
Value: string(MappingValueCharacter),
Origin: string(MappingValueCharacter),
Position: pos,
}
}
// CollectEntry create token for CollectEntry
func CollectEntry(org string, pos *Position) *Token {
return &Token{
Type: CollectEntryType,
CharacterType: CharacterTypeIndicator,
Indicator: FlowCollectionIndicator,
Value: string(CollectEntryCharacter),
Origin: org,
Position: pos,
}
}
// SequenceStart create token for SequenceStart
func SequenceStart(org string, pos *Position) *Token {
return &Token{
Type: SequenceStartType,
CharacterType: CharacterTypeIndicator,
Indicator: FlowCollectionIndicator,
Value: string(SequenceStartCharacter),
Origin: org,
Position: pos,
}
}
// SequenceEnd create token for SequenceEnd
func SequenceEnd(org string, pos *Position) *Token {
return &Token{
Type: SequenceEndType,
CharacterType: CharacterTypeIndicator,
Indicator: FlowCollectionIndicator,
Value: string(SequenceEndCharacter),
Origin: org,
Position: pos,
}
}
// MappingStart create token for MappingStart
func MappingStart(org string, pos *Position) *Token {
return &Token{
Type: MappingStartType,
CharacterType: CharacterTypeIndicator,
Indicator: FlowCollectionIndicator,
Value: string(MappingStartCharacter),
Origin: org,
Position: pos,
}
}
// MappingEnd create token for MappingEnd
func MappingEnd(org string, pos *Position) *Token {
return &Token{
Type: MappingEndType,
CharacterType: CharacterTypeIndicator,
Indicator: FlowCollectionIndicator,
Value: string(MappingEndCharacter),
Origin: org,
Position: pos,
}
}
// Comment create token for Comment
func Comment(value string, org string, pos *Position) *Token {
return &Token{
Type: CommentType,
CharacterType: CharacterTypeIndicator,
Indicator: CommentIndicator,
Value: value,
Origin: org,
Position: pos,
}
}
// Anchor create token for Anchor
func Anchor(org string, pos *Position) *Token {
return &Token{
Type: AnchorType,
CharacterType: CharacterTypeIndicator,
Indicator: NodePropertyIndicator,
Value: string(AnchorCharacter),
Origin: org,
Position: pos,
}
}
// Alias create token for Alias
func Alias(org string, pos *Position) *Token {
return &Token{
Type: AliasType,
CharacterType: CharacterTypeIndicator,
Indicator: NodePropertyIndicator,
Value: string(AliasCharacter),
Origin: org,
Position: pos,
}
}
// Tag create token for Tag
func Tag(value string, org string, pos *Position) *Token {
fn := ReservedTagKeywordMap[ReservedTagKeyword(value)]
if fn != nil {
return fn(value, org, pos)
}
return &Token{
Type: TagType,
CharacterType: CharacterTypeIndicator,
Indicator: NodePropertyIndicator,
Value: value,
Origin: org,
Position: pos,
}
}
// Literal create token for Literal
func Literal(value string, org string, pos *Position) *Token {
return &Token{
Type: LiteralType,
CharacterType: CharacterTypeIndicator,
Indicator: BlockScalarIndicator,
Value: value,
Origin: org,
Position: pos,
}
}
// Folded create token for Folded
func Folded(value string, org string, pos *Position) *Token {
return &Token{
Type: FoldedType,
CharacterType: CharacterTypeIndicator,
Indicator: BlockScalarIndicator,
Value: value,
Origin: org,
Position: pos,
}
}
// SingleQuote create token for SingleQuote
func SingleQuote(value string, org string, pos *Position) *Token {
return &Token{
Type: SingleQuoteType,
CharacterType: CharacterTypeIndicator,
Indicator: QuotedScalarIndicator,
Value: value,
Origin: org,
Position: pos,
}
}
// DoubleQuote create token for DoubleQuote
func DoubleQuote(value string, org string, pos *Position) *Token {
return &Token{
Type: DoubleQuoteType,
CharacterType: CharacterTypeIndicator,
Indicator: QuotedScalarIndicator,
Value: value,
Origin: org,
Position: pos,
}
}
// Directive create token for Directive
func Directive(org string, pos *Position) *Token {
return &Token{
Type: DirectiveType,
CharacterType: CharacterTypeIndicator,
Indicator: DirectiveIndicator,
Value: string(DirectiveCharacter),
Origin: org,
Position: pos,
}
}
// Space create token for Space
func Space(pos *Position) *Token {
return &Token{
Type: SpaceType,
CharacterType: CharacterTypeWhiteSpace,
Indicator: NotIndicator,
Value: string(SpaceCharacter),
Origin: string(SpaceCharacter),
Position: pos,
}
}
// MergeKey create token for MergeKey
func MergeKey(org string, pos *Position) *Token {
return &Token{
Type: MergeKeyType,
CharacterType: CharacterTypeMiscellaneous,
Indicator: NotIndicator,
Value: "<<",
Origin: org,
Position: pos,
}
}
// DocumentHeader create token for DocumentHeader
func DocumentHeader(org string, pos *Position) *Token {
return &Token{
Type: DocumentHeaderType,
CharacterType: CharacterTypeMiscellaneous,
Indicator: NotIndicator,
Value: "---",
Origin: org,
Position: pos,
}
}
// DocumentEnd create token for DocumentEnd
func DocumentEnd(org string, pos *Position) *Token {
return &Token{
Type: DocumentEndType,
CharacterType: CharacterTypeMiscellaneous,
Indicator: NotIndicator,
Value: "...",
Origin: org,
Position: pos,
}
}
func Invalid(err string, org string, pos *Position) *Token {
return &Token{
Type: InvalidType,
CharacterType: CharacterTypeInvalid,
Indicator: NotIndicator,
Value: org,
Origin: org,
Error: err,
Position: pos,
}
}
// DetectLineBreakCharacter detect line break character in only one inside scalar content scope.
func DetectLineBreakCharacter(src string) string {
nc := strings.Count(src, "\n")
rc := strings.Count(src, "\r")
rnc := strings.Count(src, "\r\n")
switch {
case nc == rnc && rc == rnc:
return "\r\n"
case rc > nc:
return "\r"
default:
return "\n"
}
}
goccy-go-yaml-52dacb8/token/token_test.go 0000664 0000000 0000000 00000007061 15015766371 0020520 0 ustar 00root root 0000000 0000000 package token_test
import (
"testing"
"github.com/goccy/go-yaml/token"
)
func TestToken(t *testing.T) {
pos := &token.Position{}
tokens := token.Tokens{
token.SequenceEntry("-", pos),
token.MappingKey(pos),
token.MappingValue(pos),
token.CollectEntry(",", pos),
token.SequenceStart("[", pos),
token.SequenceEnd("]", pos),
token.MappingStart("{", pos),
token.MappingEnd("}", pos),
token.Comment("#", "#", pos),
token.Anchor("&", pos),
token.Alias("*", pos),
token.Literal("|", "|", pos),
token.Folded(">", ">", pos),
token.SingleQuote("'", "'", pos),
token.DoubleQuote(`"`, `"`, pos),
token.Directive("%", pos),
token.Space(pos),
token.MergeKey("<<", pos),
token.DocumentHeader("---", pos),
token.DocumentEnd("...", pos),
token.New("1", "1", pos),
token.New("3.14", "3.14", pos),
token.New("-0b101010", "-0b101010", pos),
token.New("0xA", "0xA", pos),
token.New("685.230_15e+03", "685.230_15e+03", pos),
token.New("02472256", "02472256", pos),
token.New("0o2472256", "0o2472256", pos),
token.New("", "", pos),
token.New("_1", "_1", pos),
token.New("1.1.1.1", "1.1.1.1", pos),
token.New("+", "+", pos),
token.New("-", "-", pos),
token.New("_", "_", pos),
token.New("~", "~", pos),
token.New("true", "true", pos),
token.New("false", "false", pos),
token.New(".nan", ".nan", pos),
token.New(".inf", ".inf", pos),
token.New("-.inf", "-.inf", pos),
token.New("null", "null", pos),
token.Tag("!!null", "!!null", pos),
token.Tag("!!map", "!!map", pos),
token.Tag("!!str", "!!str", pos),
token.Tag("!!seq", "!!seq", pos),
token.Tag("!!binary", "!!binary", pos),
token.Tag("!!omap", "!!omap", pos),
token.Tag("!!set", "!!set", pos),
token.Tag("!!int", "!!int", pos),
token.Tag("!!float", "!!float", pos),
token.Tag("!hoge", "!hoge", pos),
}
tokens.Dump()
tokens.Add(token.New("hoge", "hoge", pos))
if tokens[len(tokens)-1].PreviousType() != token.TagType {
t.Fatal("invalid previous token type")
}
if tokens[0].PreviousType() != token.UnknownType {
t.Fatal("invalid previous token type")
}
if tokens[len(tokens)-2].NextType() != token.StringType {
t.Fatal("invalid next token type")
}
if tokens[len(tokens)-1].NextType() != token.UnknownType {
t.Fatal("invalid next token type")
}
}
func TestIsNeedQuoted(t *testing.T) {
needQuotedTests := []string{
"",
"true",
"1.234",
"0b11111111111111111111111111111111111111111111111111111111111111111",
"0o7777777777777777777777777777777777777777",
"999999999999999999999999999999999999999999",
"0xffffffffffffffffffffffffffffffffffffffff",
"1:1",
"2001-12-15T02:59:43.1Z",
"2001-12-14t21:59:43.10-05:00",
"2001-12-15 2:59:43.10",
"2002-12-14",
"hoge # comment",
"\\0",
"#a b",
"*a b",
"&a b",
"{a b",
"}a b",
"[a b",
"]a b",
",a b",
"!a b",
"|a b",
">a b",
">a b",
"%a b",
`'a b`,
`"a b`,
"a:",
"a: b",
"y",
"Y",
"yes",
"Yes",
"YES",
"n",
"N",
"no",
"No",
"NO",
"on",
"On",
"ON",
"off",
"Off",
"OFF",
"@test",
" a",
" a ",
"a ",
"null",
"Null",
"NULL",
"~",
"-",
"- --foo",
}
for i, test := range needQuotedTests {
if !token.IsNeedQuoted(test) {
t.Errorf("%d: failed to quoted judge for %s", i, test)
}
}
notNeedQuotedTests := []string{
"Hello World",
// time.Parse cannot handle: "2001-12-14 21:59:43.10 -5" from the examples.
// https://yaml.org/type/timestamp.html
"2001-12-14 21:59:43.10 -5",
}
for i, test := range notNeedQuotedTests {
if token.IsNeedQuoted(test) {
t.Errorf("%d: failed to quoted judge for %s", i, test)
}
}
}
goccy-go-yaml-52dacb8/validate.go 0000664 0000000 0000000 00000000626 15015766371 0017012 0 ustar 00root root 0000000 0000000 package yaml
// StructValidator need to implement Struct method only
// ( see https://pkg.go.dev/github.com/go-playground/validator/v10#Validate.Struct )
type StructValidator interface {
Struct(interface{}) error
}
// FieldError need to implement StructField method only
// ( see https://pkg.go.dev/github.com/go-playground/validator/v10#FieldError )
type FieldError interface {
StructField() string
}
goccy-go-yaml-52dacb8/yaml.go 0000664 0000000 0000000 00000030014 15015766371 0016155 0 ustar 00root root 0000000 0000000 package yaml
import (
"bytes"
"context"
"io"
"reflect"
"sync"
"github.com/goccy/go-yaml/ast"
"github.com/goccy/go-yaml/internal/errors"
)
// BytesMarshaler interface may be implemented by types to customize their
// behavior when being marshaled into a YAML document. The returned value
// is marshaled in place of the original value implementing Marshaler.
//
// If an error is returned by MarshalYAML, the marshaling procedure stops
// and returns with the provided error.
type BytesMarshaler interface {
MarshalYAML() ([]byte, error)
}
// BytesMarshalerContext interface use BytesMarshaler with context.Context.
type BytesMarshalerContext interface {
MarshalYAML(context.Context) ([]byte, error)
}
// InterfaceMarshaler interface has MarshalYAML compatible with github.com/go-yaml/yaml package.
type InterfaceMarshaler interface {
MarshalYAML() (interface{}, error)
}
// InterfaceMarshalerContext interface use InterfaceMarshaler with context.Context.
type InterfaceMarshalerContext interface {
MarshalYAML(context.Context) (interface{}, error)
}
// BytesUnmarshaler interface may be implemented by types to customize their
// behavior when being unmarshaled from a YAML document.
type BytesUnmarshaler interface {
UnmarshalYAML([]byte) error
}
// BytesUnmarshalerContext interface use BytesUnmarshaler with context.Context.
type BytesUnmarshalerContext interface {
UnmarshalYAML(context.Context, []byte) error
}
// InterfaceUnmarshaler interface has UnmarshalYAML compatible with github.com/go-yaml/yaml package.
type InterfaceUnmarshaler interface {
UnmarshalYAML(func(interface{}) error) error
}
// InterfaceUnmarshalerContext interface use InterfaceUnmarshaler with context.Context.
type InterfaceUnmarshalerContext interface {
UnmarshalYAML(context.Context, func(interface{}) error) error
}
// NodeUnmarshaler interface is similar to BytesUnmarshaler but provide related AST node instead of raw YAML source.
type NodeUnmarshaler interface {
UnmarshalYAML(ast.Node) error
}
// NodeUnmarshalerContext interface is similar to BytesUnmarshaler but provide related AST node instead of raw YAML source.
type NodeUnmarshalerContext interface {
UnmarshalYAML(context.Context, ast.Node) error
}
// MapItem is an item in a MapSlice.
type MapItem struct {
Key, Value interface{}
}
// MapSlice encodes and decodes as a YAML map.
// The order of keys is preserved when encoding and decoding.
type MapSlice []MapItem
// ToMap convert to map[interface{}]interface{}.
func (s MapSlice) ToMap() map[interface{}]interface{} {
v := map[interface{}]interface{}{}
for _, item := range s {
v[item.Key] = item.Value
}
return v
}
// Marshal serializes the value provided into a YAML document. The structure
// of the generated document will reflect the structure of the value itself.
// Maps and pointers (to struct, string, int, etc) are accepted as the in value.
//
// Struct fields are only marshaled if they are exported (have an upper case
// first letter), and are marshaled using the field name lowercased as the
// default key. Custom keys may be defined via the "yaml" name in the field
// tag: the content preceding the first comma is used as the key, and the
// following comma-separated options are used to tweak the marshaling process.
// Conflicting names result in a runtime error.
//
// The field tag format accepted is:
//
// `(...) yaml:"[][,[,]]" (...)`
//
// The following flags are currently supported:
//
// omitempty Only include the field if it's not set to the zero
// value for the type or to empty slices or maps.
// Zero valued structs will be omitted if all their public
// fields are zero, unless they implement an IsZero
// method (see the IsZeroer interface type), in which
// case the field will be included if that method returns true.
// Note that this definition is slightly different from the Go's
// encoding/json 'omitempty' definition. It combines some elements
// of 'omitempty' and 'omitzero'. See https://github.com/goccy/go-yaml/issues/695.
//
// omitzero The omitzero tag behaves in the same way as the interpretation of the omitzero tag in the encoding/json library.
// 1) If the field type has an "IsZero() bool" method, that will be used to determine whether the value is zero.
// 2) Otherwise, the value is zero if it is the zero value for its type.
//
// flow Marshal using a flow style (useful for structs,
// sequences and maps).
//
// inline Inline the field, which must be a struct or a map,
// causing all of its fields or keys to be processed as if
// they were part of the outer struct. For maps, keys must
// not conflict with the yaml keys of other struct fields.
//
// anchor Marshal with anchor. If want to define anchor name explicitly, use anchor=name style.
// Otherwise, if used 'anchor' name only, used the field name lowercased as the anchor name
//
// alias Marshal with alias. If want to define alias name explicitly, use alias=name style.
// Otherwise, If omitted alias name and the field type is pointer type,
// assigned anchor name automatically from same pointer address.
//
// In addition, if the key is "-", the field is ignored.
//
// For example:
//
// type T struct {
// F int `yaml:"a,omitempty"`
// B int
// }
// yaml.Marshal(&T{B: 2}) // Returns "b: 2\n"
// yaml.Marshal(&T{F: 1}) // Returns "a: 1\nb: 0\n"
func Marshal(v interface{}) ([]byte, error) {
return MarshalWithOptions(v)
}
// MarshalWithOptions serializes the value provided into a YAML document with EncodeOptions.
func MarshalWithOptions(v interface{}, opts ...EncodeOption) ([]byte, error) {
return MarshalContext(context.Background(), v, opts...)
}
// MarshalContext serializes the value provided into a YAML document with context.Context and EncodeOptions.
func MarshalContext(ctx context.Context, v interface{}, opts ...EncodeOption) ([]byte, error) {
var buf bytes.Buffer
if err := NewEncoder(&buf, opts...).EncodeContext(ctx, v); err != nil {
return nil, err
}
return buf.Bytes(), nil
}
// ValueToNode convert from value to ast.Node.
func ValueToNode(v interface{}, opts ...EncodeOption) (ast.Node, error) {
var buf bytes.Buffer
node, err := NewEncoder(&buf, opts...).EncodeToNode(v)
if err != nil {
return nil, err
}
return node, nil
}
// Unmarshal decodes the first document found within the in byte slice
// and assigns decoded values into the out value.
//
// Struct fields are only unmarshalled if they are exported (have an
// upper case first letter), and are unmarshalled using the field name
// lowercased as the default key. Custom keys may be defined via the
// "yaml" name in the field tag: the content preceding the first comma
// is used as the key, and the following comma-separated options are
// used to tweak the marshaling process (see Marshal).
// Conflicting names result in a runtime error.
//
// For example:
//
// type T struct {
// F int `yaml:"a,omitempty"`
// B int
// }
// var t T
// yaml.Unmarshal([]byte("a: 1\nb: 2"), &t)
//
// See the documentation of Marshal for the format of tags and a list of
// supported tag options.
func Unmarshal(data []byte, v interface{}) error {
return UnmarshalWithOptions(data, v)
}
// UnmarshalWithOptions decodes with DecodeOptions the first document found within the in byte slice
// and assigns decoded values into the out value.
func UnmarshalWithOptions(data []byte, v interface{}, opts ...DecodeOption) error {
return UnmarshalContext(context.Background(), data, v, opts...)
}
// UnmarshalContext decodes with context.Context and DecodeOptions.
func UnmarshalContext(ctx context.Context, data []byte, v interface{}, opts ...DecodeOption) error {
dec := NewDecoder(bytes.NewBuffer(data), opts...)
if err := dec.DecodeContext(ctx, v); err != nil {
if err == io.EOF {
return nil
}
return err
}
return nil
}
// NodeToValue converts node to the value pointed to by v.
func NodeToValue(node ast.Node, v interface{}, opts ...DecodeOption) error {
var buf bytes.Buffer
if err := NewDecoder(&buf, opts...).DecodeFromNode(node, v); err != nil {
return err
}
return nil
}
// FormatError is a utility function that takes advantage of the metadata
// stored in the errors returned by this package's parser.
//
// If the second argument `colored` is true, the error message is colorized.
// If the third argument `inclSource` is true, the error message will
// contain snippets of the YAML source that was used.
func FormatError(e error, colored, inclSource bool) string {
var yamlErr Error
if errors.As(e, &yamlErr) {
return yamlErr.FormatError(colored, inclSource)
}
return e.Error()
}
// YAMLToJSON convert YAML bytes to JSON.
func YAMLToJSON(bytes []byte) ([]byte, error) {
var v interface{}
if err := UnmarshalWithOptions(bytes, &v, UseOrderedMap()); err != nil {
return nil, err
}
out, err := MarshalWithOptions(v, JSON())
if err != nil {
return nil, err
}
return out, nil
}
// JSONToYAML convert JSON bytes to YAML.
func JSONToYAML(bytes []byte) ([]byte, error) {
var v interface{}
if err := UnmarshalWithOptions(bytes, &v, UseOrderedMap()); err != nil {
return nil, err
}
out, err := Marshal(v)
if err != nil {
return nil, err
}
return out, nil
}
var (
globalCustomMarshalerMu sync.Mutex
globalCustomUnmarshalerMu sync.Mutex
globalCustomMarshalerMap = map[reflect.Type]func(context.Context, interface{}) ([]byte, error){}
globalCustomUnmarshalerMap = map[reflect.Type]func(context.Context, interface{}, []byte) error{}
)
// RegisterCustomMarshaler overrides any encoding process for the type specified in generics.
// If you want to switch the behavior for each encoder, use `CustomMarshaler` defined as EncodeOption.
//
// NOTE: If type T implements MarshalYAML for pointer receiver, the type specified in RegisterCustomMarshaler must be *T.
// If RegisterCustomMarshaler and CustomMarshaler of EncodeOption are specified for the same type,
// the CustomMarshaler specified in EncodeOption takes precedence.
func RegisterCustomMarshaler[T any](marshaler func(T) ([]byte, error)) {
globalCustomMarshalerMu.Lock()
defer globalCustomMarshalerMu.Unlock()
var typ T
globalCustomMarshalerMap[reflect.TypeOf(typ)] = func(ctx context.Context, v interface{}) ([]byte, error) {
return marshaler(v.(T))
}
}
// RegisterCustomMarshalerContext overrides any encoding process for the type specified in generics.
// Similar to RegisterCustomMarshalerContext, but allows passing a context to the unmarshaler function.
func RegisterCustomMarshalerContext[T any](marshaler func(context.Context, T) ([]byte, error)) {
globalCustomMarshalerMu.Lock()
defer globalCustomMarshalerMu.Unlock()
var typ T
globalCustomMarshalerMap[reflect.TypeOf(typ)] = func(ctx context.Context, v interface{}) ([]byte, error) {
return marshaler(ctx, v.(T))
}
}
// RegisterCustomUnmarshaler overrides any decoding process for the type specified in generics.
// If you want to switch the behavior for each decoder, use `CustomUnmarshaler` defined as DecodeOption.
//
// NOTE: If RegisterCustomUnmarshaler and CustomUnmarshaler of DecodeOption are specified for the same type,
// the CustomUnmarshaler specified in DecodeOption takes precedence.
func RegisterCustomUnmarshaler[T any](unmarshaler func(*T, []byte) error) {
globalCustomUnmarshalerMu.Lock()
defer globalCustomUnmarshalerMu.Unlock()
var typ *T
globalCustomUnmarshalerMap[reflect.TypeOf(typ)] = func(ctx context.Context, v interface{}, b []byte) error {
return unmarshaler(v.(*T), b)
}
}
// RegisterCustomUnmarshalerContext overrides any decoding process for the type specified in generics.
// Similar to RegisterCustomUnmarshalerContext, but allows passing a context to the unmarshaler function.
func RegisterCustomUnmarshalerContext[T any](unmarshaler func(context.Context, *T, []byte) error) {
globalCustomUnmarshalerMu.Lock()
defer globalCustomUnmarshalerMu.Unlock()
var typ *T
globalCustomUnmarshalerMap[reflect.TypeOf(typ)] = func(ctx context.Context, v interface{}, b []byte) error {
return unmarshaler(ctx, v.(*T), b)
}
}
goccy-go-yaml-52dacb8/yaml_test.go 0000664 0000000 0000000 00000007377 15015766371 0017234 0 ustar 00root root 0000000 0000000 package yaml_test
import (
"fmt"
"io"
"reflect"
"strings"
"testing"
"github.com/goccy/go-yaml"
"github.com/goccy/go-yaml/parser"
)
func TestRoundTripWithComment(t *testing.T) {
yml := `
# head comment
key: value # line comment
`
var v struct {
Key string
}
comments := yaml.CommentMap{}
if err := yaml.UnmarshalWithOptions([]byte(yml), &v, yaml.Strict(), yaml.CommentToMap(comments)); err != nil {
t.Fatal(err)
}
out, err := yaml.MarshalWithOptions(v, yaml.WithComment(comments))
if err != nil {
t.Fatal(err)
}
got := "\n" + string(out)
if yml != got {
t.Fatalf("failed to get round tripped yaml: %s", got)
}
}
func TestStreamDecodingWithComment(t *testing.T) {
yml := `
# comment
---
a:
b:
c: # comment
---
foo: bar # comment
---
- a
- b
- c # comment
`
cm := yaml.CommentMap{}
dec := yaml.NewDecoder(strings.NewReader(yml), yaml.CommentToMap(cm))
var commentPathsWithDocIndex [][]string
for {
var v any
if err := dec.Decode(&v); err != nil {
if err == io.EOF {
break
}
t.Fatal(err)
}
paths := make([]string, 0, len(cm))
for k := range cm {
paths = append(paths, k)
}
commentPathsWithDocIndex = append(commentPathsWithDocIndex, paths)
for k := range cm {
delete(cm, k)
}
}
if !reflect.DeepEqual(commentPathsWithDocIndex, [][]string{
{"$.a.b.c"},
{"$.foo"},
{"$[2]"},
}) {
t.Fatalf("failed to get comment: %v", commentPathsWithDocIndex)
}
}
func TestDecodeKeepAddress(t *testing.T) {
var data = `
a: &a [_]
b: &b [*a,*a]
c: &c [*b,*b]
d: &d [*c,*c]
`
var v map[string]any
if err := yaml.Unmarshal([]byte(data), &v); err != nil {
t.Fatal(err)
}
a := v["a"]
b := v["b"]
for _, vv := range v["b"].([]any) {
if fmt.Sprintf("%p", a) != fmt.Sprintf("%p", vv) {
t.Fatalf("failed to decode b element as keep address")
}
}
for _, vv := range v["c"].([]any) {
if fmt.Sprintf("%p", b) != fmt.Sprintf("%p", vv) {
t.Fatalf("failed to decode c element as keep address")
}
}
}
func TestSmartAnchor(t *testing.T) {
var data = `
a: &a [_,_,_,_,_,_,_,_,_,_,_,_,_,_,_]
b: &b [*a,*a,*a,*a,*a,*a,*a,*a,*a,*a]
c: &c [*b,*b,*b,*b,*b,*b,*b,*b,*b,*b]
d: &d [*c,*c,*c,*c,*c,*c,*c,*c,*c,*c]
e: &e [*d,*d,*d,*d,*d,*d,*d,*d,*d,*d]
f: &f [*e,*e,*e,*e,*e,*e,*e,*e,*e,*e]
g: &g [*f,*f,*f,*f,*f,*f,*f,*f,*f,*f]
h: &h [*g,*g,*g,*g,*g,*g,*g,*g,*g,*g]
i: &i [*h,*h,*h,*h,*h,*h,*h,*h,*h,*h]
`
var v any
if err := yaml.Unmarshal([]byte(data), &v); err != nil {
t.Fatal(err)
}
got, err := yaml.MarshalWithOptions(v, yaml.WithSmartAnchor())
if err != nil {
t.Fatal(err)
}
expected := `
a: &a
- _
- _
- _
- _
- _
- _
- _
- _
- _
- _
- _
- _
- _
- _
- _
b: &b
- *a
- *a
- *a
- *a
- *a
- *a
- *a
- *a
- *a
- *a
c: &c
- *b
- *b
- *b
- *b
- *b
- *b
- *b
- *b
- *b
- *b
d: &d
- *c
- *c
- *c
- *c
- *c
- *c
- *c
- *c
- *c
- *c
e: &e
- *d
- *d
- *d
- *d
- *d
- *d
- *d
- *d
- *d
- *d
f: &f
- *e
- *e
- *e
- *e
- *e
- *e
- *e
- *e
- *e
- *e
g: &g
- *f
- *f
- *f
- *f
- *f
- *f
- *f
- *f
- *f
- *f
h: &h
- *g
- *g
- *g
- *g
- *g
- *g
- *g
- *g
- *g
- *g
i:
- *h
- *h
- *h
- *h
- *h
- *h
- *h
- *h
- *h
- *h
`
if strings.TrimPrefix(expected, "\n") != string(got) {
t.Fatalf("failed to encode: %s", string(got))
}
}
func TestCustomErrorMessage(t *testing.T) {
data := `
foo:
bar:
foo: 2
baz:
foo: 3
foo: 2
`
if _, err := parser.ParseBytes([]byte(data), 0); err == nil {
t.Fatalf("expected error")
} else {
yamlErr, ok := err.(yaml.Error)
if !ok {
t.Fatalf("failed to get yaml.Error from error: %T", err)
}
expected := `
[7:1] custom message
4 | foo: 2
5 | baz:
6 | foo: 3
> 7 | foo: 2
^
`
got := "\n" + yaml.FormatErrorWithToken("custom message", yamlErr.GetToken(), false, true)
if expected != got {
t.Fatalf("unexpected error message:\nexpected:\n%s\nbut got:\n%s", expected, got)
}
}
}
goccy-go-yaml-52dacb8/yaml_test_suite_test.go 0000664 0000000 0000000 00000010775 15015766371 0021500 0 ustar 00root root 0000000 0000000 //go:build !windows
package yaml_test
import (
"bytes"
"encoding/json"
"io"
"runtime/debug"
"testing"
"github.com/goccy/go-yaml"
"github.com/goccy/go-yaml/testdata/yaml-test-suite"
)
var failureTestNames = []string{
"anchors-on-empty-scalars", // no json.
"aliases-in-flow-objects", // no json.
"aliases-in-explicit-block-mapping", // no json.
"block-mapping-with-missing-keys", // no json.
"empty-implicit-key-in-single-pair-flow-sequences", // no json.
"empty-keys-in-block-and-flow-mapping", // no json.
"empty-lines-at-end-of-document", // no json.
"flow-mapping-separate-values", // no json.
"flow-sequence-in-flow-mapping", // no json.
"implicit-flow-mapping-key-on-one-line", // no json.
"mapping-key-and-flow-sequence-item-anchors", // no json.
"nested-implicit-complex-keys", // no json.
"question-mark-edge-cases/00", // no json.
"question-mark-edge-cases/01", // no json.
"single-character-streams/01", // no json.
"single-pair-implicit-entries", // no json.
"spec-example-2-11-mapping-between-sequences", // no json.
"spec-example-6-12-separation-spaces", // no json.
"spec-example-7-16-flow-mapping-entries", // no json.
"spec-example-7-3-completely-empty-flow-nodes", // no json.
"spec-example-8-18-implicit-block-mapping-entries", // no json.
"spec-example-8-19-compact-block-mappings", // no json.
"syntax-character-edge-cases/00", // no json.
"tags-on-empty-scalars", // no json.
"various-combinations-of-explicit-block-mappings", // no json.
"various-trailing-comments", // no json.
"various-trailing-comments-1-3", // no json.
"zero-indented-sequences-in-explicit-mapping-keys", // no json.
"colon-at-the-beginning-of-adjacent-flow-scalar",
"comment-without-whitespace-after-doublequoted-scalar",
"construct-binary",
"dash-in-flow-sequence",
"flow-collections-over-many-lines/01",
"flow-mapping-colon-on-line-after-key/02",
"invalid-comment-after-comma",
"invalid-comment-after-end-of-flow-sequence",
"invalid-comma-in-tag",
"plain-dashes-in-flow-sequence",
"spec-example-9-3-bare-documents",
"spec-example-9-6-stream",
"spec-example-9-6-stream-1-3",
"tabs-in-various-contexts/003",
"tabs-that-look-like-indentation/04",
"tag-shorthand-used-in-documents-but-only-defined-in-the-first",
"trailing-line-of-spaces/01", // last '\n' character is needed ?
"wrong-indented-flow-sequence", // error ?
"wrong-indented-multiline-quoted-scalar", // error ?
}
var failureTestNameMap map[string]struct{}
func init() {
failureTestNameMap = make(map[string]struct{})
for _, name := range failureTestNames {
failureTestNameMap[name] = struct{}{}
}
}
func TestYAMLTestSuite(t *testing.T) {
tests, err := yamltestsuite.TestSuites()
if err != nil {
t.Fatal(err)
}
for _, test := range tests {
if _, exists := failureTestNameMap[test.Name]; exists {
continue
}
t.Run(test.Name, func(t *testing.T) {
defer func() {
if e := recover(); e != nil {
t.Fatalf("panic occurred.\n[input]\n%s\nstack[%s]", string(test.InYAML), debug.Stack())
}
}()
if test.Error {
var v any
if err := yaml.Unmarshal(test.InYAML, &v); err == nil {
t.Fatalf("expected error.\n[input]\n%s\n", string(test.InYAML))
}
return
}
dec := yaml.NewDecoder(bytes.NewReader(test.InYAML))
var idx int
for {
var v any
if err := dec.Decode(&v); err != nil {
if err == io.EOF {
break
}
t.Fatal(err)
}
if len(test.InJSON) <= idx {
t.Fatalf("expected json value is nothing but got %v", v)
}
expected, err := json.Marshal(test.InJSON[idx])
if err != nil {
t.Fatalf("failed to encode json value: %v", err)
}
got, err := json.Marshal(v)
if err != nil {
t.Fatalf("failed to encode json value: %v", err)
}
if !bytes.Equal(expected, got) {
t.Fatalf("json mismatch [%s]:\n[expected]\n%s\n[got]\n%s\n", test.Name, string(expected), string(got))
}
idx++
}
})
}
total := len(tests)
failed := len(failureTestNames)
passed := total - failed
passedRate := float32(passed) / float32(total) * 100
t.Logf("total:[%d] passed:[%d] failure:[%d] passedRate:[%f%%]", total, passed, failed, passedRate)
}
## This library has **NO** relation to the go-yaml/yaml library
> [!IMPORTANT]
> This library is developed from scratch to replace [`go-yaml/yaml`](https://github.com/go-yaml/yaml).
> If you're looking for a better YAML library, this one should be helpful.
# Why a new library?
As of this writing, there already exists a de facto standard library for YAML processing for Go: [https://github.com/go-yaml/yaml](https://github.com/go-yaml/yaml). However, we believe that a new YAML library is necessary for the following reasons:
- Not actively maintained
- `go-yaml/yaml` has ported the libyaml written in C to Go, so the source code is not written in Go style
- There is a lot of content that cannot be parsed
- YAML is often used for configuration, and it is common to include validation along with it. However, the errors in `go-yaml/yaml` are not intuitive, and it is difficult to provide meaningful validation errors
- When creating tools that use YAML, there are cases where reversible transformation of YAML is required. However, to perform reversible transformations of content that includes Comments or Anchors/Aliases, manipulating the AST is the only option
- Non-intuitive [Marshaler](https://pkg.go.dev/gopkg.in/yaml.v3#Marshaler) / [Unmarshaler](https://pkg.go.dev/gopkg.in/yaml.v3#Unmarshaler)
By the way, libraries such as [ghodss/yaml](https://github.com/ghodss/yaml) and [sigs.k8s.io/yaml](https://github.com/kubernetes-sigs/yaml) also depend on go-yaml/yaml, so if you are using these libraries, the same issues apply: they cannot parse things that go-yaml/yaml cannot parse, and they inherit many of the problems that go-yaml/yaml has.
# Features
- No dependencies
- A better parser than `go-yaml/yaml`.
- [Support recursive processing](https://github.com/apple/device-management/blob/release/docs/schema.yaml)
- Higher coverage in the [YAML Test Suite](https://github.com/yaml/yaml-test-suite?tab=readme-ov-file)
- YAML Test Suite consists of 402 cases in total, of which `gopkg.in/yaml.v3` passes `295`. In addition to passing all those test cases, `goccy/go-yaml` successfully passes nearly 60 additional test cases ( 2024/12/15 )
- The test code is [here](https://github.com/goccy/go-yaml/blob/master/yaml_test_suite_test.go#L77)
- Ease and sustainability of maintenance
- The main maintainer is [@goccy](https://github.com/goccy), but we are also building a system to develop as a team with trusted developers
- Since it is written from scratch, the code is easy to read for Gophers
- An API structure that allows the use of not only `Encoder`/`Decoder` but also `Tokenizer` and `Parser` functionalities.
- [lexer.Tokenize](https://pkg.go.dev/github.com/goccy/go-yaml@v1.15.4/lexer#Tokenize)
- [parser.Parse](https://pkg.go.dev/github.com/goccy/go-yaml@v1.15.4/parser#Parse)
- Filtering, replacing, and merging YAML content using YAML Path
- Reversible transformation without using the AST for YAML that includes Anchors, Aliases, and Comments
- Customize the Marshal/Unmarshal behavior for primitive types and third-party library types ([RegisterCustomMarshaler](https://pkg.go.dev/github.com/goccy/go-yaml#RegisterCustomMarshaler), [RegisterCustomUnmarshaler](https://pkg.go.dev/github.com/goccy/go-yaml#RegisterCustomUnmarshaler))
- Respects `encoding/json` behavior
- Accept the `json` tag. Note that not all options from the `json` tag will have significance when parsing YAML documents. If both tags exist, `yaml` tag will take precedence.
- [json.Marshaler](https://pkg.go.dev/encoding/json#Marshaler) style [marshaler](https://pkg.go.dev/github.com/goccy/go-yaml#BytesMarshaler)
- [json.Unmarshaler](https://pkg.go.dev/encoding/json#Unmarshaler) style [unmarshaler](https://pkg.go.dev/github.com/goccy/go-yaml#BytesUnmarshaler)
- Options for using `MarshalJSON` and `UnmarshalJSON` ([UseJSONMarshaler](https://pkg.go.dev/github.com/goccy/go-yaml#UseJSONMarshaler), [UseJSONUnmarshaler](https://pkg.go.dev/github.com/goccy/go-yaml#UseJSONUnmarshaler))
- Pretty format for error notifications
- Smart validation processing combined with [go-playground/validator](https://github.com/go-playground/validator)
- [example test code is here](https://github.com/goccy/go-yaml/blob/45889c98b0a0967240eb595a1bd6896e2f575106/testdata/validate_test.go#L12)
- Allow referencing elements declared in another file via anchors
# Users
The repositories that use goccy/go-yaml are listed here.
- https://github.com/goccy/go-yaml/wiki/Users
The source data is [here](https://github.com/goccy/go-yaml/network/dependents).
It is already being used in many repositories. Now it's your turn 😄
# Playground
The Playground visualizes how go-yaml processes YAML text. Use it to assist with your debugging or issue reporting.
https://goccy.github.io/go-yaml
# Installation
```sh
go get github.com/goccy/go-yaml
```
# Synopsis
## 1. Simple Encode/Decode
Has an interface like `go-yaml/yaml` using `reflect`
```go
var v struct {
A int
B string
}
v.A = 1
v.B = "hello"
bytes, err := yaml.Marshal(v)
if err != nil {
//...
}
fmt.Println(string(bytes)) // "a: 1\nb: hello\n"
```
```go
yml := `
%YAML 1.2
---
a: 1
b: c
`
var v struct {
A int
B string
}
if err := yaml.Unmarshal([]byte(yml), &v); err != nil {
//...
}
```
To control marshal/unmarshal behavior, you can use the `yaml` tag.
```go
yml := `---
foo: 1
bar: c
`
var v struct {
A int `yaml:"foo"`
B string `yaml:"bar"`
}
if err := yaml.Unmarshal([]byte(yml), &v); err != nil {
//...
}
```
For convenience, we also accept the `json` tag. Note that not all options from
the `json` tag will have significance when parsing YAML documents. If both
tags exist, `yaml` tag will take precedence.
```go
yml := `---
foo: 1
bar: c
`
var v struct {
A int `json:"foo"`
B string `json:"bar"`
}
if err := yaml.Unmarshal([]byte(yml), &v); err != nil {
//...
}
```
For custom marshal/unmarshaling, implement either `Bytes` or `Interface` variant of marshaler/unmarshaler. The difference is that while `BytesMarshaler`/`BytesUnmarshaler` behaves like [`encoding/json`](https://pkg.go.dev/encoding/json) and `InterfaceMarshaler`/`InterfaceUnmarshaler` behaves like [`gopkg.in/yaml.v2`](https://pkg.go.dev/gopkg.in/yaml.v2).
Semantically both are the same, but they differ in performance. Because indentation matters in YAML, you cannot simply accept a valid YAML fragment from a Marshaler, and expect it to work when it is attached to the parent container's serialized form. Therefore when we receive use the `BytesMarshaler`, which returns `[]byte`, we must decode it once to figure out how to make it work in the given context. If you use the `InterfaceMarshaler`, we can skip the decoding.
If you are repeatedly marshaling complex objects, the latter is always better
performance wise. But if you are, for example, just providing a choice between
a config file format that is read only once, the former is probably easier to
code.
## 2. Reference elements declared in another file
`testdata` directory contains `anchor.yml` file:
```shell
├── testdata
└── anchor.yml
```
And `anchor.yml` is defined as follows:
```yaml
a: &a
b: 1
c: hello
```
Then, if `yaml.ReferenceDirs("testdata")` option is passed to `yaml.Decoder`,
`Decoder` tries to find the anchor definition from YAML files the under `testdata` directory.
```go
buf := bytes.NewBufferString("a: *a\n")
dec := yaml.NewDecoder(buf, yaml.ReferenceDirs("testdata"))
var v struct {
A struct {
B int
C string
}
}
if err := dec.Decode(&v); err != nil {
//...
}
fmt.Printf("%+v\n", v) // {A:{B:1 C:hello}}
```
## 3. Encode with `Anchor` and `Alias`
### 3.1. Explicitly declared `Anchor` name and `Alias` name
If you want to use `anchor`, you can define it as a struct tag.
If the value specified for an anchor is a pointer type and the same address as the pointer is found, the value is automatically set to alias.
If an explicit alias name is specified, an error is raised if its value is different from the value specified in the anchor.
```go
type T struct {
A int
B string
}
var v struct {
C *T `yaml:"c,anchor=x"`
D *T `yaml:"d,alias=x"`
}
v.C = &T{A: 1, B: "hello"}
v.D = v.C
bytes, err := yaml.Marshal(v)
if err != nil {
panic(err)
}
fmt.Println(string(bytes))
/*
c: &x
a: 1
b: hello
d: *x
*/
```
### 3.2. Implicitly declared `Anchor` and `Alias` names
If you do not explicitly declare the anchor name, the default behavior is to
use the equivalent of `strings.ToLower($FieldName)` as the name of the anchor.
If the value specified for an anchor is a pointer type and the same address as the pointer is found, the value is automatically set to alias.
```go
type T struct {
I int
S string
}
var v struct {
A *T `yaml:"a,anchor"`
B *T `yaml:"b,anchor"`
C *T `yaml:"c"`
D *T `yaml:"d"`
}
v.A = &T{I: 1, S: "hello"}
v.B = &T{I: 2, S: "world"}
v.C = v.A // C has same pointer address to A
v.D = v.B // D has same pointer address to B
bytes, err := yaml.Marshal(v)
if err != nil {
//...
}
fmt.Println(string(bytes))
/*
a: &a
i: 1
s: hello
b: &b
i: 2
s: world
c: *a
d: *b
*/
```
### 3.3 MergeKey and Alias
Merge key and alias ( `<<: *alias` ) can be used by embedding a structure with the `inline,alias` tag.
```go
type Person struct {
*Person `yaml:",omitempty,inline,alias"` // embed Person type for default value
Name string `yaml:",omitempty"`
Age int `yaml:",omitempty"`
}
defaultPerson := &Person{
Name: "John Smith",
Age: 20,
}
people := []*Person{
{
Person: defaultPerson, // assign default value
Name: "Ken", // override Name property
Age: 10, // override Age property
},
{
Person: defaultPerson, // assign default value only
},
}
var doc struct {
Default *Person `yaml:"default,anchor"`
People []*Person `yaml:"people"`
}
doc.Default = defaultPerson
doc.People = people
bytes, err := yaml.Marshal(doc)
if err != nil {
//...
}
fmt.Println(string(bytes))
/*
default: &default
name: John Smith
age: 20
people:
- <<: *default
name: Ken
age: 10
- <<: *default
*/
```
## 4. Pretty Formatted Errors
Error values produced during parsing have two extra features over regular
error values.
First, by default, they contain extra information on the location of the error
from the source YAML document, to make it easier to find the error location.
Second, the error messages can optionally be colorized.
If you would like to control exactly how the output looks like, consider
using `yaml.FormatError`, which accepts two boolean values to
control turning these features on or off.
## 5. Use YAMLPath
```go
yml := `
store:
book:
- author: john
price: 10
- author: ken
price: 12
bicycle:
color: red
price: 19.95
`
path, err := yaml.PathString("$.store.book[*].author")
if err != nil {
//...
}
var authors []string
if err := path.Read(strings.NewReader(yml), &authors); err != nil {
//...
}
fmt.Println(authors)
// [john ken]
```
### 5.1 Print customized error with YAML source code
```go
package main
import (
"fmt"
"github.com/goccy/go-yaml"
)
func main() {
yml := `
a: 1
b: "hello"
`
var v struct {
A int
B string
}
if err := yaml.Unmarshal([]byte(yml), &v); err != nil {
panic(err)
}
if v.A != 2 {
// output error with YAML source
path, err := yaml.PathString("$.a")
if err != nil {
panic(err)
}
source, err := path.AnnotateSource([]byte(yml), true)
if err != nil {
panic(err)
}
fmt.Printf("a value expected 2 but actual %d:\n%s\n", v.A, string(source))
}
}
```
output result is the following:
# Tools
## ycat
print yaml file with color
### Installation
```sh
git clone https://github.com/goccy/go-yaml.git
cd go-yaml/cmd/ycat && go install .
```
# For Developers
> [!NOTE]
> In this project, we manage such test code under the `testdata` directory to avoid adding dependencies on libraries that are only needed for testing to the top `go.mod` file. Therefore, if you want to add test cases that use 3rd party libraries, please add the test code to the `testdata` directory.
# Looking for Sponsors
I'm looking for sponsors this library. This library is being developed as a personal project in my spare time. If you want a quick response or problem resolution when using this library in your project, please register as a [sponsor](https://github.com/sponsors/goccy). I will cooperate as much as possible. Of course, this library is developed as an MIT license, so you can use it freely for free.
# License
MIT
goccy-go-yaml-52dacb8/ast/ 0000775 0000000 0000000 00000000000 15015766371 0015455 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/ast/ast.go 0000664 0000000 0000000 00000155013 15015766371 0016600 0 ustar 00root root 0000000 0000000 package ast
import (
"errors"
"fmt"
"io"
"math"
"strconv"
"strings"
"github.com/goccy/go-yaml/token"
)
var (
ErrInvalidTokenType = errors.New("invalid token type")
ErrInvalidAnchorName = errors.New("invalid anchor name")
ErrInvalidAliasName = errors.New("invalid alias name")
)
// NodeType type identifier of node
type NodeType int
const (
// UnknownNodeType type identifier for default
UnknownNodeType NodeType = iota
// DocumentType type identifier for document node
DocumentType
// NullType type identifier for null node
NullType
// BoolType type identifier for boolean node
BoolType
// IntegerType type identifier for integer node
IntegerType
// FloatType type identifier for float node
FloatType
// InfinityType type identifier for infinity node
InfinityType
// NanType type identifier for nan node
NanType
// StringType type identifier for string node
StringType
// MergeKeyType type identifier for merge key node
MergeKeyType
// LiteralType type identifier for literal node
LiteralType
// MappingType type identifier for mapping node
MappingType
// MappingKeyType type identifier for mapping key node
MappingKeyType
// MappingValueType type identifier for mapping value node
MappingValueType
// SequenceType type identifier for sequence node
SequenceType
// SequenceEntryType type identifier for sequence entry node
SequenceEntryType
// AnchorType type identifier for anchor node
AnchorType
// AliasType type identifier for alias node
AliasType
// DirectiveType type identifier for directive node
DirectiveType
// TagType type identifier for tag node
TagType
// CommentType type identifier for comment node
CommentType
// CommentGroupType type identifier for comment group node
CommentGroupType
)
// String node type identifier to text
func (t NodeType) String() string {
switch t {
case UnknownNodeType:
return "UnknownNode"
case DocumentType:
return "Document"
case NullType:
return "Null"
case BoolType:
return "Bool"
case IntegerType:
return "Integer"
case FloatType:
return "Float"
case InfinityType:
return "Infinity"
case NanType:
return "Nan"
case StringType:
return "String"
case MergeKeyType:
return "MergeKey"
case LiteralType:
return "Literal"
case MappingType:
return "Mapping"
case MappingKeyType:
return "MappingKey"
case MappingValueType:
return "MappingValue"
case SequenceType:
return "Sequence"
case SequenceEntryType:
return "SequenceEntry"
case AnchorType:
return "Anchor"
case AliasType:
return "Alias"
case DirectiveType:
return "Directive"
case TagType:
return "Tag"
case CommentType:
return "Comment"
case CommentGroupType:
return "CommentGroup"
}
return ""
}
// String node type identifier to YAML Structure name
// based on https://yaml.org/spec/1.2/spec.html
func (t NodeType) YAMLName() string {
switch t {
case UnknownNodeType:
return "unknown"
case DocumentType:
return "document"
case NullType:
return "null"
case BoolType:
return "boolean"
case IntegerType:
return "int"
case FloatType:
return "float"
case InfinityType:
return "inf"
case NanType:
return "nan"
case StringType:
return "string"
case MergeKeyType:
return "merge key"
case LiteralType:
return "scalar"
case MappingType:
return "mapping"
case MappingKeyType:
return "key"
case MappingValueType:
return "value"
case SequenceType:
return "sequence"
case SequenceEntryType:
return "value"
case AnchorType:
return "anchor"
case AliasType:
return "alias"
case DirectiveType:
return "directive"
case TagType:
return "tag"
case CommentType:
return "comment"
case CommentGroupType:
return "comment"
}
return ""
}
// Node type of node
type Node interface {
io.Reader
// String node to text
String() string
// GetToken returns token instance
GetToken() *token.Token
// Type returns type of node
Type() NodeType
// AddColumn add column number to child nodes recursively
AddColumn(int)
// SetComment set comment token to node
SetComment(*CommentGroupNode) error
// Comment returns comment token instance
GetComment() *CommentGroupNode
// GetPath returns YAMLPath for the current node
GetPath() string
// SetPath set YAMLPath for the current node
SetPath(string)
// MarshalYAML
MarshalYAML() ([]byte, error)
// already read length
readLen() int
// append read length
addReadLen(int)
// clean read length
clearLen()
}
// MapKeyNode type for map key node
type MapKeyNode interface {
Node
IsMergeKey() bool
// String node to text without comment
stringWithoutComment() string
}
// ScalarNode type for scalar node
type ScalarNode interface {
MapKeyNode
GetValue() interface{}
}
type BaseNode struct {
Path string
Comment *CommentGroupNode
read int
}
func addCommentString(base string, node *CommentGroupNode) string {
return fmt.Sprintf("%s %s", base, node.String())
}
func (n *BaseNode) readLen() int {
return n.read
}
func (n *BaseNode) clearLen() {
n.read = 0
}
func (n *BaseNode) addReadLen(len int) {
n.read += len
}
// GetPath returns YAMLPath for the current node.
func (n *BaseNode) GetPath() string {
if n == nil {
return ""
}
return n.Path
}
// SetPath set YAMLPath for the current node.
func (n *BaseNode) SetPath(path string) {
if n == nil {
return
}
n.Path = path
}
// GetComment returns comment token instance
func (n *BaseNode) GetComment() *CommentGroupNode {
return n.Comment
}
// SetComment set comment token
func (n *BaseNode) SetComment(node *CommentGroupNode) error {
n.Comment = node
return nil
}
func min(a, b int) int {
if a < b {
return a
}
return b
}
func readNode(p []byte, node Node) (int, error) {
s := node.String()
readLen := node.readLen()
remain := len(s) - readLen
if remain == 0 {
node.clearLen()
return 0, io.EOF
}
size := min(remain, len(p))
for idx, b := range []byte(s[readLen : readLen+size]) {
p[idx] = byte(b)
}
node.addReadLen(size)
return size, nil
}
func checkLineBreak(t *token.Token) bool {
if t.Prev != nil {
lbc := "\n"
prev := t.Prev
var adjustment int
// if the previous type is sequence entry use the previous type for that
if prev.Type == token.SequenceEntryType {
// as well as switching to previous type count any new lines in origin to account for:
// -
// b: c
adjustment = strings.Count(strings.TrimRight(t.Origin, lbc), lbc)
if prev.Prev != nil {
prev = prev.Prev
}
}
lineDiff := t.Position.Line - prev.Position.Line - 1
if lineDiff > 0 {
if prev.Type == token.StringType {
// Remove any line breaks included in multiline string
adjustment += strings.Count(strings.TrimRight(strings.TrimSpace(prev.Origin), lbc), lbc)
}
// Due to the way that comment parsing works its assumed that when a null value does not have new line in origin
// it was squashed therefore difference is ignored.
// foo:
// bar:
// # comment
// baz: 1
// becomes
// foo:
// bar: null # comment
//
// baz: 1
if prev.Type == token.NullType || prev.Type == token.ImplicitNullType {
return strings.Count(prev.Origin, lbc) > 0
}
if lineDiff-adjustment > 0 {
return true
}
}
}
return false
}
// Null create node for null value
func Null(tk *token.Token) *NullNode {
return &NullNode{
BaseNode: &BaseNode{},
Token: tk,
}
}
// Bool create node for boolean value
func Bool(tk *token.Token) *BoolNode {
b, _ := strconv.ParseBool(tk.Value)
return &BoolNode{
BaseNode: &BaseNode{},
Token: tk,
Value: b,
}
}
// Integer create node for integer value
func Integer(tk *token.Token) *IntegerNode {
var v any
if num := token.ToNumber(tk.Value); num != nil {
v = num.Value
}
return &IntegerNode{
BaseNode: &BaseNode{},
Token: tk,
Value: v,
}
}
// Float create node for float value
func Float(tk *token.Token) *FloatNode {
var v float64
if num := token.ToNumber(tk.Value); num != nil && num.Type == token.NumberTypeFloat {
value, ok := num.Value.(float64)
if ok {
v = value
}
}
return &FloatNode{
BaseNode: &BaseNode{},
Token: tk,
Value: v,
}
}
// Infinity create node for .inf or -.inf value
func Infinity(tk *token.Token) *InfinityNode {
node := &InfinityNode{
BaseNode: &BaseNode{},
Token: tk,
}
switch tk.Value {
case ".inf", ".Inf", ".INF":
node.Value = math.Inf(0)
case "-.inf", "-.Inf", "-.INF":
node.Value = math.Inf(-1)
}
return node
}
// Nan create node for .nan value
func Nan(tk *token.Token) *NanNode {
return &NanNode{
BaseNode: &BaseNode{},
Token: tk,
}
}
// String create node for string value
func String(tk *token.Token) *StringNode {
return &StringNode{
BaseNode: &BaseNode{},
Token: tk,
Value: tk.Value,
}
}
// Comment create node for comment
func Comment(tk *token.Token) *CommentNode {
return &CommentNode{
BaseNode: &BaseNode{},
Token: tk,
}
}
func CommentGroup(comments []*token.Token) *CommentGroupNode {
nodes := []*CommentNode{}
for _, comment := range comments {
nodes = append(nodes, Comment(comment))
}
return &CommentGroupNode{
BaseNode: &BaseNode{},
Comments: nodes,
}
}
// MergeKey create node for merge key ( << )
func MergeKey(tk *token.Token) *MergeKeyNode {
return &MergeKeyNode{
BaseNode: &BaseNode{},
Token: tk,
}
}
// Mapping create node for map
func Mapping(tk *token.Token, isFlowStyle bool, values ...*MappingValueNode) *MappingNode {
node := &MappingNode{
BaseNode: &BaseNode{},
Start: tk,
IsFlowStyle: isFlowStyle,
Values: []*MappingValueNode{},
}
node.Values = append(node.Values, values...)
return node
}
// MappingValue create node for mapping value
func MappingValue(tk *token.Token, key MapKeyNode, value Node) *MappingValueNode {
return &MappingValueNode{
BaseNode: &BaseNode{},
Start: tk,
Key: key,
Value: value,
}
}
// MappingKey create node for map key ( '?' ).
func MappingKey(tk *token.Token) *MappingKeyNode {
return &MappingKeyNode{
BaseNode: &BaseNode{},
Start: tk,
}
}
// Sequence create node for sequence
func Sequence(tk *token.Token, isFlowStyle bool) *SequenceNode {
return &SequenceNode{
BaseNode: &BaseNode{},
Start: tk,
IsFlowStyle: isFlowStyle,
Values: []Node{},
}
}
func Anchor(tk *token.Token) *AnchorNode {
return &AnchorNode{
BaseNode: &BaseNode{},
Start: tk,
}
}
func Alias(tk *token.Token) *AliasNode {
return &AliasNode{
BaseNode: &BaseNode{},
Start: tk,
}
}
func Document(tk *token.Token, body Node) *DocumentNode {
return &DocumentNode{
BaseNode: &BaseNode{},
Start: tk,
Body: body,
}
}
func Directive(tk *token.Token) *DirectiveNode {
return &DirectiveNode{
BaseNode: &BaseNode{},
Start: tk,
}
}
func Literal(tk *token.Token) *LiteralNode {
return &LiteralNode{
BaseNode: &BaseNode{},
Start: tk,
}
}
func Tag(tk *token.Token) *TagNode {
return &TagNode{
BaseNode: &BaseNode{},
Start: tk,
}
}
// File contains all documents in YAML file
type File struct {
Name string
Docs []*DocumentNode
}
// Read implements (io.Reader).Read
func (f *File) Read(p []byte) (int, error) {
for _, doc := range f.Docs {
n, err := doc.Read(p)
if err == io.EOF {
continue
}
return n, nil
}
return 0, io.EOF
}
// String all documents to text
func (f *File) String() string {
docs := []string{}
for _, doc := range f.Docs {
docs = append(docs, doc.String())
}
if len(docs) > 0 {
return strings.Join(docs, "\n") + "\n"
} else {
return ""
}
}
// DocumentNode type of Document
type DocumentNode struct {
*BaseNode
Start *token.Token // position of DocumentHeader ( `---` )
End *token.Token // position of DocumentEnd ( `...` )
Body Node
}
// Read implements (io.Reader).Read
func (d *DocumentNode) Read(p []byte) (int, error) {
return readNode(p, d)
}
// Type returns DocumentNodeType
func (d *DocumentNode) Type() NodeType { return DocumentType }
// GetToken returns token instance
func (d *DocumentNode) GetToken() *token.Token {
return d.Body.GetToken()
}
// AddColumn add column number to child nodes recursively
func (d *DocumentNode) AddColumn(col int) {
if d.Body != nil {
d.Body.AddColumn(col)
}
}
// String document to text
func (d *DocumentNode) String() string {
doc := []string{}
if d.Start != nil {
doc = append(doc, d.Start.Value)
}
if d.Body != nil {
doc = append(doc, d.Body.String())
}
if d.End != nil {
doc = append(doc, d.End.Value)
}
return strings.Join(doc, "\n")
}
// MarshalYAML encodes to a YAML text
func (d *DocumentNode) MarshalYAML() ([]byte, error) {
return []byte(d.String()), nil
}
// NullNode type of null node
type NullNode struct {
*BaseNode
Token *token.Token
}
// Read implements (io.Reader).Read
func (n *NullNode) Read(p []byte) (int, error) {
return readNode(p, n)
}
// Type returns NullType
func (n *NullNode) Type() NodeType { return NullType }
// GetToken returns token instance
func (n *NullNode) GetToken() *token.Token {
return n.Token
}
// AddColumn add column number to child nodes recursively
func (n *NullNode) AddColumn(col int) {
n.Token.AddColumn(col)
}
// GetValue returns nil value
func (n *NullNode) GetValue() interface{} {
return nil
}
// String returns `null` text
func (n *NullNode) String() string {
if n.Token.Type == token.ImplicitNullType {
if n.Comment != nil {
return n.Comment.String()
}
return ""
}
if n.Comment != nil {
return addCommentString("null", n.Comment)
}
return n.stringWithoutComment()
}
func (n *NullNode) stringWithoutComment() string {
return "null"
}
// MarshalYAML encodes to a YAML text
func (n *NullNode) MarshalYAML() ([]byte, error) {
return []byte(n.String()), nil
}
// IsMergeKey returns whether it is a MergeKey node.
func (n *NullNode) IsMergeKey() bool {
return false
}
// IntegerNode type of integer node
type IntegerNode struct {
*BaseNode
Token *token.Token
Value interface{} // int64 or uint64 value
}
// Read implements (io.Reader).Read
func (n *IntegerNode) Read(p []byte) (int, error) {
return readNode(p, n)
}
// Type returns IntegerType
func (n *IntegerNode) Type() NodeType { return IntegerType }
// GetToken returns token instance
func (n *IntegerNode) GetToken() *token.Token {
return n.Token
}
// AddColumn add column number to child nodes recursively
func (n *IntegerNode) AddColumn(col int) {
n.Token.AddColumn(col)
}
// GetValue returns int64 value
func (n *IntegerNode) GetValue() interface{} {
return n.Value
}
// String int64 to text
func (n *IntegerNode) String() string {
if n.Comment != nil {
return addCommentString(n.Token.Value, n.Comment)
}
return n.stringWithoutComment()
}
func (n *IntegerNode) stringWithoutComment() string {
return n.Token.Value
}
// MarshalYAML encodes to a YAML text
func (n *IntegerNode) MarshalYAML() ([]byte, error) {
return []byte(n.String()), nil
}
// IsMergeKey returns whether it is a MergeKey node.
func (n *IntegerNode) IsMergeKey() bool {
return false
}
// FloatNode type of float node
type FloatNode struct {
*BaseNode
Token *token.Token
Precision int
Value float64
}
// Read implements (io.Reader).Read
func (n *FloatNode) Read(p []byte) (int, error) {
return readNode(p, n)
}
// Type returns FloatType
func (n *FloatNode) Type() NodeType { return FloatType }
// GetToken returns token instance
func (n *FloatNode) GetToken() *token.Token {
return n.Token
}
// AddColumn add column number to child nodes recursively
func (n *FloatNode) AddColumn(col int) {
n.Token.AddColumn(col)
}
// GetValue returns float64 value
func (n *FloatNode) GetValue() interface{} {
return n.Value
}
// String float64 to text
func (n *FloatNode) String() string {
if n.Comment != nil {
return addCommentString(n.Token.Value, n.Comment)
}
return n.stringWithoutComment()
}
func (n *FloatNode) stringWithoutComment() string {
return n.Token.Value
}
// MarshalYAML encodes to a YAML text
func (n *FloatNode) MarshalYAML() ([]byte, error) {
return []byte(n.String()), nil
}
// IsMergeKey returns whether it is a MergeKey node.
func (n *FloatNode) IsMergeKey() bool {
return false
}
// StringNode type of string node
type StringNode struct {
*BaseNode
Token *token.Token
Value string
}
// Read implements (io.Reader).Read
func (n *StringNode) Read(p []byte) (int, error) {
return readNode(p, n)
}
// Type returns StringType
func (n *StringNode) Type() NodeType { return StringType }
// GetToken returns token instance
func (n *StringNode) GetToken() *token.Token {
return n.Token
}
// AddColumn add column number to child nodes recursively
func (n *StringNode) AddColumn(col int) {
n.Token.AddColumn(col)
}
// GetValue returns string value
func (n *StringNode) GetValue() interface{} {
return n.Value
}
// IsMergeKey returns whether it is a MergeKey node.
func (n *StringNode) IsMergeKey() bool {
return false
}
// escapeSingleQuote escapes s to a single quoted scalar.
// https://yaml.org/spec/1.2.2/#732-single-quoted-style
func escapeSingleQuote(s string) string {
var sb strings.Builder
growLen := len(s) + // s includes also one ' from the doubled pair
2 + // opening and closing '
strings.Count(s, "'") // ' added by ReplaceAll
sb.Grow(growLen)
sb.WriteString("'")
sb.WriteString(strings.ReplaceAll(s, "'", "''"))
sb.WriteString("'")
return sb.String()
}
// String string value to text with quote or literal header if required
func (n *StringNode) String() string {
switch n.Token.Type {
case token.SingleQuoteType:
quoted := escapeSingleQuote(n.Value)
if n.Comment != nil {
return addCommentString(quoted, n.Comment)
}
return quoted
case token.DoubleQuoteType:
quoted := strconv.Quote(n.Value)
if n.Comment != nil {
return addCommentString(quoted, n.Comment)
}
return quoted
}
lbc := token.DetectLineBreakCharacter(n.Value)
if strings.Contains(n.Value, lbc) {
// This block assumes that the line breaks in this inside scalar content and the Outside scalar content are the same.
// It works mostly, but inconsistencies occur if line break characters are mixed.
header := token.LiteralBlockHeader(n.Value)
space := strings.Repeat(" ", n.Token.Position.Column-1)
indent := strings.Repeat(" ", n.Token.Position.IndentNum)
values := []string{}
for _, v := range strings.Split(n.Value, lbc) {
values = append(values, fmt.Sprintf("%s%s%s", space, indent, v))
}
block := strings.TrimSuffix(strings.TrimSuffix(strings.Join(values, lbc), fmt.Sprintf("%s%s%s", lbc, indent, space)), fmt.Sprintf("%s%s", indent, space))
return fmt.Sprintf("%s%s%s", header, lbc, block)
} else if len(n.Value) > 0 && (n.Value[0] == '{' || n.Value[0] == '[') {
return fmt.Sprintf(`'%s'`, n.Value)
}
if n.Comment != nil {
return addCommentString(n.Value, n.Comment)
}
return n.Value
}
func (n *StringNode) stringWithoutComment() string {
switch n.Token.Type {
case token.SingleQuoteType:
quoted := fmt.Sprintf(`'%s'`, n.Value)
return quoted
case token.DoubleQuoteType:
quoted := strconv.Quote(n.Value)
return quoted
}
lbc := token.DetectLineBreakCharacter(n.Value)
if strings.Contains(n.Value, lbc) {
// This block assumes that the line breaks in this inside scalar content and the Outside scalar content are the same.
// It works mostly, but inconsistencies occur if line break characters are mixed.
header := token.LiteralBlockHeader(n.Value)
space := strings.Repeat(" ", n.Token.Position.Column-1)
indent := strings.Repeat(" ", n.Token.Position.IndentNum)
values := []string{}
for _, v := range strings.Split(n.Value, lbc) {
values = append(values, fmt.Sprintf("%s%s%s", space, indent, v))
}
block := strings.TrimSuffix(strings.TrimSuffix(strings.Join(values, lbc), fmt.Sprintf("%s%s%s", lbc, indent, space)), fmt.Sprintf(" %s", space))
return fmt.Sprintf("%s%s%s", header, lbc, block)
} else if len(n.Value) > 0 && (n.Value[0] == '{' || n.Value[0] == '[') {
return fmt.Sprintf(`'%s'`, n.Value)
}
return n.Value
}
// MarshalYAML encodes to a YAML text
func (n *StringNode) MarshalYAML() ([]byte, error) {
return []byte(n.String()), nil
}
// LiteralNode type of literal node
type LiteralNode struct {
*BaseNode
Start *token.Token
Value *StringNode
}
// Read implements (io.Reader).Read
func (n *LiteralNode) Read(p []byte) (int, error) {
return readNode(p, n)
}
// Type returns LiteralType
func (n *LiteralNode) Type() NodeType { return LiteralType }
// GetToken returns token instance
func (n *LiteralNode) GetToken() *token.Token {
return n.Start
}
// AddColumn add column number to child nodes recursively
func (n *LiteralNode) AddColumn(col int) {
n.Start.AddColumn(col)
if n.Value != nil {
n.Value.AddColumn(col)
}
}
// GetValue returns string value
func (n *LiteralNode) GetValue() interface{} {
return n.String()
}
// String literal to text
func (n *LiteralNode) String() string {
origin := n.Value.GetToken().Origin
lit := strings.TrimRight(strings.TrimRight(origin, " "), "\n")
if n.Comment != nil {
return fmt.Sprintf("%s %s\n%s", n.Start.Value, n.Comment.String(), lit)
}
return fmt.Sprintf("%s\n%s", n.Start.Value, lit)
}
func (n *LiteralNode) stringWithoutComment() string {
return n.String()
}
// MarshalYAML encodes to a YAML text
func (n *LiteralNode) MarshalYAML() ([]byte, error) {
return []byte(n.String()), nil
}
// IsMergeKey returns whether it is a MergeKey node.
func (n *LiteralNode) IsMergeKey() bool {
return false
}
// MergeKeyNode type of merge key node
type MergeKeyNode struct {
*BaseNode
Token *token.Token
}
// Read implements (io.Reader).Read
func (n *MergeKeyNode) Read(p []byte) (int, error) {
return readNode(p, n)
}
// Type returns MergeKeyType
func (n *MergeKeyNode) Type() NodeType { return MergeKeyType }
// GetToken returns token instance
func (n *MergeKeyNode) GetToken() *token.Token {
return n.Token
}
// GetValue returns '<<' value
func (n *MergeKeyNode) GetValue() interface{} {
return n.Token.Value
}
// String returns '<<' value
func (n *MergeKeyNode) String() string {
return n.stringWithoutComment()
}
func (n *MergeKeyNode) stringWithoutComment() string {
return n.Token.Value
}
// AddColumn add column number to child nodes recursively
func (n *MergeKeyNode) AddColumn(col int) {
n.Token.AddColumn(col)
}
// MarshalYAML encodes to a YAML text
func (n *MergeKeyNode) MarshalYAML() ([]byte, error) {
return []byte(n.String()), nil
}
// IsMergeKey returns whether it is a MergeKey node.
func (n *MergeKeyNode) IsMergeKey() bool {
return true
}
// BoolNode type of boolean node
type BoolNode struct {
*BaseNode
Token *token.Token
Value bool
}
// Read implements (io.Reader).Read
func (n *BoolNode) Read(p []byte) (int, error) {
return readNode(p, n)
}
// Type returns BoolType
func (n *BoolNode) Type() NodeType { return BoolType }
// GetToken returns token instance
func (n *BoolNode) GetToken() *token.Token {
return n.Token
}
// AddColumn add column number to child nodes recursively
func (n *BoolNode) AddColumn(col int) {
n.Token.AddColumn(col)
}
// GetValue returns boolean value
func (n *BoolNode) GetValue() interface{} {
return n.Value
}
// String boolean to text
func (n *BoolNode) String() string {
if n.Comment != nil {
return addCommentString(n.Token.Value, n.Comment)
}
return n.stringWithoutComment()
}
func (n *BoolNode) stringWithoutComment() string {
return n.Token.Value
}
// MarshalYAML encodes to a YAML text
func (n *BoolNode) MarshalYAML() ([]byte, error) {
return []byte(n.String()), nil
}
// IsMergeKey returns whether it is a MergeKey node.
func (n *BoolNode) IsMergeKey() bool {
return false
}
// InfinityNode type of infinity node
type InfinityNode struct {
*BaseNode
Token *token.Token
Value float64
}
// Read implements (io.Reader).Read
func (n *InfinityNode) Read(p []byte) (int, error) {
return readNode(p, n)
}
// Type returns InfinityType
func (n *InfinityNode) Type() NodeType { return InfinityType }
// GetToken returns token instance
func (n *InfinityNode) GetToken() *token.Token {
return n.Token
}
// AddColumn add column number to child nodes recursively
func (n *InfinityNode) AddColumn(col int) {
n.Token.AddColumn(col)
}
// GetValue returns math.Inf(0) or math.Inf(-1)
func (n *InfinityNode) GetValue() interface{} {
return n.Value
}
// String infinity to text
func (n *InfinityNode) String() string {
if n.Comment != nil {
return addCommentString(n.Token.Value, n.Comment)
}
return n.stringWithoutComment()
}
func (n *InfinityNode) stringWithoutComment() string {
return n.Token.Value
}
// MarshalYAML encodes to a YAML text
func (n *InfinityNode) MarshalYAML() ([]byte, error) {
return []byte(n.String()), nil
}
// IsMergeKey returns whether it is a MergeKey node.
func (n *InfinityNode) IsMergeKey() bool {
return false
}
// NanNode type of nan node
type NanNode struct {
*BaseNode
Token *token.Token
}
// Read implements (io.Reader).Read
func (n *NanNode) Read(p []byte) (int, error) {
return readNode(p, n)
}
// Type returns NanType
func (n *NanNode) Type() NodeType { return NanType }
// GetToken returns token instance
func (n *NanNode) GetToken() *token.Token {
return n.Token
}
// AddColumn add column number to child nodes recursively
func (n *NanNode) AddColumn(col int) {
n.Token.AddColumn(col)
}
// GetValue returns math.NaN()
func (n *NanNode) GetValue() interface{} {
return math.NaN()
}
// String returns .nan
func (n *NanNode) String() string {
if n.Comment != nil {
return addCommentString(n.Token.Value, n.Comment)
}
return n.stringWithoutComment()
}
func (n *NanNode) stringWithoutComment() string {
return n.Token.Value
}
// MarshalYAML encodes to a YAML text
func (n *NanNode) MarshalYAML() ([]byte, error) {
return []byte(n.String()), nil
}
// IsMergeKey returns whether it is a MergeKey node.
func (n *NanNode) IsMergeKey() bool {
return false
}
// MapNode interface of MappingValueNode / MappingNode
type MapNode interface {
MapRange() *MapNodeIter
}
// MapNodeIter is an iterator for ranging over a MapNode
type MapNodeIter struct {
values []*MappingValueNode
idx int
}
const (
startRangeIndex = -1
)
// Next advances the map iterator and reports whether there is another entry.
// It returns false when the iterator is exhausted.
func (m *MapNodeIter) Next() bool {
m.idx++
next := m.idx < len(m.values)
return next
}
// Key returns the key of the iterator's current map node entry.
func (m *MapNodeIter) Key() MapKeyNode {
return m.values[m.idx].Key
}
// Value returns the value of the iterator's current map node entry.
func (m *MapNodeIter) Value() Node {
return m.values[m.idx].Value
}
// KeyValue returns the MappingValueNode of the iterator's current map node entry.
func (m *MapNodeIter) KeyValue() *MappingValueNode {
return m.values[m.idx]
}
// MappingNode type of mapping node
type MappingNode struct {
*BaseNode
Start *token.Token
End *token.Token
IsFlowStyle bool
Values []*MappingValueNode
FootComment *CommentGroupNode
}
func (n *MappingNode) startPos() *token.Position {
if len(n.Values) == 0 {
return n.Start.Position
}
return n.Values[0].Key.GetToken().Position
}
// Merge merge key/value of map.
func (n *MappingNode) Merge(target *MappingNode) {
keyToMapValueMap := map[string]*MappingValueNode{}
for _, value := range n.Values {
key := value.Key.String()
keyToMapValueMap[key] = value
}
column := n.startPos().Column - target.startPos().Column
target.AddColumn(column)
for _, value := range target.Values {
mapValue, exists := keyToMapValueMap[value.Key.String()]
if exists {
mapValue.Value = value.Value
} else {
n.Values = append(n.Values, value)
}
}
}
// SetIsFlowStyle set value to IsFlowStyle field recursively.
func (n *MappingNode) SetIsFlowStyle(isFlow bool) {
n.IsFlowStyle = isFlow
for _, value := range n.Values {
value.SetIsFlowStyle(isFlow)
}
}
// Read implements (io.Reader).Read
func (n *MappingNode) Read(p []byte) (int, error) {
return readNode(p, n)
}
// Type returns MappingType
func (n *MappingNode) Type() NodeType { return MappingType }
// GetToken returns token instance
func (n *MappingNode) GetToken() *token.Token {
return n.Start
}
// AddColumn add column number to child nodes recursively
func (n *MappingNode) AddColumn(col int) {
n.Start.AddColumn(col)
n.End.AddColumn(col)
for _, value := range n.Values {
value.AddColumn(col)
}
}
func (n *MappingNode) flowStyleString(commentMode bool) string {
values := []string{}
for _, value := range n.Values {
values = append(values, strings.TrimLeft(value.String(), " "))
}
mapText := fmt.Sprintf("{%s}", strings.Join(values, ", "))
if commentMode && n.Comment != nil {
return addCommentString(mapText, n.Comment)
}
return mapText
}
func (n *MappingNode) blockStyleString(commentMode bool) string {
values := []string{}
for _, value := range n.Values {
values = append(values, value.String())
}
mapText := strings.Join(values, "\n")
if commentMode && n.Comment != nil {
value := values[0]
var spaceNum int
for i := 0; i < len(value); i++ {
if value[i] != ' ' {
break
}
spaceNum++
}
comment := n.Comment.StringWithSpace(spaceNum)
return fmt.Sprintf("%s\n%s", comment, mapText)
}
return mapText
}
// String mapping values to text
func (n *MappingNode) String() string {
if len(n.Values) == 0 {
if n.Comment != nil {
return addCommentString("{}", n.Comment)
}
return "{}"
}
commentMode := true
if n.IsFlowStyle || len(n.Values) == 0 {
return n.flowStyleString(commentMode)
}
return n.blockStyleString(commentMode)
}
// MapRange implements MapNode protocol
func (n *MappingNode) MapRange() *MapNodeIter {
return &MapNodeIter{
idx: startRangeIndex,
values: n.Values,
}
}
// MarshalYAML encodes to a YAML text
func (n *MappingNode) MarshalYAML() ([]byte, error) {
return []byte(n.String()), nil
}
// MappingKeyNode type of tag node
type MappingKeyNode struct {
*BaseNode
Start *token.Token
Value Node
}
// Read implements (io.Reader).Read
func (n *MappingKeyNode) Read(p []byte) (int, error) {
return readNode(p, n)
}
// Type returns MappingKeyType
func (n *MappingKeyNode) Type() NodeType { return MappingKeyType }
// GetToken returns token instance
func (n *MappingKeyNode) GetToken() *token.Token {
return n.Start
}
// AddColumn add column number to child nodes recursively
func (n *MappingKeyNode) AddColumn(col int) {
n.Start.AddColumn(col)
if n.Value != nil {
n.Value.AddColumn(col)
}
}
// String tag to text
func (n *MappingKeyNode) String() string {
return n.stringWithoutComment()
}
func (n *MappingKeyNode) stringWithoutComment() string {
return fmt.Sprintf("%s %s", n.Start.Value, n.Value.String())
}
// MarshalYAML encodes to a YAML text
func (n *MappingKeyNode) MarshalYAML() ([]byte, error) {
return []byte(n.String()), nil
}
// IsMergeKey returns whether it is a MergeKey node.
func (n *MappingKeyNode) IsMergeKey() bool {
if n.Value == nil {
return false
}
key, ok := n.Value.(MapKeyNode)
if !ok {
return false
}
return key.IsMergeKey()
}
// MappingValueNode type of mapping value
type MappingValueNode struct {
*BaseNode
Start *token.Token // delimiter token ':'.
CollectEntry *token.Token // collect entry token ','.
Key MapKeyNode
Value Node
FootComment *CommentGroupNode
IsFlowStyle bool
}
// Replace replace value node.
func (n *MappingValueNode) Replace(value Node) error {
column := n.Value.GetToken().Position.Column - value.GetToken().Position.Column
value.AddColumn(column)
n.Value = value
return nil
}
// Read implements (io.Reader).Read
func (n *MappingValueNode) Read(p []byte) (int, error) {
return readNode(p, n)
}
// Type returns MappingValueType
func (n *MappingValueNode) Type() NodeType { return MappingValueType }
// GetToken returns token instance
func (n *MappingValueNode) GetToken() *token.Token {
return n.Start
}
// AddColumn add column number to child nodes recursively
func (n *MappingValueNode) AddColumn(col int) {
n.Start.AddColumn(col)
if n.Key != nil {
n.Key.AddColumn(col)
}
if n.Value != nil {
n.Value.AddColumn(col)
}
}
// SetIsFlowStyle set value to IsFlowStyle field recursively.
func (n *MappingValueNode) SetIsFlowStyle(isFlow bool) {
n.IsFlowStyle = isFlow
switch value := n.Value.(type) {
case *MappingNode:
value.SetIsFlowStyle(isFlow)
case *MappingValueNode:
value.SetIsFlowStyle(isFlow)
case *SequenceNode:
value.SetIsFlowStyle(isFlow)
}
}
// String mapping value to text
func (n *MappingValueNode) String() string {
var text string
if n.Comment != nil {
text = fmt.Sprintf(
"%s\n%s",
n.Comment.StringWithSpace(n.Key.GetToken().Position.Column-1),
n.toString(),
)
} else {
text = n.toString()
}
if n.FootComment != nil {
text += fmt.Sprintf("\n%s", n.FootComment.StringWithSpace(n.Key.GetToken().Position.Column-1))
}
return text
}
func (n *MappingValueNode) toString() string {
space := strings.Repeat(" ", n.Key.GetToken().Position.Column-1)
if checkLineBreak(n.Key.GetToken()) {
space = fmt.Sprintf("%s%s", "\n", space)
}
keyIndentLevel := n.Key.GetToken().Position.IndentLevel
valueIndentLevel := n.Value.GetToken().Position.IndentLevel
keyComment := n.Key.GetComment()
if _, ok := n.Value.(ScalarNode); ok {
value := n.Value.String()
if value == "" {
// implicit null value.
return fmt.Sprintf("%s%s:", space, n.Key.String())
}
return fmt.Sprintf("%s%s: %s", space, n.Key.String(), value)
} else if keyIndentLevel < valueIndentLevel && !n.IsFlowStyle {
if keyComment != nil {
return fmt.Sprintf(
"%s%s: %s\n%s",
space,
n.Key.stringWithoutComment(),
keyComment.String(),
n.Value.String(),
)
}
return fmt.Sprintf("%s%s:\n%s", space, n.Key.String(), n.Value.String())
} else if m, ok := n.Value.(*MappingNode); ok && (m.IsFlowStyle || len(m.Values) == 0) {
return fmt.Sprintf("%s%s: %s", space, n.Key.String(), n.Value.String())
} else if s, ok := n.Value.(*SequenceNode); ok && (s.IsFlowStyle || len(s.Values) == 0) {
return fmt.Sprintf("%s%s: %s", space, n.Key.String(), n.Value.String())
} else if _, ok := n.Value.(*AnchorNode); ok {
return fmt.Sprintf("%s%s: %s", space, n.Key.String(), n.Value.String())
} else if _, ok := n.Value.(*AliasNode); ok {
return fmt.Sprintf("%s%s: %s", space, n.Key.String(), n.Value.String())
} else if _, ok := n.Value.(*TagNode); ok {
return fmt.Sprintf("%s%s: %s", space, n.Key.String(), n.Value.String())
}
if keyComment != nil {
return fmt.Sprintf(
"%s%s: %s\n%s",
space,
n.Key.stringWithoutComment(),
keyComment.String(),
n.Value.String(),
)
}
if m, ok := n.Value.(*MappingNode); ok && m.Comment != nil {
return fmt.Sprintf(
"%s%s: %s",
space,
n.Key.String(),
strings.TrimLeft(n.Value.String(), " "),
)
}
return fmt.Sprintf("%s%s:\n%s", space, n.Key.String(), n.Value.String())
}
// MapRange implements MapNode protocol
func (n *MappingValueNode) MapRange() *MapNodeIter {
return &MapNodeIter{
idx: startRangeIndex,
values: []*MappingValueNode{n},
}
}
// MarshalYAML encodes to a YAML text
func (n *MappingValueNode) MarshalYAML() ([]byte, error) {
return []byte(n.String()), nil
}
// ArrayNode interface of SequenceNode
type ArrayNode interface {
ArrayRange() *ArrayNodeIter
}
// ArrayNodeIter is an iterator for ranging over a ArrayNode
type ArrayNodeIter struct {
values []Node
idx int
}
// Next advances the array iterator and reports whether there is another entry.
// It returns false when the iterator is exhausted.
func (m *ArrayNodeIter) Next() bool {
m.idx++
next := m.idx < len(m.values)
return next
}
// Value returns the value of the iterator's current array entry.
func (m *ArrayNodeIter) Value() Node {
return m.values[m.idx]
}
// Len returns length of array
func (m *ArrayNodeIter) Len() int {
return len(m.values)
}
// SequenceNode type of sequence node
type SequenceNode struct {
*BaseNode
Start *token.Token
End *token.Token
IsFlowStyle bool
Values []Node
ValueHeadComments []*CommentGroupNode
Entries []*SequenceEntryNode
FootComment *CommentGroupNode
}
// Replace replace value node.
func (n *SequenceNode) Replace(idx int, value Node) error {
if len(n.Values) <= idx {
return fmt.Errorf(
"invalid index for sequence: sequence length is %d, but specified %d index",
len(n.Values), idx,
)
}
column := n.Values[idx].GetToken().Position.Column - value.GetToken().Position.Column
value.AddColumn(column)
n.Values[idx] = value
return nil
}
// Merge merge sequence value.
func (n *SequenceNode) Merge(target *SequenceNode) {
column := n.Start.Position.Column - target.Start.Position.Column
target.AddColumn(column)
n.Values = append(n.Values, target.Values...)
if len(target.ValueHeadComments) == 0 {
n.ValueHeadComments = append(n.ValueHeadComments, make([]*CommentGroupNode, len(target.Values))...)
return
}
n.ValueHeadComments = append(n.ValueHeadComments, target.ValueHeadComments...)
}
// SetIsFlowStyle set value to IsFlowStyle field recursively.
func (n *SequenceNode) SetIsFlowStyle(isFlow bool) {
n.IsFlowStyle = isFlow
for _, value := range n.Values {
switch value := value.(type) {
case *MappingNode:
value.SetIsFlowStyle(isFlow)
case *MappingValueNode:
value.SetIsFlowStyle(isFlow)
case *SequenceNode:
value.SetIsFlowStyle(isFlow)
}
}
}
// Read implements (io.Reader).Read
func (n *SequenceNode) Read(p []byte) (int, error) {
return readNode(p, n)
}
// Type returns SequenceType
func (n *SequenceNode) Type() NodeType { return SequenceType }
// GetToken returns token instance
func (n *SequenceNode) GetToken() *token.Token {
return n.Start
}
// AddColumn add column number to child nodes recursively
func (n *SequenceNode) AddColumn(col int) {
n.Start.AddColumn(col)
n.End.AddColumn(col)
for _, value := range n.Values {
value.AddColumn(col)
}
}
func (n *SequenceNode) flowStyleString() string {
values := []string{}
for _, value := range n.Values {
values = append(values, value.String())
}
return fmt.Sprintf("[%s]", strings.Join(values, ", "))
}
func (n *SequenceNode) blockStyleString() string {
space := strings.Repeat(" ", n.Start.Position.Column-1)
values := []string{}
if n.Comment != nil {
values = append(values, n.Comment.StringWithSpace(n.Start.Position.Column-1))
}
for idx, value := range n.Values {
if value == nil {
continue
}
valueStr := value.String()
newLinePrefix := ""
if strings.HasPrefix(valueStr, "\n") {
valueStr = valueStr[1:]
newLinePrefix = "\n"
}
splittedValues := strings.Split(valueStr, "\n")
trimmedFirstValue := strings.TrimLeft(splittedValues[0], " ")
diffLength := len(splittedValues[0]) - len(trimmedFirstValue)
if len(splittedValues) > 1 && value.Type() == StringType || value.Type() == LiteralType {
// If multi-line string, the space characters for indent have already been added, so delete them.
prefix := space + " "
for i := 1; i < len(splittedValues); i++ {
splittedValues[i] = strings.TrimPrefix(splittedValues[i], prefix)
}
}
newValues := []string{trimmedFirstValue}
for i := 1; i < len(splittedValues); i++ {
if len(splittedValues[i]) <= diffLength {
// this line is \n or white space only
newValues = append(newValues, "")
continue
}
trimmed := splittedValues[i][diffLength:]
newValues = append(newValues, fmt.Sprintf("%s %s", space, trimmed))
}
newValue := strings.Join(newValues, "\n")
if len(n.ValueHeadComments) == len(n.Values) && n.ValueHeadComments[idx] != nil {
values = append(values, fmt.Sprintf("%s%s", newLinePrefix, n.ValueHeadComments[idx].StringWithSpace(n.Start.Position.Column-1)))
newLinePrefix = ""
}
values = append(values, fmt.Sprintf("%s%s- %s", newLinePrefix, space, newValue))
}
if n.FootComment != nil {
values = append(values, n.FootComment.StringWithSpace(n.Start.Position.Column-1))
}
return strings.Join(values, "\n")
}
// String sequence to text
func (n *SequenceNode) String() string {
if n.IsFlowStyle || len(n.Values) == 0 {
return n.flowStyleString()
}
return n.blockStyleString()
}
// ArrayRange implements ArrayNode protocol
func (n *SequenceNode) ArrayRange() *ArrayNodeIter {
return &ArrayNodeIter{
idx: startRangeIndex,
values: n.Values,
}
}
// MarshalYAML encodes to a YAML text
func (n *SequenceNode) MarshalYAML() ([]byte, error) {
return []byte(n.String()), nil
}
// SequenceEntryNode is the sequence entry.
type SequenceEntryNode struct {
*BaseNode
HeadComment *CommentGroupNode // head comment.
LineComment *CommentGroupNode // line comment e.g.) - # comment.
Start *token.Token // entry token.
Value Node // value node.
}
// String node to text
func (n *SequenceEntryNode) String() string {
return "" // TODO
}
// GetToken returns token instance
func (n *SequenceEntryNode) GetToken() *token.Token {
return n.Start
}
// Type returns type of node
func (n *SequenceEntryNode) Type() NodeType {
return SequenceEntryType
}
// AddColumn add column number to child nodes recursively
func (n *SequenceEntryNode) AddColumn(col int) {
n.Start.AddColumn(col)
}
// SetComment set line comment.
func (n *SequenceEntryNode) SetComment(cm *CommentGroupNode) error {
n.LineComment = cm
return nil
}
// Comment returns comment token instance
func (n *SequenceEntryNode) GetComment() *CommentGroupNode {
return n.LineComment
}
// MarshalYAML
func (n *SequenceEntryNode) MarshalYAML() ([]byte, error) {
return []byte(n.String()), nil
}
func (n *SequenceEntryNode) Read(p []byte) (int, error) {
return readNode(p, n)
}
// SequenceEntry creates SequenceEntryNode instance.
func SequenceEntry(start *token.Token, value Node, headComment *CommentGroupNode) *SequenceEntryNode {
return &SequenceEntryNode{
BaseNode: &BaseNode{},
HeadComment: headComment,
Start: start,
Value: value,
}
}
// SequenceMergeValue creates SequenceMergeValueNode instance.
func SequenceMergeValue(values ...MapNode) *SequenceMergeValueNode {
return &SequenceMergeValueNode{
values: values,
}
}
// SequenceMergeValueNode is used to convert the Sequence node specified for the merge key into a MapNode format.
type SequenceMergeValueNode struct {
values []MapNode
}
// MapRange returns MapNodeIter instance.
func (n *SequenceMergeValueNode) MapRange() *MapNodeIter {
ret := &MapNodeIter{idx: startRangeIndex}
for _, value := range n.values {
iter := value.MapRange()
ret.values = append(ret.values, iter.values...)
}
return ret
}
// AnchorNode type of anchor node
type AnchorNode struct {
*BaseNode
Start *token.Token
Name Node
Value Node
}
func (n *AnchorNode) stringWithoutComment() string {
return n.Value.String()
}
func (n *AnchorNode) SetName(name string) error {
if n.Name == nil {
return ErrInvalidAnchorName
}
s, ok := n.Name.(*StringNode)
if !ok {
return ErrInvalidAnchorName
}
s.Value = name
return nil
}
// Read implements (io.Reader).Read
func (n *AnchorNode) Read(p []byte) (int, error) {
return readNode(p, n)
}
// Type returns AnchorType
func (n *AnchorNode) Type() NodeType { return AnchorType }
// GetToken returns token instance
func (n *AnchorNode) GetToken() *token.Token {
return n.Start
}
func (n *AnchorNode) GetValue() any {
return n.Value.GetToken().Value
}
// AddColumn add column number to child nodes recursively
func (n *AnchorNode) AddColumn(col int) {
n.Start.AddColumn(col)
if n.Name != nil {
n.Name.AddColumn(col)
}
if n.Value != nil {
n.Value.AddColumn(col)
}
}
// String anchor to text
func (n *AnchorNode) String() string {
anchor := "&" + n.Name.String()
value := n.Value.String()
if s, ok := n.Value.(*SequenceNode); ok && !s.IsFlowStyle {
return fmt.Sprintf("%s\n%s", anchor, value)
} else if m, ok := n.Value.(*MappingNode); ok && !m.IsFlowStyle {
return fmt.Sprintf("%s\n%s", anchor, value)
}
if value == "" {
// implicit null value.
return anchor
}
return fmt.Sprintf("%s %s", anchor, value)
}
// MarshalYAML encodes to a YAML text
func (n *AnchorNode) MarshalYAML() ([]byte, error) {
return []byte(n.String()), nil
}
// IsMergeKey returns whether it is a MergeKey node.
func (n *AnchorNode) IsMergeKey() bool {
if n.Value == nil {
return false
}
key, ok := n.Value.(MapKeyNode)
if !ok {
return false
}
return key.IsMergeKey()
}
// AliasNode type of alias node
type AliasNode struct {
*BaseNode
Start *token.Token
Value Node
}
func (n *AliasNode) stringWithoutComment() string {
return n.Value.String()
}
func (n *AliasNode) SetName(name string) error {
if n.Value == nil {
return ErrInvalidAliasName
}
s, ok := n.Value.(*StringNode)
if !ok {
return ErrInvalidAliasName
}
s.Value = name
return nil
}
// Read implements (io.Reader).Read
func (n *AliasNode) Read(p []byte) (int, error) {
return readNode(p, n)
}
// Type returns AliasType
func (n *AliasNode) Type() NodeType { return AliasType }
// GetToken returns token instance
func (n *AliasNode) GetToken() *token.Token {
return n.Start
}
func (n *AliasNode) GetValue() any {
return n.Value.GetToken().Value
}
// AddColumn add column number to child nodes recursively
func (n *AliasNode) AddColumn(col int) {
n.Start.AddColumn(col)
if n.Value != nil {
n.Value.AddColumn(col)
}
}
// String alias to text
func (n *AliasNode) String() string {
return fmt.Sprintf("*%s", n.Value.String())
}
// MarshalYAML encodes to a YAML text
func (n *AliasNode) MarshalYAML() ([]byte, error) {
return []byte(n.String()), nil
}
// IsMergeKey returns whether it is a MergeKey node.
func (n *AliasNode) IsMergeKey() bool {
return false
}
// DirectiveNode type of directive node
type DirectiveNode struct {
*BaseNode
// Start is '%' token.
Start *token.Token
// Name is directive name e.g.) "YAML" or "TAG".
Name Node
// Values is directive values e.g.) "1.2" or "!!" and "tag:clarkevans.com,2002:app/".
Values []Node
}
// Read implements (io.Reader).Read
func (n *DirectiveNode) Read(p []byte) (int, error) {
return readNode(p, n)
}
// Type returns DirectiveType
func (n *DirectiveNode) Type() NodeType { return DirectiveType }
// GetToken returns token instance
func (n *DirectiveNode) GetToken() *token.Token {
return n.Start
}
// AddColumn add column number to child nodes recursively
func (n *DirectiveNode) AddColumn(col int) {
if n.Name != nil {
n.Name.AddColumn(col)
}
for _, value := range n.Values {
value.AddColumn(col)
}
}
// String directive to text
func (n *DirectiveNode) String() string {
values := make([]string, 0, len(n.Values))
for _, val := range n.Values {
values = append(values, val.String())
}
return strings.Join(append([]string{"%" + n.Name.String()}, values...), " ")
}
// MarshalYAML encodes to a YAML text
func (n *DirectiveNode) MarshalYAML() ([]byte, error) {
return []byte(n.String()), nil
}
// TagNode type of tag node
type TagNode struct {
*BaseNode
Directive *DirectiveNode
Start *token.Token
Value Node
}
func (n *TagNode) GetValue() any {
scalar, ok := n.Value.(ScalarNode)
if !ok {
return nil
}
return scalar.GetValue()
}
func (n *TagNode) stringWithoutComment() string {
return n.Value.String()
}
// Read implements (io.Reader).Read
func (n *TagNode) Read(p []byte) (int, error) {
return readNode(p, n)
}
// Type returns TagType
func (n *TagNode) Type() NodeType { return TagType }
// GetToken returns token instance
func (n *TagNode) GetToken() *token.Token {
return n.Start
}
// AddColumn add column number to child nodes recursively
func (n *TagNode) AddColumn(col int) {
n.Start.AddColumn(col)
if n.Value != nil {
n.Value.AddColumn(col)
}
}
// String tag to text
func (n *TagNode) String() string {
value := n.Value.String()
if s, ok := n.Value.(*SequenceNode); ok && !s.IsFlowStyle {
return fmt.Sprintf("%s\n%s", n.Start.Value, value)
} else if m, ok := n.Value.(*MappingNode); ok && !m.IsFlowStyle {
return fmt.Sprintf("%s\n%s", n.Start.Value, value)
}
return fmt.Sprintf("%s %s", n.Start.Value, value)
}
// MarshalYAML encodes to a YAML text
func (n *TagNode) MarshalYAML() ([]byte, error) {
return []byte(n.String()), nil
}
// IsMergeKey returns whether it is a MergeKey node.
func (n *TagNode) IsMergeKey() bool {
if n.Value == nil {
return false
}
key, ok := n.Value.(MapKeyNode)
if !ok {
return false
}
return key.IsMergeKey()
}
func (n *TagNode) ArrayRange() *ArrayNodeIter {
arr, ok := n.Value.(ArrayNode)
if !ok {
return nil
}
return arr.ArrayRange()
}
// CommentNode type of comment node
type CommentNode struct {
*BaseNode
Token *token.Token
}
// Read implements (io.Reader).Read
func (n *CommentNode) Read(p []byte) (int, error) {
return readNode(p, n)
}
// Type returns TagType
func (n *CommentNode) Type() NodeType { return CommentType }
// GetToken returns token instance
func (n *CommentNode) GetToken() *token.Token { return n.Token }
// AddColumn add column number to child nodes recursively
func (n *CommentNode) AddColumn(col int) {
if n.Token == nil {
return
}
n.Token.AddColumn(col)
}
// String comment to text
func (n *CommentNode) String() string {
return fmt.Sprintf("#%s", n.Token.Value)
}
// MarshalYAML encodes to a YAML text
func (n *CommentNode) MarshalYAML() ([]byte, error) {
return []byte(n.String()), nil
}
// CommentGroupNode type of comment node
type CommentGroupNode struct {
*BaseNode
Comments []*CommentNode
}
// Read implements (io.Reader).Read
func (n *CommentGroupNode) Read(p []byte) (int, error) {
return readNode(p, n)
}
// Type returns TagType
func (n *CommentGroupNode) Type() NodeType { return CommentType }
// GetToken returns token instance
func (n *CommentGroupNode) GetToken() *token.Token {
if len(n.Comments) > 0 {
return n.Comments[0].Token
}
return nil
}
// AddColumn add column number to child nodes recursively
func (n *CommentGroupNode) AddColumn(col int) {
for _, comment := range n.Comments {
comment.AddColumn(col)
}
}
// String comment to text
func (n *CommentGroupNode) String() string {
values := []string{}
for _, comment := range n.Comments {
values = append(values, comment.String())
}
return strings.Join(values, "\n")
}
func (n *CommentGroupNode) StringWithSpace(col int) string {
values := []string{}
space := strings.Repeat(" ", col)
for _, comment := range n.Comments {
space := space
if checkLineBreak(comment.Token) {
space = fmt.Sprintf("%s%s", "\n", space)
}
values = append(values, space+comment.String())
}
return strings.Join(values, "\n")
}
// MarshalYAML encodes to a YAML text
func (n *CommentGroupNode) MarshalYAML() ([]byte, error) {
return []byte(n.String()), nil
}
// Visitor has Visit method that is invokded for each node encountered by Walk.
// If the result visitor w is not nil, Walk visits each of the children of node with the visitor w,
// followed by a call of w.Visit(nil).
type Visitor interface {
Visit(Node) Visitor
}
// Walk traverses an AST in depth-first order: It starts by calling v.Visit(node); node must not be nil.
// If the visitor w returned by v.Visit(node) is not nil,
// Walk is invoked recursively with visitor w for each of the non-nil children of node,
// followed by a call of w.Visit(nil).
func Walk(v Visitor, node Node) {
if v = v.Visit(node); v == nil {
return
}
switch n := node.(type) {
case *CommentNode:
case *NullNode:
walkComment(v, n.BaseNode)
case *IntegerNode:
walkComment(v, n.BaseNode)
case *FloatNode:
walkComment(v, n.BaseNode)
case *StringNode:
walkComment(v, n.BaseNode)
case *MergeKeyNode:
walkComment(v, n.BaseNode)
case *BoolNode:
walkComment(v, n.BaseNode)
case *InfinityNode:
walkComment(v, n.BaseNode)
case *NanNode:
walkComment(v, n.BaseNode)
case *LiteralNode:
walkComment(v, n.BaseNode)
Walk(v, n.Value)
case *DirectiveNode:
walkComment(v, n.BaseNode)
Walk(v, n.Name)
for _, value := range n.Values {
Walk(v, value)
}
case *TagNode:
walkComment(v, n.BaseNode)
Walk(v, n.Value)
case *DocumentNode:
walkComment(v, n.BaseNode)
Walk(v, n.Body)
case *MappingNode:
walkComment(v, n.BaseNode)
for _, value := range n.Values {
Walk(v, value)
}
case *MappingKeyNode:
walkComment(v, n.BaseNode)
Walk(v, n.Value)
case *MappingValueNode:
walkComment(v, n.BaseNode)
Walk(v, n.Key)
Walk(v, n.Value)
case *SequenceNode:
walkComment(v, n.BaseNode)
for _, value := range n.Values {
Walk(v, value)
}
case *AnchorNode:
walkComment(v, n.BaseNode)
Walk(v, n.Name)
Walk(v, n.Value)
case *AliasNode:
walkComment(v, n.BaseNode)
Walk(v, n.Value)
}
}
func walkComment(v Visitor, base *BaseNode) {
if base == nil {
return
}
if base.Comment == nil {
return
}
Walk(v, base.Comment)
}
type filterWalker struct {
typ NodeType
results []Node
}
func (v *filterWalker) Visit(n Node) Visitor {
if v.typ == n.Type() {
v.results = append(v.results, n)
}
return v
}
type parentFinder struct {
target Node
}
func (f *parentFinder) walk(parent, node Node) Node {
if f.target == node {
return parent
}
switch n := node.(type) {
case *CommentNode:
return nil
case *NullNode:
return nil
case *IntegerNode:
return nil
case *FloatNode:
return nil
case *StringNode:
return nil
case *MergeKeyNode:
return nil
case *BoolNode:
return nil
case *InfinityNode:
return nil
case *NanNode:
return nil
case *LiteralNode:
return f.walk(node, n.Value)
case *DirectiveNode:
if found := f.walk(node, n.Name); found != nil {
return found
}
for _, value := range n.Values {
if found := f.walk(node, value); found != nil {
return found
}
}
case *TagNode:
return f.walk(node, n.Value)
case *DocumentNode:
return f.walk(node, n.Body)
case *MappingNode:
for _, value := range n.Values {
if found := f.walk(node, value); found != nil {
return found
}
}
case *MappingKeyNode:
return f.walk(node, n.Value)
case *MappingValueNode:
if found := f.walk(node, n.Key); found != nil {
return found
}
return f.walk(node, n.Value)
case *SequenceNode:
for _, value := range n.Values {
if found := f.walk(node, value); found != nil {
return found
}
}
case *AnchorNode:
if found := f.walk(node, n.Name); found != nil {
return found
}
return f.walk(node, n.Value)
case *AliasNode:
return f.walk(node, n.Value)
}
return nil
}
// Parent get parent node from child node.
func Parent(root, child Node) Node {
finder := &parentFinder{target: child}
return finder.walk(root, root)
}
// Filter returns a list of nodes that match the given type.
func Filter(typ NodeType, node Node) []Node {
walker := &filterWalker{typ: typ}
Walk(walker, node)
return walker.results
}
// FilterFile returns a list of nodes that match the given type.
func FilterFile(typ NodeType, file *File) []Node {
results := []Node{}
for _, doc := range file.Docs {
walker := &filterWalker{typ: typ}
Walk(walker, doc)
results = append(results, walker.results...)
}
return results
}
type ErrInvalidMergeType struct {
dst Node
src Node
}
func (e *ErrInvalidMergeType) Error() string {
return fmt.Sprintf("cannot merge %s into %s", e.src.Type(), e.dst.Type())
}
// Merge merge document, map, sequence node.
func Merge(dst Node, src Node) error {
if doc, ok := src.(*DocumentNode); ok {
src = doc.Body
}
err := &ErrInvalidMergeType{dst: dst, src: src}
switch dst.Type() {
case DocumentType:
node, _ := dst.(*DocumentNode)
return Merge(node.Body, src)
case MappingType:
node, _ := dst.(*MappingNode)
target, ok := src.(*MappingNode)
if !ok {
return err
}
node.Merge(target)
return nil
case SequenceType:
node, _ := dst.(*SequenceNode)
target, ok := src.(*SequenceNode)
if !ok {
return err
}
node.Merge(target)
return nil
}
return err
}
goccy-go-yaml-52dacb8/ast/ast_test.go 0000664 0000000 0000000 00000001531 15015766371 0017632 0 ustar 00root root 0000000 0000000 package ast
import (
"testing"
"github.com/goccy/go-yaml/token"
)
func TestEscapeSingleQuote(t *testing.T) {
expected := `'Victor''s victory'`
got := escapeSingleQuote("Victor's victory")
if got != expected {
t.Fatalf("expected:%s\ngot:%s", expected, got)
}
}
func TestReadNode(t *testing.T) {
t.Run("utf-8", func(t *testing.T) {
value := "éɛทᛞ⠻チ▓🦄"
node := &StringNode{
BaseNode: &BaseNode{},
Token: &token.Token{},
Value: value,
}
expectedSize := len(value)
gotBuffer := make([]byte, expectedSize)
expectedBuffer := []byte(value)
gotSize, _ := readNode(gotBuffer, node)
if gotSize != expectedSize {
t.Fatalf("expected size:%d\ngot:%d", expectedSize, gotSize)
}
if string(gotBuffer) != string(expectedBuffer) {
t.Fatalf("expected buffer:%s\ngot:%s", expectedBuffer, gotBuffer)
}
})
}
goccy-go-yaml-52dacb8/benchmarks/ 0000775 0000000 0000000 00000000000 15015766371 0017003 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/benchmarks/benchmark_test.go 0000664 0000000 0000000 00000001657 15015766371 0022334 0 ustar 00root root 0000000 0000000 package benchmarks
import (
"testing"
"github.com/goccy/go-yaml"
goyaml2 "gopkg.in/yaml.v2"
goyaml3 "gopkg.in/yaml.v3"
)
func Benchmark(b *testing.B) {
const src = `---
id: 1
message: Hello, World
verified: true
elements:
- one
- 0.02
- null
- -inf
`
type T struct {
ID int `yaml:"id"`
Message string `yaml:"message"`
Verified bool `yaml:"verified,omitempty"`
}
b.Run("gopkg.in/yaml.v2", func(b *testing.B) {
var t T
for i := 0; i < b.N; i++ {
if err := goyaml2.Unmarshal([]byte(src), &t); err != nil {
b.Fatal(err)
}
}
})
b.Run("gopkg.in/yaml.v3", func(b *testing.B) {
var t T
for i := 0; i < b.N; i++ {
if err := goyaml3.Unmarshal([]byte(src), &t); err != nil {
b.Fatal(err)
}
}
})
b.Run("github.com/goccy/go-yaml", func(b *testing.B) {
var t T
for i := 0; i < b.N; i++ {
if err := yaml.Unmarshal([]byte(src), &t); err != nil {
b.Fatal(err)
}
}
})
}
goccy-go-yaml-52dacb8/benchmarks/go.mod 0000664 0000000 0000000 00000000332 15015766371 0020107 0 ustar 00root root 0000000 0000000 module github.com/goccy/go-yaml/benchmarks
go 1.21.0
replace github.com/goccy/go-yaml => ..
require (
github.com/goccy/go-yaml v0.0.0-00010101000000-000000000000
gopkg.in/yaml.v2 v2.4.0
gopkg.in/yaml.v3 v3.0.1
)
goccy-go-yaml-52dacb8/benchmarks/go.sum 0000664 0000000 0000000 00000000777 15015766371 0020151 0 ustar 00root root 0000000 0000000 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
goccy-go-yaml-52dacb8/cmd/ 0000775 0000000 0000000 00000000000 15015766371 0015431 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/cmd/ycat/ 0000775 0000000 0000000 00000000000 15015766371 0016371 5 ustar 00root root 0000000 0000000 goccy-go-yaml-52dacb8/cmd/ycat/go.mod 0000664 0000000 0000000 00000000524 15015766371 0017500 0 ustar 00root root 0000000 0000000 module github.com/goccy/go-yaml/cmd/ycat
go 1.21.0
require (
github.com/fatih/color v1.18.0
github.com/goccy/go-yaml v0.0.0-00010101000000-000000000000
github.com/mattn/go-colorable v0.1.13
)
require (
github.com/mattn/go-isatty v0.0.20 // indirect
golang.org/x/sys v0.26.0 // indirect
)
replace github.com/goccy/go-yaml => ../../
goccy-go-yaml-52dacb8/cmd/ycat/go.sum 0000664 0000000 0000000 00000004743 15015766371 0017534 0 ustar 00root root 0000000 0000000 github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM=
github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU=
github.com/gabriel-vasile/mimetype v1.4.3 h1:in2uUcidCuFcDKtdcBxlR0rJ1+fsokWf+uqxgUFjbI0=
github.com/gabriel-vasile/mimetype v1.4.3/go.mod h1:d8uq/6HKRL6CGdk+aubisF/M5GcPfT7nKyLpA0lbSSk=
github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA=
github.com/go-playground/locales v0.14.1/go.mod h1:hxrqLVvrK65+Rwrd5Fc6F2O76J/NuW9t0sjnWqG1slY=
github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJnYK9S473LQFuzCbDbfSFY=
github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY=
github.com/go-playground/validator/v10 v10.22.1 h1:40JcKH+bBNGFczGuoBYgX4I6m/i27HYW8P9FDk5PbgA=
github.com/go-playground/validator/v10 v10.22.1/go.mod h1:dbuPbCMFw/DrkbEynArYaCwl3amGuJotoKCe95atGMM=
github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
github.com/leodido/go-urn v1.4.0 h1:WT9HwE9SGECu3lg4d/dIA+jxlljEa1/ffXKmRjqdmIQ=
github.com/leodido/go-urn v1.4.0/go.mod h1:bvxc+MVxLKB4z00jd1z+Dvzr47oO32F/QSNjSBOlFxI=
github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
golang.org/x/crypto v0.28.0 h1:GBDwsMXVQi34v5CCYUm2jkJvu4cbtru2U4TN2PSyQnw=
golang.org/x/crypto v0.28.0/go.mod h1:rmgy+3RHxRZMyY0jjAJShp2zgEdOqj2AO7U0pYmeQ7U=
golang.org/x/net v0.30.0 h1:AcW1SDZMkb8IpzCdQUaIq2sP4sZ4zw+55h6ynffypl4=
golang.org/x/net v0.30.0/go.mod h1:2wGyMJ5iFasEhkwi13ChkO/t1ECNC4X4eBKkVFyYFlU=
golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.26.0 h1:KHjCJyddX0LoSTb3J+vWpupP9p0oznkqVk/IfjymZbo=
golang.org/x/sys v0.26.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
golang.org/x/text v0.19.0 h1:kTxAhCbGbxhK0IwgSKiMO5awPoDQ0RpfiVYBfK860YM=
golang.org/x/text v0.19.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY=
goccy-go-yaml-52dacb8/cmd/ycat/ycat.go 0000664 0000000 0000000 00000003674 15015766371 0017672 0 ustar 00root root 0000000 0000000 package main
import (
"errors"
"fmt"
"os"
"github.com/fatih/color"
"github.com/mattn/go-colorable"
"github.com/goccy/go-yaml"
"github.com/goccy/go-yaml/lexer"
"github.com/goccy/go-yaml/printer"
)
const escape = "\x1b"
func format(attr color.Attribute) string {
return fmt.Sprintf("%s[%dm", escape, attr)
}
func _main(args []string) error {
if len(args) < 2 {
return errors.New("ycat: usage: ycat file.yml")
}
filename := args[1]
bytes, err := os.ReadFile(filename)
if err != nil {
return err
}
tokens := lexer.Tokenize(string(bytes))
var p printer.Printer
p.LineNumber = true
p.LineNumberFormat = func(num int) string {
fn := color.New(color.Bold, color.FgHiWhite).SprintFunc()
return fn(fmt.Sprintf("%2d | ", num))
}
p.Bool = func() *printer.Property {
return &printer.Property{
Prefix: format(color.FgHiMagenta),
Suffix: format(color.Reset),
}
}
p.Number = func() *printer.Property {
return &printer.Property{
Prefix: format(color.FgHiMagenta),
Suffix: format(color.Reset),
}
}
p.MapKey = func() *printer.Property {
return &printer.Property{
Prefix: format(color.FgHiCyan),
Suffix: format(color.Reset),
}
}
p.Anchor = func() *printer.Property {
return &printer.Property{
Prefix: format(color.FgHiYellow),
Suffix: format(color.Reset),
}
}
p.Alias = func() *printer.Property {
return &printer.Property{
Prefix: format(color.FgHiYellow),
Suffix: format(color.Reset),
}
}
p.String = func() *printer.Property {
return &printer.Property{
Prefix: format(color.FgHiGreen),
Suffix: format(color.Reset),
}
}
p.Comment = func() *printer.Property {
return &printer.Property{
Prefix: format(color.FgHiBlack),
Suffix: format(color.Reset),
}
}
writer := colorable.NewColorableStdout()
_, _ = writer.Write([]byte(p.PrintTokens(tokens) + "\n"))
return nil
}
func main() {
if err := _main(os.Args); err != nil {
fmt.Printf("%v\n", yaml.FormatError(err, true, true))
}
}
goccy-go-yaml-52dacb8/context.go 0000664 0000000 0000000 00000001337 15015766371 0016705 0 ustar 00root root 0000000 0000000 package yaml
import "context"
type (
ctxMergeKey struct{}
ctxAnchorKey struct{}
)
func withMerge(ctx context.Context) context.Context {
return context.WithValue(ctx, ctxMergeKey{}, true)
}
func isMerge(ctx context.Context) bool {
v, ok := ctx.Value(ctxMergeKey{}).(bool)
if !ok {
return false
}
return v
}
func withAnchor(ctx context.Context, name string) context.Context {
anchorMap := getAnchorMap(ctx)
if anchorMap == nil {
anchorMap = make(map[string]struct{})
}
anchorMap[name] = struct{}{}
return context.WithValue(ctx, ctxAnchorKey{}, anchorMap)
}
func getAnchorMap(ctx context.Context) map[string]struct{} {
v, ok := ctx.Value(ctxAnchorKey{}).(map[string]struct{})
if !ok {
return nil
}
return v
}
goccy-go-yaml-52dacb8/decode.go 0000664 0000000 0000000 00000143403 15015766371 0016445 0 ustar 00root root 0000000 0000000 package yaml
import (
"bytes"
"context"
"encoding"
"encoding/base64"
"fmt"
"io"
"maps"
"math"
"os"
"path/filepath"
"reflect"
"sort"
"strconv"
"strings"
"time"
"github.com/goccy/go-yaml/ast"
"github.com/goccy/go-yaml/internal/errors"
"github.com/goccy/go-yaml/internal/format"
"github.com/goccy/go-yaml/parser"
"github.com/goccy/go-yaml/token"
)
// Decoder reads and decodes YAML values from an input stream.
type Decoder struct {
reader io.Reader
referenceReaders []io.Reader
anchorNodeMap map[string]ast.Node
anchorValueMap map[string]reflect.Value
customUnmarshalerMap map[reflect.Type]func(context.Context, interface{}, []byte) error
commentMaps []CommentMap
toCommentMap CommentMap
opts []DecodeOption
referenceFiles []string
referenceDirs []string
isRecursiveDir bool
isResolvedReference bool
validator StructValidator
disallowUnknownField bool
allowDuplicateMapKey bool
useOrderedMap bool
useJSONUnmarshaler bool
parsedFile *ast.File
streamIndex int
decodeDepth int
}
// NewDecoder returns a new decoder that reads from r.
func NewDecoder(r io.Reader, opts ...DecodeOption) *Decoder {
return &Decoder{
reader: r,
anchorNodeMap: map[string]ast.Node{},
anchorValueMap: map[string]reflect.Value{},
customUnmarshalerMap: map[reflect.Type]func(context.Context, interface{}, []byte) error{},
opts: opts,
referenceReaders: []io.Reader{},
referenceFiles: []string{},
referenceDirs: []string{},
isRecursiveDir: false,
isResolvedReference: false,
disallowUnknownField: false,
allowDuplicateMapKey: false,
useOrderedMap: false,
}
}
const maxDecodeDepth = 10000
func (d *Decoder) stepIn() {
d.decodeDepth++
}
func (d *Decoder) stepOut() {
d.decodeDepth--
}
func (d *Decoder) isExceededMaxDepth() bool {
return d.decodeDepth > maxDecodeDepth
}
func (d *Decoder) castToFloat(v interface{}) interface{} {
switch vv := v.(type) {
case int:
return float64(vv)
case int8:
return float64(vv)
case int16:
return float64(vv)
case int32:
return float64(vv)
case int64:
return float64(vv)
case uint:
return float64(vv)
case uint8:
return float64(vv)
case uint16:
return float64(vv)
case uint32:
return float64(vv)
case uint64:
return float64(vv)
case float32:
return float64(vv)
case float64:
return vv
case string:
// if error occurred, return zero value
f, _ := strconv.ParseFloat(vv, 64)
return f
}
return 0
}
func (d *Decoder) mapKeyNodeToString(ctx context.Context, node ast.MapKeyNode) (string, error) {
key, err := d.nodeToValue(ctx, node)
if err != nil {
return "", err
}
if key == nil {
return "null", nil
}
if k, ok := key.(string); ok {
return k, nil
}
return fmt.Sprint(key), nil
}
func (d *Decoder) setToMapValue(ctx context.Context, node ast.Node, m map[string]interface{}) error {
d.stepIn()
defer d.stepOut()
if d.isExceededMaxDepth() {
return ErrExceededMaxDepth
}
d.setPathToCommentMap(node)
switch n := node.(type) {
case *ast.MappingValueNode:
if n.Key.IsMergeKey() {
value, err := d.getMapNode(n.Value, true)
if err != nil {
return err
}
iter := value.MapRange()
for iter.Next() {
if err := d.setToMapValue(ctx, iter.KeyValue(), m); err != nil {
return err
}
}
} else {
key, err := d.mapKeyNodeToString(ctx, n.Key)
if err != nil {
return err
}
v, err := d.nodeToValue(ctx, n.Value)
if err != nil {
return err
}
m[key] = v
}
case *ast.MappingNode:
for _, value := range n.Values {
if err := d.setToMapValue(ctx, value, m); err != nil {
return err
}
}
case *ast.AnchorNode:
anchorName := n.Name.GetToken().Value
d.anchorNodeMap[anchorName] = n.Value
}
return nil
}
func (d *Decoder) setToOrderedMapValue(ctx context.Context, node ast.Node, m *MapSlice) error {
d.stepIn()
defer d.stepOut()
if d.isExceededMaxDepth() {
return ErrExceededMaxDepth
}
d.setPathToCommentMap(node)
switch n := node.(type) {
case *ast.MappingValueNode:
if n.Key.IsMergeKey() {
value, err := d.getMapNode(n.Value, true)
if err != nil {
return err
}
iter := value.MapRange()
for iter.Next() {
if err := d.setToOrderedMapValue(ctx, iter.KeyValue(), m); err != nil {
return err
}
}
} else {
key, err := d.mapKeyNodeToString(ctx, n.Key)
if err != nil {
return err
}
value, err := d.nodeToValue(ctx, n.Value)
if err != nil {
return err
}
*m = append(*m, MapItem{Key: key, Value: value})
}
case *ast.MappingNode:
for _, value := range n.Values {
if err := d.setToOrderedMapValue(ctx, value, m); err != nil {
return err
}
}
}
return nil
}
func (d *Decoder) setPathToCommentMap(node ast.Node) {
if node == nil {
return
}
if d.toCommentMap == nil {
return
}
d.addHeadOrLineCommentToMap(node)
d.addFootCommentToMap(node)
}
func (d *Decoder) addHeadOrLineCommentToMap(node ast.Node) {
sequence, ok := node.(*ast.SequenceNode)
if ok {
d.addSequenceNodeCommentToMap(sequence)
return
}
commentGroup := node.GetComment()
if commentGroup == nil {
return
}
texts := []string{}
targetLine := node.GetToken().Position.Line
minCommentLine := math.MaxInt
for _, comment := range commentGroup.Comments {
if minCommentLine > comment.Token.Position.Line {
minCommentLine = comment.Token.Position.Line
}
texts = append(texts, comment.Token.Value)
}
if len(texts) == 0 {
return
}
commentPath := node.GetPath()
if minCommentLine < targetLine {
switch n := node.(type) {
case *ast.MappingNode:
if len(n.Values) != 0 {
commentPath = n.Values[0].Key.GetPath()
}
case *ast.MappingValueNode:
commentPath = n.Key.GetPath()
}
d.addCommentToMap(commentPath, HeadComment(texts...))
} else {
d.addCommentToMap(commentPath, LineComment(texts[0]))
}
}
func (d *Decoder) addSequenceNodeCommentToMap(node *ast.SequenceNode) {
if len(node.ValueHeadComments) != 0 {
for idx, headComment := range node.ValueHeadComments {
if headComment == nil {
continue
}
texts := make([]string, 0, len(headComment.Comments))
for _, comment := range headComment.Comments {
texts = append(texts, comment.Token.Value)
}
if len(texts) != 0 {
d.addCommentToMap(node.Values[idx].GetPath(), HeadComment(texts...))
}
}
}
firstElemHeadComment := node.GetComment()
if firstElemHeadComment != nil {
texts := make([]string, 0, len(firstElemHeadComment.Comments))
for _, comment := range firstElemHeadComment.Comments {
texts = append(texts, comment.Token.Value)
}
if len(texts) != 0 {
d.addCommentToMap(node.Values[0].GetPath(), HeadComment(texts...))
}
}
}
func (d *Decoder) addFootCommentToMap(node ast.Node) {
var (
footComment *ast.CommentGroupNode
footCommentPath = node.GetPath()
)
switch n := node.(type) {
case *ast.SequenceNode:
footComment = n.FootComment
if n.FootComment != nil {
footCommentPath = n.FootComment.GetPath()
}
case *ast.MappingNode:
footComment = n.FootComment
if n.FootComment != nil {
footCommentPath = n.FootComment.GetPath()
}
case *ast.MappingValueNode:
footComment = n.FootComment
if n.FootComment != nil {
footCommentPath = n.FootComment.GetPath()
}
}
if footComment == nil {
return
}
var texts []string
for _, comment := range footComment.Comments {
texts = append(texts, comment.Token.Value)
}
if len(texts) != 0 {
d.addCommentToMap(footCommentPath, FootComment(texts...))
}
}
func (d *Decoder) addCommentToMap(path string, comment *Comment) {
for _, c := range d.toCommentMap[path] {
if c.Position == comment.Position {
// already added same comment
return
}
}
d.toCommentMap[path] = append(d.toCommentMap[path], comment)
sort.Slice(d.toCommentMap[path], func(i, j int) bool {
return d.toCommentMap[path][i].Position < d.toCommentMap[path][j].Position
})
}
func (d *Decoder) nodeToValue(ctx context.Context, node ast.Node) (any, error) {
d.stepIn()
defer d.stepOut()
if d.isExceededMaxDepth() {
return nil, ErrExceededMaxDepth
}
d.setPathToCommentMap(node)
switch n := node.(type) {
case *ast.NullNode:
return nil, nil
case *ast.StringNode:
return n.GetValue(), nil
case *ast.IntegerNode:
return n.GetValue(), nil
case *ast.FloatNode:
return n.GetValue(), nil
case *ast.BoolNode:
return n.GetValue(), nil
case *ast.InfinityNode:
return n.GetValue(), nil
case *ast.NanNode:
return n.GetValue(), nil
case *ast.TagNode:
if n.Directive != nil {
v, err := d.nodeToValue(ctx, n.Value)
if err != nil {
return nil, err
}
if v == nil {
return "", nil
}
return fmt.Sprint(v), nil
}
switch token.ReservedTagKeyword(n.Start.Value) {
case token.TimestampTag:
t, _ := d.castToTime(ctx, n.Value)
return t, nil
case token.IntegerTag:
v, err := d.nodeToValue(ctx, n.Value)
if err != nil {
return nil, err
}
i, _ := strconv.Atoi(fmt.Sprint(v))
return i, nil
case token.FloatTag:
v, err := d.nodeToValue(ctx, n.Value)
if err != nil {
return nil, err
}
return d.castToFloat(v), nil
case token.NullTag:
return nil, nil
case token.BinaryTag:
v, err := d.nodeToValue(ctx, n.Value)
if err != nil {
return nil, err
}
str, ok := v.(string)
if !ok {
return nil, errors.ErrSyntax(
fmt.Sprintf("cannot convert %q to string", fmt.Sprint(v)),
n.Value.GetToken(),
)
}
b, _ := base64.StdEncoding.DecodeString(str)
return b, nil
case token.BooleanTag:
v, err := d.nodeToValue(ctx, n.Value)
if err != nil {
return nil, err
}
str := strings.ToLower(fmt.Sprint(v))
b, err := strconv.ParseBool(str)
if err == nil {
return b, nil
}
switch str {
case "yes":
return true, nil
case "no":
return false, nil
}
return nil, errors.ErrSyntax(fmt.Sprintf("cannot convert %q to boolean", fmt.Sprint(v)), n.Value.GetToken())
case token.StringTag:
v, err := d.nodeToValue(ctx, n.Value)
if err != nil {
return nil, err
}
if v == nil {
return "", nil
}
return fmt.Sprint(v), nil
case token.MappingTag:
return d.nodeToValue(ctx, n.Value)
default:
return d.nodeToValue(ctx, n.Value)
}
case *ast.AnchorNode:
anchorName := n.Name.GetToken().Value
// To handle the case where alias is processed recursively, the result of alias can be set to nil in advance.
d.anchorNodeMap[anchorName] = nil
anchorValue, err := d.nodeToValue(withAnchor(ctx, anchorName), n.Value)
if err != nil {
delete(d.anchorNodeMap, anchorName)
return nil, err
}
d.anchorNodeMap[anchorName] = n.Value
d.anchorValueMap[anchorName] = reflect.ValueOf(anchorValue)
return anchorValue, nil
case *ast.AliasNode:
text := n.Value.String()
if _, exists := getAnchorMap(ctx)[text]; exists {
// self recursion.
return nil, nil
}
if v, exists := d.anchorValueMap[text]; exists {
if !v.IsValid() {
return nil, nil
}
return v.Interface(), nil
}
aliasName := n.Value.GetToken().Value
return nil, errors.ErrSyntax(fmt.Sprintf("could not find alias %q", aliasName), n.Value.GetToken())
case *ast.LiteralNode:
return n.Value.GetValue(), nil
case *ast.MappingKeyNode:
return d.nodeToValue(ctx, n.Value)
case *ast.MappingValueNode:
if n.Key.IsMergeKey() {
value, err := d.getMapNode(n.Value, true)
if err != nil {
return nil, err
}
iter := value.MapRange()
if d.useOrderedMap {
m := MapSlice{}
for iter.Next() {
if err := d.setToOrderedMapValue(ctx, iter.KeyValue(), &m); err != nil {
return nil, err
}
}
return m, nil
}
m := make(map[string]any)
for iter.Next() {
if err := d.setToMapValue(ctx, iter.KeyValue(), m); err != nil {
return nil, err
}
}
return m, nil
}
key, err := d.mapKeyNodeToString(ctx, n.Key)
if err != nil {
return nil, err
}
if d.useOrderedMap {
v, err := d.nodeToValue(ctx, n.Value)
if err != nil {
return nil, err
}
return MapSlice{{Key: key, Value: v}}, nil
}
v, err := d.nodeToValue(ctx, n.Value)
if err != nil {
return nil, err
}
return map[string]interface{}{key: v}, nil
case *ast.MappingNode:
if d.useOrderedMap {
m := make(MapSlice, 0, len(n.Values))
for _, value := range n.Values {
if err := d.setToOrderedMapValue(ctx, value, &m); err != nil {
return nil, err
}
}
return m, nil
}
m := make(map[string]interface{}, len(n.Values))
for _, value := range n.Values {
if err := d.setToMapValue(ctx, value, m); err != nil {
return nil, err
}
}
return m, nil
case *ast.SequenceNode:
v := make([]interface{}, 0, len(n.Values))
for _, value := range n.Values {
vv, err := d.nodeToValue(ctx, value)
if err != nil {
return nil, err
}
v = append(v, vv)
}
return v, nil
}
return nil, nil
}
func (d *Decoder) getMapNode(node ast.Node, isMerge bool) (ast.MapNode, error) {
d.stepIn()
defer d.stepOut()
if d.isExceededMaxDepth() {
return nil, ErrExceededMaxDepth
}
switch n := node.(type) {
case ast.MapNode:
return n, nil
case *ast.AnchorNode:
anchorName := n.Name.GetToken().Value
d.anchorNodeMap[anchorName] = n.Value
return d.getMapNode(n.Value, isMerge)
case *ast.AliasNode:
aliasName := n.Value.GetToken().Value
node := d.anchorNodeMap[aliasName]
if node == nil {
return nil, fmt.Errorf("cannot find anchor by alias name %s", aliasName)
}
return d.getMapNode(node, isMerge)
case *ast.SequenceNode:
if !isMerge {
return nil, errors.ErrUnexpectedNodeType(node.Type(), ast.MappingType, node.GetToken())
}
var mapNodes []ast.MapNode
for _, value := range n.Values {
mapNode, err := d.getMapNode(value, false)
if err != nil {
return nil, err
}
mapNodes = append(mapNodes, mapNode)
}
return ast.SequenceMergeValue(mapNodes...), nil
}
return nil, errors.ErrUnexpectedNodeType(node.Type(), ast.MappingType, node.GetToken())
}
func (d *Decoder) getArrayNode(node ast.Node) (ast.ArrayNode, error) {
d.stepIn()
defer d.stepOut()
if d.isExceededMaxDepth() {
return nil, ErrExceededMaxDepth
}
if _, ok := node.(*ast.NullNode); ok {
return nil, nil
}
if anchor, ok := node.(*ast.AnchorNode); ok {
arrayNode, ok := anchor.Value.(ast.ArrayNode)
if ok {
return arrayNode, nil
}
return nil, errors.ErrUnexpectedNodeType(anchor.Value.Type(), ast.SequenceType, node.GetToken())
}
if alias, ok := node.(*ast.AliasNode); ok {
aliasName := alias.Value.GetToken().Value
node := d.anchorNodeMap[aliasName]
if node == nil {
return nil, fmt.Errorf("cannot find anchor by alias name %s", aliasName)
}
arrayNode, ok := node.(ast.ArrayNode)
if ok {
return arrayNode, nil
}
return nil, errors.ErrUnexpectedNodeType(node.Type(), ast.SequenceType, node.GetToken())
}
arrayNode, ok := node.(ast.ArrayNode)
if !ok {
return nil, errors.ErrUnexpectedNodeType(node.Type(), ast.SequenceType, node.GetToken())
}
return arrayNode, nil
}
func (d *Decoder) convertValue(v reflect.Value, typ reflect.Type, src ast.Node) (reflect.Value, error) {
if typ.Kind() != reflect.String {
if !v.Type().ConvertibleTo(typ) {
// Special case for "strings -> floats" aka scientific notation
// If the destination type is a float and the source type is a string, check if we can
// use strconv.ParseFloat to convert the string to a float.
if (typ.Kind() == reflect.Float32 || typ.Kind() == reflect.Float64) &&
v.Type().Kind() == reflect.String {
if f, err := strconv.ParseFloat(v.String(), 64); err == nil {
if typ.Kind() == reflect.Float32 {
return reflect.ValueOf(float32(f)), nil
} else if typ.Kind() == reflect.Float64 {
return reflect.ValueOf(f), nil
}
// else, fall through to the error below
}
}
return reflect.Zero(typ), errors.ErrTypeMismatch(typ, v.Type(), src.GetToken())
}
return v.Convert(typ), nil
}
// cast value to string
var strVal string
switch v.Type().Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
strVal = strconv.FormatInt(v.Int(), 10)
case reflect.Float32, reflect.Float64:
strVal = fmt.Sprint(v.Float())
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
strVal = strconv.FormatUint(v.Uint(), 10)
case reflect.Bool:
strVal = strconv.FormatBool(v.Bool())
default:
if !v.Type().ConvertibleTo(typ) {
return reflect.Zero(typ), errors.ErrTypeMismatch(typ, v.Type(), src.GetToken())
}
return v.Convert(typ), nil
}
val := reflect.ValueOf(strVal)
if val.Type() != typ {
// Handle named types, e.g., `type MyString string`
val = val.Convert(typ)
}
return val, nil
}
func (d *Decoder) deleteStructKeys(structType reflect.Type, unknownFields map[string]ast.Node) error {
if structType.Kind() == reflect.Ptr {
structType = structType.Elem()
}
structFieldMap, err := structFieldMap(structType)
if err != nil {
return err
}
for j := 0; j < structType.NumField(); j++ {
field := structType.Field(j)
if isIgnoredStructField(field) {
continue
}
structField, exists := structFieldMap[field.Name]
if !exists {
continue
}
if structField.IsInline {
_ = d.deleteStructKeys(field.Type, unknownFields)
} else {
delete(unknownFields, structField.RenderName)
}
}
return nil
}
func (d *Decoder) unmarshalableDocument(node ast.Node) ([]byte, error) {
doc := format.FormatNodeWithResolvedAlias(node, d.anchorNodeMap)
return []byte(doc), nil
}
func (d *Decoder) unmarshalableText(node ast.Node) ([]byte, bool) {
doc := format.FormatNodeWithResolvedAlias(node, d.anchorNodeMap)
var v string
if err := Unmarshal([]byte(doc), &v); err != nil {
return nil, false
}
return []byte(v), true
}
type jsonUnmarshaler interface {
UnmarshalJSON([]byte) error
}
func (d *Decoder) existsTypeInCustomUnmarshalerMap(t reflect.Type) bool {
if _, exists := d.customUnmarshalerMap[t]; exists {
return true
}
globalCustomUnmarshalerMu.Lock()
defer globalCustomUnmarshalerMu.Unlock()
if _, exists := globalCustomUnmarshalerMap[t]; exists {
return true
}
return false
}
func (d *Decoder) unmarshalerFromCustomUnmarshalerMap(t reflect.Type) (func(context.Context, interface{}, []byte) error, bool) {
if unmarshaler, exists := d.customUnmarshalerMap[t]; exists {
return unmarshaler, exists
}
globalCustomUnmarshalerMu.Lock()
defer globalCustomUnmarshalerMu.Unlock()
if unmarshaler, exists := globalCustomUnmarshalerMap[t]; exists {
return unmarshaler, exists
}
return nil, false
}
func (d *Decoder) canDecodeByUnmarshaler(dst reflect.Value) bool {
ptrValue := dst.Addr()
if d.existsTypeInCustomUnmarshalerMap(ptrValue.Type()) {
return true
}
iface := ptrValue.Interface()
switch iface.(type) {
case BytesUnmarshalerContext,
BytesUnmarshaler,
InterfaceUnmarshalerContext,
InterfaceUnmarshaler,
NodeUnmarshaler,
NodeUnmarshalerContext,
*time.Time,
*time.Duration,
encoding.TextUnmarshaler:
return true
case jsonUnmarshaler:
return d.useJSONUnmarshaler
}
return false
}
func (d *Decoder) decodeByUnmarshaler(ctx context.Context, dst reflect.Value, src ast.Node) error {
ptrValue := dst.Addr()
if unmarshaler, exists := d.unmarshalerFromCustomUnmarshalerMap(ptrValue.Type()); exists {
b, err := d.unmarshalableDocument(src)
if err != nil {
return err
}
if err := unmarshaler(ctx, ptrValue.Interface(), b); err != nil {
return err
}
return nil
}
iface := ptrValue.Interface()
if unmarshaler, ok := iface.(BytesUnmarshalerContext); ok {
b, err := d.unmarshalableDocument(src)
if err != nil {
return err
}
if err := unmarshaler.UnmarshalYAML(ctx, b); err != nil {
return err
}
return nil
}
if unmarshaler, ok := iface.(BytesUnmarshaler); ok {
b, err := d.unmarshalableDocument(src)
if err != nil {
return err
}
if err := unmarshaler.UnmarshalYAML(b); err != nil {
return err
}
return nil
}
if unmarshaler, ok := iface.(InterfaceUnmarshalerContext); ok {
if err := unmarshaler.UnmarshalYAML(ctx, func(v interface{}) error {
rv := reflect.ValueOf(v)
if rv.Type().Kind() != reflect.Ptr {
return ErrDecodeRequiredPointerType
}
if err := d.decodeValue(ctx, rv.Elem(), src); err != nil {
return err
}
return nil
}); err != nil {
return err
}
return nil
}
if unmarshaler, ok := iface.(InterfaceUnmarshaler); ok {
if err := unmarshaler.UnmarshalYAML(func(v interface{}) error {
rv := reflect.ValueOf(v)
if rv.Type().Kind() != reflect.Ptr {
return ErrDecodeRequiredPointerType
}
if err := d.decodeValue(ctx, rv.Elem(), src); err != nil {
return err
}
return nil
}); err != nil {
return err
}
return nil
}
if unmarshaler, ok := iface.(NodeUnmarshaler); ok {
if err := unmarshaler.UnmarshalYAML(src); err != nil {
return err
}
return nil
}
if unmarshaler, ok := iface.(NodeUnmarshalerContext); ok {
if err := unmarshaler.UnmarshalYAML(ctx, src); err != nil {
return err
}
return nil
}
if _, ok := iface.(*time.Time); ok {
return d.decodeTime(ctx, dst, src)
}
if _, ok := iface.(*time.Duration); ok {
return d.decodeDuration(ctx, dst, src)
}
if unmarshaler, isText := iface.(encoding.TextUnmarshaler); isText {
b, ok := d.unmarshalableText(src)
if ok {
if err := unmarshaler.UnmarshalText(b); err != nil {
return err
}
return nil
}
}
if d.useJSONUnmarshaler {
if unmarshaler, ok := iface.(jsonUnmarshaler); ok {
b, err := d.unmarshalableDocument(src)
if err != nil {
return err
}
jsonBytes, err := YAMLToJSON(b)
if err != nil {
return err
}
jsonBytes = bytes.TrimRight(jsonBytes, "\n")
if err := unmarshaler.UnmarshalJSON(jsonBytes); err != nil {
return err
}
return nil
}
}
return errors.New("does not implemented Unmarshaler")
}
var (
astNodeType = reflect.TypeOf((*ast.Node)(nil)).Elem()
)
func (d *Decoder) decodeValue(ctx context.Context, dst reflect.Value, src ast.Node) error {
d.stepIn()
defer d.stepOut()
if d.isExceededMaxDepth() {
return ErrExceededMaxDepth
}
if !dst.IsValid() {
return nil
}
if src.Type() == ast.AnchorType {
anchor, _ := src.(*ast.AnchorNode)
anchorName := anchor.Name.GetToken().Value
if err := d.decodeValue(withAnchor(ctx, anchorName), dst, anchor.Value); err != nil {
return err
}
d.anchorValueMap[anchorName] = dst
return nil
}
if d.canDecodeByUnmarshaler(dst) {
if err := d.decodeByUnmarshaler(ctx, dst, src); err != nil {
return err
}
return nil
}
valueType := dst.Type()
switch valueType.Kind() {
case reflect.Ptr:
if dst.IsNil() {
return nil
}
if src.Type() == ast.NullType {
// set nil value to pointer
dst.Set(reflect.Zero(valueType))
return nil
}
v := d.createDecodableValue(dst.Type())
if err := d.decodeValue(ctx, v, src); err != nil {
return err
}
castedValue, err := d.castToAssignableValue(v, dst.Type(), src)
if err != nil {
return err
}
dst.Set(castedValue)
case reflect.Interface:
if dst.Type() == astNodeType {
dst.Set(reflect.ValueOf(src))
return nil
}
srcVal, err := d.nodeToValue(ctx, src)
if err != nil {
return err
}
v := reflect.ValueOf(srcVal)
if v.IsValid() {
dst.Set(v)
} else {
dst.Set(reflect.Zero(valueType))
}
case reflect.Map:
return d.decodeMap(ctx, dst, src)
case reflect.Array:
return d.decodeArray(ctx, dst, src)
case reflect.Slice:
if mapSlice, ok := dst.Addr().Interface().(*MapSlice); ok {
return d.decodeMapSlice(ctx, mapSlice, src)
}
return d.decodeSlice(ctx, dst, src)
case reflect.Struct:
if mapItem, ok := dst.Addr().Interface().(*MapItem); ok {
return d.decodeMapItem(ctx, mapItem, src)
}
return d.decodeStruct(ctx, dst, src)
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
v, err := d.nodeToValue(ctx, src)
if err != nil {
return err
}
switch vv := v.(type) {
case int64:
if !dst.OverflowInt(vv) {
dst.SetInt(vv)
return nil
}
case uint64:
if vv <= math.MaxInt64 && !dst.OverflowInt(int64(vv)) {
dst.SetInt(int64(vv))
return nil
}
case float64:
if vv <= math.MaxInt64 && !dst.OverflowInt(int64(vv)) {
dst.SetInt(int64(vv))
return nil
}
case string: // handle scientific notation
if i, err := strconv.ParseFloat(vv, 64); err == nil {
if 0 <= i && i <= math.MaxUint64 && !dst.OverflowInt(int64(i)) {
dst.SetInt(int64(i))
return nil
}
} else { // couldn't be parsed as float
return errors.ErrTypeMismatch(valueType, reflect.TypeOf(v), src.GetToken())
}
default:
return errors.ErrTypeMismatch(valueType, reflect.TypeOf(v), src.GetToken())
}
return errors.ErrOverflow(valueType, fmt.Sprint(v), src.GetToken())
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
v, err := d.nodeToValue(ctx, src)
if err != nil {
return err
}
switch vv := v.(type) {
case int64:
if 0 <= vv && !dst.OverflowUint(uint64(vv)) {
dst.SetUint(uint64(vv))
return nil
}
case uint64:
if !dst.OverflowUint(vv) {
dst.SetUint(vv)
return nil
}
case float64:
if 0 <= vv && vv <= math.MaxUint64 && !dst.OverflowUint(uint64(vv)) {
dst.SetUint(uint64(vv))
return nil
}
case string: // handle scientific notation
if i, err := strconv.ParseFloat(vv, 64); err == nil {
if 0 <= i && i <= math.MaxUint64 && !dst.OverflowUint(uint64(i)) {
dst.SetUint(uint64(i))
return nil
}
} else { // couldn't be parsed as float
return errors.ErrTypeMismatch(valueType, reflect.TypeOf(v), src.GetToken())
}
default:
return errors.ErrTypeMismatch(valueType, reflect.TypeOf(v), src.GetToken())
}
return errors.ErrOverflow(valueType, fmt.Sprint(v), src.GetToken())
}
srcVal, err := d.nodeToValue(ctx, src)
if err != nil {
return err
}
v := reflect.ValueOf(srcVal)
if v.IsValid() {
convertedValue, err := d.convertValue(v, dst.Type(), src)
if err != nil {
return err
}
dst.Set(convertedValue)
}
return nil
}
func (d *Decoder) createDecodableValue(typ reflect.Type) reflect.Value {
for {
if typ.Kind() == reflect.Ptr {
typ = typ.Elem()
continue
}
break
}
return reflect.New(typ).Elem()
}
func (d *Decoder) castToAssignableValue(value reflect.Value, target reflect.Type, src ast.Node) (reflect.Value, error) {
if target.Kind() != reflect.Ptr {
if !value.Type().AssignableTo(target) {
return reflect.Value{}, errors.ErrTypeMismatch(target, value.Type(), src.GetToken())
}
return value, nil
}
const maxAddrCount = 5
for i := 0; i < maxAddrCount; i++ {
if value.Type().AssignableTo(target) {
break
}
if !value.CanAddr() {
break
}
value = value.Addr()
}
if !value.Type().AssignableTo(target) {
return reflect.Value{}, errors.ErrTypeMismatch(target, value.Type(), src.GetToken())
}
return value, nil
}
func (d *Decoder) createDecodedNewValue(
ctx context.Context, typ reflect.Type, defaultVal reflect.Value, node ast.Node,
) (reflect.Value, error) {
if node.Type() == ast.AliasType {
aliasName := node.(*ast.AliasNode).Value.GetToken().Value
value := d.anchorValueMap[aliasName]
if value.IsValid() {
v, err := d.castToAssignableValue(value, typ, node)
if err == nil {
return v, nil
}
}
anchor, exists := d.anchorNodeMap[aliasName]
if exists {
node = anchor
}
}
var newValue reflect.Value
if node.Type() == ast.NullType {
newValue = reflect.New(typ).Elem()
} else {
newValue = d.createDecodableValue(typ)
}
for defaultVal.Kind() == reflect.Ptr {
defaultVal = defaultVal.Elem()
}
if defaultVal.IsValid() && defaultVal.Type().AssignableTo(newValue.Type()) {
newValue.Set(defaultVal)
}
if node.Type() != ast.NullType {
if err := d.decodeValue(ctx, newValue, node); err != nil {
return reflect.Value{}, err
}
}
return d.castToAssignableValue(newValue, typ, node)
}
func (d *Decoder) keyToNodeMap(ctx context.Context, node ast.Node, ignoreMergeKey bool, getKeyOrValueNode func(*ast.MapNodeIter) ast.Node) (map[string]ast.Node, error) {
d.stepIn()
defer d.stepOut()
if d.isExceededMaxDepth() {
return nil, ErrExceededMaxDepth
}
mapNode, err := d.getMapNode(node, false)
if err != nil {
return nil, err
}
keyMap := map[string]struct{}{}
keyToNodeMap := map[string]ast.Node{}
mapIter := mapNode.MapRange()
for mapIter.Next() {
keyNode := mapIter.Key()
if keyNode.IsMergeKey() {
if ignoreMergeKey {
continue
}
mergeMap, err := d.keyToNodeMap(ctx, mapIter.Value(), ignoreMergeKey, getKeyOrValueNode)
if err != nil {
return nil, err
}
for k, v := range mergeMap {
if err := d.validateDuplicateKey(keyMap, k, v); err != nil {
return nil, err
}
keyToNodeMap[k] = v
}
} else {
keyVal, err := d.nodeToValue(ctx, keyNode)
if err != nil {
return nil, err
}
key, ok := keyVal.(string)
if !ok {
return nil, err
}
if err := d.validateDuplicateKey(keyMap, key, keyNode); err != nil {
return nil, err
}
keyToNodeMap[key] = getKeyOrValueNode(mapIter)
}
}
return keyToNodeMap, nil
}
func (d *Decoder) keyToKeyNodeMap(ctx context.Context, node ast.Node, ignoreMergeKey bool) (map[string]ast.Node, error) {
m, err := d.keyToNodeMap(ctx, node, ignoreMergeKey, func(nodeMap *ast.MapNodeIter) ast.Node { return nodeMap.Key() })
if err != nil {
return nil, err
}
return m, nil
}
func (d *Decoder) keyToValueNodeMap(ctx context.Context, node ast.Node, ignoreMergeKey bool) (map[string]ast.Node, error) {
m, err := d.keyToNodeMap(ctx, node, ignoreMergeKey, func(nodeMap *ast.MapNodeIter) ast.Node { return nodeMap.Value() })
if err != nil {
return nil, err
}
return m, nil
}
func (d *Decoder) setDefaultValueIfConflicted(v reflect.Value, fieldMap StructFieldMap) error {
for v.Type().Kind() == reflect.Ptr {
v = v.Elem()
}
typ := v.Type()
if typ.Kind() != reflect.Struct {
return nil
}
embeddedStructFieldMap, err := structFieldMap(typ)
if err != nil {
return err
}
for i := 0; i < typ.NumField(); i++ {
field := typ.Field(i)
if isIgnoredStructField(field) {
continue
}
structField := embeddedStructFieldMap[field.Name]
if !fieldMap.isIncludedRenderName(structField.RenderName) {
continue
}
// if declared same key name, set default value
fieldValue := v.Field(i)
if fieldValue.CanSet() {
fieldValue.Set(reflect.Zero(fieldValue.Type()))
}
}
return nil
}
// This is a subset of the formats allowed by the regular expression
// defined at http://yaml.org/type/timestamp.html.
var allowedTimestampFormats = []string{
"2006-1-2T15:4:5.999999999Z07:00", // RCF3339Nano with short date fields.
"2006-1-2t15:4:5.999999999Z07:00", // RFC3339Nano with short date fields and lower-case "t".
"2006-1-2 15:4:5.999999999", // space separated with no time zone
"2006-1-2", // date only
}
func (d *Decoder) castToTime(ctx context.Context, src ast.Node) (time.Time, error) {
if src == nil {
return time.Time{}, nil
}
v, err := d.nodeToValue(ctx, src)
if err != nil {
return time.Time{}, err
}
if t, ok := v.(time.Time); ok {
return t, nil
}
s, ok := v.(string)
if !ok {
return time.Time{}, errors.ErrTypeMismatch(reflect.TypeOf(time.Time{}), reflect.TypeOf(v), src.GetToken())
}
for _, format := range allowedTimestampFormats {
t, err := time.Parse(format, s)
if err != nil {
// invalid format
continue
}
return t, nil
}
return time.Time{}, nil
}
func (d *Decoder) decodeTime(ctx context.Context, dst reflect.Value, src ast.Node) error {
t, err := d.castToTime(ctx, src)
if err != nil {
return err
}
dst.Set(reflect.ValueOf(t))
return nil
}
func (d *Decoder) castToDuration(ctx context.Context, src ast.Node) (time.Duration, error) {
if src == nil {
return 0, nil
}
v, err := d.nodeToValue(ctx, src)
if err != nil {
return 0, err
}
if t, ok := v.(time.Duration); ok {
return t, nil
}
s, ok := v.(string)
if !ok {
return 0, errors.ErrTypeMismatch(reflect.TypeOf(time.Duration(0)), reflect.TypeOf(v), src.GetToken())
}
t, err := time.ParseDuration(s)
if err != nil {
return 0, err
}
return t, nil
}
func (d *Decoder) decodeDuration(ctx context.Context, dst reflect.Value, src ast.Node) error {
t, err := d.castToDuration(ctx, src)
if err != nil {
return err
}
dst.Set(reflect.ValueOf(t))
return nil
}
// getMergeAliasName support single alias only
func (d *Decoder) getMergeAliasName(src ast.Node) string {
mapNode, err := d.getMapNode(src, true)
if err != nil {
return ""
}
mapIter := mapNode.MapRange()
for mapIter.Next() {
key := mapIter.Key()
value := mapIter.Value()
if key.IsMergeKey() && value.Type() == ast.AliasType {
return value.(*ast.AliasNode).Value.GetToken().Value
}
}
return ""
}
func (d *Decoder) decodeStruct(ctx context.Context, dst reflect.Value, src ast.Node) error {
if src == nil {
return nil
}
d.stepIn()
defer d.stepOut()
if d.isExceededMaxDepth() {
return ErrExceededMaxDepth
}
structType := dst.Type()
srcValue := reflect.ValueOf(src)
srcType := srcValue.Type()
if srcType.Kind() == reflect.Ptr {
srcType = srcType.Elem()
srcValue = srcValue.Elem()
}
if structType == srcType {
// dst value implements ast.Node
dst.Set(srcValue)
return nil
}
structFieldMap, err := structFieldMap(structType)
if err != nil {
return err
}
ignoreMergeKey := structFieldMap.hasMergeProperty()
keyToNodeMap, err := d.keyToValueNodeMap(ctx, src, ignoreMergeKey)
if err != nil {
return err
}
var unknownFields map[string]ast.Node
if d.disallowUnknownField {
unknownFields, err = d.keyToKeyNodeMap(ctx, src, ignoreMergeKey)
if err != nil {
return err
}
}
aliasName := d.getMergeAliasName(src)
var foundErr error
for i := 0; i < structType.NumField(); i++ {
field := structType.Field(i)
if isIgnoredStructField(field) {
continue
}
structField := structFieldMap[field.Name]
if structField.IsInline {
fieldValue := dst.FieldByName(field.Name)
if structField.IsAutoAlias {
if aliasName != "" {
newFieldValue := d.anchorValueMap[aliasName]
if newFieldValue.IsValid() {
value, err := d.castToAssignableValue(newFieldValue, fieldValue.Type(), d.anchorNodeMap[aliasName])
if err != nil {
return err
}
fieldValue.Set(value)
}
}
continue
}
if !fieldValue.CanSet() {
return fmt.Errorf("cannot set embedded type as unexported field %s.%s", field.PkgPath, field.Name)
}
if fieldValue.Type().Kind() == reflect.Ptr && src.Type() == ast.NullType {
// set nil value to pointer
fieldValue.Set(reflect.Zero(fieldValue.Type()))
continue
}
mapNode := ast.Mapping(nil, false)
for k, v := range keyToNodeMap {
key := &ast.StringNode{BaseNode: &ast.BaseNode{}, Value: k}
mapNode.Values = append(mapNode.Values, ast.MappingValue(nil, key, v))
}
newFieldValue, err := d.createDecodedNewValue(ctx, fieldValue.Type(), fieldValue, mapNode)
if d.disallowUnknownField {
if err := d.deleteStructKeys(fieldValue.Type(), unknownFields); err != nil {
return err
}
}
if err != nil {
if foundErr != nil {
continue
}
var te *errors.TypeError
if errors.As(err, &te) {
if te.StructFieldName != nil {
fieldName := fmt.Sprintf("%s.%s", structType.Name(), *te.StructFieldName)
te.StructFieldName = &fieldName
} else {
fieldName := fmt.Sprintf("%s.%s", structType.Name(), field.Name)
te.StructFieldName = &fieldName
}
foundErr = te
continue
} else {
foundErr = err
}
continue
}
_ = d.setDefaultValueIfConflicted(newFieldValue, structFieldMap)
fieldValue.Set(newFieldValue)
continue
}
v, exists := keyToNodeMap[structField.RenderName]
if !exists {
continue
}
delete(unknownFields, structField.RenderName)
fieldValue := dst.FieldByName(field.Name)
if fieldValue.Type().Kind() == reflect.Ptr && src.Type() == ast.NullType {
// set nil value to pointer
fieldValue.Set(reflect.Zero(fieldValue.Type()))
continue
}
newFieldValue, err := d.createDecodedNewValue(ctx, fieldValue.Type(), fieldValue, v)
if err != nil {
if foundErr != nil {
continue
}
var te *errors.TypeError
if errors.As(err, &te) {
fieldName := fmt.Sprintf("%s.%s", structType.Name(), field.Name)
te.StructFieldName = &fieldName
foundErr = te
} else {
foundErr = err
}
continue
}
fieldValue.Set(newFieldValue)
}
if foundErr != nil {
return foundErr
}
// Ignore unknown fields when parsing an inline struct (recognized by a nil token).
// Unknown fields are expected (they could be fields from the parent struct).
if len(unknownFields) != 0 && d.disallowUnknownField && src.GetToken() != nil {
for key, node := range unknownFields {
return errors.ErrUnknownField(fmt.Sprintf(`unknown field "%s"`, key), node.GetToken())
}
}
if d.validator != nil {
if err := d.validator.Struct(dst.Addr().Interface()); err != nil {
ev := reflect.ValueOf(err)
if ev.Type().Kind() == reflect.Slice {
for i := 0; i < ev.Len(); i++ {
fieldErr, ok := ev.Index(i).Interface().(FieldError)
if !ok {
continue
}
fieldName := fieldErr.StructField()
structField, exists := structFieldMap[fieldName]
if !exists {
continue
}
node, exists := keyToNodeMap[structField.RenderName]
if exists {
// TODO: to make FieldError message cutomizable
return errors.ErrSyntax(
fmt.Sprintf("%s", err),
d.getParentMapTokenIfExistsForValidationError(node.Type(), node.GetToken()),
)
} else if t := src.GetToken(); t != nil && t.Prev != nil && t.Prev.Prev != nil {
// A missing required field will not be in the keyToNodeMap
// the error needs to be associated with the parent of the source node
return errors.ErrSyntax(fmt.Sprintf("%s", err), t.Prev.Prev)
}
}
}
return err
}
}
return nil
}
// getParentMapTokenIfExists if the NodeType is a container type such as MappingType or SequenceType,
// it is necessary to return the parent MapNode's colon token to represent the entire container.
func (d *Decoder) getParentMapTokenIfExistsForValidationError(typ ast.NodeType, tk *token.Token) *token.Token {
if tk == nil {
return nil
}
if typ == ast.MappingType {
// map:
// key: value
// ^ current token ( colon )
if tk.Prev == nil {
return tk
}
key := tk.Prev
if key.Prev == nil {
return tk
}
return key.Prev
}
if typ == ast.SequenceType {
// map:
// - value
// ^ current token ( sequence entry )
if tk.Prev == nil {
return tk
}
return tk.Prev
}
return tk
}
func (d *Decoder) decodeArray(ctx context.Context, dst reflect.Value, src ast.Node) error {
d.stepIn()
defer d.stepOut()
if d.isExceededMaxDepth() {
return ErrExceededMaxDepth
}
arrayNode, err := d.getArrayNode(src)
if err != nil {
return err
}
if arrayNode == nil {
return nil
}
iter := arrayNode.ArrayRange()
arrayValue := reflect.New(dst.Type()).Elem()
arrayType := dst.Type()
elemType := arrayType.Elem()
idx := 0
var foundErr error
for iter.Next() {
v := iter.Value()
if elemType.Kind() == reflect.Ptr && v.Type() == ast.NullType {
// set nil value to pointer
arrayValue.Index(idx).Set(reflect.Zero(elemType))
} else {
dstValue, err := d.createDecodedNewValue(ctx, elemType, reflect.Value{}, v)
if err != nil {
if foundErr == nil {
foundErr = err
}
continue
}
arrayValue.Index(idx).Set(dstValue)
}
idx++
}
dst.Set(arrayValue)
if foundErr != nil {
return foundErr
}
return nil
}
func (d *Decoder) decodeSlice(ctx context.Context, dst reflect.Value, src ast.Node) error {
d.stepIn()
defer d.stepOut()
if d.isExceededMaxDepth() {
return ErrExceededMaxDepth
}
arrayNode, err := d.getArrayNode(src)
if err != nil {
return err
}
if arrayNode == nil {
return nil
}
iter := arrayNode.ArrayRange()
sliceType := dst.Type()
sliceValue := reflect.MakeSlice(sliceType, 0, iter.Len())
elemType := sliceType.Elem()
var foundErr error
for iter.Next() {
v := iter.Value()
if elemType.Kind() == reflect.Ptr && v.Type() == ast.NullType {
// set nil value to pointer
sliceValue = reflect.Append(sliceValue, reflect.Zero(elemType))
continue
}
dstValue, err := d.createDecodedNewValue(ctx, elemType, reflect.Value{}, v)
if err != nil {
if foundErr == nil {
foundErr = err
}
continue
}
sliceValue = reflect.Append(sliceValue, dstValue)
}
dst.Set(sliceValue)
if foundErr != nil {
return foundErr
}
return nil
}
func (d *Decoder) decodeMapItem(ctx context.Context, dst *MapItem, src ast.Node) error {
d.stepIn()
defer d.stepOut()
if d.isExceededMaxDepth() {
return ErrExceededMaxDepth
}
mapNode, err := d.getMapNode(src, isMerge(ctx))
if err != nil {
return err
}
mapIter := mapNode.MapRange()
if !mapIter.Next() {
return nil
}
key := mapIter.Key()
value := mapIter.Value()
if key.IsMergeKey() {
if err := d.decodeMapItem(withMerge(ctx), dst, value); err != nil {
return err
}
return nil
}
k, err := d.nodeToValue(ctx, key)
if err != nil {
return err
}
v, err := d.nodeToValue(ctx, value)
if err != nil {
return err
}
*dst = MapItem{Key: k, Value: v}
return nil
}
func (d *Decoder) validateDuplicateKey(keyMap map[string]struct{}, key interface{}, keyNode ast.Node) error {
k, ok := key.(string)
if !ok {
return nil
}
if !d.allowDuplicateMapKey {
if _, exists := keyMap[k]; exists {
return errors.ErrDuplicateKey(fmt.Sprintf(`duplicate key "%s"`, k), keyNode.GetToken())
}
}
keyMap[k] = struct{}{}
return nil
}
func (d *Decoder) decodeMapSlice(ctx context.Context, dst *MapSlice, src ast.Node) error {
d.stepIn()
defer d.stepOut()
if d.isExceededMaxDepth() {
return ErrExceededMaxDepth
}
mapNode, err := d.getMapNode(src, isMerge(ctx))
if err != nil {
return err
}
mapSlice := MapSlice{}
mapIter := mapNode.MapRange()
keyMap := map[string]struct{}{}
for mapIter.Next() {
key := mapIter.Key()
value := mapIter.Value()
if key.IsMergeKey() {
var m MapSlice
if err := d.decodeMapSlice(withMerge(ctx), &m, value); err != nil {
return err
}
for _, v := range m {
if err := d.validateDuplicateKey(keyMap, v.Key, value); err != nil {
return err
}
mapSlice = append(mapSlice, v)
}
continue
}
k, err := d.nodeToValue(ctx, key)
if err != nil {
return err
}
if err := d.validateDuplicateKey(keyMap, k, key); err != nil {
return err
}
v, err := d.nodeToValue(ctx, value)
if err != nil {
return err
}
mapSlice = append(mapSlice, MapItem{Key: k, Value: v})
}
*dst = mapSlice
return nil
}
func (d *Decoder) decodeMap(ctx context.Context, dst reflect.Value, src ast.Node) error {
d.stepIn()
defer d.stepOut()
if d.isExceededMaxDepth() {
return ErrExceededMaxDepth
}
mapNode, err := d.getMapNode(src, isMerge(ctx))
if err != nil {
return err
}
mapType := dst.Type()
mapValue := reflect.MakeMap(mapType)
keyType := mapValue.Type().Key()
valueType := mapValue.Type().Elem()
mapIter := mapNode.MapRange()
keyMap := map[string]struct{}{}
var foundErr error
for mapIter.Next() {
key := mapIter.Key()
value := mapIter.Value()
if key.IsMergeKey() {
if err := d.decodeMap(withMerge(ctx), dst, value); err != nil {
return err
}
iter := dst.MapRange()
for iter.Next() {
if err := d.validateDuplicateKey(keyMap, iter.Key(), value); err != nil {
return err
}
mapValue.SetMapIndex(iter.Key(), iter.Value())
}
continue
}
k := d.createDecodableValue(keyType)
if d.canDecodeByUnmarshaler(k) {
if err := d.decodeByUnmarshaler(ctx, k, key); err != nil {
return err
}
} else {
keyVal, err := d.nodeToValue(ctx, key)
if err != nil {
return err
}
k = reflect.ValueOf(keyVal)
if k.IsValid() && k.Type().ConvertibleTo(keyType) {
k = k.Convert(keyType)
}
}
if k.IsValid() {
if err := d.validateDuplicateKey(keyMap, k.Interface(), key); err != nil {
return err
}
}
if valueType.Kind() == reflect.Ptr && value.Type() == ast.NullType {
// set nil value to pointer
mapValue.SetMapIndex(k, reflect.Zero(valueType))
continue
}
dstValue, err := d.createDecodedNewValue(ctx, valueType, reflect.Value{}, value)
if err != nil {
if foundErr == nil {
foundErr = err
}
}
if !k.IsValid() {
// expect nil key
mapValue.SetMapIndex(d.createDecodableValue(keyType), dstValue)
continue
}
if keyType.Kind() != k.Kind() {
return errors.ErrSyntax(
fmt.Sprintf("cannot convert %q type to %q type", k.Kind(), keyType.Kind()),
key.GetToken(),
)
}
mapValue.SetMapIndex(k, dstValue)
}
dst.Set(mapValue)
if foundErr != nil {
return foundErr
}
return nil
}
func (d *Decoder) fileToReader(file string) (io.Reader, error) {
reader, err := os.Open(file)
if err != nil {
return nil, err
}
return reader, nil
}
func (d *Decoder) isYAMLFile(file string) bool {
ext := filepath.Ext(file)
if ext == ".yml" {
return true
}
if ext == ".yaml" {
return true
}
return false
}
func (d *Decoder) readersUnderDir(dir string) ([]io.Reader, error) {
pattern := fmt.Sprintf("%s/*", dir)
matches, err := filepath.Glob(pattern)
if err != nil {
return nil, err
}
readers := []io.Reader{}
for _, match := range matches {
if !d.isYAMLFile(match) {
continue
}
reader, err := d.fileToReader(match)
if err != nil {
return nil, err
}
readers = append(readers, reader)
}
return readers, nil
}
func (d *Decoder) readersUnderDirRecursive(dir string) ([]io.Reader, error) {
readers := []io.Reader{}
if err := filepath.Walk(dir, func(path string, info os.FileInfo, _ error) error {
if !d.isYAMLFile(path) {
return nil
}
reader, readerErr := d.fileToReader(path)
if readerErr != nil {
return readerErr
}
readers = append(readers, reader)
return nil
}); err != nil {
return nil, err
}
return readers, nil
}
func (d *Decoder) resolveReference(ctx context.Context) error {
for _, opt := range d.opts {
if err := opt(d); err != nil {
return err
}
}
for _, file := range d.referenceFiles {
reader, err := d.fileToReader(file)
if err != nil {
return err
}
d.referenceReaders = append(d.referenceReaders, reader)
}
for _, dir := range d.referenceDirs {
if !d.isRecursiveDir {
readers, err := d.readersUnderDir(dir)
if err != nil {
return err
}
d.referenceReaders = append(d.referenceReaders, readers...)
} else {
readers, err := d.readersUnderDirRecursive(dir)
if err != nil {
return err
}
d.referenceReaders = append(d.referenceReaders, readers...)
}
}
for _, reader := range d.referenceReaders {
bytes, err := io.ReadAll(reader)
if err != nil {
return err
}
// assign new anchor definition to anchorMap
if _, err := d.parse(ctx, bytes); err != nil {
return err
}
}
d.isResolvedReference = true
return nil
}
func (d *Decoder) parse(ctx context.Context, bytes []byte) (*ast.File, error) {
var parseMode parser.Mode
if d.toCommentMap != nil {
parseMode = parser.ParseComments
}
var opts []parser.Option
if d.allowDuplicateMapKey {
opts = append(opts, parser.AllowDuplicateMapKey())
}
f, err := parser.ParseBytes(bytes, parseMode, opts...)
if err != nil {
return nil, err
}
normalizedFile := &ast.File{}
for _, doc := range f.Docs {
// try to decode ast.Node to value and map anchor value to anchorMap
v, err := d.nodeToValue(ctx, doc.Body)
if err != nil {
return nil, err
}
if v != nil || (doc.Body != nil && doc.Body.Type() == ast.NullType) {
normalizedFile.Docs = append(normalizedFile.Docs, doc)
cm := CommentMap{}
maps.Copy(cm, d.toCommentMap)
d.commentMaps = append(d.commentMaps, cm)
}
for k := range d.toCommentMap {
delete(d.toCommentMap, k)
}
}
return normalizedFile, nil
}
func (d *Decoder) isInitialized() bool {
return d.parsedFile != nil
}
func (d *Decoder) decodeInit(ctx context.Context) error {
if !d.isResolvedReference {
if err := d.resolveReference(ctx); err != nil {
return err
}
}
var buf bytes.Buffer
if _, err := io.Copy(&buf, d.reader); err != nil {
return err
}
file, err := d.parse(ctx, buf.Bytes())
if err != nil {
return err
}
d.parsedFile = file
return nil
}
func (d *Decoder) decode(ctx context.Context, v reflect.Value) error {
d.decodeDepth = 0
d.anchorValueMap = make(map[string]reflect.Value)
if len(d.parsedFile.Docs) == 0 {
// empty document.
dst := v.Elem()
if dst.IsValid() {
dst.Set(reflect.Zero(dst.Type()))
}
}
if len(d.parsedFile.Docs) <= d.streamIndex {
return io.EOF
}
body := d.parsedFile.Docs[d.streamIndex].Body
if body == nil {
return nil
}
if len(d.commentMaps) > d.streamIndex {
maps.Copy(d.toCommentMap, d.commentMaps[d.streamIndex])
}
if err := d.decodeValue(ctx, v.Elem(), body); err != nil {
return err
}
d.streamIndex++
return nil
}
// Decode reads the next YAML-encoded value from its input
// and stores it in the value pointed to by v.
//
// See the documentation for Unmarshal for details about the
// conversion of YAML into a Go value.
func (d *Decoder) Decode(v interface{}) error {
return d.DecodeContext(context.Background(), v)
}
// DecodeContext reads the next YAML-encoded value from its input
// and stores it in the value pointed to by v with context.Context.
func (d *Decoder) DecodeContext(ctx context.Context, v interface{}) error {
rv := reflect.ValueOf(v)
if !rv.IsValid() || rv.Type().Kind() != reflect.Ptr {
return ErrDecodeRequiredPointerType
}
if d.isInitialized() {
if err := d.decode(ctx, rv); err != nil {
return err
}
return nil
}
if err := d.decodeInit(ctx); err != nil {
return err
}
if err := d.decode(ctx, rv); err != nil {
return err
}
return nil
}
// DecodeFromNode decodes node into the value pointed to by v.
func (d *Decoder) DecodeFromNode(node ast.Node, v interface{}) error {
return d.DecodeFromNodeContext(context.Background(), node, v)
}
// DecodeFromNodeContext decodes node into the value pointed to by v with context.Context.
func (d *Decoder) DecodeFromNodeContext(ctx context.Context, node ast.Node, v interface{}) error {
rv := reflect.ValueOf(v)
if rv.Type().Kind() != reflect.Ptr {
return ErrDecodeRequiredPointerType
}
if !d.isInitialized() {
if err := d.decodeInit(ctx); err != nil {
return err
}
}
// resolve references to the anchor on the same file
if _, err := d.nodeToValue(ctx, node); err != nil {
return err
}
if err := d.decodeValue(ctx, rv.Elem(), node); err != nil {
return err
}
return nil
}
goccy-go-yaml-52dacb8/decode_test.go 0000664 0000000 0000000 00000232010 15015766371 0017475 0 ustar 00root root 0000000 0000000 package yaml_test
import (
"bytes"
"context"
"fmt"
"io"
"log"
"math"
"net"
"reflect"
"strconv"
"strings"
"testing"
"time"
"github.com/goccy/go-yaml"
"github.com/goccy/go-yaml/ast"
"github.com/goccy/go-yaml/internal/errors"
"github.com/goccy/go-yaml/parser"
)
type Child struct {
B int
C int `yaml:"-"`
}
type TestString string
func TestDecoder(t *testing.T) {
tests := []struct {
source string
value interface{}
eof bool
}{
{
source: "v: hi\n",
value: map[string]string{"v": "hi"},
},
{
source: "v: hi\n",
value: map[string]TestString{"v": "hi"},
},
{
source: "v: \"true\"\n",
value: map[string]string{"v": "true"},
},
{
source: "v: \"false\"\n",
value: map[string]string{"v": "false"},
},
{
source: "v: true\n",
value: map[string]interface{}{"v": true},
},
{
source: "v: true\n",
value: map[string]string{"v": "true"},
},
{
source: "v: 10\n",
value: map[string]string{"v": "10"},
},
{
source: "v: 10\n",
value: map[string]TestString{"v": "10"},
},
{
source: "v: -10\n",
value: map[string]string{"v": "-10"},
},
{
source: "v: 1.234\n",
value: map[string]string{"v": "1.234"},
},
{
source: "v: \" foo\"\n",
value: map[string]string{"v": " foo"},
},
{
source: "v: \"foo \"\n",
value: map[string]string{"v": "foo "},
},
{
source: "v: \" foo \"\n",
value: map[string]string{"v": " foo "},
},
{
source: "v: false\n",
value: map[string]bool{"v": false},
},
{
source: "v: 10\n",
value: map[string]int{"v": 10},
},
{
source: "v: 10",
value: map[string]interface{}{"v": 10},
},
{
source: "v: 0b10",
value: map[string]interface{}{"v": 2},
},
{
source: "v: -0b101010",
value: map[string]interface{}{"v": -42},
},
{
source: "v: -0b1000000000000000000000000000000000000000000000000000000000000000",
value: map[string]interface{}{"v": int64(-9223372036854775808)},
},
{
source: "v: 0xA",
value: map[string]interface{}{"v": 10},
},
{
source: "v: .1",
value: map[string]interface{}{"v": 0.1},
},
{
source: "v: -.1",
value: map[string]interface{}{"v": -0.1},
},
{
source: "v: -10\n",
value: map[string]int{"v": -10},
},
{
source: "v: 4294967296\n",
value: map[string]int64{"v": int64(4294967296)},
},
{
source: "v: 0.1\n",
value: map[string]interface{}{"v": 0.1},
},
{
source: "v: 0.99\n",
value: map[string]float32{"v": 0.99},
},
{
source: "v: -0.1\n",
value: map[string]float64{"v": -0.1},
},
{
source: "v: 6.8523e+5",
value: map[string]interface{}{"v": 6.8523e+5},
},
{
source: "v: 685.230_15e+03",
value: map[string]interface{}{"v": 685.23015e+03},
},
{
source: "v: 685_230.15",
value: map[string]interface{}{"v": 685230.15},
},
{
source: "v: 685_230.15",
value: map[string]float64{"v": 685230.15},
},
{
source: "v: 685230",
value: map[string]interface{}{"v": 685230},
},
{
source: "v: +685_230",
value: map[string]interface{}{"v": 685230},
},
{
source: "v: 02472256",
value: map[string]interface{}{"v": 685230},
},
{
source: "v: 0x_0A_74_AE",
value: map[string]interface{}{"v": 685230},
},
{
source: "v: 0b1010_0111_0100_1010_1110",
value: map[string]interface{}{"v": 685230},
},
{
source: "v: +685_230",
value: map[string]int{"v": 685230},
},
// Bools from spec
{
source: "v: True",
value: map[string]interface{}{"v": true},
},
{
source: "v: TRUE",
value: map[string]interface{}{"v": true},
},
{
source: "v: False",
value: map[string]interface{}{"v": false},
},
{
source: "v: FALSE",
value: map[string]interface{}{"v": false},
},
{
source: "v: y",
value: map[string]interface{}{"v": "y"}, // y or yes or Yes is string
},
{
source: "v: NO",
value: map[string]interface{}{"v": "NO"}, // no or No or NO is string
},
{
source: "v: on",
value: map[string]interface{}{"v": "on"}, // on is string
},
// Some cross type conversions
{
source: "v: 42",
value: map[string]uint{"v": 42},
},
{
source: "v: 4294967296",
value: map[string]uint64{"v": uint64(4294967296)},
},
// int
{
source: "v: 2147483647",
value: map[string]int{"v": math.MaxInt32},
},
{
source: "v: -2147483648",
value: map[string]int{"v": math.MinInt32},
},
// int64
{
source: "v: 9223372036854775807",
value: map[string]int64{"v": math.MaxInt64},
},
{
source: "v: 0b111111111111111111111111111111111111111111111111111111111111111",
value: map[string]int64{"v": math.MaxInt64},
},
{
source: "v: -9223372036854775808",
value: map[string]int64{"v": math.MinInt64},
},
{
source: "v: -0b111111111111111111111111111111111111111111111111111111111111111",
value: map[string]int64{"v": -math.MaxInt64},
},
// uint
{
source: "v: 0",
value: map[string]uint{"v": 0},
},
{
source: "v: 4294967295",
value: map[string]uint{"v": math.MaxUint32},
},
{
source: "v: 1e3",
value: map[string]uint{"v": 1000},
},
// uint64
{
source: "v: 0",
value: map[string]uint{"v": 0},
},
{
source: "v: 18446744073709551615",
value: map[string]uint64{"v": math.MaxUint64},
},
{
source: "v: 0b1111111111111111111111111111111111111111111111111111111111111111",
value: map[string]uint64{"v": math.MaxUint64},
},
{
source: "v: 9223372036854775807",
value: map[string]uint64{"v": math.MaxInt64},
},
{
source: "v: 1e3",
value: map[string]uint64{"v": 1000},
},
// float32
{
source: "v: 3.40282346638528859811704183484516925440e+38",
value: map[string]float32{"v": math.MaxFloat32},
},
{
source: "v: 1.401298464324817070923729583289916131280e-45",
value: map[string]float32{"v": math.SmallestNonzeroFloat32},
},
{
source: "v: 18446744073709551615",
value: map[string]float32{"v": float32(math.MaxUint64)},
},
{
source: "v: 18446744073709551616",
value: map[string]float32{"v": float32(math.MaxUint64 + 1)},
},
{
source: "v: 1e-06",
value: map[string]float32{"v": 1e-6},
},
// float64
{
source: "v: 1.797693134862315708145274237317043567981e+308",
value: map[string]float64{"v": math.MaxFloat64},
},
{
source: "v: 4.940656458412465441765687928682213723651e-324",
value: map[string]float64{"v": math.SmallestNonzeroFloat64},
},
{
source: "v: 18446744073709551615",
value: map[string]float64{"v": float64(math.MaxUint64)},
},
{
source: "v: 18446744073709551616",
value: map[string]float64{"v": float64(math.MaxUint64 + 1)},
},
{
source: "v: 1e-06",
value: map[string]float64{"v": 1e-06},
},
// Timestamps
{
// Date only.
source: "v: 2015-01-01\n",
value: map[string]time.Time{"v": time.Date(2015, 1, 1, 0, 0, 0, 0, time.UTC)},
},
{
// RFC3339
source: "v: 2015-02-24T18:19:39.12Z\n",
value: map[string]time.Time{"v": time.Date(2015, 2, 24, 18, 19, 39, .12e9, time.UTC)},
},
{
// RFC3339 with short dates.
source: "v: 2015-2-3T3:4:5Z",
value: map[string]time.Time{"v": time.Date(2015, 2, 3, 3, 4, 5, 0, time.UTC)},
},
{
// ISO8601 lower case t
source: "v: 2015-02-24t18:19:39Z\n",
value: map[string]time.Time{"v": time.Date(2015, 2, 24, 18, 19, 39, 0, time.UTC)},
},
{
// space separate, no time zone
source: "v: 2015-02-24 18:19:39\n",
value: map[string]time.Time{"v": time.Date(2015, 2, 24, 18, 19, 39, 0, time.UTC)},
},
{
source: "v: 60s\n",
value: map[string]time.Duration{"v": time.Minute},
},
{
source: "v: -0.5h\n",
value: map[string]time.Duration{"v": -30 * time.Minute},
},
// Single Quoted values.
{
source: `'1': '2'`,
value: map[interface{}]interface{}{"1": `2`},
},
{
source: `'1': '"2"'`,
value: map[interface{}]interface{}{"1": `"2"`},
},
{
source: `'1': ''''`,
value: map[interface{}]interface{}{"1": `'`},
},
{
source: `'1': '''2'''`,
value: map[interface{}]interface{}{"1": `'2'`},
},
{
source: `'1': 'B''z'`,
value: map[interface{}]interface{}{"1": `B'z`},
},
{
source: `'1': '\'`,
value: map[interface{}]interface{}{"1": `\`},
},
{
source: `'1': '\\'`,
value: map[interface{}]interface{}{"1": `\\`},
},
{
source: `'1': '\"2\"'`,
value: map[interface{}]interface{}{"1": `\"2\"`},
},
{
source: `'1': '\\"2\\"'`,
value: map[interface{}]interface{}{"1": `\\"2\\"`},
},
{
source: "'1': ' 1\n 2\n 3'",
value: map[interface{}]interface{}{"1": " 1 2 3"},
},
{
source: "'1': '\n 2\n 3'",
value: map[interface{}]interface{}{"1": " 2 3"},
},
// Double Quoted values.
{
source: `"1": "2"`,
value: map[interface{}]interface{}{"1": `2`},
},
{
source: `"1": "\"2\""`,
value: map[interface{}]interface{}{"1": `"2"`},
},
{
source: `"1": "\""`,
value: map[interface{}]interface{}{"1": `"`},
},
{
source: `"1": "X\"z"`,
value: map[interface{}]interface{}{"1": `X"z`},
},
{
source: `"1": "\\"`,
value: map[interface{}]interface{}{"1": `\`},
},
{
source: `"1": "\\\\"`,
value: map[interface{}]interface{}{"1": `\\`},
},
{
source: `"1": "\\\"2\\\""`,
value: map[interface{}]interface{}{"1": `\"2\"`},
},
{
source: "'1': \" 1\n 2\n 3\"",
value: map[interface{}]interface{}{"1": " 1 2 3"},
},
{
source: "'1': \"\n 2\n 3\"",
value: map[interface{}]interface{}{"1": " 2 3"},
},
{
source: `"1": "a\x2Fb"`,
value: map[interface{}]interface{}{"1": `a/b`},
},
{
source: `"1": "a\u002Fb"`,
value: map[interface{}]interface{}{"1": `a/b`},
},
{
source: `"1": "a\x2Fb\u002Fc\U0000002Fd"`,
value: map[interface{}]interface{}{"1": `a/b/c/d`},
},
{
source: "'1': \"2\\n3\"",
value: map[interface{}]interface{}{"1": "2\n3"},
},
{
source: "'1': \"2\\r\\n3\"",
value: map[interface{}]interface{}{"1": "2\r\n3"},
},
{
source: "'1': \"a\\\nb\\\nc\"",
value: map[interface{}]interface{}{"1": "abc"},
},
{
source: "'1': \"a\\\r\nb\\\r\nc\"",
value: map[interface{}]interface{}{"1": "abc"},
},
{
source: "'1': \"a\\\rb\\\rc\"",
value: map[interface{}]interface{}{"1": "abc"},
},
{
source: "a: -b_c",
value: map[string]interface{}{"a": "-b_c"},
},
{
source: "a: +b_c",
value: map[string]interface{}{"a": "+b_c"},
},
{
source: "a: 50cent_of_dollar",
value: map[string]interface{}{"a": "50cent_of_dollar"},
},
// Nulls
{
source: "null",
value: (*struct{})(nil),
},
{
source: "~",
value: (*struct{})(nil),
},
{
source: "v:",
value: map[string]interface{}{"v": nil},
},
{
source: "v: ~",
value: map[string]interface{}{"v": nil},
},
{
source: "~: null key",
value: map[interface{}]string{nil: "null key"},
},
{
source: "v:",
value: map[string]*bool{"v": nil},
},
{
source: "v: null",
value: map[string]*string{"v": nil},
},
{
source: "v: null",
value: map[string]string{"v": ""},
},
{
source: "v: null",
value: map[string]interface{}{"v": nil},
},
{
source: "v: Null",
value: map[string]interface{}{"v": nil},
},
{
source: "v: NULL",
value: map[string]interface{}{"v": nil},
},
{
source: "v: ~",
value: map[string]*string{"v": nil},
},
{
source: "v: ~",
value: map[string]string{"v": ""},
},
{
source: "v: .inf\n",
value: map[string]interface{}{"v": math.Inf(0)},
},
{
source: "v: .Inf\n",
value: map[string]interface{}{"v": math.Inf(0)},
},
{
source: "v: .INF\n",
value: map[string]interface{}{"v": math.Inf(0)},
},
{
source: "v: -.inf\n",
value: map[string]interface{}{"v": math.Inf(-1)},
},
{
source: "v: -.Inf\n",
value: map[string]interface{}{"v": math.Inf(-1)},
},
{
source: "v: -.INF\n",
value: map[string]interface{}{"v": math.Inf(-1)},
},
{
source: "v: .nan\n",
value: map[string]interface{}{"v": math.NaN()},
},
{
source: "v: .NaN\n",
value: map[string]interface{}{"v": math.NaN()},
},
{
source: "v: .NAN\n",
value: map[string]interface{}{"v": math.NaN()},
},
// Explicit tags.
{
source: "v: !!float '1.1'",
value: map[string]interface{}{"v": 1.1},
},
{
source: "v: !!float 0",
value: map[string]interface{}{"v": float64(0)},
},
{
source: "v: !!float -1",
value: map[string]interface{}{"v": float64(-1)},
},
{
source: "v: !!null ''",
value: map[string]interface{}{"v": nil},
},
{
source: "v: !!timestamp \"2015-01-01\"",
value: map[string]time.Time{"v": time.Date(2015, 1, 1, 0, 0, 0, 0, time.UTC)},
},
{
source: "v: !!timestamp 2015-01-01",
value: map[string]time.Time{"v": time.Date(2015, 1, 1, 0, 0, 0, 0, time.UTC)},
},
{
source: "v: !!bool yes",
value: map[string]bool{"v": true},
},
{
source: "v: !!bool False",
value: map[string]bool{"v": false},
},
{
source: `
!!merge <<: { a: 1, b: 2 }
c: 3
`,
value: map[string]any{"a": 1, "b": 2, "c": 3},
},
// merge
{
source: `
a: &a
foo: 1
b: &b
bar: 2
merge:
<<: [*a, *b]
`,
value: map[string]map[string]any{
"a": {"foo": 1},
"b": {"bar": 2},
"merge": {"foo": 1, "bar": 2},
},
},
{
source: `
a: &a
foo: 1
b: &b
bar: 2
merge:
<<: [*a, *b]
`,
value: map[string]yaml.MapSlice{
"a": {{Key: "foo", Value: 1}},
"b": {{Key: "bar", Value: 2}},
"merge": {{Key: "foo", Value: 1}, {Key: "bar", Value: 2}},
},
},
// Flow sequence
{
source: "v: [A,B]",
value: map[string]interface{}{"v": []interface{}{"A", "B"}},
},
{
source: "v: [A,B,C,]",
value: map[string][]string{"v": {"A", "B", "C"}},
},
{
source: "v: [A,1,C]",
value: map[string][]string{"v": {"A", "1", "C"}},
},
{
source: "v: [A,1,C]",
value: map[string]interface{}{"v": []interface{}{"A", 1, "C"}},
},
{
source: "v: [a: b, c: d]",
value: map[string]any{"v": []any{
map[string]any{"a": "b"},
map[string]any{"c": "d"},
}},
},
{
source: "v: [{a: b}, {c: d, e: f}]",
value: map[string]any{"v": []any{
map[string]any{"a": "b"},
map[string]any{
"c": "d",
"e": "f",
},
}},
},
// Block sequence
{
source: "v:\n - A\n - B",
value: map[string]interface{}{"v": []interface{}{"A", "B"}},
},
{
source: "v:\n - A\n - B\n - C",
value: map[string][]string{"v": {"A", "B", "C"}},
},
{
source: "v:\n - A\n - 1\n - C",
value: map[string][]string{"v": {"A", "1", "C"}},
},
{
source: "v:\n - A\n - 1\n - C",
value: map[string]interface{}{"v": []interface{}{"A", 1, "C"}},
},
// Map inside interface with no type hints.
{
source: "a: {b: c}",
value: map[interface{}]interface{}{"a": map[interface{}]interface{}{"b": "c"}},
},
{
source: "v: \"\"\n",
value: map[string]string{"v": ""},
},
{
source: "v:\n- A\n- B\n",
value: map[string][]string{"v": {"A", "B"}},
},
{
source: "a: '-'\n",
value: map[string]string{"a": "-"},
},
{
source: "123\n",
value: 123,
},
{
source: "hello: world\n",
value: map[string]string{"hello": "world"},
},
{
source: "hello: world\r\n",
value: map[string]string{"hello": "world"},
},
{
source: "hello: world\rGo: Gopher",
value: map[string]string{"hello": "world", "Go": "Gopher"},
},
// Structs and type conversions.
{
source: "hello: world",
value: struct{ Hello string }{"world"},
},
{
source: "a: {b: c}",
value: struct{ A struct{ B string } }{struct{ B string }{"c"}},
},
{
source: "a: {b: c}",
value: struct{ A map[string]string }{map[string]string{"b": "c"}},
},
{
source: "a:",
value: struct{ A map[string]string }{},
},
{
source: "a: 1",
value: struct{ A int }{1},
},
{
source: "a: 1",
value: struct{ A float64 }{1},
},
{
source: "a: 1.0",
value: struct{ A int }{1},
},
{
source: "a: 1.0",
value: struct{ A uint }{1},
},
{
source: "a: [1, 2]",
value: struct{ A []int }{[]int{1, 2}},
},
{
source: "a: [1, 2]",
value: struct{ A [2]int }{[2]int{1, 2}},
},
{
source: "a: 1",
value: struct{ B int }{0},
},
{
source: "a: 1",
value: struct {
B int `yaml:"a"`
}{1},
},
{
source: "a: 1\n",
value: yaml.MapItem{Key: "a", Value: 1},
},
{
source: "a: 1\nb: 2\nc: 3\n",
value: yaml.MapSlice{
{Key: "a", Value: 1},
{Key: "b", Value: 2},
{Key: "c", Value: 3},
},
},
{
source: "v:\n- A\n- 1\n- B:\n - 2\n - 3\n",
value: map[string]interface{}{
"v": []interface{}{
"A",
1,
map[string][]int{
"B": {2, 3},
},
},
},
},
{
source: "a:\n b: c\n",
value: map[string]interface{}{
"a": map[string]string{
"b": "c",
},
},
},
{
source: "a: {x: 1}\n",
value: map[string]map[string]int{
"a": {
"x": 1,
},
},
},
{
source: "t2: 2018-01-09T10:40:47Z\nt4: 2098-01-09T10:40:47Z\n",
value: map[string]string{
"t2": "2018-01-09T10:40:47Z",
"t4": "2098-01-09T10:40:47Z",
},
},
{
source: "a: [1, 2]\n",
value: map[string][]int{
"a": {1, 2},
},
},
{
source: "a: {b: c, d: e}\n",
value: map[string]interface{}{
"a": map[string]string{
"b": "c",
"d": "e",
},
},
},
{
source: "a: 3s\n",
value: map[string]string{
"a": "3s",
},
},
{
source: "a: