Showing preview only (9,206K chars total). Download the full file or copy to clipboard to get everything.
Repository: kevinburke/go-html-boilerplate
Branch: master
Commit: 4951e684aa80
Files: 578
Total size: 8.7 MB
Directory structure:
gitextract_xmv5ggsg/
├── .github/
│ ├── dependabot.yml
│ └── workflows/
│ └── ci.yml
├── .gitignore
├── LICENSE
├── Makefile
├── README.md
├── assets/
│ └── bindata.go
├── config.yml
├── crypto.go
├── flash.go
├── go.mod
├── go.sum
├── main.go
├── main_test.go
├── static/
│ └── style.css
├── templates/
│ └── index.html
└── vendor/
├── github.com/
│ ├── goccy/
│ │ └── go-yaml/
│ │ ├── .codecov.yml
│ │ ├── .gitignore
│ │ ├── .golangci.yml
│ │ ├── CHANGELOG.md
│ │ ├── LICENSE
│ │ ├── Makefile
│ │ ├── README.md
│ │ ├── ast/
│ │ │ └── ast.go
│ │ ├── context.go
│ │ ├── decode.go
│ │ ├── encode.go
│ │ ├── error.go
│ │ ├── internal/
│ │ │ ├── errors/
│ │ │ │ └── error.go
│ │ │ └── format/
│ │ │ └── format.go
│ │ ├── lexer/
│ │ │ └── lexer.go
│ │ ├── option.go
│ │ ├── parser/
│ │ │ ├── color.go
│ │ │ ├── context.go
│ │ │ ├── node.go
│ │ │ ├── option.go
│ │ │ ├── parser.go
│ │ │ └── token.go
│ │ ├── path.go
│ │ ├── printer/
│ │ │ ├── color.go
│ │ │ └── printer.go
│ │ ├── scanner/
│ │ │ ├── context.go
│ │ │ ├── error.go
│ │ │ └── scanner.go
│ │ ├── stdlib_quote.go
│ │ ├── struct.go
│ │ ├── token/
│ │ │ └── token.go
│ │ ├── validate.go
│ │ └── yaml.go
│ ├── gofrs/
│ │ └── uuid/
│ │ └── v5/
│ │ ├── .gitignore
│ │ ├── .pre-commit-config.yaml
│ │ ├── LICENSE
│ │ ├── README.md
│ │ ├── SECURITY.md
│ │ ├── codec.go
│ │ ├── error.go
│ │ ├── generator.go
│ │ ├── sql.go
│ │ └── uuid.go
│ ├── inconshreveable/
│ │ └── log15/
│ │ └── v3/
│ │ ├── LICENSE
│ │ ├── doc.go
│ │ ├── format.go
│ │ ├── handler.go
│ │ ├── handler_go13.go
│ │ ├── handler_go14.go
│ │ ├── logger.go
│ │ ├── root.go
│ │ └── syslog.go
│ ├── kevinburke/
│ │ ├── handlers/
│ │ │ ├── .gitignore
│ │ │ ├── CHANGELOG.md
│ │ │ ├── LICENSE
│ │ │ ├── Makefile
│ │ │ ├── README.md
│ │ │ ├── ctx.go
│ │ │ ├── gzip.go
│ │ │ ├── lib.go
│ │ │ ├── lib_noslog.go
│ │ │ ├── lib_slog.go
│ │ │ ├── logger_noslog.go
│ │ │ ├── logger_slog.go
│ │ │ └── regex_handler.go
│ │ ├── nacl/
│ │ │ ├── .gitignore
│ │ │ ├── CHANGELOG.md
│ │ │ ├── LICENSE
│ │ │ ├── Makefile
│ │ │ ├── README.md
│ │ │ ├── internal/
│ │ │ │ └── subtle/
│ │ │ │ ├── aliasing.go
│ │ │ │ └── aliasing_appengine.go
│ │ │ ├── nacl.go
│ │ │ ├── onetimeauth/
│ │ │ │ └── onetimeauth.go
│ │ │ ├── randombytes/
│ │ │ │ └── randombytes.go
│ │ │ └── secretbox/
│ │ │ └── secretbox.go
│ │ └── rest/
│ │ ├── .gitignore
│ │ ├── CHANGELOG.md
│ │ ├── LICENSE
│ │ ├── Makefile
│ │ ├── README.md
│ │ ├── ctx.go
│ │ ├── noctx.go
│ │ ├── rest.go
│ │ ├── rest_noslog.go
│ │ ├── rest_slog.go
│ │ ├── restclient/
│ │ │ ├── client.go
│ │ │ └── transport.go
│ │ └── resterror/
│ │ └── resterror.go
│ └── mattn/
│ ├── go-colorable/
│ │ ├── LICENSE
│ │ ├── README.md
│ │ ├── colorable_others.go
│ │ ├── colorable_windows.go
│ │ ├── go.test.sh
│ │ └── noncolorable.go
│ └── go-isatty/
│ ├── LICENSE
│ ├── README.md
│ ├── doc.go
│ ├── go.test.sh
│ ├── isatty_bsd.go
│ ├── isatty_others.go
│ ├── isatty_plan9.go
│ ├── isatty_solaris.go
│ ├── isatty_tcgets.go
│ └── isatty_windows.go
├── golang.org/
│ └── x/
│ ├── crypto/
│ │ ├── LICENSE
│ │ ├── PATENTS
│ │ ├── internal/
│ │ │ └── poly1305/
│ │ │ ├── mac_noasm.go
│ │ │ ├── poly1305.go
│ │ │ ├── sum_amd64.s
│ │ │ ├── sum_asm.go
│ │ │ ├── sum_generic.go
│ │ │ ├── sum_loong64.s
│ │ │ ├── sum_ppc64x.s
│ │ │ ├── sum_s390x.go
│ │ │ └── sum_s390x.s
│ │ ├── poly1305/
│ │ │ └── poly1305_compat.go
│ │ └── salsa20/
│ │ └── salsa/
│ │ ├── hsalsa20.go
│ │ ├── salsa208.go
│ │ ├── salsa20_amd64.go
│ │ ├── salsa20_amd64.s
│ │ ├── salsa20_noasm.go
│ │ └── salsa20_ref.go
│ ├── sys/
│ │ ├── LICENSE
│ │ ├── PATENTS
│ │ ├── cpu/
│ │ │ ├── asm_aix_ppc64.s
│ │ │ ├── asm_darwin_x86_gc.s
│ │ │ ├── byteorder.go
│ │ │ ├── cpu.go
│ │ │ ├── cpu_aix.go
│ │ │ ├── cpu_arm.go
│ │ │ ├── cpu_arm64.go
│ │ │ ├── cpu_arm64.s
│ │ │ ├── cpu_darwin_x86.go
│ │ │ ├── cpu_gc_arm64.go
│ │ │ ├── cpu_gc_s390x.go
│ │ │ ├── cpu_gc_x86.go
│ │ │ ├── cpu_gc_x86.s
│ │ │ ├── cpu_gccgo_arm64.go
│ │ │ ├── cpu_gccgo_s390x.go
│ │ │ ├── cpu_gccgo_x86.c
│ │ │ ├── cpu_gccgo_x86.go
│ │ │ ├── cpu_linux.go
│ │ │ ├── cpu_linux_arm.go
│ │ │ ├── cpu_linux_arm64.go
│ │ │ ├── cpu_linux_loong64.go
│ │ │ ├── cpu_linux_mips64x.go
│ │ │ ├── cpu_linux_noinit.go
│ │ │ ├── cpu_linux_ppc64x.go
│ │ │ ├── cpu_linux_riscv64.go
│ │ │ ├── cpu_linux_s390x.go
│ │ │ ├── cpu_loong64.go
│ │ │ ├── cpu_loong64.s
│ │ │ ├── cpu_mips64x.go
│ │ │ ├── cpu_mipsx.go
│ │ │ ├── cpu_netbsd_arm64.go
│ │ │ ├── cpu_openbsd_arm64.go
│ │ │ ├── cpu_openbsd_arm64.s
│ │ │ ├── cpu_other_arm.go
│ │ │ ├── cpu_other_arm64.go
│ │ │ ├── cpu_other_mips64x.go
│ │ │ ├── cpu_other_ppc64x.go
│ │ │ ├── cpu_other_riscv64.go
│ │ │ ├── cpu_other_x86.go
│ │ │ ├── cpu_ppc64x.go
│ │ │ ├── cpu_riscv64.go
│ │ │ ├── cpu_s390x.go
│ │ │ ├── cpu_s390x.s
│ │ │ ├── cpu_wasm.go
│ │ │ ├── cpu_windows_arm64.go
│ │ │ ├── cpu_x86.go
│ │ │ ├── cpu_zos.go
│ │ │ ├── cpu_zos_s390x.go
│ │ │ ├── endian_big.go
│ │ │ ├── endian_little.go
│ │ │ ├── hwcap_linux.go
│ │ │ ├── parse.go
│ │ │ ├── proc_cpuinfo_linux.go
│ │ │ ├── runtime_auxv.go
│ │ │ ├── runtime_auxv_go121.go
│ │ │ ├── syscall_aix_gccgo.go
│ │ │ ├── syscall_aix_ppc64_gc.go
│ │ │ └── syscall_darwin_x86_gc.go
│ │ ├── plan9/
│ │ │ ├── asm.s
│ │ │ ├── asm_plan9_386.s
│ │ │ ├── asm_plan9_amd64.s
│ │ │ ├── asm_plan9_arm.s
│ │ │ ├── const_plan9.go
│ │ │ ├── dir_plan9.go
│ │ │ ├── env_plan9.go
│ │ │ ├── errors_plan9.go
│ │ │ ├── mkall.sh
│ │ │ ├── mkerrors.sh
│ │ │ ├── mksysnum_plan9.sh
│ │ │ ├── pwd_plan9.go
│ │ │ ├── race.go
│ │ │ ├── race0.go
│ │ │ ├── str.go
│ │ │ ├── syscall.go
│ │ │ ├── syscall_plan9.go
│ │ │ ├── zsyscall_plan9_386.go
│ │ │ ├── zsyscall_plan9_amd64.go
│ │ │ ├── zsyscall_plan9_arm.go
│ │ │ └── zsysnum_plan9.go
│ │ ├── unix/
│ │ │ ├── .gitignore
│ │ │ ├── README.md
│ │ │ ├── affinity_linux.go
│ │ │ ├── aliases.go
│ │ │ ├── asm_aix_ppc64.s
│ │ │ ├── asm_bsd_386.s
│ │ │ ├── asm_bsd_amd64.s
│ │ │ ├── asm_bsd_arm.s
│ │ │ ├── asm_bsd_arm64.s
│ │ │ ├── asm_bsd_ppc64.s
│ │ │ ├── asm_bsd_riscv64.s
│ │ │ ├── asm_linux_386.s
│ │ │ ├── asm_linux_amd64.s
│ │ │ ├── asm_linux_arm.s
│ │ │ ├── asm_linux_arm64.s
│ │ │ ├── asm_linux_loong64.s
│ │ │ ├── asm_linux_mips64x.s
│ │ │ ├── asm_linux_mipsx.s
│ │ │ ├── asm_linux_ppc64x.s
│ │ │ ├── asm_linux_riscv64.s
│ │ │ ├── asm_linux_s390x.s
│ │ │ ├── asm_openbsd_mips64.s
│ │ │ ├── asm_solaris_amd64.s
│ │ │ ├── asm_zos_s390x.s
│ │ │ ├── auxv.go
│ │ │ ├── auxv_unsupported.go
│ │ │ ├── bluetooth_linux.go
│ │ │ ├── bpxsvc_zos.go
│ │ │ ├── bpxsvc_zos.s
│ │ │ ├── cap_freebsd.go
│ │ │ ├── constants.go
│ │ │ ├── dev_aix_ppc.go
│ │ │ ├── dev_aix_ppc64.go
│ │ │ ├── dev_darwin.go
│ │ │ ├── dev_dragonfly.go
│ │ │ ├── dev_freebsd.go
│ │ │ ├── dev_linux.go
│ │ │ ├── dev_netbsd.go
│ │ │ ├── dev_openbsd.go
│ │ │ ├── dev_zos.go
│ │ │ ├── dirent.go
│ │ │ ├── endian_big.go
│ │ │ ├── endian_little.go
│ │ │ ├── env_unix.go
│ │ │ ├── fcntl.go
│ │ │ ├── fcntl_darwin.go
│ │ │ ├── fcntl_linux_32bit.go
│ │ │ ├── fdset.go
│ │ │ ├── gccgo.go
│ │ │ ├── gccgo_c.c
│ │ │ ├── gccgo_linux_amd64.go
│ │ │ ├── ifreq_linux.go
│ │ │ ├── ioctl_linux.go
│ │ │ ├── ioctl_signed.go
│ │ │ ├── ioctl_unsigned.go
│ │ │ ├── ioctl_zos.go
│ │ │ ├── mkall.sh
│ │ │ ├── mkerrors.sh
│ │ │ ├── mmap_nomremap.go
│ │ │ ├── mremap.go
│ │ │ ├── pagesize_unix.go
│ │ │ ├── pledge_openbsd.go
│ │ │ ├── ptrace_darwin.go
│ │ │ ├── ptrace_ios.go
│ │ │ ├── race.go
│ │ │ ├── race0.go
│ │ │ ├── readdirent_getdents.go
│ │ │ ├── readdirent_getdirentries.go
│ │ │ ├── sockcmsg_dragonfly.go
│ │ │ ├── sockcmsg_linux.go
│ │ │ ├── sockcmsg_unix.go
│ │ │ ├── sockcmsg_unix_other.go
│ │ │ ├── sockcmsg_zos.go
│ │ │ ├── symaddr_zos_s390x.s
│ │ │ ├── syscall.go
│ │ │ ├── syscall_aix.go
│ │ │ ├── syscall_aix_ppc.go
│ │ │ ├── syscall_aix_ppc64.go
│ │ │ ├── syscall_bsd.go
│ │ │ ├── syscall_darwin.go
│ │ │ ├── syscall_darwin_amd64.go
│ │ │ ├── syscall_darwin_arm64.go
│ │ │ ├── syscall_darwin_libSystem.go
│ │ │ ├── syscall_dragonfly.go
│ │ │ ├── syscall_dragonfly_amd64.go
│ │ │ ├── syscall_freebsd.go
│ │ │ ├── syscall_freebsd_386.go
│ │ │ ├── syscall_freebsd_amd64.go
│ │ │ ├── syscall_freebsd_arm.go
│ │ │ ├── syscall_freebsd_arm64.go
│ │ │ ├── syscall_freebsd_riscv64.go
│ │ │ ├── syscall_hurd.go
│ │ │ ├── syscall_hurd_386.go
│ │ │ ├── syscall_illumos.go
│ │ │ ├── syscall_linux.go
│ │ │ ├── syscall_linux_386.go
│ │ │ ├── syscall_linux_alarm.go
│ │ │ ├── syscall_linux_amd64.go
│ │ │ ├── syscall_linux_amd64_gc.go
│ │ │ ├── syscall_linux_arm.go
│ │ │ ├── syscall_linux_arm64.go
│ │ │ ├── syscall_linux_gc.go
│ │ │ ├── syscall_linux_gc_386.go
│ │ │ ├── syscall_linux_gc_arm.go
│ │ │ ├── syscall_linux_gccgo_386.go
│ │ │ ├── syscall_linux_gccgo_arm.go
│ │ │ ├── syscall_linux_loong64.go
│ │ │ ├── syscall_linux_mips64x.go
│ │ │ ├── syscall_linux_mipsx.go
│ │ │ ├── syscall_linux_ppc.go
│ │ │ ├── syscall_linux_ppc64x.go
│ │ │ ├── syscall_linux_riscv64.go
│ │ │ ├── syscall_linux_s390x.go
│ │ │ ├── syscall_linux_sparc64.go
│ │ │ ├── syscall_netbsd.go
│ │ │ ├── syscall_netbsd_386.go
│ │ │ ├── syscall_netbsd_amd64.go
│ │ │ ├── syscall_netbsd_arm.go
│ │ │ ├── syscall_netbsd_arm64.go
│ │ │ ├── syscall_openbsd.go
│ │ │ ├── syscall_openbsd_386.go
│ │ │ ├── syscall_openbsd_amd64.go
│ │ │ ├── syscall_openbsd_arm.go
│ │ │ ├── syscall_openbsd_arm64.go
│ │ │ ├── syscall_openbsd_libc.go
│ │ │ ├── syscall_openbsd_mips64.go
│ │ │ ├── syscall_openbsd_ppc64.go
│ │ │ ├── syscall_openbsd_riscv64.go
│ │ │ ├── syscall_solaris.go
│ │ │ ├── syscall_solaris_amd64.go
│ │ │ ├── syscall_unix.go
│ │ │ ├── syscall_unix_gc.go
│ │ │ ├── syscall_unix_gc_ppc64x.go
│ │ │ ├── syscall_zos_s390x.go
│ │ │ ├── sysvshm_linux.go
│ │ │ ├── sysvshm_unix.go
│ │ │ ├── sysvshm_unix_other.go
│ │ │ ├── timestruct.go
│ │ │ ├── unveil_openbsd.go
│ │ │ ├── vgetrandom_linux.go
│ │ │ ├── vgetrandom_unsupported.go
│ │ │ ├── xattr_bsd.go
│ │ │ ├── zerrors_aix_ppc.go
│ │ │ ├── zerrors_aix_ppc64.go
│ │ │ ├── zerrors_darwin_amd64.go
│ │ │ ├── zerrors_darwin_arm64.go
│ │ │ ├── zerrors_dragonfly_amd64.go
│ │ │ ├── zerrors_freebsd_386.go
│ │ │ ├── zerrors_freebsd_amd64.go
│ │ │ ├── zerrors_freebsd_arm.go
│ │ │ ├── zerrors_freebsd_arm64.go
│ │ │ ├── zerrors_freebsd_riscv64.go
│ │ │ ├── zerrors_linux.go
│ │ │ ├── zerrors_linux_386.go
│ │ │ ├── zerrors_linux_amd64.go
│ │ │ ├── zerrors_linux_arm.go
│ │ │ ├── zerrors_linux_arm64.go
│ │ │ ├── zerrors_linux_loong64.go
│ │ │ ├── zerrors_linux_mips.go
│ │ │ ├── zerrors_linux_mips64.go
│ │ │ ├── zerrors_linux_mips64le.go
│ │ │ ├── zerrors_linux_mipsle.go
│ │ │ ├── zerrors_linux_ppc.go
│ │ │ ├── zerrors_linux_ppc64.go
│ │ │ ├── zerrors_linux_ppc64le.go
│ │ │ ├── zerrors_linux_riscv64.go
│ │ │ ├── zerrors_linux_s390x.go
│ │ │ ├── zerrors_linux_sparc64.go
│ │ │ ├── zerrors_netbsd_386.go
│ │ │ ├── zerrors_netbsd_amd64.go
│ │ │ ├── zerrors_netbsd_arm.go
│ │ │ ├── zerrors_netbsd_arm64.go
│ │ │ ├── zerrors_openbsd_386.go
│ │ │ ├── zerrors_openbsd_amd64.go
│ │ │ ├── zerrors_openbsd_arm.go
│ │ │ ├── zerrors_openbsd_arm64.go
│ │ │ ├── zerrors_openbsd_mips64.go
│ │ │ ├── zerrors_openbsd_ppc64.go
│ │ │ ├── zerrors_openbsd_riscv64.go
│ │ │ ├── zerrors_solaris_amd64.go
│ │ │ ├── zerrors_zos_s390x.go
│ │ │ ├── zptrace_armnn_linux.go
│ │ │ ├── zptrace_linux_arm64.go
│ │ │ ├── zptrace_mipsnn_linux.go
│ │ │ ├── zptrace_mipsnnle_linux.go
│ │ │ ├── zptrace_x86_linux.go
│ │ │ ├── zsymaddr_zos_s390x.s
│ │ │ ├── zsyscall_aix_ppc.go
│ │ │ ├── zsyscall_aix_ppc64.go
│ │ │ ├── zsyscall_aix_ppc64_gc.go
│ │ │ ├── zsyscall_aix_ppc64_gccgo.go
│ │ │ ├── zsyscall_darwin_amd64.go
│ │ │ ├── zsyscall_darwin_amd64.s
│ │ │ ├── zsyscall_darwin_arm64.go
│ │ │ ├── zsyscall_darwin_arm64.s
│ │ │ ├── zsyscall_dragonfly_amd64.go
│ │ │ ├── zsyscall_freebsd_386.go
│ │ │ ├── zsyscall_freebsd_amd64.go
│ │ │ ├── zsyscall_freebsd_arm.go
│ │ │ ├── zsyscall_freebsd_arm64.go
│ │ │ ├── zsyscall_freebsd_riscv64.go
│ │ │ ├── zsyscall_illumos_amd64.go
│ │ │ ├── zsyscall_linux.go
│ │ │ ├── zsyscall_linux_386.go
│ │ │ ├── zsyscall_linux_amd64.go
│ │ │ ├── zsyscall_linux_arm.go
│ │ │ ├── zsyscall_linux_arm64.go
│ │ │ ├── zsyscall_linux_loong64.go
│ │ │ ├── zsyscall_linux_mips.go
│ │ │ ├── zsyscall_linux_mips64.go
│ │ │ ├── zsyscall_linux_mips64le.go
│ │ │ ├── zsyscall_linux_mipsle.go
│ │ │ ├── zsyscall_linux_ppc.go
│ │ │ ├── zsyscall_linux_ppc64.go
│ │ │ ├── zsyscall_linux_ppc64le.go
│ │ │ ├── zsyscall_linux_riscv64.go
│ │ │ ├── zsyscall_linux_s390x.go
│ │ │ ├── zsyscall_linux_sparc64.go
│ │ │ ├── zsyscall_netbsd_386.go
│ │ │ ├── zsyscall_netbsd_amd64.go
│ │ │ ├── zsyscall_netbsd_arm.go
│ │ │ ├── zsyscall_netbsd_arm64.go
│ │ │ ├── zsyscall_openbsd_386.go
│ │ │ ├── zsyscall_openbsd_386.s
│ │ │ ├── zsyscall_openbsd_amd64.go
│ │ │ ├── zsyscall_openbsd_amd64.s
│ │ │ ├── zsyscall_openbsd_arm.go
│ │ │ ├── zsyscall_openbsd_arm.s
│ │ │ ├── zsyscall_openbsd_arm64.go
│ │ │ ├── zsyscall_openbsd_arm64.s
│ │ │ ├── zsyscall_openbsd_mips64.go
│ │ │ ├── zsyscall_openbsd_mips64.s
│ │ │ ├── zsyscall_openbsd_ppc64.go
│ │ │ ├── zsyscall_openbsd_ppc64.s
│ │ │ ├── zsyscall_openbsd_riscv64.go
│ │ │ ├── zsyscall_openbsd_riscv64.s
│ │ │ ├── zsyscall_solaris_amd64.go
│ │ │ ├── zsyscall_zos_s390x.go
│ │ │ ├── zsysctl_openbsd_386.go
│ │ │ ├── zsysctl_openbsd_amd64.go
│ │ │ ├── zsysctl_openbsd_arm.go
│ │ │ ├── zsysctl_openbsd_arm64.go
│ │ │ ├── zsysctl_openbsd_mips64.go
│ │ │ ├── zsysctl_openbsd_ppc64.go
│ │ │ ├── zsysctl_openbsd_riscv64.go
│ │ │ ├── zsysnum_darwin_amd64.go
│ │ │ ├── zsysnum_darwin_arm64.go
│ │ │ ├── zsysnum_dragonfly_amd64.go
│ │ │ ├── zsysnum_freebsd_386.go
│ │ │ ├── zsysnum_freebsd_amd64.go
│ │ │ ├── zsysnum_freebsd_arm.go
│ │ │ ├── zsysnum_freebsd_arm64.go
│ │ │ ├── zsysnum_freebsd_riscv64.go
│ │ │ ├── zsysnum_linux_386.go
│ │ │ ├── zsysnum_linux_amd64.go
│ │ │ ├── zsysnum_linux_arm.go
│ │ │ ├── zsysnum_linux_arm64.go
│ │ │ ├── zsysnum_linux_loong64.go
│ │ │ ├── zsysnum_linux_mips.go
│ │ │ ├── zsysnum_linux_mips64.go
│ │ │ ├── zsysnum_linux_mips64le.go
│ │ │ ├── zsysnum_linux_mipsle.go
│ │ │ ├── zsysnum_linux_ppc.go
│ │ │ ├── zsysnum_linux_ppc64.go
│ │ │ ├── zsysnum_linux_ppc64le.go
│ │ │ ├── zsysnum_linux_riscv64.go
│ │ │ ├── zsysnum_linux_s390x.go
│ │ │ ├── zsysnum_linux_sparc64.go
│ │ │ ├── zsysnum_netbsd_386.go
│ │ │ ├── zsysnum_netbsd_amd64.go
│ │ │ ├── zsysnum_netbsd_arm.go
│ │ │ ├── zsysnum_netbsd_arm64.go
│ │ │ ├── zsysnum_openbsd_386.go
│ │ │ ├── zsysnum_openbsd_amd64.go
│ │ │ ├── zsysnum_openbsd_arm.go
│ │ │ ├── zsysnum_openbsd_arm64.go
│ │ │ ├── zsysnum_openbsd_mips64.go
│ │ │ ├── zsysnum_openbsd_ppc64.go
│ │ │ ├── zsysnum_openbsd_riscv64.go
│ │ │ ├── zsysnum_zos_s390x.go
│ │ │ ├── ztypes_aix_ppc.go
│ │ │ ├── ztypes_aix_ppc64.go
│ │ │ ├── ztypes_darwin_amd64.go
│ │ │ ├── ztypes_darwin_arm64.go
│ │ │ ├── ztypes_dragonfly_amd64.go
│ │ │ ├── ztypes_freebsd_386.go
│ │ │ ├── ztypes_freebsd_amd64.go
│ │ │ ├── ztypes_freebsd_arm.go
│ │ │ ├── ztypes_freebsd_arm64.go
│ │ │ ├── ztypes_freebsd_riscv64.go
│ │ │ ├── ztypes_linux.go
│ │ │ ├── ztypes_linux_386.go
│ │ │ ├── ztypes_linux_amd64.go
│ │ │ ├── ztypes_linux_arm.go
│ │ │ ├── ztypes_linux_arm64.go
│ │ │ ├── ztypes_linux_loong64.go
│ │ │ ├── ztypes_linux_mips.go
│ │ │ ├── ztypes_linux_mips64.go
│ │ │ ├── ztypes_linux_mips64le.go
│ │ │ ├── ztypes_linux_mipsle.go
│ │ │ ├── ztypes_linux_ppc.go
│ │ │ ├── ztypes_linux_ppc64.go
│ │ │ ├── ztypes_linux_ppc64le.go
│ │ │ ├── ztypes_linux_riscv64.go
│ │ │ ├── ztypes_linux_s390x.go
│ │ │ ├── ztypes_linux_sparc64.go
│ │ │ ├── ztypes_netbsd_386.go
│ │ │ ├── ztypes_netbsd_amd64.go
│ │ │ ├── ztypes_netbsd_arm.go
│ │ │ ├── ztypes_netbsd_arm64.go
│ │ │ ├── ztypes_openbsd_386.go
│ │ │ ├── ztypes_openbsd_amd64.go
│ │ │ ├── ztypes_openbsd_arm.go
│ │ │ ├── ztypes_openbsd_arm64.go
│ │ │ ├── ztypes_openbsd_mips64.go
│ │ │ ├── ztypes_openbsd_ppc64.go
│ │ │ ├── ztypes_openbsd_riscv64.go
│ │ │ ├── ztypes_solaris_amd64.go
│ │ │ └── ztypes_zos_s390x.go
│ │ └── windows/
│ │ ├── aliases.go
│ │ ├── dll_windows.go
│ │ ├── env_windows.go
│ │ ├── eventlog.go
│ │ ├── exec_windows.go
│ │ ├── memory_windows.go
│ │ ├── mkerrors.bash
│ │ ├── mkknownfolderids.bash
│ │ ├── mksyscall.go
│ │ ├── race.go
│ │ ├── race0.go
│ │ ├── security_windows.go
│ │ ├── service.go
│ │ ├── setupapi_windows.go
│ │ ├── str.go
│ │ ├── syscall.go
│ │ ├── syscall_windows.go
│ │ ├── types_windows.go
│ │ ├── types_windows_386.go
│ │ ├── types_windows_amd64.go
│ │ ├── types_windows_arm.go
│ │ ├── types_windows_arm64.go
│ │ ├── zerrors_windows.go
│ │ ├── zknownfolderids_windows.go
│ │ └── zsyscall_windows.go
│ └── term/
│ ├── CONTRIBUTING.md
│ ├── LICENSE
│ ├── PATENTS
│ ├── README.md
│ ├── codereview.cfg
│ ├── term.go
│ ├── term_plan9.go
│ ├── term_unix.go
│ ├── term_unix_bsd.go
│ ├── term_unix_other.go
│ ├── term_unsupported.go
│ ├── term_windows.go
│ └── terminal.go
└── modules.txt
================================================
FILE CONTENTS
================================================
================================================
FILE: .github/dependabot.yml
================================================
version: 2
updates:
- package-ecosystem: gomod
directory: /
schedule:
interval: weekly
day: monday
time: "06:00"
timezone: America/Los_Angeles
open-pull-requests-limit: 10
- package-ecosystem: github-actions
directory: /
schedule:
interval: weekly
day: monday
time: "06:00"
timezone: America/Los_Angeles
open-pull-requests-limit: 5
================================================
FILE: .github/workflows/ci.yml
================================================
name: CI
on:
push:
pull_request:
permissions:
contents: read
concurrency:
group: ci-${{ github.workflow }}-${{ github.ref }}
cancel-in-progress: true
jobs:
test:
name: ${{ matrix.os }} / Go stable
runs-on: ${{ matrix.os }}
timeout-minutes: 15
strategy:
fail-fast: false
matrix:
os:
- ubuntu-latest
- macos-latest
- windows-latest
steps:
- uses: actions/checkout@v6
- uses: actions/setup-go@v6
with:
go-version: stable
check-latest: true
cache-dependency-path: go.sum
- name: Show Go version
run: go version
- name: Lint and test
run: |
go run honnef.co/go/tools/cmd/staticcheck@latest ./...
go vet ./...
go test -trimpath ./...
================================================
FILE: .gitignore
================================================
/certs
/releases
# These aren't generated anymore but might have been generated by an older
# release.
/*.pem
================================================
FILE: LICENSE
================================================
Copyright (c) 2019 Kevin Burke
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
================================================
FILE: Makefile
================================================
.PHONY: assets static templates
SHELL = /bin/bash -o pipefail
BENCHSTAT := $(GOPATH)/bin/benchstat
BUMP_VERSION := $(GOPATH)/bin/bump_version
DIFFER := $(GOPATH)/bin/differ
GENERATE_TLS_CERT = $(GOPATH)/bin/generate-tls-cert
GO_BINDATA := $(GOPATH)/bin/go-bindata
JUSTRUN := $(GOPATH)/bin/justrun
RELEASE := $(GOPATH)/bin/github-release
# Add files that change frequently to this list.
WATCH_TARGETS = $(shell find ./static ./templates -type f)
GO_FILES = $(shell find . -name '*.go')
GO_NOASSET_FILES := $(filter-out ./assets/bindata.go,$(GO_FILES))
test: vet
go test -trimpath ./...
vet:
staticcheck ./...
go vet ./...
race-test: vet
go test -race -trimpath ./...
diff: $(DIFFER)
$(DIFFER) $(MAKE) assets
$(BENCHSTAT):
go get golang.org/x/perf/cmd/benchstat
bench: | $(BENCHSTAT)
tmp=$$(mktemp); go list ./... | grep -v vendor | xargs go test -benchtime=2s -bench=. -run='^$$' > "$$tmp" 2>&1 && $(BENCHSTAT) "$$tmp"
$(GOPATH)/bin/go-html-boilerplate: $(GO_FILES)
go install .
serve: $(GOPATH)/bin/go-html-boilerplate
$(GOPATH)/bin/go-html-boilerplate
$(GENERATE_TLS_CERT):
go install github.com/kevinburke/generate-tls-cert@latest
certs/leaf.pem: | $(GENERATE_TLS_CERT)
mkdir -p certs
cd certs && $(GENERATE_TLS_CERT) --host=localhost,127.0.0.1
# Generate TLS certificates for local development.
generate_cert: certs/leaf.pem | $(GENERATE_TLS_CERT)
$(GO_BINDATA):
go get -u github.com/kevinburke/go-bindata/...
assets/bindata.go: $(WATCH_TARGETS) | $(GO_BINDATA)
$(GO_BINDATA) -o=assets/bindata.go --nocompress --nometadata --pkg=assets templates/... static/...
assets: assets/bindata.go
$(JUSTRUN):
go get -u github.com/jmhodges/justrun
watch: | $(JUSTRUN)
$(JUSTRUN) -v --delay=100ms -c 'make assets serve' $(WATCH_TARGETS) $(GO_NOASSET_FILES)
$(BUMP_VERSION):
go get github.com/kevinburke/bump_version
$(DIFFER):
go get github.com/kevinburke/differ
$(RELEASE):
go get -u github.com/aktau/github-release
# Run "GITHUB_TOKEN=my-token make release version=major|minor|patch" to release a new version.
release: diff race-test | $(BUMP_VERSION) $(RELEASE)
ifndef version
@echo "Please provide a version"
exit 1
endif
$(BUMP_VERSION) --tag-prefix=v $(version) main.go
git push origin --tags
================================================
FILE: README.md
================================================
# Go html boilerplate
This is a starter pack for doing [web development with Go][post], with support
for some of the things you'll usually want to add to an HTML web server:
- Adding templates and rendering them
- Regex matching for routes
- Logging requests and responses
- Serving static content with caching/busting
- Watching/restarting the server after changes to CSS/templates
- Loading configuration from a config file
- Flash success and error messages
[Read more about the choices and the feature set found here][post]. You can [see
an example project using go-html-boilerplate here][multi-emailer].
[multi-emailer]: https://github.com/kevinburke/multi-emailer
Feel free to adapt the project as you see fit; that should be pretty easy to
do since no one component does too much on its own, and all of them operate on
standard library interfaces like `http.Handler`.
To get started, run `go get ./...` and then `make serve` to start a server on
port 7065. You may need to run `make generate_cert` to generate a self-signed
certificate for local use.
Templates go in the "templates" folder; you can see how they're loaded by
examining the `init` function in main.go. Run `make assets` to recompile them
into the binary.
Static files go in the "static" folder. Run `make assets` to recompile them into
the binary.
### Watching for changes
Run `make watch` to restart the server after you make changes to the assets
directory.
If you are on a Mac, be sure to **add this folder to the Spotlight privacy
list**, or file modify events will [fire a second time when Spotlight indexes
updates][fsnotify].
[fsnotify]: https://github.com/fsnotify/fsnotify/issues/15
[post]: https://kev.inburke.com/kevin/go-web-development/?github
================================================
FILE: assets/bindata.go
================================================
// Code generated by go-bindata. DO NOT EDIT.
// sources:
// templates/index.html (502B)
// static/style.css (99B)
package assets
import (
"crypto/sha256"
"fmt"
"os"
"path/filepath"
"strings"
"time"
)
type asset struct {
bytes []byte
info os.FileInfo
digest [sha256.Size]byte
}
type bindataFileInfo struct {
name string
size int64
mode os.FileMode
modTime time.Time
}
func (fi bindataFileInfo) Name() string {
return fi.name
}
func (fi bindataFileInfo) Size() int64 {
return fi.size
}
func (fi bindataFileInfo) Mode() os.FileMode {
return fi.mode
}
func (fi bindataFileInfo) ModTime() time.Time {
return fi.modTime
}
func (fi bindataFileInfo) IsDir() bool {
return false
}
func (fi bindataFileInfo) Sys() interface{} {
return nil
}
var _templatesIndexHtml = []byte(`<!doctype html>
<html>
<head>
<meta charset="utf-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>Go HTML Template</title>
<link rel="stylesheet" href="/static/style.css?{{ hashurl "/static/style.css" }}">
</head>
<body>
<h1>Hello World!</h1>
<p>
<a href="https://github.com/kevinburke/go-html-boilerplate">View the source code for this server</a>.
</p>
</body>
</html>
`)
func templatesIndexHtmlBytes() ([]byte, error) {
return _templatesIndexHtml, nil
}
func templatesIndexHtml() (*asset, error) {
bytes, err := templatesIndexHtmlBytes()
if err != nil {
return nil, err
}
info := bindataFileInfo{name: "templates/index.html", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)}
a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x2c, 0x8d, 0x8, 0x84, 0x8c, 0xb7, 0x38, 0x19, 0x0, 0x10, 0xf9, 0xa7, 0x67, 0x7c, 0xbe, 0x1f, 0x89, 0xfa, 0xce, 0x7b, 0x7c, 0xfe, 0x23, 0x47, 0x43, 0xe9, 0x1a, 0xa9, 0xa6, 0x42, 0xc8, 0x52}}
return a, nil
}
var _staticStyleCss = []byte(`body {
max-width: 1200px;
margin: 0 auto;
font-family: Helvetica, Arial, sans-serif;
}
`)
func staticStyleCssBytes() ([]byte, error) {
return _staticStyleCss, nil
}
func staticStyleCss() (*asset, error) {
bytes, err := staticStyleCssBytes()
if err != nil {
return nil, err
}
info := bindataFileInfo{name: "static/style.css", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)}
a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xf6, 0x2e, 0x3c, 0x9b, 0x2a, 0xb2, 0x32, 0x4c, 0x7d, 0xe0, 0xa5, 0x70, 0x8b, 0x9d, 0x33, 0xf2, 0x4c, 0x1c, 0x32, 0xf9, 0x79, 0xfc, 0x1a, 0x74, 0xd9, 0x1d, 0xae, 0xc, 0x87, 0xf4, 0xdb, 0xa6}}
return a, nil
}
// Asset loads and returns the asset for the given name.
// It returns an error if the asset could not be found or
// could not be loaded.
func Asset(name string) ([]byte, error) {
canonicalName := strings.Replace(name, "\\", "/", -1)
if f, ok := _bindata[canonicalName]; ok {
a, err := f()
if err != nil {
return nil, fmt.Errorf("Asset %s can't read by error: %v", name, err)
}
return a.bytes, nil
}
return nil, fmt.Errorf("Asset %s not found", name)
}
// AssetString returns the asset contents as a string (instead of a []byte).
func AssetString(name string) (string, error) {
data, err := Asset(name)
return string(data), err
}
// MustAsset is like Asset but panics when Asset would return an error.
// It simplifies safe initialization of global variables.
func MustAsset(name string) []byte {
a, err := Asset(name)
if err != nil {
panic("asset: Asset(" + name + "): " + err.Error())
}
return a
}
// MustAssetString is like AssetString but panics when Asset would return an
// error. It simplifies safe initialization of global variables.
func MustAssetString(name string) string {
return string(MustAsset(name))
}
// AssetInfo loads and returns the asset info for the given name.
// It returns an error if the asset could not be found or
// could not be loaded.
func AssetInfo(name string) (os.FileInfo, error) {
canonicalName := strings.Replace(name, "\\", "/", -1)
if f, ok := _bindata[canonicalName]; ok {
a, err := f()
if err != nil {
return nil, fmt.Errorf("AssetInfo %s can't read by error: %v", name, err)
}
return a.info, nil
}
return nil, fmt.Errorf("AssetInfo %s not found", name)
}
// AssetDigest returns the digest of the file with the given name. It returns an
// error if the asset could not be found or the digest could not be loaded.
func AssetDigest(name string) ([sha256.Size]byte, error) {
canonicalName := strings.Replace(name, "\\", "/", -1)
if f, ok := _bindata[canonicalName]; ok {
a, err := f()
if err != nil {
return [sha256.Size]byte{}, fmt.Errorf("AssetDigest %s can't read by error: %v", name, err)
}
return a.digest, nil
}
return [sha256.Size]byte{}, fmt.Errorf("AssetDigest %s not found", name)
}
// Digests returns a map of all known files and their checksums.
func Digests() (map[string][sha256.Size]byte, error) {
mp := make(map[string][sha256.Size]byte, len(_bindata))
for name := range _bindata {
a, err := _bindata[name]()
if err != nil {
return nil, err
}
mp[name] = a.digest
}
return mp, nil
}
// AssetNames returns the names of the assets.
func AssetNames() []string {
names := make([]string, 0, len(_bindata))
for name := range _bindata {
names = append(names, name)
}
return names
}
// _bindata is a table, holding each asset generator, mapped to its name.
var _bindata = map[string]func() (*asset, error){
"templates/index.html": templatesIndexHtml,
"static/style.css": staticStyleCss,
}
// AssetDebug is true if the assets were built with the debug flag enabled.
const AssetDebug = false
// AssetDir returns the file names below a certain
// directory embedded in the file by go-bindata.
// For example if you run go-bindata on data/... and data contains the
// following hierarchy:
//
// data/
// foo.txt
// img/
// a.png
// b.png
//
// then AssetDir("data") would return []string{"foo.txt", "img"},
// AssetDir("data/img") would return []string{"a.png", "b.png"},
// AssetDir("foo.txt") and AssetDir("notexist") would return an error, and
// AssetDir("") will return []string{"data"}.
func AssetDir(name string) ([]string, error) {
node := _bintree
if len(name) != 0 {
canonicalName := strings.Replace(name, "\\", "/", -1)
pathList := strings.Split(canonicalName, "/")
for _, p := range pathList {
node = node.Children[p]
if node == nil {
return nil, fmt.Errorf("Asset %s not found", name)
}
}
}
if node.Func != nil {
return nil, fmt.Errorf("Asset %s not found", name)
}
rv := make([]string, 0, len(node.Children))
for childName := range node.Children {
rv = append(rv, childName)
}
return rv, nil
}
type bintree struct {
Func func() (*asset, error)
Children map[string]*bintree
}
var _bintree = &bintree{nil, map[string]*bintree{
"static": {nil, map[string]*bintree{
"style.css": {staticStyleCss, map[string]*bintree{}},
}},
"templates": {nil, map[string]*bintree{
"index.html": {templatesIndexHtml, map[string]*bintree{}},
}},
}}
// RestoreAsset restores an asset under the given directory.
func RestoreAsset(dir, name string) error {
data, err := Asset(name)
if err != nil {
return err
}
info, err := AssetInfo(name)
if err != nil {
return err
}
err = os.MkdirAll(_filePath(dir, filepath.Dir(name)), os.FileMode(0755))
if err != nil {
return err
}
err = os.WriteFile(_filePath(dir, name), data, info.Mode())
if err != nil {
return err
}
return os.Chtimes(_filePath(dir, name), info.ModTime(), info.ModTime())
}
// RestoreAssets restores an asset under the given directory recursively.
func RestoreAssets(dir, name string) error {
children, err := AssetDir(name)
// File
if err != nil {
return RestoreAsset(dir, name)
}
// Dir
for _, child := range children {
err = RestoreAssets(dir, filepath.Join(name, child))
if err != nil {
return err
}
}
return nil
}
func _filePath(dir, name string) string {
canonicalName := strings.Replace(name, "\\", "/", -1)
return filepath.Join(append([]string{dir}, strings.Split(canonicalName, "/")...)...)
}
================================================
FILE: config.yml
================================================
port: 7065
# Run "make generate_cert" to generate these files.
cert_file: certs/leaf.pem
key_file: certs/leaf.key
================================================
FILE: crypto.go
================================================
package main
// Helpers for two-way encryption with a secret key.
import (
"encoding/base64"
"github.com/kevinburke/nacl"
"github.com/kevinburke/nacl/secretbox"
)
func opaqueByte(b []byte, secretKey nacl.Key) string {
out := secretbox.EasySeal(b, secretKey)
return base64.URLEncoding.EncodeToString(out)
}
func unopaqueByte(compressed string, secretKey nacl.Key) ([]byte, error) {
encrypted, err := base64.URLEncoding.DecodeString(compressed)
if err != nil {
return nil, err
}
return secretbox.EasyOpen(encrypted, secretKey)
}
// Opaque encrypts s with secretKey and returns the encrypted string encoded
// with base64, or an error.
func opaque(s string, secretKey *[32]byte) string {
return opaqueByte([]byte(s), secretKey)
}
// Unopaque decodes compressed using base64, then decrypts the decoded byte
// array using the secretKey.
func unopaque(compressed string, secretKey *[32]byte) (string, error) {
b, err := unopaqueByte(compressed, secretKey)
if err != nil {
return "", err
}
return string(b), nil
}
================================================
FILE: flash.go
================================================
package main
// Helper functions for setting a flash message as a cookie, and then reading
// that flash message in another request.
import (
"net/http"
"strings"
"time"
)
// FlashSuccess encrypts msg and sets it as a cookie on w. Only one success
// message can be set on w; the last call to FlashSuccess will be set on the
// response.
func FlashSuccess(w http.ResponseWriter, msg string, key *[32]byte) {
setCookie(w, msg, "flash-success", key)
}
// FlashError encrypts msg and sets it as a cookie on w. Only one error can be
// set on w; the last call to FlashError will be set on the response.
func FlashError(w http.ResponseWriter, msg string, key *[32]byte) {
setCookie(w, msg, "flash-error", key)
}
func setCookie(w http.ResponseWriter, msg string, name string, key *[32]byte) {
c := &http.Cookie{
Name: name,
Path: "/",
Value: opaque(name+"|"+msg, key),
HttpOnly: true,
}
http.SetCookie(w, c)
}
// GetFlashSuccess finds a flash success message in the request (if one exists).
// If one exists then it's unset and returned.
func GetFlashSuccess(w http.ResponseWriter, r *http.Request, key *[32]byte) string {
return getCookie(w, r, "flash-success", key)
}
// GetFlashError finds a flash error in the request (if one exists). If one
// exists then it's unset and returned.
func GetFlashError(w http.ResponseWriter, r *http.Request, key *[32]byte) string {
return getCookie(w, r, "flash-error", key)
}
func getCookie(w http.ResponseWriter, r *http.Request, name string, key *[32]byte) string {
cookie, err := r.Cookie(name)
if err == http.ErrNoCookie {
return ""
}
clearCookie(w, name)
msg, err := unopaque(cookie.Value, key)
if err != nil {
return ""
}
if !strings.HasPrefix(msg, name+"|") {
clearCookie(w, name)
return ""
}
return msg[len(name)+1:]
}
func clearCookie(w http.ResponseWriter, name string) {
http.SetCookie(w, &http.Cookie{
Name: name,
Path: "/",
MaxAge: -1,
Expires: time.Unix(1, 0),
})
}
================================================
FILE: go.mod
================================================
module github.com/kevinburke/go-html-boilerplate
go 1.24.0
require (
github.com/goccy/go-yaml v1.19.2
github.com/kevinburke/handlers v0.48.0
github.com/kevinburke/nacl v0.9.0
github.com/kevinburke/rest v0.0.0-20260226201626-8eed36da8c35
)
require (
github.com/gofrs/uuid/v5 v5.4.0 // indirect
github.com/inconshreveable/log15/v3 v3.1.0 // indirect
github.com/mattn/go-colorable v0.1.14 // indirect
github.com/mattn/go-isatty v0.0.20 // indirect
golang.org/x/crypto v0.40.0 // indirect
golang.org/x/sys v0.41.0 // indirect
golang.org/x/term v0.40.0 // indirect
)
================================================
FILE: go.sum
================================================
github.com/goccy/go-yaml v1.19.2 h1:PmFC1S6h8ljIz6gMRBopkjP1TVT7xuwrButHID66PoM=
github.com/goccy/go-yaml v1.19.2/go.mod h1:XBurs7gK8ATbW4ZPGKgcbrY1Br56PdM69F7LkFRi1kA=
github.com/gofrs/uuid/v5 v5.4.0 h1:EfbpCTjqMuGyq5ZJwxqzn3Cbr2d0rUZU7v5ycAk/e/0=
github.com/gofrs/uuid/v5 v5.4.0/go.mod h1:CDOjlDMVAtN56jqyRUZh58JT31Tiw7/oQyEXZV+9bD8=
github.com/inconshreveable/log15/v3 v3.1.0 h1:k2mDgq/cBXG0zfVwoDUGvZfel7r+cGD3/6+5cFhM0Zg=
github.com/inconshreveable/log15/v3 v3.1.0/go.mod h1:wBTTBTUs5OkuP5707+qsSwdJidDzxReILCwJgEb8lN8=
github.com/kevinburke/handlers v0.48.0 h1:KlLRpzjfAqkm5nyN5bEbNv+xpB89f76Ojs7sO1ui4sM=
github.com/kevinburke/handlers v0.48.0/go.mod h1:SU5P4j4X4RePv7gr4vNYp2fCWmkWMkqxNvFKRAHJLmk=
github.com/kevinburke/nacl v0.9.0 h1:2C9v+jXTUUlK19kw+9rqfsdO7riP5xIyHNJ3GvsgOro=
github.com/kevinburke/nacl v0.9.0/go.mod h1:qxFJhGMHIPiWJXUauGGORlObOR4bLKBqf/n6PL8l8N0=
github.com/kevinburke/rest v0.0.0-20260226201626-8eed36da8c35 h1:oKRql5U9KOeRmyyetZUKWSoAZFzFHakJ3tqdFBELVTc=
github.com/kevinburke/rest v0.0.0-20260226201626-8eed36da8c35/go.mod h1:Fqq3AMJ2uvn3zSO5bO+FIM3gzJcA1+zAPJU2SnrwOuc=
github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
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.40.0 h1:r4x+VvoG5Fm+eJcxMaY8CQM7Lb0l1lsmjGBQ6s8BfKM=
golang.org/x/crypto v0.40.0/go.mod h1:Qr1vMER5WyS2dfPHAlsOj01wgLbsyWtFn/aY+5+ZdxY=
golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.41.0 h1:Ivj+2Cp/ylzLiEU89QhWblYnOE9zerudt9Ftecq2C6k=
golang.org/x/sys v0.41.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
golang.org/x/term v0.40.0 h1:36e4zGLqU4yhjlmxEaagx2KuYbJq3EwY8K943ZsHcvg=
golang.org/x/term v0.40.0/go.mod h1:w2P8uVp06p2iyKKuvXIm7N/y0UCRt3UfJTfZ7oOpglM=
================================================
FILE: main.go
================================================
// go-html-boilerplate loads configuration from a file and starts a HTTP server
// that can render HTML templates and static assets.
//
// See config.yml for an explanation of the configuration options for the
// server, and the Makefile for various tasks you can run in coordination with
// the server (run tests, build assets, start the server).
package main
import (
"bytes"
"crypto/sha256"
"encoding/base64"
"flag"
"fmt"
"html/template"
"log/slog"
"net"
"net/http"
"os"
"regexp"
"strconv"
"strings"
"time"
// When you copy this project, change this to the name of your project,
// otherwise you'll get inexplicable 404's.
"github.com/kevinburke/go-html-boilerplate/assets"
"github.com/goccy/go-yaml"
"github.com/kevinburke/handlers"
"github.com/kevinburke/nacl"
"github.com/kevinburke/rest"
)
// DefaultPort is the listening port if no other port is specified.
var DefaultPort = 7065
// The server's Version.
const Version = "0.9.0"
var homepageTpl *template.Template
var logger *slog.Logger
var digests map[string][sha256.Size]byte
// hashurl returns a hash of the resource with the given key
func hashurl(key string) template.URL {
d, ok := digests[strings.TrimPrefix(key, "/")]
if !ok {
return ""
}
// we don't actually need the whole hash.
return template.URL("s=" + b64(d[:12]))
}
func b64(digest []byte) string {
return strings.TrimRight(base64.URLEncoding.EncodeToString(digest), "=")
}
func init() {
var err error
digests, err = assets.Digests()
if err != nil {
panic(err)
}
homepageHTML := assets.MustAssetString("templates/index.html")
homepageTpl = template.Must(
template.New("homepage").Option("missingkey=error").Funcs(template.FuncMap{
"hashurl": hashurl,
}).Parse(homepageHTML),
)
logger = handlers.Logger
// Add more templates here.
}
// A HTTP server for static files. All assets are packaged up in the assets
// directory with the go-bindata binary. Run "make assets" to rerun the
// go-bindata binary.
type static struct {
modTime time.Time
}
var expires = time.Date(2050, time.January, 1, 0, 0, 0, 0, time.UTC).Format(time.RFC1123)
func (s *static) ServeHTTP(w http.ResponseWriter, r *http.Request) {
if r.URL.Path == "/favicon.ico" {
r.URL.Path = "/static/favicon.ico"
}
bits, err := assets.Asset(strings.TrimPrefix(r.URL.Path, "/"))
if err != nil {
rest.NotFound(w, r)
return
}
// with the hashurl implementation below, we can set a super-long content
// expiry and ensure content is never stale.
if query := r.URL.Query(); query.Get("s") != "" {
w.Header().Set("Expires", expires)
}
http.ServeContent(w, r, r.URL.Path, s.modTime, bytes.NewReader(bits))
}
// Render a template, or a server error.
func render(w http.ResponseWriter, r *http.Request, tpl *template.Template, name string, data interface{}) {
buf := new(bytes.Buffer)
if err := tpl.ExecuteTemplate(buf, name, data); err != nil {
rest.ServerError(w, r, err)
return
}
w.Write(buf.Bytes())
}
// NewServeMux returns a HTTP handler that covers all routes known to the
// server.
func NewServeMux() http.Handler {
staticServer := &static{
modTime: time.Now().UTC(),
}
r := new(handlers.Regexp)
r.Handle(regexp.MustCompile(`(^/static|^/favicon.ico$)`), []string{"GET"}, handlers.GZip(staticServer))
r.HandleFunc(regexp.MustCompile(`^/$`), []string{"GET"}, func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "text/html; charset=utf-8")
render(w, r, homepageTpl, "homepage", nil)
})
// Add more routes here. Routes not matched will get a 404 error page.
// Call rest.RegisterHandler(404, http.HandlerFunc) to provide your own 404
// page instead of the default.
return r
}
// FileConfig represents the data in a config file.
type FileConfig struct {
// SecretKey is used to encrypt sessions and other data before serving it to
// the client. It should be a hex string that's exactly 64 bytes long. For
// example:
//
// d7211b215341871968869dontusethisc0ff1789fc88e0ac6e296ba36703edf8
//
// That key is invalid - you can generate a random key by running:
//
// openssl rand -hex 32
//
// If no secret key is present, we'll generate one when the server starts.
// However, this means that sessions may error when the server restarts.
//
// If a server key is present, but invalid, the server will not start.
SecretKey string `yaml:"secret_key"`
// Port to listen on. Set to 0 to choose a port at random. If unspecified,
// defaults to 7065.
Port *int `yaml:"port"`
// Set to true to listen for HTTP traffic (instead of TLS traffic). Note
// you need to terminate TLS to use HTTP server push.
HTTPOnly bool `yaml:"http_only"`
// For TLS configuration.
CertFile string `yaml:"cert_file"`
KeyFile string `yaml:"key_file"`
// Add other configuration settings here.
}
var cfg = flag.String("config", "config.yml", "Path to a config file")
var version = flag.Bool("version", false, "Print the version string and exit")
func main() {
start := time.Now()
flag.Parse()
if *version {
fmt.Fprintf(os.Stderr, "go-html-boilerplate version %s\n", Version)
os.Exit(0)
}
data, err := os.ReadFile(*cfg)
c := new(FileConfig)
if err == nil {
if err := yaml.Unmarshal(data, c); err != nil {
logger.Error("Couldn't parse config file", "err", err)
os.Exit(2)
}
} else {
logger.Error("Couldn't find config file", "err", err)
os.Exit(2)
}
var key nacl.Key
if c.SecretKey == "" {
logger.Warn("No secret key specified, generating a random one")
key = nacl.NewKey()
} else {
key, err = nacl.Load(c.SecretKey)
if err != nil {
logger.Error("Error getting secret key", "err", err)
os.Exit(2)
}
}
// You can use the secret key with secretbox
// (godoc.org/github.com/kevinburke/nacl/secretbox/) to generate cookies and
// secrets. See flash.go and crypto.go for examples.
_ = key
if c.Port == nil {
port, ok := os.LookupEnv("PORT")
if ok {
iPort, err := strconv.Atoi(port)
if err != nil {
logger.Error("Invalid port", "err", err, "port", port)
os.Exit(2)
}
c.Port = &iPort
} else {
c.Port = &DefaultPort
}
}
mux := NewServeMux()
mux = handlers.UUID(mux) // add UUID header
mux = handlers.Server(mux, "go-html-boilerplate/"+Version) // add Server header
mux = handlers.Log(mux) // log requests/responses
mux = handlers.Duration(mux) // add Duration header
addr := net.JoinHostPort("localhost", strconv.Itoa(*c.Port))
if c.HTTPOnly {
ln, err := net.Listen("tcp", addr)
if err != nil {
logger.Error("Error listening", "addr", addr, "err", err)
os.Exit(2)
}
logger.Info("Started server", "time", time.Since(start).Round(100*time.Microsecond),
"protocol", "http", "port", *c.Port)
http.Serve(ln, mux)
} else {
mux = handlers.STS(mux) // set Strict-Transport-Security header
if c.CertFile == "" {
c.CertFile = "certs/leaf.pem"
}
if _, err := os.Stat(c.CertFile); os.IsNotExist(err) {
logger.Error("Could not find a cert file; generate using 'make generate_cert'", "file", c.CertFile)
os.Exit(2)
}
if c.KeyFile == "" {
c.KeyFile = "certs/leaf.key"
}
if _, err := os.Stat(c.KeyFile); os.IsNotExist(err) {
logger.Error("Could not find a key file; generate using 'make generate_cert'", "file", c.KeyFile)
os.Exit(2)
}
logger.Info("Starting server", "time", time.Since(start).Round(100*time.Microsecond), "protocol", "https", "port", *c.Port)
listenErr := http.ListenAndServeTLS(addr, c.CertFile, c.KeyFile, mux)
logger.Error("server shut down", "err", listenErr)
}
}
================================================
FILE: main_test.go
================================================
package main
import (
"io"
"net/http"
"net/http/httptest"
"strings"
"testing"
"github.com/kevinburke/nacl"
)
func TestServer(t *testing.T) {
mux := NewServeMux()
req := httptest.NewRequest("GET", "/", nil)
w := httptest.NewRecorder()
mux.ServeHTTP(w, req)
if w.Code != 200 {
t.Errorf("GET /: got code %d, want 200", w.Code)
}
if body := w.Body.String(); !strings.Contains(body, "Hello World") {
t.Errorf("GET /: expected 'Hello World' in body, got %s", body)
}
}
func BenchmarkHomepage(b *testing.B) {
mux := NewServeMux()
s := httptest.NewServer(mux)
b.ReportAllocs()
b.ResetTimer()
for i := 0; i < b.N; i++ {
res, err := http.Get(s.URL)
if err != nil {
b.Fatal(err)
}
if res.StatusCode != 200 {
b.Fatalf("GET /: expected code 200, got %d", res.StatusCode)
}
n, err := io.ReadAll(res.Body)
if err != nil {
b.Fatal(err)
}
b.SetBytes(int64(len(n)))
res.Body.Close()
}
}
var sink string
// Just curious about how fast secretbox encryption is
func BenchmarkOpaque(b *testing.B) {
key := nacl.NewKey()
secret := "this is an average length message, about sixty characters long."
b.SetBytes(int64(len(secret)))
b.ReportAllocs()
b.ResetTimer()
for i := 0; i < b.N; i++ {
sink = opaque(secret, key)
}
}
================================================
FILE: static/style.css
================================================
body {
max-width: 1200px;
margin: 0 auto;
font-family: Helvetica, Arial, sans-serif;
}
================================================
FILE: templates/index.html
================================================
<!doctype html>
<html>
<head>
<meta charset="utf-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>Go HTML Template</title>
<link rel="stylesheet" href="/static/style.css?{{ hashurl "/static/style.css" }}">
</head>
<body>
<h1>Hello World!</h1>
<p>
<a href="https://github.com/kevinburke/go-html-boilerplate">View the source code for this server</a>.
</p>
</body>
</html>
================================================
FILE: vendor/github.com/goccy/go-yaml/.codecov.yml
================================================
codecov:
require_ci_to_pass: yes
coverage:
precision: 2
round: down
range: "70...100"
status:
project:
default:
target: 75%
threshold: 2%
patch: off
changes: no
parsers:
gcov:
branch_detection:
conditional: yes
loop: yes
method: no
macro: no
comment:
layout: "header,diff"
behavior: default
require_changes: no
ignore:
- ast
================================================
FILE: vendor/github.com/goccy/go-yaml/.gitignore
================================================
bin/
.idea/
cover.out
================================================
FILE: vendor/github.com/goccy/go-yaml/.golangci.yml
================================================
version: "2"
linters:
default: none
enable:
- errcheck
- govet
- ineffassign
- misspell
- perfsprint
- staticcheck
- unused
settings:
errcheck:
without_tests: true
govet:
disable:
- tests
misspell:
locale: US
perfsprint:
int-conversion: false
err-error: false
errorf: true
sprintf1: false
strconcat: false
staticcheck:
checks:
- -ST1000
- -ST1005
- all
exclusions:
generated: lax
presets:
- comments
- common-false-positives
- legacy
- std-error-handling
rules:
- linters:
- staticcheck
path: _test\.go
paths:
- third_party$
- builtin$
- examples$
formatters:
enable:
- gci
- gofmt
settings:
gci:
sections:
- standard
- default
- prefix(github.com/goccy/go-yaml)
- blank
- dot
gofmt:
simplify: true
exclusions:
generated: lax
paths:
- third_party$
- builtin$
- examples$
================================================
FILE: vendor/github.com/goccy/go-yaml/CHANGELOG.md
================================================
# 1.11.2 - 2023-09-15
### Fix bugs
- Fix quoted comments ( #370 )
- Fix handle of space at start or last ( #376 )
- Fix sequence with comment ( #390 )
# 1.11.1 - 2023-09-14
### Fix bugs
- Handle `\r` in a double-quoted string the same as `\n` ( #372 )
- Replace loop with n.Values = append(n.Values, target.Values...) ( #380 )
- Skip encoding an inline field if it is null ( #386 )
- Fix comment parsing with null value ( #388 )
# 1.11.0 - 2023-04-03
### Features
- Supports dynamically switch encode and decode processing for a given type
# 1.10.1 - 2023-03-28
### Features
- Quote YAML 1.1 bools at encoding time for compatibility with other legacy parsers
- Add support of 32-bit architecture
### Fix bugs
- Don't trim all space characters in block style sequence
- Support strings starting with `@`
# 1.10.0 - 2023-03-01
### Fix bugs
Reversible conversion of comments was not working in various cases, which has been corrected.
**Breaking Change** exists in the comment map interface. However, if you are dealing with CommentMap directly, there is no problem.
# 1.9.8 - 2022-12-19
### Fix feature
- Append new line at the end of file ( #329 )
### Fix bugs
- Fix custom marshaler ( #333, #334 )
- Fix behavior when struct fields conflicted( #335 )
- Fix position calculation for literal, folded and raw folded strings ( #330 )
# 1.9.7 - 2022-12-03
### Fix bugs
- Fix handling of quoted map key ( #328 )
- Fix resusing process of scanning context ( #322 )
## v1.9.6 - 2022-10-26
### New Features
- Introduce MapKeyNode interface to limit node types for map key ( #312 )
### Fix bugs
- Quote strings with special characters in flow mode ( #270 )
- typeError implements PrettyPrinter interface ( #280 )
- Fix incorrect const type ( #284 )
- Fix large literals type inference on 32 bits ( #293 )
- Fix UTF-8 characters ( #294 )
- Fix decoding of unknown aliases ( #317 )
- Fix stream encoder for insert a separator between each encoded document ( #318 )
### Update
- Update golang.org/x/sys ( #289 )
- Update Go version in CI ( #295 )
- Add test cases for missing keys to struct literals ( #300 )
## v1.9.5 - 2022-01-12
### New Features
* Add UseSingleQuote option ( #265 )
### Fix bugs
* Preserve defaults while decoding nested structs ( #260 )
* Fix minor typo in decodeInit error ( #264 )
* Handle empty sequence entries ( #275 )
* Fix encoding of sequence with multiline string ( #276 )
* Fix encoding of BytesMarshaler type ( #277 )
* Fix indentState logic for multi-line value ( #278 )
## v1.9.4 - 2021-10-12
### Fix bugs
* Keep prev/next reference between tokens containing comments when filtering comment tokens ( #257 )
* Supports escaping reserved keywords in PathBuilder ( #258 )
## v1.9.3 - 2021-09-07
### New Features
* Support encoding and decoding `time.Duration` fields ( #246 )
* Allow reserved characters for key name in YAMLPath ( #251 )
* Support getting YAMLPath from ast.Node ( #252 )
* Support CommentToMap option ( #253 )
### Fix bugs
* Fix encoding nested sequences with `yaml.IndentSequence` ( #241 )
* Fix error reporting on inline structs in strict mode ( #244, #245 )
* Fix encoding of large floats ( #247 )
### Improve workflow
* Migrate CI from CircleCI to GitHub Action ( #249 )
* Add workflow for ycat ( #250 )
## v1.9.2 - 2021-07-26
### Support WithComment option ( #238 )
`yaml.WithComment` is a option for encoding with comment.
The position where you want to add a comment is represented by YAMLPath, and it is the key of `yaml.CommentMap`.
Also, you can select `Head` comment or `Line` comment as the comment type.
## v1.9.1 - 2021-07-20
### Fix DecodeFromNode ( #237 )
- Fix YAML handling where anchor exists
## v1.9.0 - 2021-07-19
### New features
- Support encoding of comment node ( #233 )
- Support `yaml.NodeToValue(ast.Node, interface{}, ...DecodeOption) error` ( #236 )
- Can convert a AST node to a value directly
### Fix decoder for comment
- Fix parsing of literal with comment ( #234 )
### Rename API ( #235 )
- Rename `MarshalWithContext` to `MarshalContext`
- Rename `UnmarshalWithContext` to `UnmarshalContext`
## v1.8.10 - 2021-07-02
### Fixed bugs
- Fix searching anchor by alias name ( #212 )
- Fixing Issue 186, scanner should account for newline characters when processing multi-line text. Without this source annotations line/column number (for this and all subsequent tokens) is inconsistent with plain text editors. e.g. https://github.com/goccy/go-yaml/issues/186. This addresses the issue specifically for single and double quote text only. ( #210 )
- Add error for unterminated flow mapping node ( #213 )
- Handle missing required field validation ( #221 )
- Nicely format unexpected node type errors ( #229 )
- Support to encode map which has defined type key ( #231 )
### New features
- Support sequence indentation by EncodeOption ( #232 )
## v1.8.9 - 2021-03-01
### Fixed bugs
- Fix origin buffer for DocumentHeader and DocumentEnd and Directive
- Fix origin buffer for anchor value
- Fix syntax error about map value
- Fix parsing MergeKey ('<<') characters
- Fix encoding of float value
- Fix incorrect column annotation when single or double quotes are used
### New features
- Support to encode/decode of ast.Node directly
================================================
FILE: vendor/github.com/goccy/go-yaml/LICENSE
================================================
MIT License
Copyright (c) 2019 Masaaki Goshima
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
================================================
FILE: vendor/github.com/goccy/go-yaml/Makefile
================================================
## Location to install dependencies to
LOCALBIN ?= $(shell pwd)/bin
TESTMOD := testdata/go_test.mod
$(LOCALBIN):
mkdir -p $(LOCALBIN)
.PHONY: test
test:
go test -v -race ./...
go test -v -race ./testdata -modfile=$(TESTMOD)
.PHONY: simple-test
simple-test:
go test -v ./...
go test -v ./testdata -modfile=$(TESTMOD)
.PHONY: fuzz
fuzz:
go test -fuzz=Fuzz -fuzztime 60s
.PHONY: cover
cover:
go test -coverpkg=.,./ast,./lexer,./parser,./printer,./scanner,./token -coverprofile=cover.out -modfile=$(TESTMOD) ./... ./testdata
.PHONY: cover-html
cover-html: cover
go tool cover -html=cover.out
.PHONY: ycat/build
ycat/build: $(LOCALBIN)
cd ./cmd/ycat && go build -o $(LOCALBIN)/ycat .
.PHONY: lint
lint: golangci-lint ## Run golangci-lint
@$(GOLANGCI_LINT) run
.PHONY: fmt
fmt: golangci-lint ## Ensure consistent code style
@go mod tidy
@go fmt ./...
@$(GOLANGCI_LINT) run --fix
## Tool Binaries
GOLANGCI_LINT ?= $(LOCALBIN)/golangci-lint
## Tool Versions
GOLANGCI_VERSION := 2.1.2
.PHONY: golangci-lint
.PHONY: $(GOLANGCI_LINT)
golangci-lint: $(GOLANGCI_LINT) ## Download golangci-lint locally if necessary.
$(GOLANGCI_LINT): $(LOCALBIN)
@test -s $(LOCALBIN)/golangci-lint && $(LOCALBIN)/golangci-lint version --short | grep -q $(GOLANGCI_VERSION) || \
curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh | sh -s -- -b $(LOCALBIN) v$(GOLANGCI_VERSION)
================================================
FILE: vendor/github.com/goccy/go-yaml/README.md
================================================
# YAML support for the Go language
[](https://pkg.go.dev/github.com/goccy/go-yaml)
[](https://codecov.io/gh/goccy/go-yaml)
[](https://goreportcard.com/report/github.com/goccy/go-yaml)
<img width="300px" src="https://user-images.githubusercontent.com/209884/67159116-64d94b80-f37b-11e9-9b28-f8379636a43c.png"></img>
## 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.
<img src="https://user-images.githubusercontent.com/209884/67358124-587f0980-f59a-11e9-96fc-7205aab77695.png"></img>
## 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:
<img src="https://user-images.githubusercontent.com/209884/84148813-7aca8680-aa9a-11ea-8fc9-37dece2ebdac.png"></img>
# Tools
## ycat
print yaml file with color
<img width="713" alt="ycat" src="https://user-images.githubusercontent.com/209884/66986084-19b00600-f0f9-11e9-9f0e-1f91eb072fe0.png">
### 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
================================================
FILE: vendor/github.com/goccy/go-yaml/ast/ast.go
================================================
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 {
valueStr := n.Value.String()
// For flow-style values indented on the next line, we need to add the proper indentation
if m, ok := n.Value.(*MappingNode); ok && m.IsFlowStyle {
valueIndent := strings.Repeat(" ", n.Value.GetToken().Position.Column-1)
valueStr = valueIndent + valueStr
} else if s, ok := n.Value.(*SequenceNode); ok && s.IsFlowStyle {
valueIndent := strings.Repeat(" ", n.Value.GetToken().Position.Column-1)
valueStr = valueIndent + valueStr
}
if keyComment != nil {
return fmt.Sprintf(
"%s%s: %s\n%s",
space,
n.Key.stringWithoutComment(),
keyComment.String(),
valueStr,
)
}
return fmt.Sprintf("%s%s:\n%s", space, n.Key.String(), valueStr)
} 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())
}
seqText := fmt.Sprintf("[%s]", strings.Join(values, ", "))
if n.Comment != nil {
return addCommentString(seqText, n.Comment)
}
return seqText
}
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
}
================================================
FILE: vendor/github.com/goccy/go-yaml/context.go
================================================
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
}
================================================
FILE: vendor/github.com/goccy/go-yaml/decode.go
================================================
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
allowedFieldPrefixes []string
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 {
if len(node.Values) != 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
}
if node, exists := d.anchorNodeMap[text]; exists {
return d.nodeToValue(ctx, node)
}
return nil, errors.ErrSyntax(fmt.Sprintf("could not find alias %q", text), 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 {
var ok bool
for _, prefix := range d.allowedFieldPrefixes {
if strings.HasPrefix(key, prefix) {
ok = true
break
}
}
if !ok {
return errors.ErrUnknownField(fmt.Sprintf(`unknown field "%s"`, key), node.GetToken())
}
}
}
if d.validator != nil {
if err := d.validator.Struct(dst.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.createDecodedNewValue(ctx, keyType, reflect.Value{}, key)
if err != nil {
return err
}
k = keyVal
}
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
}
================================================
FILE: vendor/github.com/goccy/go-yaml/encode.go
================================================
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
}
kn, err := e.encodeValue(ctx, reflect.ValueOf(key), column)
keyNode, ok := kn.(ast.MapKeyNode)
if !ok || err != nil {
keyNode = e.encodeString(fmt.Sprint(key), column)
}
node.Values = append(node.Values, ast.MappingValue(
nil,
keyNode,
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
}
================================================
FILE: vendor/github.com/goccy/go-yaml/error.go
================================================
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)
}
================================================
FILE: vendor/github.com/goccy/go-yaml/internal/errors/error.go
================================================
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)
}
fu
gitextract_xmv5ggsg/
├── .github/
│ ├── dependabot.yml
│ └── workflows/
│ └── ci.yml
├── .gitignore
├── LICENSE
├── Makefile
├── README.md
├── assets/
│ └── bindata.go
├── config.yml
├── crypto.go
├── flash.go
├── go.mod
├── go.sum
├── main.go
├── main_test.go
├── static/
│ └── style.css
├── templates/
│ └── index.html
└── vendor/
├── github.com/
│ ├── goccy/
│ │ └── go-yaml/
│ │ ├── .codecov.yml
│ │ ├── .gitignore
│ │ ├── .golangci.yml
│ │ ├── CHANGELOG.md
│ │ ├── LICENSE
│ │ ├── Makefile
│ │ ├── README.md
│ │ ├── ast/
│ │ │ └── ast.go
│ │ ├── context.go
│ │ ├── decode.go
│ │ ├── encode.go
│ │ ├── error.go
│ │ ├── internal/
│ │ │ ├── errors/
│ │ │ │ └── error.go
│ │ │ └── format/
│ │ │ └── format.go
│ │ ├── lexer/
│ │ │ └── lexer.go
│ │ ├── option.go
│ │ ├── parser/
│ │ │ ├── color.go
│ │ │ ├── context.go
│ │ │ ├── node.go
│ │ │ ├── option.go
│ │ │ ├── parser.go
│ │ │ └── token.go
│ │ ├── path.go
│ │ ├── printer/
│ │ │ ├── color.go
│ │ │ └── printer.go
│ │ ├── scanner/
│ │ │ ├── context.go
│ │ │ ├── error.go
│ │ │ └── scanner.go
│ │ ├── stdlib_quote.go
│ │ ├── struct.go
│ │ ├── token/
│ │ │ └── token.go
│ │ ├── validate.go
│ │ └── yaml.go
│ ├── gofrs/
│ │ └── uuid/
│ │ └── v5/
│ │ ├── .gitignore
│ │ ├── .pre-commit-config.yaml
│ │ ├── LICENSE
│ │ ├── README.md
│ │ ├── SECURITY.md
│ │ ├── codec.go
│ │ ├── error.go
│ │ ├── generator.go
│ │ ├── sql.go
│ │ └── uuid.go
│ ├── inconshreveable/
│ │ └── log15/
│ │ └── v3/
│ │ ├── LICENSE
│ │ ├── doc.go
│ │ ├── format.go
│ │ ├── handler.go
│ │ ├── handler_go13.go
│ │ ├── handler_go14.go
│ │ ├── logger.go
│ │ ├── root.go
│ │ └── syslog.go
│ ├── kevinburke/
│ │ ├── handlers/
│ │ │ ├── .gitignore
│ │ │ ├── CHANGELOG.md
│ │ │ ├── LICENSE
│ │ │ ├── Makefile
│ │ │ ├── README.md
│ │ │ ├── ctx.go
│ │ │ ├── gzip.go
│ │ │ ├── lib.go
│ │ │ ├── lib_noslog.go
│ │ │ ├── lib_slog.go
│ │ │ ├── logger_noslog.go
│ │ │ ├── logger_slog.go
│ │ │ └── regex_handler.go
│ │ ├── nacl/
│ │ │ ├── .gitignore
│ │ │ ├── CHANGELOG.md
│ │ │ ├── LICENSE
│ │ │ ├── Makefile
│ │ │ ├── README.md
│ │ │ ├── internal/
│ │ │ │ └── subtle/
│ │ │ │ ├── aliasing.go
│ │ │ │ └── aliasing_appengine.go
│ │ │ ├── nacl.go
│ │ │ ├── onetimeauth/
│ │ │ │ └── onetimeauth.go
│ │ │ ├── randombytes/
│ │ │ │ └── randombytes.go
│ │ │ └── secretbox/
│ │ │ └── secretbox.go
│ │ └── rest/
│ │ ├── .gitignore
│ │ ├── CHANGELOG.md
│ │ ├── LICENSE
│ │ ├── Makefile
│ │ ├── README.md
│ │ ├── ctx.go
│ │ ├── noctx.go
│ │ ├── rest.go
│ │ ├── rest_noslog.go
│ │ ├── rest_slog.go
│ │ ├── restclient/
│ │ │ ├── client.go
│ │ │ └── transport.go
│ │ └── resterror/
│ │ └── resterror.go
│ └── mattn/
│ ├── go-colorable/
│ │ ├── LICENSE
│ │ ├── README.md
│ │ ├── colorable_others.go
│ │ ├── colorable_windows.go
│ │ ├── go.test.sh
│ │ └── noncolorable.go
│ └── go-isatty/
│ ├── LICENSE
│ ├── README.md
│ ├── doc.go
│ ├── go.test.sh
│ ├── isatty_bsd.go
│ ├── isatty_others.go
│ ├── isatty_plan9.go
│ ├── isatty_solaris.go
│ ├── isatty_tcgets.go
│ └── isatty_windows.go
├── golang.org/
│ └── x/
│ ├── crypto/
│ │ ├── LICENSE
│ │ ├── PATENTS
│ │ ├── internal/
│ │ │ └── poly1305/
│ │ │ ├── mac_noasm.go
│ │ │ ├── poly1305.go
│ │ │ ├── sum_amd64.s
│ │ │ ├── sum_asm.go
│ │ │ ├── sum_generic.go
│ │ │ ├── sum_loong64.s
│ │ │ ├── sum_ppc64x.s
│ │ │ ├── sum_s390x.go
│ │ │ └── sum_s390x.s
│ │ ├── poly1305/
│ │ │ └── poly1305_compat.go
│ │ └── salsa20/
│ │ └── salsa/
│ │ ├── hsalsa20.go
│ │ ├── salsa208.go
│ │ ├── salsa20_amd64.go
│ │ ├── salsa20_amd64.s
│ │ ├── salsa20_noasm.go
│ │ └── salsa20_ref.go
│ ├── sys/
│ │ ├── LICENSE
│ │ ├── PATENTS
│ │ ├── cpu/
│ │ │ ├── asm_aix_ppc64.s
│ │ │ ├── asm_darwin_x86_gc.s
│ │ │ ├── byteorder.go
│ │ │ ├── cpu.go
│ │ │ ├── cpu_aix.go
│ │ │ ├── cpu_arm.go
│ │ │ ├── cpu_arm64.go
│ │ │ ├── cpu_arm64.s
│ │ │ ├── cpu_darwin_x86.go
│ │ │ ├── cpu_gc_arm64.go
│ │ │ ├── cpu_gc_s390x.go
│ │ │ ├── cpu_gc_x86.go
│ │ │ ├── cpu_gc_x86.s
│ │ │ ├── cpu_gccgo_arm64.go
│ │ │ ├── cpu_gccgo_s390x.go
│ │ │ ├── cpu_gccgo_x86.c
│ │ │ ├── cpu_gccgo_x86.go
│ │ │ ├── cpu_linux.go
│ │ │ ├── cpu_linux_arm.go
│ │ │ ├── cpu_linux_arm64.go
│ │ │ ├── cpu_linux_loong64.go
│ │ │ ├── cpu_linux_mips64x.go
│ │ │ ├── cpu_linux_noinit.go
│ │ │ ├── cpu_linux_ppc64x.go
│ │ │ ├── cpu_linux_riscv64.go
│ │ │ ├── cpu_linux_s390x.go
│ │ │ ├── cpu_loong64.go
│ │ │ ├── cpu_loong64.s
│ │ │ ├── cpu_mips64x.go
│ │ │ ├── cpu_mipsx.go
│ │ │ ├── cpu_netbsd_arm64.go
│ │ │ ├── cpu_openbsd_arm64.go
│ │ │ ├── cpu_openbsd_arm64.s
│ │ │ ├── cpu_other_arm.go
│ │ │ ├── cpu_other_arm64.go
│ │ │ ├── cpu_other_mips64x.go
│ │ │ ├── cpu_other_ppc64x.go
│ │ │ ├── cpu_other_riscv64.go
│ │ │ ├── cpu_other_x86.go
│ │ │ ├── cpu_ppc64x.go
│ │ │ ├── cpu_riscv64.go
│ │ │ ├── cpu_s390x.go
│ │ │ ├── cpu_s390x.s
│ │ │ ├── cpu_wasm.go
│ │ │ ├── cpu_windows_arm64.go
│ │ │ ├── cpu_x86.go
│ │ │ ├── cpu_zos.go
│ │ │ ├── cpu_zos_s390x.go
│ │ │ ├── endian_big.go
│ │ │ ├── endian_little.go
│ │ │ ├── hwcap_linux.go
│ │ │ ├── parse.go
│ │ │ ├── proc_cpuinfo_linux.go
│ │ │ ├── runtime_auxv.go
│ │ │ ├── runtime_auxv_go121.go
│ │ │ ├── syscall_aix_gccgo.go
│ │ │ ├── syscall_aix_ppc64_gc.go
│ │ │ └── syscall_darwin_x86_gc.go
│ │ ├── plan9/
│ │ │ ├── asm.s
│ │ │ ├── asm_plan9_386.s
│ │ │ ├── asm_plan9_amd64.s
│ │ │ ├── asm_plan9_arm.s
│ │ │ ├── const_plan9.go
│ │ │ ├── dir_plan9.go
│ │ │ ├── env_plan9.go
│ │ │ ├── errors_plan9.go
│ │ │ ├── mkall.sh
│ │ │ ├── mkerrors.sh
│ │ │ ├── mksysnum_plan9.sh
│ │ │ ├── pwd_plan9.go
│ │ │ ├── race.go
│ │ │ ├── race0.go
│ │ │ ├── str.go
│ │ │ ├── syscall.go
│ │ │ ├── syscall_plan9.go
│ │ │ ├── zsyscall_plan9_386.go
│ │ │ ├── zsyscall_plan9_amd64.go
│ │ │ ├── zsyscall_plan9_arm.go
│ │ │ └── zsysnum_plan9.go
│ │ ├── unix/
│ │ │ ├── .gitignore
│ │ │ ├── README.md
│ │ │ ├── affinity_linux.go
│ │ │ ├── aliases.go
│ │ │ ├── asm_aix_ppc64.s
│ │ │ ├── asm_bsd_386.s
│ │ │ ├── asm_bsd_amd64.s
│ │ │ ├── asm_bsd_arm.s
│ │ │ ├── asm_bsd_arm64.s
│ │ │ ├── asm_bsd_ppc64.s
│ │ │ ├── asm_bsd_riscv64.s
│ │ │ ├── asm_linux_386.s
│ │ │ ├── asm_linux_amd64.s
│ │ │ ├── asm_linux_arm.s
│ │ │ ├── asm_linux_arm64.s
│ │ │ ├── asm_linux_loong64.s
│ │ │ ├── asm_linux_mips64x.s
│ │ │ ├── asm_linux_mipsx.s
│ │ │ ├── asm_linux_ppc64x.s
│ │ │ ├── asm_linux_riscv64.s
│ │ │ ├── asm_linux_s390x.s
│ │ │ ├── asm_openbsd_mips64.s
│ │ │ ├── asm_solaris_amd64.s
│ │ │ ├── asm_zos_s390x.s
│ │ │ ├── auxv.go
│ │ │ ├── auxv_unsupported.go
│ │ │ ├── bluetooth_linux.go
│ │ │ ├── bpxsvc_zos.go
│ │ │ ├── bpxsvc_zos.s
│ │ │ ├── cap_freebsd.go
│ │ │ ├── constants.go
│ │ │ ├── dev_aix_ppc.go
│ │ │ ├── dev_aix_ppc64.go
│ │ │ ├── dev_darwin.go
│ │ │ ├── dev_dragonfly.go
│ │ │ ├── dev_freebsd.go
│ │ │ ├── dev_linux.go
│ │ │ ├── dev_netbsd.go
│ │ │ ├── dev_openbsd.go
│ │ │ ├── dev_zos.go
│ │ │ ├── dirent.go
│ │ │ ├── endian_big.go
│ │ │ ├── endian_little.go
│ │ │ ├── env_unix.go
│ │ │ ├── fcntl.go
│ │ │ ├── fcntl_darwin.go
│ │ │ ├── fcntl_linux_32bit.go
│ │ │ ├── fdset.go
│ │ │ ├── gccgo.go
│ │ │ ├── gccgo_c.c
│ │ │ ├── gccgo_linux_amd64.go
│ │ │ ├── ifreq_linux.go
│ │ │ ├── ioctl_linux.go
│ │ │ ├── ioctl_signed.go
│ │ │ ├── ioctl_unsigned.go
│ │ │ ├── ioctl_zos.go
│ │ │ ├── mkall.sh
│ │ │ ├── mkerrors.sh
│ │ │ ├── mmap_nomremap.go
│ │ │ ├── mremap.go
│ │ │ ├── pagesize_unix.go
│ │ │ ├── pledge_openbsd.go
│ │ │ ├── ptrace_darwin.go
│ │ │ ├── ptrace_ios.go
│ │ │ ├── race.go
│ │ │ ├── race0.go
│ │ │ ├── readdirent_getdents.go
│ │ │ ├── readdirent_getdirentries.go
│ │ │ ├── sockcmsg_dragonfly.go
│ │ │ ├── sockcmsg_linux.go
│ │ │ ├── sockcmsg_unix.go
│ │ │ ├── sockcmsg_unix_other.go
│ │ │ ├── sockcmsg_zos.go
│ │ │ ├── symaddr_zos_s390x.s
│ │ │ ├── syscall.go
│ │ │ ├── syscall_aix.go
│ │ │ ├── syscall_aix_ppc.go
│ │ │ ├── syscall_aix_ppc64.go
│ │ │ ├── syscall_bsd.go
│ │ │ ├── syscall_darwin.go
│ │ │ ├── syscall_darwin_amd64.go
│ │ │ ├── syscall_darwin_arm64.go
│ │ │ ├── syscall_darwin_libSystem.go
│ │ │ ├── syscall_dragonfly.go
│ │ │ ├── syscall_dragonfly_amd64.go
│ │ │ ├── syscall_freebsd.go
│ │ │ ├── syscall_freebsd_386.go
│ │ │ ├── syscall_freebsd_amd64.go
│ │ │ ├── syscall_freebsd_arm.go
│ │ │ ├── syscall_freebsd_arm64.go
│ │ │ ├── syscall_freebsd_riscv64.go
│ │ │ ├── syscall_hurd.go
│ │ │ ├── syscall_hurd_386.go
│ │ │ ├── syscall_illumos.go
│ │ │ ├── syscall_linux.go
│ │ │ ├── syscall_linux_386.go
│ │ │ ├── syscall_linux_alarm.go
│ │ │ ├── syscall_linux_amd64.go
│ │ │ ├── syscall_linux_amd64_gc.go
│ │ │ ├── syscall_linux_arm.go
│ │ │ ├── syscall_linux_arm64.go
│ │ │ ├── syscall_linux_gc.go
│ │ │ ├── syscall_linux_gc_386.go
│ │ │ ├── syscall_linux_gc_arm.go
│ │ │ ├── syscall_linux_gccgo_386.go
│ │ │ ├── syscall_linux_gccgo_arm.go
│ │ │ ├── syscall_linux_loong64.go
│ │ │ ├── syscall_linux_mips64x.go
│ │ │ ├── syscall_linux_mipsx.go
│ │ │ ├── syscall_linux_ppc.go
│ │ │ ├── syscall_linux_ppc64x.go
│ │ │ ├── syscall_linux_riscv64.go
│ │ │ ├── syscall_linux_s390x.go
│ │ │ ├── syscall_linux_sparc64.go
│ │ │ ├── syscall_netbsd.go
│ │ │ ├── syscall_netbsd_386.go
│ │ │ ├── syscall_netbsd_amd64.go
│ │ │ ├── syscall_netbsd_arm.go
│ │ │ ├── syscall_netbsd_arm64.go
│ │ │ ├── syscall_openbsd.go
│ │ │ ├── syscall_openbsd_386.go
│ │ │ ├── syscall_openbsd_amd64.go
│ │ │ ├── syscall_openbsd_arm.go
│ │ │ ├── syscall_openbsd_arm64.go
│ │ │ ├── syscall_openbsd_libc.go
│ │ │ ├── syscall_openbsd_mips64.go
│ │ │ ├── syscall_openbsd_ppc64.go
│ │ │ ├── syscall_openbsd_riscv64.go
│ │ │ ├── syscall_solaris.go
│ │ │ ├── syscall_solaris_amd64.go
│ │ │ ├── syscall_unix.go
│ │ │ ├── syscall_unix_gc.go
│ │ │ ├── syscall_unix_gc_ppc64x.go
│ │ │ ├── syscall_zos_s390x.go
│ │ │ ├── sysvshm_linux.go
│ │ │ ├── sysvshm_unix.go
│ │ │ ├── sysvshm_unix_other.go
│ │ │ ├── timestruct.go
│ │ │ ├── unveil_openbsd.go
│ │ │ ├── vgetrandom_linux.go
│ │ │ ├── vgetrandom_unsupported.go
│ │ │ ├── xattr_bsd.go
│ │ │ ├── zerrors_aix_ppc.go
│ │ │ ├── zerrors_aix_ppc64.go
│ │ │ ├── zerrors_darwin_amd64.go
│ │ │ ├── zerrors_darwin_arm64.go
│ │ │ ├── zerrors_dragonfly_amd64.go
│ │ │ ├── zerrors_freebsd_386.go
│ │ │ ├── zerrors_freebsd_amd64.go
│ │ │ ├── zerrors_freebsd_arm.go
│ │ │ ├── zerrors_freebsd_arm64.go
│ │ │ ├── zerrors_freebsd_riscv64.go
│ │ │ ├── zerrors_linux.go
│ │ │ ├── zerrors_linux_386.go
│ │ │ ├── zerrors_linux_amd64.go
│ │ │ ├── zerrors_linux_arm.go
│ │ │ ├── zerrors_linux_arm64.go
│ │ │ ├── zerrors_linux_loong64.go
│ │ │ ├── zerrors_linux_mips.go
│ │ │ ├── zerrors_linux_mips64.go
│ │ │ ├── zerrors_linux_mips64le.go
│ │ │ ├── zerrors_linux_mipsle.go
│ │ │ ├── zerrors_linux_ppc.go
│ │ │ ├── zerrors_linux_ppc64.go
│ │ │ ├── zerrors_linux_ppc64le.go
│ │ │ ├── zerrors_linux_riscv64.go
│ │ │ ├── zerrors_linux_s390x.go
│ │ │ ├── zerrors_linux_sparc64.go
│ │ │ ├── zerrors_netbsd_386.go
│ │ │ ├── zerrors_netbsd_amd64.go
│ │ │ ├── zerrors_netbsd_arm.go
│ │ │ ├── zerrors_netbsd_arm64.go
│ │ │ ├── zerrors_openbsd_386.go
│ │ │ ├── zerrors_openbsd_amd64.go
│ │ │ ├── zerrors_openbsd_arm.go
│ │ │ ├── zerrors_openbsd_arm64.go
│ │ │ ├── zerrors_openbsd_mips64.go
│ │ │ ├── zerrors_openbsd_ppc64.go
│ │ │ ├── zerrors_openbsd_riscv64.go
│ │ │ ├── zerrors_solaris_amd64.go
│ │ │ ├── zerrors_zos_s390x.go
│ │ │ ├── zptrace_armnn_linux.go
│ │ │ ├── zptrace_linux_arm64.go
│ │ │ ├── zptrace_mipsnn_linux.go
│ │ │ ├── zptrace_mipsnnle_linux.go
│ │ │ ├── zptrace_x86_linux.go
│ │ │ ├── zsymaddr_zos_s390x.s
│ │ │ ├── zsyscall_aix_ppc.go
│ │ │ ├── zsyscall_aix_ppc64.go
│ │ │ ├── zsyscall_aix_ppc64_gc.go
│ │ │ ├── zsyscall_aix_ppc64_gccgo.go
│ │ │ ├── zsyscall_darwin_amd64.go
│ │ │ ├── zsyscall_darwin_amd64.s
│ │ │ ├── zsyscall_darwin_arm64.go
│ │ │ ├── zsyscall_darwin_arm64.s
│ │ │ ├── zsyscall_dragonfly_amd64.go
│ │ │ ├── zsyscall_freebsd_386.go
│ │ │ ├── zsyscall_freebsd_amd64.go
│ │ │ ├── zsyscall_freebsd_arm.go
│ │ │ ├── zsyscall_freebsd_arm64.go
│ │ │ ├── zsyscall_freebsd_riscv64.go
│ │ │ ├── zsyscall_illumos_amd64.go
│ │ │ ├── zsyscall_linux.go
│ │ │ ├── zsyscall_linux_386.go
│ │ │ ├── zsyscall_linux_amd64.go
│ │ │ ├── zsyscall_linux_arm.go
│ │ │ ├── zsyscall_linux_arm64.go
│ │ │ ├── zsyscall_linux_loong64.go
│ │ │ ├── zsyscall_linux_mips.go
│ │ │ ├── zsyscall_linux_mips64.go
│ │ │ ├── zsyscall_linux_mips64le.go
│ │ │ ├── zsyscall_linux_mipsle.go
│ │ │ ├── zsyscall_linux_ppc.go
│ │ │ ├── zsyscall_linux_ppc64.go
│ │ │ ├── zsyscall_linux_ppc64le.go
│ │ │ ├── zsyscall_linux_riscv64.go
│ │ │ ├── zsyscall_linux_s390x.go
│ │ │ ├── zsyscall_linux_sparc64.go
│ │ │ ├── zsyscall_netbsd_386.go
│ │ │ ├── zsyscall_netbsd_amd64.go
│ │ │ ├── zsyscall_netbsd_arm.go
│ │ │ ├── zsyscall_netbsd_arm64.go
│ │ │ ├── zsyscall_openbsd_386.go
│ │ │ ├── zsyscall_openbsd_386.s
│ │ │ ├── zsyscall_openbsd_amd64.go
│ │ │ ├── zsyscall_openbsd_amd64.s
│ │ │ ├── zsyscall_openbsd_arm.go
│ │ │ ├── zsyscall_openbsd_arm.s
│ │ │ ├── zsyscall_openbsd_arm64.go
│ │ │ ├── zsyscall_openbsd_arm64.s
│ │ │ ├── zsyscall_openbsd_mips64.go
│ │ │ ├── zsyscall_openbsd_mips64.s
│ │ │ ├── zsyscall_openbsd_ppc64.go
│ │ │ ├── zsyscall_openbsd_ppc64.s
│ │ │ ├── zsyscall_openbsd_riscv64.go
│ │ │ ├── zsyscall_openbsd_riscv64.s
│ │ │ ├── zsyscall_solaris_amd64.go
│ │ │ ├── zsyscall_zos_s390x.go
│ │ │ ├── zsysctl_openbsd_386.go
│ │ │ ├── zsysctl_openbsd_amd64.go
│ │ │ ├── zsysctl_openbsd_arm.go
│ │ │ ├── zsysctl_openbsd_arm64.go
│ │ │ ├── zsysctl_openbsd_mips64.go
│ │ │ ├── zsysctl_openbsd_ppc64.go
│ │ │ ├── zsysctl_openbsd_riscv64.go
│ │ │ ├── zsysnum_darwin_amd64.go
│ │ │ ├── zsysnum_darwin_arm64.go
│ │ │ ├── zsysnum_dragonfly_amd64.go
│ │ │ ├── zsysnum_freebsd_386.go
│ │ │ ├── zsysnum_freebsd_amd64.go
│ │ │ ├── zsysnum_freebsd_arm.go
│ │ │ ├── zsysnum_freebsd_arm64.go
│ │ │ ├── zsysnum_freebsd_riscv64.go
│ │ │ ├── zsysnum_linux_386.go
│ │ │ ├── zsysnum_linux_amd64.go
│ │ │ ├── zsysnum_linux_arm.go
│ │ │ ├── zsysnum_linux_arm64.go
│ │ │ ├── zsysnum_linux_loong64.go
│ │ │ ├── zsysnum_linux_mips.go
│ │ │ ├── zsysnum_linux_mips64.go
│ │ │ ├── zsysnum_linux_mips64le.go
│ │ │ ├── zsysnum_linux_mipsle.go
│ │ │ ├── zsysnum_linux_ppc.go
│ │ │ ├── zsysnum_linux_ppc64.go
│ │ │ ├── zsysnum_linux_ppc64le.go
│ │ │ ├── zsysnum_linux_riscv64.go
│ │ │ ├── zsysnum_linux_s390x.go
│ │ │ ├── zsysnum_linux_sparc64.go
│ │ │ ├── zsysnum_netbsd_386.go
│ │ │ ├── zsysnum_netbsd_amd64.go
│ │ │ ├── zsysnum_netbsd_arm.go
│ │ │ ├── zsysnum_netbsd_arm64.go
│ │ │ ├── zsysnum_openbsd_386.go
│ │ │ ├── zsysnum_openbsd_amd64.go
│ │ │ ├── zsysnum_openbsd_arm.go
│ │ │ ├── zsysnum_openbsd_arm64.go
│ │ │ ├── zsysnum_openbsd_mips64.go
│ │ │ ├── zsysnum_openbsd_ppc64.go
│ │ │ ├── zsysnum_openbsd_riscv64.go
│ │ │ ├── zsysnum_zos_s390x.go
│ │ │ ├── ztypes_aix_ppc.go
│ │ │ ├── ztypes_aix_ppc64.go
│ │ │ ├── ztypes_darwin_amd64.go
│ │ │ ├── ztypes_darwin_arm64.go
│ │ │ ├── ztypes_dragonfly_amd64.go
│ │ │ ├── ztypes_freebsd_386.go
│ │ │ ├── ztypes_freebsd_amd64.go
│ │ │ ├── ztypes_freebsd_arm.go
│ │ │ ├── ztypes_freebsd_arm64.go
│ │ │ ├── ztypes_freebsd_riscv64.go
│ │ │ ├── ztypes_linux.go
│ │ │ ├── ztypes_linux_386.go
│ │ │ ├── ztypes_linux_amd64.go
│ │ │ ├── ztypes_linux_arm.go
│ │ │ ├── ztypes_linux_arm64.go
│ │ │ ├── ztypes_linux_loong64.go
│ │ │ ├── ztypes_linux_mips.go
│ │ │ ├── ztypes_linux_mips64.go
│ │ │ ├── ztypes_linux_mips64le.go
│ │ │ ├── ztypes_linux_mipsle.go
│ │ │ ├── ztypes_linux_ppc.go
│ │ │ ├── ztypes_linux_ppc64.go
│ │ │ ├── ztypes_linux_ppc64le.go
│ │ │ ├── ztypes_linux_riscv64.go
│ │ │ ├── ztypes_linux_s390x.go
│ │ │ ├── ztypes_linux_sparc64.go
│ │ │ ├── ztypes_netbsd_386.go
│ │ │ ├── ztypes_netbsd_amd64.go
│ │ │ ├── ztypes_netbsd_arm.go
│ │ │ ├── ztypes_netbsd_arm64.go
│ │ │ ├── ztypes_openbsd_386.go
│ │ │ ├── ztypes_openbsd_amd64.go
│ │ │ ├── ztypes_openbsd_arm.go
│ │ │ ├── ztypes_openbsd_arm64.go
│ │ │ ├── ztypes_openbsd_mips64.go
│ │ │ ├── ztypes_openbsd_ppc64.go
│ │ │ ├── ztypes_openbsd_riscv64.go
│ │ │ ├── ztypes_solaris_amd64.go
│ │ │ └── ztypes_zos_s390x.go
│ │ └── windows/
│ │ ├── aliases.go
│ │ ├── dll_windows.go
│ │ ├── env_windows.go
│ │ ├── eventlog.go
│ │ ├── exec_windows.go
│ │ ├── memory_windows.go
│ │ ├── mkerrors.bash
│ │ ├── mkknownfolderids.bash
│ │ ├── mksyscall.go
│ │ ├── race.go
│ │ ├── race0.go
│ │ ├── security_windows.go
│ │ ├── service.go
│ │ ├── setupapi_windows.go
│ │ ├── str.go
│ │ ├── syscall.go
│ │ ├── syscall_windows.go
│ │ ├── types_windows.go
│ │ ├── types_windows_386.go
│ │ ├── types_windows_amd64.go
│ │ ├── types_windows_arm.go
│ │ ├── types_windows_arm64.go
│ │ ├── zerrors_windows.go
│ │ ├── zknownfolderids_windows.go
│ │ └── zsyscall_windows.go
│ └── term/
│ ├── CONTRIBUTING.md
│ ├── LICENSE
│ ├── PATENTS
│ ├── README.md
│ ├── codereview.cfg
│ ├── term.go
│ ├── term_plan9.go
│ ├── term_unix.go
│ ├── term_unix_bsd.go
│ ├── term_unix_other.go
│ ├── term_unsupported.go
│ ├── term_windows.go
│ └── terminal.go
└── modules.txt
Showing preview only (8,330K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (98854 symbols across 458 files)
FILE: assets/bindata.go
type asset (line 17) | type asset struct
type bindataFileInfo (line 23) | type bindataFileInfo struct
method Name (line 30) | func (fi bindataFileInfo) Name() string {
method Size (line 33) | func (fi bindataFileInfo) Size() int64 {
method Mode (line 36) | func (fi bindataFileInfo) Mode() os.FileMode {
method ModTime (line 39) | func (fi bindataFileInfo) ModTime() time.Time {
method IsDir (line 42) | func (fi bindataFileInfo) IsDir() bool {
method Sys (line 45) | func (fi bindataFileInfo) Sys() interface{} {
function templatesIndexHtmlBytes (line 68) | func templatesIndexHtmlBytes() ([]byte, error) {
function templatesIndexHtml (line 72) | func templatesIndexHtml() (*asset, error) {
function staticStyleCssBytes (line 90) | func staticStyleCssBytes() ([]byte, error) {
function staticStyleCss (line 94) | func staticStyleCss() (*asset, error) {
function Asset (line 108) | func Asset(name string) ([]byte, error) {
function AssetString (line 121) | func AssetString(name string) (string, error) {
function MustAsset (line 128) | func MustAsset(name string) []byte {
function MustAssetString (line 139) | func MustAssetString(name string) string {
function AssetInfo (line 146) | func AssetInfo(name string) (os.FileInfo, error) {
function AssetDigest (line 160) | func AssetDigest(name string) ([sha256.Size]byte, error) {
function Digests (line 173) | func Digests() (map[string][sha256.Size]byte, error) {
function AssetNames (line 186) | func AssetNames() []string {
constant AssetDebug (line 201) | AssetDebug = false
function AssetDir (line 218) | func AssetDir(name string) ([]string, error) {
type bintree (line 240) | type bintree struct
function RestoreAsset (line 255) | func RestoreAsset(dir, name string) error {
function RestoreAssets (line 276) | func RestoreAssets(dir, name string) error {
function _filePath (line 292) | func _filePath(dir, name string) string {
FILE: crypto.go
function opaqueByte (line 12) | func opaqueByte(b []byte, secretKey nacl.Key) string {
function unopaqueByte (line 17) | func unopaqueByte(compressed string, secretKey nacl.Key) ([]byte, error) {
function opaque (line 27) | func opaque(s string, secretKey *[32]byte) string {
function unopaque (line 33) | func unopaque(compressed string, secretKey *[32]byte) (string, error) {
FILE: flash.go
function FlashSuccess (line 15) | func FlashSuccess(w http.ResponseWriter, msg string, key *[32]byte) {
function FlashError (line 21) | func FlashError(w http.ResponseWriter, msg string, key *[32]byte) {
function setCookie (line 25) | func setCookie(w http.ResponseWriter, msg string, name string, key *[32]...
function GetFlashSuccess (line 37) | func GetFlashSuccess(w http.ResponseWriter, r *http.Request, key *[32]by...
function GetFlashError (line 43) | func GetFlashError(w http.ResponseWriter, r *http.Request, key *[32]byte...
function getCookie (line 47) | func getCookie(w http.ResponseWriter, r *http.Request, name string, key ...
function clearCookie (line 64) | func clearCookie(w http.ResponseWriter, name string) {
FILE: main.go
constant Version (line 39) | Version = "0.9.0"
function hashurl (line 46) | func hashurl(key string) template.URL {
function b64 (line 55) | func b64(digest []byte) string {
function init (line 59) | func init() {
type static (line 79) | type static struct
method ServeHTTP (line 85) | func (s *static) ServeHTTP(w http.ResponseWriter, r *http.Request) {
function render (line 103) | func render(w http.ResponseWriter, r *http.Request, tpl *template.Templa...
function NewServeMux (line 114) | func NewServeMux() http.Handler {
type FileConfig (line 132) | type FileConfig struct
function main (line 167) | func main() {
FILE: main_test.go
function TestServer (line 13) | func TestServer(t *testing.T) {
function BenchmarkHomepage (line 26) | func BenchmarkHomepage(b *testing.B) {
function BenchmarkOpaque (line 51) | func BenchmarkOpaque(b *testing.B) {
FILE: vendor/github.com/goccy/go-yaml/ast/ast.go
type NodeType (line 21) | type NodeType
method String (line 71) | func (t NodeType) String() string {
method YAMLName (line 123) | func (t NodeType) YAMLName() string {
constant UnknownNodeType (line 25) | UnknownNodeType NodeType = iota
constant DocumentType (line 27) | DocumentType
constant NullType (line 29) | NullType
constant BoolType (line 31) | BoolType
constant IntegerType (line 33) | IntegerType
constant FloatType (line 35) | FloatType
constant InfinityType (line 37) | InfinityType
constant NanType (line 39) | NanType
constant StringType (line 41) | StringType
constant MergeKeyType (line 43) | MergeKeyType
constant LiteralType (line 45) | LiteralType
constant MappingType (line 47) | MappingType
constant MappingKeyType (line 49) | MappingKeyType
constant MappingValueType (line 51) | MappingValueType
constant SequenceType (line 53) | SequenceType
constant SequenceEntryType (line 55) | SequenceEntryType
constant AnchorType (line 57) | AnchorType
constant AliasType (line 59) | AliasType
constant DirectiveType (line 61) | DirectiveType
constant TagType (line 63) | TagType
constant CommentType (line 65) | CommentType
constant CommentGroupType (line 67) | CommentGroupType
type Node (line 174) | type Node interface
type MapKeyNode (line 203) | type MapKeyNode interface
type ScalarNode (line 211) | type ScalarNode interface
type BaseNode (line 216) | type BaseNode struct
method readLen (line 226) | func (n *BaseNode) readLen() int {
method clearLen (line 230) | func (n *BaseNode) clearLen() {
method addReadLen (line 234) | func (n *BaseNode) addReadLen(len int) {
method GetPath (line 239) | func (n *BaseNode) GetPath() string {
method SetPath (line 247) | func (n *BaseNode) SetPath(path string) {
method GetComment (line 255) | func (n *BaseNode) GetComment() *CommentGroupNode {
method SetComment (line 260) | func (n *BaseNode) SetComment(node *CommentGroupNode) error {
function addCommentString (line 222) | func addCommentString(base string, node *CommentGroupNode) string {
function min (line 265) | func min(a, b int) int {
function readNode (line 272) | func readNode(p []byte, node Node) (int, error) {
function checkLineBreak (line 288) | func checkLineBreak(t *token.Token) bool {
function Null (line 332) | func Null(tk *token.Token) *NullNode {
function Bool (line 340) | func Bool(tk *token.Token) *BoolNode {
function Integer (line 350) | func Integer(tk *token.Token) *IntegerNode {
function Float (line 363) | func Float(tk *token.Token) *FloatNode {
function Infinity (line 379) | func Infinity(tk *token.Token) *InfinityNode {
function Nan (line 394) | func Nan(tk *token.Token) *NanNode {
function String (line 402) | func String(tk *token.Token) *StringNode {
function Comment (line 411) | func Comment(tk *token.Token) *CommentNode {
function CommentGroup (line 418) | func CommentGroup(comments []*token.Token) *CommentGroupNode {
function MergeKey (line 430) | func MergeKey(tk *token.Token) *MergeKeyNode {
function Mapping (line 438) | func Mapping(tk *token.Token, isFlowStyle bool, values ...*MappingValueN...
function MappingValue (line 450) | func MappingValue(tk *token.Token, key MapKeyNode, value Node) *MappingV...
function MappingKey (line 460) | func MappingKey(tk *token.Token) *MappingKeyNode {
function Sequence (line 468) | func Sequence(tk *token.Token, isFlowStyle bool) *SequenceNode {
function Anchor (line 477) | func Anchor(tk *token.Token) *AnchorNode {
function Alias (line 484) | func Alias(tk *token.Token) *AliasNode {
function Document (line 491) | func Document(tk *token.Token, body Node) *DocumentNode {
function Directive (line 499) | func Directive(tk *token.Token) *DirectiveNode {
function Literal (line 506) | func Literal(tk *token.Token) *LiteralNode {
function Tag (line 513) | func Tag(tk *token.Token) *TagNode {
type File (line 521) | type File struct
method Read (line 527) | func (f *File) Read(p []byte) (int, error) {
method String (line 539) | func (f *File) String() string {
type DocumentNode (line 552) | type DocumentNode struct
method Read (line 560) | func (d *DocumentNode) Read(p []byte) (int, error) {
method Type (line 565) | func (d *DocumentNode) Type() NodeType { return DocumentType }
method GetToken (line 568) | func (d *DocumentNode) GetToken() *token.Token {
method AddColumn (line 573) | func (d *DocumentNode) AddColumn(col int) {
method String (line 580) | func (d *DocumentNode) String() string {
method MarshalYAML (line 595) | func (d *DocumentNode) MarshalYAML() ([]byte, error) {
type NullNode (line 600) | type NullNode struct
method Read (line 606) | func (n *NullNode) Read(p []byte) (int, error) {
method Type (line 611) | func (n *NullNode) Type() NodeType { return NullType }
method GetToken (line 614) | func (n *NullNode) GetToken() *token.Token {
method AddColumn (line 619) | func (n *NullNode) AddColumn(col int) {
method GetValue (line 624) | func (n *NullNode) GetValue() interface{} {
method String (line 629) | func (n *NullNode) String() string {
method stringWithoutComment (line 642) | func (n *NullNode) stringWithoutComment() string {
method MarshalYAML (line 647) | func (n *NullNode) MarshalYAML() ([]byte, error) {
method IsMergeKey (line 652) | func (n *NullNode) IsMergeKey() bool {
type IntegerNode (line 657) | type IntegerNode struct
method Read (line 664) | func (n *IntegerNode) Read(p []byte) (int, error) {
method Type (line 669) | func (n *IntegerNode) Type() NodeType { return IntegerType }
method GetToken (line 672) | func (n *IntegerNode) GetToken() *token.Token {
method AddColumn (line 677) | func (n *IntegerNode) AddColumn(col int) {
method GetValue (line 682) | func (n *IntegerNode) GetValue() interface{} {
method String (line 687) | func (n *IntegerNode) String() string {
method stringWithoutComment (line 694) | func (n *IntegerNode) stringWithoutComment() string {
method MarshalYAML (line 699) | func (n *IntegerNode) MarshalYAML() ([]byte, error) {
method IsMergeKey (line 704) | func (n *IntegerNode) IsMergeKey() bool {
type FloatNode (line 709) | type FloatNode struct
method Read (line 717) | func (n *FloatNode) Read(p []byte) (int, error) {
method Type (line 722) | func (n *FloatNode) Type() NodeType { return FloatType }
method GetToken (line 725) | func (n *FloatNode) GetToken() *token.Token {
method AddColumn (line 730) | func (n *FloatNode) AddColumn(col int) {
method GetValue (line 735) | func (n *FloatNode) GetValue() interface{} {
method String (line 740) | func (n *FloatNode) String() string {
method stringWithoutComment (line 747) | func (n *FloatNode) stringWithoutComment() string {
method MarshalYAML (line 752) | func (n *FloatNode) MarshalYAML() ([]byte, error) {
method IsMergeKey (line 757) | func (n *FloatNode) IsMergeKey() bool {
type StringNode (line 762) | type StringNode struct
method Read (line 769) | func (n *StringNode) Read(p []byte) (int, error) {
method Type (line 774) | func (n *StringNode) Type() NodeType { return StringType }
method GetToken (line 777) | func (n *StringNode) GetToken() *token.Token {
method AddColumn (line 782) | func (n *StringNode) AddColumn(col int) {
method GetValue (line 787) | func (n *StringNode) GetValue() interface{} {
method IsMergeKey (line 792) | func (n *StringNode) IsMergeKey() bool {
method String (line 811) | func (n *StringNode) String() string {
method stringWithoutComment (line 849) | func (n *StringNode) stringWithoutComment() string {
method MarshalYAML (line 879) | func (n *StringNode) MarshalYAML() ([]byte, error) {
function escapeSingleQuote (line 798) | func escapeSingleQuote(s string) string {
type LiteralNode (line 884) | type LiteralNode struct
method Read (line 891) | func (n *LiteralNode) Read(p []byte) (int, error) {
method Type (line 896) | func (n *LiteralNode) Type() NodeType { return LiteralType }
method GetToken (line 899) | func (n *LiteralNode) GetToken() *token.Token {
method AddColumn (line 904) | func (n *LiteralNode) AddColumn(col int) {
method GetValue (line 912) | func (n *LiteralNode) GetValue() interface{} {
method String (line 917) | func (n *LiteralNode) String() string {
method stringWithoutComment (line 926) | func (n *LiteralNode) stringWithoutComment() string {
method MarshalYAML (line 931) | func (n *LiteralNode) MarshalYAML() ([]byte, error) {
method IsMergeKey (line 936) | func (n *LiteralNode) IsMergeKey() bool {
type MergeKeyNode (line 941) | type MergeKeyNode struct
method Read (line 947) | func (n *MergeKeyNode) Read(p []byte) (int, error) {
method Type (line 952) | func (n *MergeKeyNode) Type() NodeType { return MergeKeyType }
method GetToken (line 955) | func (n *MergeKeyNode) GetToken() *token.Token {
method GetValue (line 960) | func (n *MergeKeyNode) GetValue() interface{} {
method String (line 965) | func (n *MergeKeyNode) String() string {
method stringWithoutComment (line 969) | func (n *MergeKeyNode) stringWithoutComment() string {
method AddColumn (line 974) | func (n *MergeKeyNode) AddColumn(col int) {
method MarshalYAML (line 979) | func (n *MergeKeyNode) MarshalYAML() ([]byte, error) {
method IsMergeKey (line 984) | func (n *MergeKeyNode) IsMergeKey() bool {
type BoolNode (line 989) | type BoolNode struct
method Read (line 996) | func (n *BoolNode) Read(p []byte) (int, error) {
method Type (line 1001) | func (n *BoolNode) Type() NodeType { return BoolType }
method GetToken (line 1004) | func (n *BoolNode) GetToken() *token.Token {
method AddColumn (line 1009) | func (n *BoolNode) AddColumn(col int) {
method GetValue (line 1014) | func (n *BoolNode) GetValue() interface{} {
method String (line 1019) | func (n *BoolNode) String() string {
method stringWithoutComment (line 1026) | func (n *BoolNode) stringWithoutComment() string {
method MarshalYAML (line 1031) | func (n *BoolNode) MarshalYAML() ([]byte, error) {
method IsMergeKey (line 1036) | func (n *BoolNode) IsMergeKey() bool {
type InfinityNode (line 1041) | type InfinityNode struct
method Read (line 1048) | func (n *InfinityNode) Read(p []byte) (int, error) {
method Type (line 1053) | func (n *InfinityNode) Type() NodeType { return InfinityType }
method GetToken (line 1056) | func (n *InfinityNode) GetToken() *token.Token {
method AddColumn (line 1061) | func (n *InfinityNode) AddColumn(col int) {
method GetValue (line 1066) | func (n *InfinityNode) GetValue() interface{} {
method String (line 1071) | func (n *InfinityNode) String() string {
method stringWithoutComment (line 1078) | func (n *InfinityNode) stringWithoutComment() string {
method MarshalYAML (line 1083) | func (n *InfinityNode) MarshalYAML() ([]byte, error) {
method IsMergeKey (line 1088) | func (n *InfinityNode) IsMergeKey() bool {
type NanNode (line 1093) | type NanNode struct
method Read (line 1099) | func (n *NanNode) Read(p []byte) (int, error) {
method Type (line 1104) | func (n *NanNode) Type() NodeType { return NanType }
method GetToken (line 1107) | func (n *NanNode) GetToken() *token.Token {
method AddColumn (line 1112) | func (n *NanNode) AddColumn(col int) {
method GetValue (line 1117) | func (n *NanNode) GetValue() interface{} {
method String (line 1122) | func (n *NanNode) String() string {
method stringWithoutComment (line 1129) | func (n *NanNode) stringWithoutComment() string {
method MarshalYAML (line 1134) | func (n *NanNode) MarshalYAML() ([]byte, error) {
method IsMergeKey (line 1139) | func (n *NanNode) IsMergeKey() bool {
type MapNode (line 1144) | type MapNode interface
type MapNodeIter (line 1149) | type MapNodeIter struct
method Next (line 1160) | func (m *MapNodeIter) Next() bool {
method Key (line 1167) | func (m *MapNodeIter) Key() MapKeyNode {
method Value (line 1172) | func (m *MapNodeIter) Value() Node {
method KeyValue (line 1177) | func (m *MapNodeIter) KeyValue() *MappingValueNode {
constant startRangeIndex (line 1155) | startRangeIndex = -1
type MappingNode (line 1182) | type MappingNode struct
method startPos (line 1191) | func (n *MappingNode) startPos() *token.Position {
method Merge (line 1199) | func (n *MappingNode) Merge(target *MappingNode) {
method SetIsFlowStyle (line 1218) | func (n *MappingNode) SetIsFlowStyle(isFlow bool) {
method Read (line 1226) | func (n *MappingNode) Read(p []byte) (int, error) {
method Type (line 1231) | func (n *MappingNode) Type() NodeType { return MappingType }
method GetToken (line 1234) | func (n *MappingNode) GetToken() *token.Token {
method AddColumn (line 1239) | func (n *MappingNode) AddColumn(col int) {
method flowStyleString (line 1247) | func (n *MappingNode) flowStyleString(commentMode bool) string {
method blockStyleString (line 1259) | func (n *MappingNode) blockStyleString(commentMode bool) string {
method String (line 1281) | func (n *MappingNode) String() string {
method MapRange (line 1297) | func (n *MappingNode) MapRange() *MapNodeIter {
method MarshalYAML (line 1305) | func (n *MappingNode) MarshalYAML() ([]byte, error) {
type MappingKeyNode (line 1310) | type MappingKeyNode struct
method Read (line 1317) | func (n *MappingKeyNode) Read(p []byte) (int, error) {
method Type (line 1322) | func (n *MappingKeyNode) Type() NodeType { return MappingKeyType }
method GetToken (line 1325) | func (n *MappingKeyNode) GetToken() *token.Token {
method AddColumn (line 1330) | func (n *MappingKeyNode) AddColumn(col int) {
method String (line 1338) | func (n *MappingKeyNode) String() string {
method stringWithoutComment (line 1342) | func (n *MappingKeyNode) stringWithoutComment() string {
method MarshalYAML (line 1347) | func (n *MappingKeyNode) MarshalYAML() ([]byte, error) {
method IsMergeKey (line 1352) | func (n *MappingKeyNode) IsMergeKey() bool {
type MappingValueNode (line 1364) | type MappingValueNode struct
method Replace (line 1375) | func (n *MappingValueNode) Replace(value Node) error {
method Read (line 1383) | func (n *MappingValueNode) Read(p []byte) (int, error) {
method Type (line 1388) | func (n *MappingValueNode) Type() NodeType { return MappingValueType }
method GetToken (line 1391) | func (n *MappingValueNode) GetToken() *token.Token {
method AddColumn (line 1396) | func (n *MappingValueNode) AddColumn(col int) {
method SetIsFlowStyle (line 1407) | func (n *MappingValueNode) SetIsFlowStyle(isFlow bool) {
method String (line 1420) | func (n *MappingValueNode) String() string {
method toString (line 1437) | func (n *MappingValueNode) toString() string {
method MapRange (line 1505) | func (n *MappingValueNode) MapRange() *MapNodeIter {
method MarshalYAML (line 1513) | func (n *MappingValueNode) MarshalYAML() ([]byte, error) {
type ArrayNode (line 1518) | type ArrayNode interface
type ArrayNodeIter (line 1523) | type ArrayNodeIter struct
method Next (line 1530) | func (m *ArrayNodeIter) Next() bool {
method Value (line 1537) | func (m *ArrayNodeIter) Value() Node {
method Len (line 1542) | func (m *ArrayNodeIter) Len() int {
type SequenceNode (line 1547) | type SequenceNode struct
method Replace (line 1559) | func (n *SequenceNode) Replace(idx int, value Node) error {
method Merge (line 1573) | func (n *SequenceNode) Merge(target *SequenceNode) {
method SetIsFlowStyle (line 1585) | func (n *SequenceNode) SetIsFlowStyle(isFlow bool) {
method Read (line 1600) | func (n *SequenceNode) Read(p []byte) (int, error) {
method Type (line 1605) | func (n *SequenceNode) Type() NodeType { return SequenceType }
method GetToken (line 1608) | func (n *SequenceNode) GetToken() *token.Token {
method AddColumn (line 1613) | func (n *SequenceNode) AddColumn(col int) {
method flowStyleString (line 1621) | func (n *SequenceNode) flowStyleString() string {
method blockStyleString (line 1633) | func (n *SequenceNode) blockStyleString() string {
method String (line 1684) | func (n *SequenceNode) String() string {
method ArrayRange (line 1692) | func (n *SequenceNode) ArrayRange() *ArrayNodeIter {
method MarshalYAML (line 1700) | func (n *SequenceNode) MarshalYAML() ([]byte, error) {
type SequenceEntryNode (line 1705) | type SequenceEntryNode struct
method String (line 1714) | func (n *SequenceEntryNode) String() string {
method GetToken (line 1719) | func (n *SequenceEntryNode) GetToken() *token.Token {
method Type (line 1724) | func (n *SequenceEntryNode) Type() NodeType {
method AddColumn (line 1729) | func (n *SequenceEntryNode) AddColumn(col int) {
method SetComment (line 1734) | func (n *SequenceEntryNode) SetComment(cm *CommentGroupNode) error {
method GetComment (line 1740) | func (n *SequenceEntryNode) GetComment() *CommentGroupNode {
method MarshalYAML (line 1745) | func (n *SequenceEntryNode) MarshalYAML() ([]byte, error) {
method Read (line 1749) | func (n *SequenceEntryNode) Read(p []byte) (int, error) {
function SequenceEntry (line 1754) | func SequenceEntry(start *token.Token, value Node, headComment *CommentG...
function SequenceMergeValue (line 1764) | func SequenceMergeValue(values ...MapNode) *SequenceMergeValueNode {
type SequenceMergeValueNode (line 1771) | type SequenceMergeValueNode struct
method MapRange (line 1776) | func (n *SequenceMergeValueNode) MapRange() *MapNodeIter {
type AnchorNode (line 1786) | type AnchorNode struct
method stringWithoutComment (line 1793) | func (n *AnchorNode) stringWithoutComment() string {
method SetName (line 1797) | func (n *AnchorNode) SetName(name string) error {
method Read (line 1810) | func (n *AnchorNode) Read(p []byte) (int, error) {
method Type (line 1815) | func (n *AnchorNode) Type() NodeType { return AnchorType }
method GetToken (line 1818) | func (n *AnchorNode) GetToken() *token.Token {
method GetValue (line 1822) | func (n *AnchorNode) GetValue() any {
method AddColumn (line 1827) | func (n *AnchorNode) AddColumn(col int) {
method String (line 1838) | func (n *AnchorNode) String() string {
method MarshalYAML (line 1854) | func (n *AnchorNode) MarshalYAML() ([]byte, error) {
method IsMergeKey (line 1859) | func (n *AnchorNode) IsMergeKey() bool {
type AliasNode (line 1871) | type AliasNode struct
method stringWithoutComment (line 1877) | func (n *AliasNode) stringWithoutComment() string {
method SetName (line 1881) | func (n *AliasNode) SetName(name string) error {
method Read (line 1894) | func (n *AliasNode) Read(p []byte) (int, error) {
method Type (line 1899) | func (n *AliasNode) Type() NodeType { return AliasType }
method GetToken (line 1902) | func (n *AliasNode) GetToken() *token.Token {
method GetValue (line 1906) | func (n *AliasNode) GetValue() any {
method AddColumn (line 1911) | func (n *AliasNode) AddColumn(col int) {
method String (line 1919) | func (n *AliasNode) String() string {
method MarshalYAML (line 1924) | func (n *AliasNode) MarshalYAML() ([]byte, error) {
method IsMergeKey (line 1929) | func (n *AliasNode) IsMergeKey() bool {
type DirectiveNode (line 1934) | type DirectiveNode struct
method Read (line 1945) | func (n *DirectiveNode) Read(p []byte) (int, error) {
method Type (line 1950) | func (n *DirectiveNode) Type() NodeType { return DirectiveType }
method GetToken (line 1953) | func (n *DirectiveNode) GetToken() *token.Token {
method AddColumn (line 1958) | func (n *DirectiveNode) AddColumn(col int) {
method String (line 1968) | func (n *DirectiveNode) String() string {
method MarshalYAML (line 1977) | func (n *DirectiveNode) MarshalYAML() ([]byte, error) {
type TagNode (line 1982) | type TagNode struct
method GetValue (line 1989) | func (n *TagNode) GetValue() any {
method stringWithoutComment (line 1997) | func (n *TagNode) stringWithoutComment() string {
method Read (line 2002) | func (n *TagNode) Read(p []byte) (int, error) {
method Type (line 2007) | func (n *TagNode) Type() NodeType { return TagType }
method GetToken (line 2010) | func (n *TagNode) GetToken() *token.Token {
method AddColumn (line 2015) | func (n *TagNode) AddColumn(col int) {
method String (line 2023) | func (n *TagNode) String() string {
method MarshalYAML (line 2035) | func (n *TagNode) MarshalYAML() ([]byte, error) {
method IsMergeKey (line 2040) | func (n *TagNode) IsMergeKey() bool {
method ArrayRange (line 2051) | func (n *TagNode) ArrayRange() *ArrayNodeIter {
type CommentNode (line 2060) | type CommentNode struct
method Read (line 2066) | func (n *CommentNode) Read(p []byte) (int, error) {
method Type (line 2071) | func (n *CommentNode) Type() NodeType { return CommentType }
method GetToken (line 2074) | func (n *CommentNode) GetToken() *token.Token { return n.Token }
method AddColumn (line 2077) | func (n *CommentNode) AddColumn(col int) {
method String (line 2085) | func (n *CommentNode) String() string {
method MarshalYAML (line 2090) | func (n *CommentNode) MarshalYAML() ([]byte, error) {
type CommentGroupNode (line 2095) | type CommentGroupNode struct
method Read (line 2101) | func (n *CommentGroupNode) Read(p []byte) (int, error) {
method Type (line 2106) | func (n *CommentGroupNode) Type() NodeType { return CommentType }
method GetToken (line 2109) | func (n *CommentGroupNode) GetToken() *token.Token {
method AddColumn (line 2117) | func (n *CommentGroupNode) AddColumn(col int) {
method String (line 2124) | func (n *CommentGroupNode) String() string {
method StringWithSpace (line 2132) | func (n *CommentGroupNode) StringWithSpace(col int) string {
method MarshalYAML (line 2146) | func (n *CommentGroupNode) MarshalYAML() ([]byte, error) {
type Visitor (line 2153) | type Visitor interface
function Walk (line 2161) | func Walk(v Visitor, node Node) {
function walkComment (line 2226) | func walkComment(v Visitor, base *BaseNode) {
type filterWalker (line 2236) | type filterWalker struct
method Visit (line 2241) | func (v *filterWalker) Visit(n Node) Visitor {
type parentFinder (line 2248) | type parentFinder struct
method walk (line 2252) | func (f *parentFinder) walk(parent, node Node) Node {
function Parent (line 2321) | func Parent(root, child Node) Node {
function Filter (line 2327) | func Filter(typ NodeType, node Node) []Node {
function FilterFile (line 2334) | func FilterFile(typ NodeType, file *File) []Node {
type ErrInvalidMergeType (line 2344) | type ErrInvalidMergeType struct
method Error (line 2349) | func (e *ErrInvalidMergeType) Error() string {
function Merge (line 2354) | func Merge(dst Node, src Node) error {
FILE: vendor/github.com/goccy/go-yaml/context.go
type ctxMergeKey (line 6) | type ctxMergeKey struct
type ctxAnchorKey (line 7) | type ctxAnchorKey struct
function withMerge (line 10) | func withMerge(ctx context.Context) context.Context {
function isMerge (line 14) | func isMerge(ctx context.Context) bool {
function withAnchor (line 22) | func withAnchor(ctx context.Context, name string) context.Context {
function getAnchorMap (line 31) | func getAnchorMap(ctx context.Context) map[string]struct{} {
FILE: vendor/github.com/goccy/go-yaml/decode.go
type Decoder (line 28) | type Decoder struct
method stepIn (line 73) | func (d *Decoder) stepIn() {
method stepOut (line 77) | func (d *Decoder) stepOut() {
method isExceededMaxDepth (line 81) | func (d *Decoder) isExceededMaxDepth() bool {
method castToFloat (line 85) | func (d *Decoder) castToFloat(v interface{}) interface{} {
method mapKeyNodeToString (line 119) | func (d *Decoder) mapKeyNodeToString(ctx context.Context, node ast.Map...
method setToMapValue (line 133) | func (d *Decoder) setToMapValue(ctx context.Context, node ast.Node, m ...
method setToOrderedMapValue (line 178) | func (d *Decoder) setToOrderedMapValue(ctx context.Context, node ast.N...
method setPathToCommentMap (line 220) | func (d *Decoder) setPathToCommentMap(node ast.Node) {
method addHeadOrLineCommentToMap (line 231) | func (d *Decoder) addHeadOrLineCommentToMap(node ast.Node) {
method addSequenceNodeCommentToMap (line 269) | func (d *Decoder) addSequenceNodeCommentToMap(node *ast.SequenceNode) {
method addFootCommentToMap (line 298) | func (d *Decoder) addFootCommentToMap(node ast.Node) {
method addCommentToMap (line 332) | func (d *Decoder) addCommentToMap(path string, comment *Comment) {
method nodeToValue (line 345) | func (d *Decoder) nodeToValue(ctx context.Context, node ast.Node) (any...
method getMapNode (line 547) | func (d *Decoder) getMapNode(node ast.Node, isMerge bool) (ast.MapNode...
method getArrayNode (line 585) | func (d *Decoder) getArrayNode(node ast.Node) (ast.ArrayNode, error) {
method convertValue (line 622) | func (d *Decoder) convertValue(v reflect.Value, typ reflect.Type, src ...
method deleteStructKeys (line 670) | func (d *Decoder) deleteStructKeys(structType reflect.Type, unknownFie...
method unmarshalableDocument (line 699) | func (d *Decoder) unmarshalableDocument(node ast.Node) ([]byte, error) {
method unmarshalableText (line 704) | func (d *Decoder) unmarshalableText(node ast.Node) ([]byte, bool) {
method existsTypeInCustomUnmarshalerMap (line 717) | func (d *Decoder) existsTypeInCustomUnmarshalerMap(t reflect.Type) bool {
method unmarshalerFromCustomUnmarshalerMap (line 730) | func (d *Decoder) unmarshalerFromCustomUnmarshalerMap(t reflect.Type) ...
method canDecodeByUnmarshaler (line 743) | func (d *Decoder) canDecodeByUnmarshaler(dst reflect.Value) bool {
method decodeByUnmarshaler (line 766) | func (d *Decoder) decodeByUnmarshaler(ctx context.Context, dst reflect...
method decodeValue (line 893) | func (d *Decoder) decodeValue(ctx context.Context, dst reflect.Value, ...
method createDecodableValue (line 1052) | func (d *Decoder) createDecodableValue(typ reflect.Type) reflect.Value {
method castToAssignableValue (line 1063) | func (d *Decoder) castToAssignableValue(value reflect.Value, target re...
method createDecodedNewValue (line 1088) | func (d *Decoder) createDecodedNewValue(
method keyToNodeMap (line 1125) | func (d *Decoder) keyToNodeMap(ctx context.Context, node ast.Node, ign...
method keyToKeyNodeMap (line 1173) | func (d *Decoder) keyToKeyNodeMap(ctx context.Context, node ast.Node, ...
method keyToValueNodeMap (line 1181) | func (d *Decoder) keyToValueNodeMap(ctx context.Context, node ast.Node...
method setDefaultValueIfConflicted (line 1189) | func (d *Decoder) setDefaultValueIfConflicted(v reflect.Value, fieldMa...
method castToTime (line 1228) | func (d *Decoder) castToTime(ctx context.Context, src ast.Node) (time....
method decodeTime (line 1254) | func (d *Decoder) decodeTime(ctx context.Context, dst reflect.Value, s...
method castToDuration (line 1263) | func (d *Decoder) castToDuration(ctx context.Context, src ast.Node) (t...
method decodeDuration (line 1285) | func (d *Decoder) decodeDuration(ctx context.Context, dst reflect.Valu...
method getMergeAliasName (line 1295) | func (d *Decoder) getMergeAliasName(src ast.Node) string {
method decodeStruct (line 1311) | func (d *Decoder) decodeStruct(ctx context.Context, dst reflect.Value,...
method getParentMapTokenIfExistsForValidationError (line 1503) | func (d *Decoder) getParentMapTokenIfExistsForValidationError(typ ast....
method decodeArray (line 1532) | func (d *Decoder) decodeArray(ctx context.Context, dst reflect.Value, ...
method decodeSlice (line 1577) | func (d *Decoder) decodeSlice(ctx context.Context, dst reflect.Value, ...
method decodeMapItem (line 1620) | func (d *Decoder) decodeMapItem(ctx context.Context, dst *MapItem, src...
method validateDuplicateKey (line 1655) | func (d *Decoder) validateDuplicateKey(keyMap map[string]struct{}, key...
method decodeMapSlice (line 1669) | func (d *Decoder) decodeMapSlice(ctx context.Context, dst *MapSlice, s...
method decodeMap (line 1716) | func (d *Decoder) decodeMap(ctx context.Context, dst reflect.Value, sr...
method fileToReader (line 1800) | func (d *Decoder) fileToReader(file string) (io.Reader, error) {
method isYAMLFile (line 1808) | func (d *Decoder) isYAMLFile(file string) bool {
method readersUnderDir (line 1819) | func (d *Decoder) readersUnderDir(dir string) ([]io.Reader, error) {
method readersUnderDirRecursive (line 1839) | func (d *Decoder) readersUnderDirRecursive(dir string) ([]io.Reader, e...
method resolveReference (line 1857) | func (d *Decoder) resolveReference(ctx context.Context) error {
method parse (line 1900) | func (d *Decoder) parse(ctx context.Context, bytes []byte) (*ast.File,...
method isInitialized (line 1933) | func (d *Decoder) isInitialized() bool {
method decodeInit (line 1937) | func (d *Decoder) decodeInit(ctx context.Context) error {
method decode (line 1955) | func (d *Decoder) decode(ctx context.Context, v reflect.Value) error {
method Decode (line 1987) | func (d *Decoder) Decode(v interface{}) error {
method DecodeContext (line 1993) | func (d *Decoder) DecodeContext(ctx context.Context, v interface{}) er...
method DecodeFromNode (line 2014) | func (d *Decoder) DecodeFromNode(node ast.Node, v interface{}) error {
method DecodeFromNodeContext (line 2019) | func (d *Decoder) DecodeFromNodeContext(ctx context.Context, node ast....
function NewDecoder (line 53) | func NewDecoder(r io.Reader, opts ...DecodeOption) *Decoder {
constant maxDecodeDepth (line 71) | maxDecodeDepth = 10000
type jsonUnmarshaler (line 713) | type jsonUnmarshaler interface
FILE: vendor/github.com/goccy/go-yaml/encode.go
constant DefaultIndentSpaces (line 24) | DefaultIndentSpaces = 2
type Encoder (line 28) | type Encoder struct
method Close (line 75) | func (e *Encoder) Close() error {
method Encode (line 85) | func (e *Encoder) Encode(v interface{}) error {
method EncodeContext (line 90) | func (e *Encoder) EncodeContext(ctx context.Context, v interface{}) er...
method EncodeToNode (line 110) | func (e *Encoder) EncodeToNode(v interface{}) (ast.Node, error) {
method EncodeToNodeContext (line 115) | func (e *Encoder) EncodeToNodeContext(ctx context.Context, v interface...
method setCommentByCommentMap (line 135) | func (e *Encoder) setCommentByCommentMap(node ast.Node) error {
method setHeadComment (line 174) | func (e *Encoder) setHeadComment(node ast.Node, filtered ast.Node, com...
method setLineComment (line 206) | func (e *Encoder) setLineComment(node ast.Node, filtered ast.Node, com...
method setLineCommentToParentMapNode (line 222) | func (e *Encoder) setLineCommentToParentMapNode(node ast.Node, filtere...
method setFootComment (line 242) | func (e *Encoder) setFootComment(node ast.Node, filtered ast.Node, com...
method encodeDocument (line 260) | func (e *Encoder) encodeDocument(doc []byte) (ast.Node, error) {
method isInvalidValue (line 273) | func (e *Encoder) isInvalidValue(v reflect.Value) bool {
method existsTypeInCustomMarshalerMap (line 291) | func (e *Encoder) existsTypeInCustomMarshalerMap(t reflect.Type) bool {
method marshalerFromCustomMarshalerMap (line 304) | func (e *Encoder) marshalerFromCustomMarshalerMap(t reflect.Type) (fun...
method canEncodeByMarshaler (line 317) | func (e *Encoder) canEncodeByMarshaler(v reflect.Value) bool {
method encodeByMarshaler (line 346) | func (e *Encoder) encodeByMarshaler(ctx context.Context, v reflect.Val...
method encodeValue (line 443) | func (e *Encoder) encodeValue(ctx context.Context, v reflect.Value, co...
method encodePtrAnchor (line 504) | func (e *Encoder) encodePtrAnchor(v reflect.Value, column int) ast.Node {
method pos (line 516) | func (e *Encoder) pos(column int) *token.Position {
method encodeNil (line 526) | func (e *Encoder) encodeNil() *ast.NullNode {
method encodeInt (line 531) | func (e *Encoder) encodeInt(v int64) *ast.IntegerNode {
method encodeUint (line 536) | func (e *Encoder) encodeUint(v uint64) *ast.IntegerNode {
method encodeFloat (line 541) | func (e *Encoder) encodeFloat(v float64, bitSize int) ast.Node {
method isNeedQuoted (line 563) | func (e *Encoder) isNeedQuoted(v string) bool {
method encodeString (line 590) | func (e *Encoder) encodeString(v string, column int) *ast.StringNode {
method encodeBool (line 601) | func (e *Encoder) encodeBool(v bool) *ast.BoolNode {
method encodeSlice (line 606) | func (e *Encoder) encodeSlice(ctx context.Context, value reflect.Value...
method encodeArray (line 623) | func (e *Encoder) encodeArray(ctx context.Context, value reflect.Value...
method encodeMapItem (line 640) | func (e *Encoder) encodeMapItem(ctx context.Context, item MapItem, col...
method encodeMapSlice (line 660) | func (e *Encoder) encodeMapSlice(ctx context.Context, value MapSlice, ...
method isMapNode (line 672) | func (e *Encoder) isMapNode(node ast.Node) bool {
method isTagAndMapNode (line 677) | func (e *Encoder) isTagAndMapNode(node ast.Node) bool {
method encodeMap (line 682) | func (e *Encoder) encodeMap(ctx context.Context, value reflect.Value, ...
method isOmittedByOmitZero (line 738) | func (e *Encoder) isOmittedByOmitZero(v reflect.Value) bool {
method isOmittedByOmitEmptyOption (line 774) | func (e *Encoder) isOmittedByOmitEmptyOption(v reflect.Value) bool {
method isOmittedByOmitEmptyTag (line 801) | func (e *Encoder) isOmittedByOmitEmptyTag(v reflect.Value) bool {
method encodeTime (line 839) | func (e *Encoder) encodeTime(v time.Time, column int) *ast.StringNode {
method encodeDuration (line 847) | func (e *Encoder) encodeDuration(v time.Duration, column int) *ast.Str...
method encodeAnchor (line 855) | func (e *Encoder) encodeAnchor(anchorName string, value ast.Node, fiel...
method encodeStruct (line 873) | func (e *Encoder) encodeStruct(ctx context.Context, value reflect.Valu...
method toPointer (line 998) | func (e *Encoder) toPointer(v reflect.Value) uintptr {
method clearSmartAnchorRef (line 1016) | func (e *Encoder) clearSmartAnchorRef() {
method setSmartAnchor (line 1024) | func (e *Encoder) setSmartAnchor(ptr uintptr, name string) {
method setAnchor (line 1031) | func (e *Encoder) setAnchor(ptr uintptr, name string) {
method generateAnchorName (line 1042) | func (e *Encoder) generateAnchorName(base string) string {
method getAnchor (line 1056) | func (e *Encoder) getAnchor(ref uintptr) (string, bool) {
method setSmartAlias (line 1061) | func (e *Encoder) setSmartAlias(name string, ref uintptr) {
method getSmartAlias (line 1068) | func (e *Encoder) getSmartAlias(ref uintptr) (string, bool) {
function NewEncoder (line 58) | func NewEncoder(w io.Writer, opts ...EncodeOption) *Encoder {
type jsonMarshaler (line 287) | type jsonMarshaler interface
type IsZeroer (line 734) | type IsZeroer interface
FILE: vendor/github.com/goccy/go-yaml/error.go
function ErrUnsupportedHeadPositionType (line 32) | func ErrUnsupportedHeadPositionType(node ast.Node) error {
function ErrUnsupportedLinePositionType (line 36) | func ErrUnsupportedLinePositionType(node ast.Node) error {
function ErrUnsupportedFootPositionType (line 40) | func ErrUnsupportedFootPositionType(node ast.Node) error {
function IsInvalidQueryError (line 45) | func IsInvalidQueryError(err error) bool {
function IsInvalidPathError (line 50) | func IsInvalidPathError(err error) bool {
function IsInvalidPathStringError (line 55) | func IsInvalidPathStringError(err error) bool {
function IsNotFoundNodeError (line 60) | func IsNotFoundNodeError(err error) bool {
function IsInvalidTokenTypeError (line 65) | func IsInvalidTokenTypeError(err error) bool {
function IsInvalidAnchorNameError (line 70) | func IsInvalidAnchorNameError(err error) bool {
function IsInvalidAliasNameError (line 75) | func IsInvalidAliasNameError(err error) bool {
FILE: vendor/github.com/goccy/go-yaml/internal/errors/error.go
constant defaultFormatColor (line 20) | defaultFormatColor = false
constant defaultIncludeSource (line 21) | defaultIncludeSource = true
type Error (line 24) | type Error interface
type SyntaxError (line 40) | type SyntaxError struct
method GetMessage (line 124) | func (e *SyntaxError) GetMessage() string {
method GetToken (line 128) | func (e *SyntaxError) GetToken() *token.Token {
method Error (line 132) | func (e *SyntaxError) Error() string {
method FormatError (line 136) | func (e *SyntaxError) FormatError(colored, inclSource bool) string {
type TypeError (line 45) | type TypeError struct
method msg (line 160) | func (e *TypeError) msg() string {
method GetMessage (line 167) | func (e *TypeError) GetMessage() string {
method GetToken (line 171) | func (e *TypeError) GetToken() *token.Token {
method Error (line 175) | func (e *TypeError) Error() string {
method FormatError (line 179) | func (e *TypeError) FormatError(colored, inclSource bool) string {
type OverflowError (line 52) | type OverflowError struct
method GetMessage (line 140) | func (e *OverflowError) GetMessage() string {
method GetToken (line 144) | func (e *OverflowError) GetToken() *token.Token {
method Error (line 148) | func (e *OverflowError) Error() string {
method FormatError (line 152) | func (e *OverflowError) FormatError(colored, inclSource bool) string {
method msg (line 156) | func (e *OverflowError) msg() string {
type DuplicateKeyError (line 58) | type DuplicateKeyError struct
method GetMessage (line 183) | func (e *DuplicateKeyError) GetMessage() string {
method GetToken (line 187) | func (e *DuplicateKeyError) GetToken() *token.Token {
method Error (line 191) | func (e *DuplicateKeyError) Error() string {
method FormatError (line 195) | func (e *DuplicateKeyError) FormatError(colored, inclSource bool) stri...
type UnknownFieldError (line 63) | type UnknownFieldError struct
method GetMessage (line 199) | func (e *UnknownFieldError) GetMessage() string {
method GetToken (line 203) | func (e *UnknownFieldError) GetToken() *token.Token {
method Error (line 207) | func (e *UnknownFieldError) Error() string {
method FormatError (line 211) | func (e *UnknownFieldError) FormatError(colored, inclSource bool) stri...
type UnexpectedNodeTypeError (line 68) | type UnexpectedNodeTypeError struct
method GetMessage (line 215) | func (e *UnexpectedNodeTypeError) GetMessage() string {
method GetToken (line 219) | func (e *UnexpectedNodeTypeError) GetToken() *token.Token {
method Error (line 223) | func (e *UnexpectedNodeTypeError) Error() string {
method FormatError (line 227) | func (e *UnexpectedNodeTypeError) FormatError(colored, inclSource bool...
method msg (line 231) | func (e *UnexpectedNodeTypeError) msg() string {
function ErrSyntax (line 75) | func ErrSyntax(msg string, tk *token.Token) *SyntaxError {
function ErrOverflow (line 83) | func ErrOverflow(dstType reflect.Type, num string, tk *token.Token) *Ove...
function ErrTypeMismatch (line 92) | func ErrTypeMismatch(dstType, srcType reflect.Type, token *token.Token) ...
function ErrDuplicateKey (line 101) | func ErrDuplicateKey(msg string, tk *token.Token) *DuplicateKeyError {
function ErrUnknownField (line 109) | func ErrUnknownField(msg string, tk *token.Token) *UnknownFieldError {
function ErrUnexpectedNodeType (line 116) | func ErrUnexpectedNodeType(actual, expected ast.NodeType, tk *token.Toke...
function FormatError (line 235) | func FormatError(errMsg string, token *token.Token, colored, inclSource ...
FILE: vendor/github.com/goccy/go-yaml/internal/format/format.go
function FormatNodeWithResolvedAlias (line 10) | func FormatNodeWithResolvedAlias(n ast.Node, anchorNodeMap map[string]as...
function FormatNode (line 20) | func FormatNode(n ast.Node) string {
function FormatFile (line 28) | func FormatFile(file *ast.File) string {
function hasCommentFile (line 39) | func hasCommentFile(f *ast.File) bool {
function hasComment (line 48) | func hasComment(n ast.Node) bool {
function getFirstToken (line 134) | func getFirstToken(n ast.Node) *token.Token {
type Formatter (line 186) | type Formatter struct
method format (line 266) | func (f *Formatter) format(n ast.Node) string {
method formatFile (line 275) | func (f *Formatter) formatFile(file *ast.File) string {
method origin (line 286) | func (f *Formatter) origin(tk *token.Token) string {
method formatDocument (line 296) | func (f *Formatter) formatDocument(n *ast.DocumentNode) string {
method formatNull (line 300) | func (f *Formatter) formatNull(n *ast.NullNode) string {
method formatString (line 304) | func (f *Formatter) formatString(n *ast.StringNode) string {
method formatInteger (line 308) | func (f *Formatter) formatInteger(n *ast.IntegerNode) string {
method formatFloat (line 312) | func (f *Formatter) formatFloat(n *ast.FloatNode) string {
method formatBool (line 316) | func (f *Formatter) formatBool(n *ast.BoolNode) string {
method formatInfinity (line 320) | func (f *Formatter) formatInfinity(n *ast.InfinityNode) string {
method formatNan (line 324) | func (f *Formatter) formatNan(n *ast.NanNode) string {
method formatLiteral (line 328) | func (f *Formatter) formatLiteral(n *ast.LiteralNode) string {
method formatMergeKey (line 332) | func (f *Formatter) formatMergeKey(n *ast.MergeKeyNode) string {
method formatMappingValue (line 336) | func (f *Formatter) formatMappingValue(n *ast.MappingValueNode) string {
method formatDirective (line 342) | func (f *Formatter) formatDirective(n *ast.DirectiveNode) string {
method formatMapping (line 350) | func (f *Formatter) formatMapping(n *ast.MappingNode) string {
method formatTag (line 370) | func (f *Formatter) formatTag(n *ast.TagNode) string {
method formatMappingKey (line 374) | func (f *Formatter) formatMappingKey(n *ast.MappingKeyNode) string {
method formatSequence (line 378) | func (f *Formatter) formatSequence(n *ast.SequenceNode) string {
method formatSequenceEntry (line 397) | func (f *Formatter) formatSequenceEntry(n *ast.SequenceEntryNode) stri...
method formatAnchor (line 401) | func (f *Formatter) formatAnchor(n *ast.AnchorNode) string {
method formatAlias (line 405) | func (f *Formatter) formatAlias(n *ast.AliasNode) string {
method formatNode (line 423) | func (f *Formatter) formatNode(n ast.Node) string {
method formatCommentGroup (line 467) | func (f *Formatter) formatCommentGroup(g *ast.CommentGroupNode) string {
method formatComment (line 478) | func (f *Formatter) formatComment(n *ast.CommentNode) string {
method formatIndent (line 486) | func (f *Formatter) formatIndent(col int) string {
method trimNewLineCharPrefix (line 493) | func (f *Formatter) trimNewLineCharPrefix(v string) string {
method trimSpacePrefix (line 499) | func (f *Formatter) trimSpacePrefix(v string) string {
method trimIndentSpace (line 505) | func (f *Formatter) trimIndentSpace(trimIndentNum int, v string) string {
method addIndentSpace (line 521) | func (f *Formatter) addIndentSpace(indentNum int, v string, isIgnoredF...
function newFormatter (line 192) | func newFormatter(tk *token.Token, existsComment bool) *Formatter {
function getIndentNumByFirstLineToken (line 216) | func getIndentNumByFirstLineToken(tk *token.Token) int {
function normalizeNewLineChars (line 539) | func normalizeNewLineChars(v string) string {
FILE: vendor/github.com/goccy/go-yaml/lexer/lexer.go
function Tokenize (line 11) | func Tokenize(src string) token.Tokens {
FILE: vendor/github.com/goccy/go-yaml/option.go
type DecodeOption (line 12) | type DecodeOption
function ReferenceReaders (line 15) | func ReferenceReaders(readers ...io.Reader) DecodeOption {
function ReferenceFiles (line 23) | func ReferenceFiles(files ...string) DecodeOption {
function ReferenceDirs (line 31) | func ReferenceDirs(dirs ...string) DecodeOption {
function RecursiveDir (line 39) | func RecursiveDir(isRecursive bool) DecodeOption {
function Validator (line 47) | func Validator(v StructValidator) DecodeOption {
function Strict (line 55) | func Strict() DecodeOption {
function DisallowUnknownField (line 65) | func DisallowUnknownField() DecodeOption {
function AllowFieldPrefixes (line 74) | func AllowFieldPrefixes(prefixes ...string) DecodeOption {
function AllowDuplicateMapKey (line 82) | func AllowDuplicateMapKey() DecodeOption {
function UseOrderedMap (line 91) | func UseOrderedMap() DecodeOption {
function UseJSONUnmarshaler (line 100) | func UseJSONUnmarshaler() DecodeOption {
function CustomUnmarshaler (line 111) | func CustomUnmarshaler[T any](unmarshaler func(*T, []byte) error) Decode...
function CustomUnmarshalerContext (line 123) | func CustomUnmarshalerContext[T any](unmarshaler func(context.Context, *...
type EncodeOption (line 134) | type EncodeOption
function Indent (line 137) | func Indent(spaces int) EncodeOption {
function IndentSequence (line 145) | func IndentSequence(indent bool) EncodeOption {
function UseSingleQuote (line 153) | func UseSingleQuote(sq bool) EncodeOption {
function Flow (line 161) | func Flow(isFlowStyle bool) EncodeOption {
function WithSmartAnchor (line 173) | func WithSmartAnchor() EncodeOption {
function UseLiteralStyleIfMultiline (line 182) | func UseLiteralStyleIfMultiline(useLiteralStyleIfMultiline bool) EncodeO...
function JSON (line 190) | func JSON() EncodeOption {
function MarshalAnchor (line 199) | func MarshalAnchor(callback func(*ast.AnchorNode, interface{}) error) En...
function UseJSONMarshaler (line 209) | func UseJSONMarshaler() EncodeOption {
function CustomMarshaler (line 221) | func CustomMarshaler[T any](marshaler func(T) ([]byte, error)) EncodeOpt...
function CustomMarshalerContext (line 233) | func CustomMarshalerContext[T any](marshaler func(context.Context, T) ([...
function AutoInt (line 245) | func AutoInt() EncodeOption {
function OmitEmpty (line 256) | func OmitEmpty() EncodeOption {
function OmitZero (line 265) | func OmitZero() EncodeOption {
type CommentPosition (line 273) | type CommentPosition
method String (line 281) | func (p CommentPosition) String() string {
constant CommentHeadPosition (line 276) | CommentHeadPosition CommentPosition = CommentPosition(iota)
constant CommentLinePosition (line 277) | CommentLinePosition
constant CommentFootPosition (line 278) | CommentFootPosition
function LineComment (line 295) | func LineComment(text string) *Comment {
function HeadComment (line 303) | func HeadComment(texts ...string) *Comment {
function FootComment (line 311) | func FootComment(texts ...string) *Comment {
type Comment (line 319) | type Comment struct
type CommentMap (line 325) | type CommentMap
function WithComment (line 328) | func WithComment(cm CommentMap) EncodeOption {
function CommentToMap (line 344) | func CommentToMap(cm CommentMap) DecodeOption {
FILE: vendor/github.com/goccy/go-yaml/parser/color.go
constant colorFgHiBlack (line 6) | colorFgHiBlack int = iota + 90
constant colorFgHiRed (line 7) | colorFgHiRed
constant colorFgHiGreen (line 8) | colorFgHiGreen
constant colorFgHiYellow (line 9) | colorFgHiYellow
constant colorFgHiBlue (line 10) | colorFgHiBlue
constant colorFgHiMagenta (line 11) | colorFgHiMagenta
constant colorFgHiCyan (line 12) | colorFgHiCyan
function colorize (line 24) | func colorize(idx int, content string) string {
FILE: vendor/github.com/goccy/go-yaml/parser/context.go
type context (line 11) | type context struct
method currentToken (line 43) | func (c *context) currentToken() *Token {
method isComment (line 50) | func (c *context) isComment() bool {
method nextToken (line 54) | func (c *context) nextToken() *Token {
method nextNotCommentToken (line 61) | func (c *context) nextNotCommentToken() *Token {
method isTokenNotFound (line 72) | func (c *context) isTokenNotFound() bool {
method withGroup (line 76) | func (c *context) withGroup(g *TokenGroup) *context {
method withChild (line 85) | func (c *context) withChild(path string) *context {
method withIndex (line 91) | func (c *context) withIndex(idx uint) *context {
method withFlow (line 97) | func (c *context) withFlow(isFlow bool) *context {
method goNext (line 109) | func (c *context) goNext() {
method next (line 118) | func (c *context) next() bool {
method insertNullToken (line 122) | func (c *context) insertNullToken(tk *Token) *Token {
method addNullValueToken (line 130) | func (c *context) addNullValueToken(tk *Token) *Token {
method createImplicitNullToken (line 143) | func (c *context) createImplicitNullToken(base *Token) *Token {
method insertToken (line 151) | func (c *context) insertToken(tk *Token) {
method addToken (line 176) | func (c *context) addToken(tk *Token) {
type tokenRef (line 17) | type tokenRef struct
function containsPathSpecialChar (line 27) | func containsPathSpecialChar(path string) bool {
function normalizePath (line 36) | func normalizePath(path string) string {
function newContext (line 103) | func newContext() *context {
FILE: vendor/github.com/goccy/go-yaml/parser/node.go
function newMappingNode (line 11) | func newMappingNode(ctx *context, tk *Token, isFlow bool, values ...*ast...
function newMappingValueNode (line 17) | func newMappingValueNode(ctx *context, colonTk, entryTk *Token, key ast....
function newMappingKeyNode (line 42) | func newMappingKeyNode(ctx *context, tk *Token) (*ast.MappingKeyNode, er...
function newAnchorNode (line 51) | func newAnchorNode(ctx *context, tk *Token) (*ast.AnchorNode, error) {
function newAliasNode (line 60) | func newAliasNode(ctx *context, tk *Token) (*ast.AliasNode, error) {
function newDirectiveNode (line 69) | func newDirectiveNode(ctx *context, tk *Token) (*ast.DirectiveNode, erro...
function newMergeKeyNode (line 78) | func newMergeKeyNode(ctx *context, tk *Token) (*ast.MergeKeyNode, error) {
function newNullNode (line 87) | func newNullNode(ctx *context, tk *Token) (*ast.NullNode, error) {
function newBoolNode (line 96) | func newBoolNode(ctx *context, tk *Token) (*ast.BoolNode, error) {
function newIntegerNode (line 105) | func newIntegerNode(ctx *context, tk *Token) (*ast.IntegerNode, error) {
function newFloatNode (line 114) | func newFloatNode(ctx *context, tk *Token) (*ast.FloatNode, error) {
function newInfinityNode (line 123) | func newInfinityNode(ctx *context, tk *Token) (*ast.InfinityNode, error) {
function newNanNode (line 132) | func newNanNode(ctx *context, tk *Token) (*ast.NanNode, error) {
function newStringNode (line 141) | func newStringNode(ctx *context, tk *Token) (*ast.StringNode, error) {
function newLiteralNode (line 150) | func newLiteralNode(ctx *context, tk *Token) (*ast.LiteralNode, error) {
function newTagNode (line 159) | func newTagNode(ctx *context, tk *Token) (*ast.TagNode, error) {
function newSequenceNode (line 168) | func newSequenceNode(ctx *context, tk *Token, isFlow bool) (*ast.Sequenc...
function newTagDefaultScalarValueNode (line 177) | func newTagDefaultScalarValueNode(ctx *context, tag *token.Token) (ast.S...
function setLineComment (line 229) | func setLineComment(ctx *context, node ast.Node, tk *Token) error {
function setHeadComment (line 241) | func setHeadComment(cm *ast.CommentGroupNode, value ast.Node) error {
FILE: vendor/github.com/goccy/go-yaml/parser/option.go
type Option (line 4) | type Option
function AllowDuplicateMapKey (line 8) | func AllowDuplicateMapKey() Option {
FILE: vendor/github.com/goccy/go-yaml/parser/parser.go
type Mode (line 14) | type Mode
constant ParseComments (line 17) | ParseComments Mode = 1 << iota
function ParseBytes (line 21) | func ParseBytes(bytes []byte, mode Mode, opts ...Option) (*ast.File, err...
function Parse (line 31) | func Parse(tokens token.Tokens, mode Mode, opts ...Option) (*ast.File, e...
function ParseFile (line 47) | func ParseFile(filename string, mode Mode, opts ...Option) (*ast.File, e...
type YAMLVersion (line 60) | type YAMLVersion
constant YAML10 (line 63) | YAML10 YAMLVersion = "1.0"
constant YAML11 (line 64) | YAML11 YAMLVersion = "1.1"
constant YAML12 (line 65) | YAML12 YAMLVersion = "1.2"
constant YAML13 (line 66) | YAML13 YAMLVersion = "1.3"
type parser (line 76) | type parser struct
method parse (line 112) | func (p *parser) parse(ctx *context) (*ast.File, error) {
method parseDocument (line 124) | func (p *parser) parseDocument(ctx *context, docGroup *TokenGroup) (*a...
method parseDocumentBody (line 165) | func (p *parser) parseDocumentBody(ctx *context) (ast.Node, error) {
method parseToken (line 176) | func (p *parser) parseToken(ctx *context, tk *Token) (ast.Node, error) {
method parseScalarValue (line 271) | func (p *parser) parseScalarValue(ctx *context, tk *Token) (ast.Scalar...
method parseFlowMap (line 329) | func (p *parser) parseFlowMap(ctx *context) (*ast.MappingNode, error) {
method isFlowMapDelim (line 438) | func (p *parser) isFlowMapDelim(tk *Token) bool {
method parseMap (line 442) | func (p *parser) parseMap(ctx *context) (*ast.MappingNode, error) {
method validateMapKeyValueNextToken (line 540) | func (p *parser) validateMapKeyValueNextToken(ctx *context, keyTk, tk ...
method isMapToken (line 558) | func (p *parser) isMapToken(tk *Token) bool {
method parseMapKeyValue (line 566) | func (p *parser) parseMapKeyValue(ctx *context, g *TokenGroup, entryTk...
method parseMapKey (line 587) | func (p *parser) parseMapKey(ctx *context, g *TokenGroup) (ast.MapKeyN...
method validateMapKey (line 641) | func (p *parser) validateMapKey(ctx *context, tk *token.Token, keyPath...
method removeLeftWhiteSpace (line 670) | func (p *parser) removeLeftWhiteSpace(src string) string {
method removeRightWhiteSpace (line 677) | func (p *parser) removeRightWhiteSpace(src string) string {
method existsNewLineCharacter (line 684) | func (p *parser) existsNewLineCharacter(src string) bool {
method newLineCharacterNum (line 688) | func (p *parser) newLineCharacterNum(src string) int {
method mapKeyText (line 704) | func (p *parser) mapKeyText(n ast.Node) string {
method parseMapValue (line 721) | func (p *parser) parseMapValue(ctx *context, key ast.MapKeyNode, colon...
method validateAnchorValueInMapOrSeq (line 815) | func (p *parser) validateAnchorValueInMapOrSeq(value ast.Node, col int...
method parseAnchor (line 846) | func (p *parser) parseAnchor(ctx *context, g *TokenGroup) (*ast.Anchor...
method parseAnchorName (line 868) | func (p *parser) parseAnchorName(ctx *context) (*ast.AnchorNode, error) {
method parseAlias (line 889) | func (p *parser) parseAlias(ctx *context) (*ast.AliasNode, error) {
method parseLiteral (line 910) | func (p *parser) parseLiteral(ctx *context) (*ast.LiteralNode, error) {
method parseScalarTag (line 938) | func (p *parser) parseScalarTag(ctx *context) (*ast.TagNode, error) {
method parseTag (line 952) | func (p *parser) parseTag(ctx *context) (*ast.TagNode, error) {
method parseTagValue (line 985) | func (p *parser) parseTagValue(ctx *context, tagRawTk *token.Token, tk...
method parseFlowSequence (line 1019) | func (p *parser) parseFlowSequence(ctx *context) (*ast.SequenceNode, e...
method parseSequence (line 1083) | func (p *parser) parseSequence(ctx *context) (*ast.SequenceNode, error) {
method parseSequenceValue (line 1129) | func (p *parser) parseSequenceValue(ctx *context, seqTk *Token) (ast.N...
method parseDirective (line 1214) | func (p *parser) parseDirective(ctx *context, g *TokenGroup) (*ast.Dir...
method parseDirectiveName (line 1272) | func (p *parser) parseDirectiveName(ctx *context) (*ast.DirectiveNode,...
method parseComment (line 1293) | func (p *parser) parseComment(ctx *context) (ast.Node, error) {
method parseHeadComment (line 1308) | func (p *parser) parseHeadComment(ctx *context) *ast.CommentGroupNode {
method parseFootComment (line 1320) | func (p *parser) parseFootComment(ctx *context, col int) *ast.CommentG...
function newParser (line 84) | func newParser(tokens token.Tokens, mode Mode, opts []Option) (*parser, ...
FILE: vendor/github.com/goccy/go-yaml/parser/token.go
type TokenGroupType (line 12) | type TokenGroupType
method String (line 30) | func (t TokenGroupType) String() string {
constant TokenGroupNone (line 15) | TokenGroupNone TokenGroupType = iota
constant TokenGroupDirective (line 16) | TokenGroupDirective
constant TokenGroupDirectiveName (line 17) | TokenGroupDirectiveName
constant TokenGroupDocument (line 18) | TokenGroupDocument
constant TokenGroupDocumentBody (line 19) | TokenGroupDocumentBody
constant TokenGroupAnchor (line 20) | TokenGroupAnchor
constant TokenGroupAnchorName (line 21) | TokenGroupAnchorName
constant TokenGroupAlias (line 22) | TokenGroupAlias
constant TokenGroupLiteral (line 23) | TokenGroupLiteral
constant TokenGroupFolded (line 24) | TokenGroupFolded
constant TokenGroupScalarTag (line 25) | TokenGroupScalarTag
constant TokenGroupMapKey (line 26) | TokenGroupMapKey
constant TokenGroupMapKeyValue (line 27) | TokenGroupMapKeyValue
type Token (line 62) | type Token struct
method RawToken (line 68) | func (t *Token) RawToken() *token.Token {
method Type (line 78) | func (t *Token) Type() token.Type {
method GroupType (line 88) | func (t *Token) GroupType() TokenGroupType {
method Line (line 98) | func (t *Token) Line() int {
method Column (line 108) | func (t *Token) Column() int {
method SetGroupType (line 118) | func (t *Token) SetGroupType(typ TokenGroupType) {
method Dump (line 125) | func (t *Token) Dump() {
method dump (line 135) | func (t *Token) dump(ctx *groupTokenRenderContext) {
type groupTokenRenderContext (line 143) | type groupTokenRenderContext struct
type TokenGroup (line 147) | type TokenGroup struct
method First (line 152) | func (g *TokenGroup) First() *Token {
method Last (line 159) | func (g *TokenGroup) Last() *Token {
method dump (line 166) | func (g *TokenGroup) dump(ctx *groupTokenRenderContext) {
method RawToken (line 176) | func (g *TokenGroup) RawToken() *token.Token {
method Line (line 183) | func (g *TokenGroup) Line() int {
method Column (line 190) | func (g *TokenGroup) Column() int {
method TokenType (line 197) | func (g *TokenGroup) TokenType() token.Type {
function CreateGroupedTokens (line 204) | func CreateGroupedTokens(tokens token.Tokens) ([]*Token, error) {
function newTokens (line 240) | func newTokens(tks token.Tokens) []*Token {
function createLineCommentTokenGroups (line 248) | func createLineCommentTokenGroups(tokens []*Token) []*Token {
function createLiteralAndFoldedTokenGroups (line 266) | func createLiteralAndFoldedTokenGroups(tokens []*Token) ([]*Token, error) {
function createAnchorAndAliasTokenGroups (line 302) | func createAnchorAndAliasTokenGroups(tokens []*Token) ([]*Token, error) {
function createScalarTagTokenGroups (line 354) | func createScalarTagTokenGroups(tokens []*Token) ([]*Token, error) {
function createAnchorWithScalarTagTokenGroups (line 445) | func createAnchorWithScalarTagTokenGroups(tokens []*Token) ([]*Token, er...
function createMapKeyTokenGroups (line 473) | func createMapKeyTokenGroups(tokens []*Token) ([]*Token, error) {
function createMapKeyByMappingKey (line 481) | func createMapKeyByMappingKey(tokens []*Token) ([]*Token, error) {
function createMapKeyByMappingValue (line 504) | func createMapKeyByMappingValue(tokens []*Token) ([]*Token, error) {
function createMapKeyValueTokenGroups (line 530) | func createMapKeyValueTokenGroups(tokens []*Token) []*Token {
function createDirectiveTokenGroups (line 573) | func createDirectiveTokenGroups(tokens []*Token) ([]*Token, error) {
function createDocumentTokens (line 617) | func createDocumentTokens(tokens []*Token) ([]*Token, error) {
function isScalarType (line 701) | func isScalarType(tk *Token) bool {
function isNotMapKeyType (line 726) | func isNotMapKeyType(tk *Token) bool {
function isFlowType (line 740) | func isFlowType(tk *Token) bool {
FILE: vendor/github.com/goccy/go-yaml/path.go
function PathString (line 27) | func PathString(s string) (*Path, error) {
function parsePathRecursive (line 61) | func parsePathRecursive(b *PathBuilder, buf []rune, cursor int) (*PathBu...
function parsePathDot (line 85) | func parsePathDot(b *PathBuilder, buf []rune, cursor int) (*PathBuilder,...
function parseQuotedKey (line 124) | func parseQuotedKey(b *PathBuilder, buf []rune, cursor int) (*PathBuilde...
function parsePathIndex (line 165) | func parsePathIndex(b *PathBuilder, buf []rune, cursor int) (*PathBuilde...
type Path (line 205) | type Path struct
method String (line 210) | func (p *Path) String() string {
method Read (line 215) | func (p *Path) Read(r io.Reader, v interface{}) error {
method ReadNode (line 227) | func (p *Path) ReadNode(r io.Reader) (ast.Node, error) {
method Filter (line 247) | func (p *Path) Filter(target, v interface{}) error {
method FilterFile (line 259) | func (p *Path) FilterFile(f *ast.File) (ast.Node, error) {
method FilterNode (line 277) | func (p *Path) FilterNode(node ast.Node) (ast.Node, error) {
method MergeFromReader (line 289) | func (p *Path) MergeFromReader(dst *ast.File, src io.Reader) error {
method MergeFromFile (line 305) | func (p *Path) MergeFromFile(dst *ast.File, src *ast.File) error {
method MergeFromNode (line 319) | func (p *Path) MergeFromNode(dst *ast.File, src ast.Node) error {
method ReplaceWithReader (line 331) | func (p *Path) ReplaceWithReader(dst *ast.File, src io.Reader) error {
method ReplaceWithFile (line 347) | func (p *Path) ReplaceWithFile(dst *ast.File, src *ast.File) error {
method ReplaceWithNode (line 357) | func (p *Path) ReplaceWithNode(dst *ast.File, node ast.Node) error {
method AnnotateSource (line 374) | func (p *Path) AnnotateSource(source []byte, colored bool) ([]byte, er...
type PathBuilder (line 388) | type PathBuilder struct
method Root (line 394) | func (b *PathBuilder) Root() *PathBuilder {
method IndexAll (line 400) | func (b *PathBuilder) IndexAll() *PathBuilder {
method Recursive (line 406) | func (b *PathBuilder) Recursive(selector string) *PathBuilder {
method containsReservedPathCharacters (line 411) | func (b *PathBuilder) containsReservedPathCharacters(path string) bool {
method enclosedSingleQuote (line 421) | func (b *PathBuilder) enclosedSingleQuote(name string) bool {
method normalizeSelectorName (line 425) | func (b *PathBuilder) normalizeSelectorName(name string) string {
method child (line 437) | func (b *PathBuilder) child(name string) *PathBuilder {
method Child (line 443) | func (b *PathBuilder) Child(name string) *PathBuilder {
method Index (line 448) | func (b *PathBuilder) Index(idx uint) *PathBuilder {
method Build (line 454) | func (b *PathBuilder) Build() *Path {
type pathNode (line 458) | type pathNode interface
type basePathNode (line 465) | type basePathNode struct
method chain (line 469) | func (n *basePathNode) chain(node pathNode) pathNode {
type rootNode (line 474) | type rootNode struct
method String (line 482) | func (n *rootNode) String() string {
method filter (line 490) | func (n *rootNode) filter(node ast.Node) (ast.Node, error) {
method replace (line 501) | func (n *rootNode) replace(node ast.Node, target ast.Node) error {
function newRootNode (line 478) | func newRootNode() *rootNode {
type selectorNode (line 511) | type selectorNode struct
method filter (line 523) | func (n *selectorNode) filter(node ast.Node) (ast.Node, error) {
method replaceMapValue (line 576) | func (n *selectorNode) replaceMapValue(value *ast.MappingValueNode, ta...
method replace (line 593) | func (n *selectorNode) replace(node ast.Node, target ast.Node) error {
method String (line 612) | func (n *selectorNode) String() string {
function newSelectorNode (line 516) | func newSelectorNode(selector string) *selectorNode {
type indexNode (line 622) | type indexNode struct
method filter (line 634) | func (n *indexNode) filter(node ast.Node) (ast.Node, error) {
method replace (line 653) | func (n *indexNode) replace(node ast.Node, target ast.Node) error {
method String (line 673) | func (n *indexNode) String() string {
function newIndexNode (line 627) | func newIndexNode(selector uint) *indexNode {
type indexAllNode (line 681) | type indexAllNode struct
method String (line 691) | func (n *indexAllNode) String() string {
method filter (line 699) | func (n *indexAllNode) filter(node ast.Node) (ast.Node, error) {
method replace (line 719) | func (n *indexAllNode) replace(node ast.Node, target ast.Node) error {
function newIndexAllNode (line 685) | func newIndexAllNode() *indexAllNode {
type recursiveNode (line 740) | type recursiveNode struct
method String (line 752) | func (n *recursiveNode) String() string {
method filterNode (line 760) | func (n *recursiveNode) filterNode(node ast.Node) (*ast.SequenceNode, ...
method filter (line 793) | func (n *recursiveNode) filter(node ast.Node) (ast.Node, error) {
method replaceNode (line 802) | func (n *recursiveNode) replaceNode(node ast.Node, target ast.Node) er...
method replace (line 830) | func (n *recursiveNode) replace(node ast.Node, target ast.Node) error {
function newRecursiveNode (line 745) | func newRecursiveNode(selector string) *recursiveNode {
FILE: vendor/github.com/goccy/go-yaml/printer/color.go
type ColorAttribute (line 9) | type ColorAttribute
constant ColorReset (line 12) | ColorReset ColorAttribute = iota
constant ColorBold (line 13) | ColorBold
constant ColorFaint (line 14) | ColorFaint
constant ColorItalic (line 15) | ColorItalic
constant ColorUnderline (line 16) | ColorUnderline
constant ColorBlinkSlow (line 17) | ColorBlinkSlow
constant ColorBlinkRapid (line 18) | ColorBlinkRapid
constant ColorReverseVideo (line 19) | ColorReverseVideo
constant ColorConcealed (line 20) | ColorConcealed
constant ColorCrossedOut (line 21) | ColorCrossedOut
constant ColorFgHiBlack (line 25) | ColorFgHiBlack ColorAttribute = iota + 90
constant ColorFgHiRed (line 26) | ColorFgHiRed
constant ColorFgHiGreen (line 27) | ColorFgHiGreen
constant ColorFgHiYellow (line 28) | ColorFgHiYellow
constant ColorFgHiBlue (line 29) | ColorFgHiBlue
constant ColorFgHiMagenta (line 30) | ColorFgHiMagenta
constant ColorFgHiCyan (line 31) | ColorFgHiCyan
constant ColorFgHiWhite (line 32) | ColorFgHiWhite
constant ColorResetBold (line 36) | ColorResetBold ColorAttribute = iota + 22
constant ColorResetItalic (line 37) | ColorResetItalic
constant ColorResetUnderline (line 38) | ColorResetUnderline
constant ColorResetBlinking (line 39) | ColorResetBlinking
constant ColorResetReversed (line 41) | ColorResetReversed
constant ColorResetConcealed (line 42) | ColorResetConcealed
constant ColorResetCrossedOut (line 43) | ColorResetCrossedOut
constant escape (line 46) | escape = "\x1b"
function format (line 60) | func format(attrs ...ColorAttribute) string {
function unformat (line 68) | func unformat(attrs ...ColorAttribute) string {
function colorize (line 81) | func colorize(msg string, attrs ...ColorAttribute) string {
FILE: vendor/github.com/goccy/go-yaml/printer/printer.go
type Property (line 13) | type Property struct
type PrintFunc (line 19) | type PrintFunc
type Printer (line 22) | type Printer struct
method property (line 38) | func (p *Printer) property(tk *token.Token) *Property {
method PrintTokens (line 96) | func (p *Printer) PrintTokens(tokens token.Tokens) string {
method PrintNode (line 148) | func (p *Printer) PrintNode(node ast.Node) []byte {
method setDefaultColorSet (line 152) | func (p *Printer) setDefaultColorSet() {
method PrintErrorMessage (line 197) | func (p *Printer) PrintErrorMessage(msg string, isColored bool) string {
method removeLeftSideNewLineChar (line 208) | func (p *Printer) removeLeftSideNewLineChar(src string) string {
method removeRightSideNewLineChar (line 212) | func (p *Printer) removeRightSideNewLineChar(src string) string {
method removeRightSideWhiteSpaceChar (line 216) | func (p *Printer) removeRightSideWhiteSpaceChar(src string) string {
method newLineCount (line 220) | func (p *Printer) newLineCount(s string) int {
method isNewLineLastChar (line 239) | func (p *Printer) isNewLineLastChar(s string) bool {
method printBeforeTokens (line 253) | func (p *Printer) printBeforeTokens(tk *token.Token, minLine, extLine ...
method printAfterTokens (line 292) | func (p *Printer) printAfterTokens(tk *token.Token, maxLine int) token...
method setupErrorTokenFormat (line 312) | func (p *Printer) setupErrorTokenFormat(annotateLine int, isColored bo...
method PrintErrorToken (line 331) | func (p *Printer) PrintErrorToken(tk *token.Token, isColored bool) str...
function defaultLineNumberFormat (line 34) | func defaultLineNumberFormat(num int) string {
FILE: vendor/github.com/goccy/go-yaml/scanner/context.go
type Context (line 13) | type Context struct
method release (line 59) | func (c *Context) release() {
method clear (line 63) | func (c *Context) clear() {
method reset (line 68) | func (c *Context) reset(src []rune) {
method resetBuffer (line 77) | func (c *Context) resetBuffer() {
method breakMultiLine (line 84) | func (c *Context) breakMultiLine() {
method getMultiLineState (line 88) | func (c *Context) getMultiLineState() *MultiLineState {
method setLiteral (line 92) | func (c *Context) setLiteral(lastDelimColumn int, opt string) {
method setFolded (line 104) | func (c *Context) setFolded(lastDelimColumn int, opt string) {
method setRawFolded (line 116) | func (c *Context) setRawFolded(column int) {
method addToken (line 265) | func (c *Context) addToken(tk *token.Token) {
method addBuf (line 272) | func (c *Context) addBuf(r rune) {
method addBufWithTab (line 282) | func (c *Context) addBufWithTab(r rune) {
method addOriginBuf (line 292) | func (c *Context) addOriginBuf(r rune) {
method removeRightSpaceFromBuf (line 299) | func (c *Context) removeRightSpaceFromBuf() {
method isEOS (line 309) | func (c *Context) isEOS() bool {
method isNextEOS (line 313) | func (c *Context) isNextEOS() bool {
method next (line 317) | func (c *Context) next() bool {
method source (line 321) | func (c *Context) source(s, e int) string {
method previousChar (line 325) | func (c *Context) previousChar() rune {
method currentChar (line 332) | func (c *Context) currentChar() rune {
method nextChar (line 339) | func (c *Context) nextChar() rune {
method repeatNum (line 346) | func (c *Context) repeatNum(r rune) int {
method progress (line 358) | func (c *Context) progress(num int) {
method existsBuffer (line 362) | func (c *Context) existsBuffer() bool {
method isMultiLine (line 366) | func (c *Context) isMultiLine() bool {
method bufferedSrc (line 370) | func (c *Context) bufferedSrc() []rune {
method bufferedToken (line 413) | func (c *Context) bufferedToken(pos *token.Position) *token.Token {
method setTokenTypeByPrevTag (line 433) | func (c *Context) setTokenTypeByPrevTag(tk *token.Token) {
method lastToken (line 447) | func (c *Context) lastToken() *token.Token {
type MultiLineState (line 25) | type MultiLineState struct
method lastDelimColumn (line 133) | func (s *MultiLineState) lastDelimColumn() int {
method updateIndentColumn (line 140) | func (s *MultiLineState) updateIndentColumn(column int) {
method updateSpaceOnlyIndentColumn (line 149) | func (s *MultiLineState) updateSpaceOnlyIndentColumn(column int) {
method validateIndentAfterSpaceOnly (line 156) | func (s *MultiLineState) validateIndentAfterSpaceOnly(column int) error {
method validateIndentColumn (line 166) | func (s *MultiLineState) validateIndentColumn() error {
method updateNewLineState (line 176) | func (s *MultiLineState) updateNewLineState() {
method isIndentColumn (line 185) | func (s *MultiLineState) isIndentColumn(column int) bool {
method addIndent (line 192) | func (s *MultiLineState) addIndent(ctx *Context, column int) {
method updateNewLineInFolded (line 213) | func (s *MultiLineState) updateNewLineInFolded(ctx *Context, column in...
method hasTrimAllEndNewlineOpt (line 257) | func (s *MultiLineState) hasTrimAllEndNewlineOpt() bool {
method hasKeepAllEndNewlineOpt (line 261) | func (s *MultiLineState) hasKeepAllEndNewlineOpt() bool {
function createContext (line 46) | func createContext() *Context {
function newContext (line 53) | func newContext(src []rune) *Context {
function firstLineIndentColumnByOpt (line 124) | func firstLineIndentColumnByOpt(opt string) int {
FILE: vendor/github.com/goccy/go-yaml/scanner/error.go
type InvalidTokenError (line 5) | type InvalidTokenError struct
method Error (line 9) | func (e *InvalidTokenError) Error() string {
function ErrInvalidToken (line 13) | func ErrInvalidToken(tk *token.Token) *InvalidTokenError {
FILE: vendor/github.com/goccy/go-yaml/scanner/scanner.go
type IndentState (line 14) | type IndentState
constant IndentStateEqual (line 18) | IndentStateEqual IndentState = iota
constant IndentStateUp (line 20) | IndentStateUp
constant IndentStateDown (line 22) | IndentStateDown
constant IndentStateKeep (line 24) | IndentStateKeep
type Scanner (line 29) | type Scanner struct
method pos (line 57) | func (s *Scanner) pos() *token.Position {
method bufferedToken (line 67) | func (s *Scanner) bufferedToken(ctx *Context) *token.Token {
method progressColumn (line 95) | func (s *Scanner) progressColumn(ctx *Context, num int) {
method progressOnly (line 101) | func (s *Scanner) progressOnly(ctx *Context, num int) {
method progressLine (line 106) | func (s *Scanner) progressLine(ctx *Context) {
method progress (line 119) | func (s *Scanner) progress(ctx *Context, num int) {
method isNewLineChar (line 124) | func (s *Scanner) isNewLineChar(c rune) bool {
method newLineCount (line 134) | func (s *Scanner) newLineCount(src []rune) int {
method updateIndentLevel (line 152) | func (s *Scanner) updateIndentLevel() {
method updateIndentState (line 162) | func (s *Scanner) updateIndentState(ctx *Context) {
method updateIndent (line 176) | func (s *Scanner) updateIndent(ctx *Context, c rune) {
method isChangedToIndentStateDown (line 198) | func (s *Scanner) isChangedToIndentStateDown() bool {
method isChangedToIndentStateUp (line 202) | func (s *Scanner) isChangedToIndentStateUp() bool {
method addBufferedTokenIfExists (line 206) | func (s *Scanner) addBufferedTokenIfExists(ctx *Context) {
method breakMultiLine (line 210) | func (s *Scanner) breakMultiLine(ctx *Context) {
method scanSingleQuote (line 214) | func (s *Scanner) scanSingleQuote(ctx *Context) (*token.Token, error) {
method scanDoubleQuote (line 312) | func (s *Scanner) scanDoubleQuote(ctx *Context) (*token.Token, error) {
method validateDocumentSeparatorMarker (line 594) | func (s *Scanner) validateDocumentSeparatorMarker(ctx *Context, src []...
method foundDocumentSeparatorMarker (line 603) | func (s *Scanner) foundDocumentSeparatorMarker(src []rune) bool {
method scanQuote (line 618) | func (s *Scanner) scanQuote(ctx *Context, ch rune) (bool, error) {
method scanWhiteSpace (line 639) | func (s *Scanner) scanWhiteSpace(ctx *Context) bool {
method isMergeKey (line 665) | func (s *Scanner) isMergeKey(ctx *Context) bool {
method scanTag (line 689) | func (s *Scanner) scanTag(ctx *Context) (bool, error) {
method scanComment (line 739) | func (s *Scanner) scanComment(ctx *Context) bool {
method scanMultiLine (line 777) | func (s *Scanner) scanMultiLine(ctx *Context, c rune) error {
method scanNewLine (line 855) | func (s *Scanner) scanNewLine(ctx *Context, c rune) {
method isFlowMode (line 899) | func (s *Scanner) isFlowMode() bool {
method scanFlowMapStart (line 909) | func (s *Scanner) scanFlowMapStart(ctx *Context) bool {
method scanFlowMapEnd (line 923) | func (s *Scanner) scanFlowMapEnd(ctx *Context) bool {
method scanFlowArrayStart (line 937) | func (s *Scanner) scanFlowArrayStart(ctx *Context) bool {
method scanFlowArrayEnd (line 951) | func (s *Scanner) scanFlowArrayEnd(ctx *Context) bool {
method scanFlowEntry (line 965) | func (s *Scanner) scanFlowEntry(ctx *Context, c rune) bool {
method scanMapDelim (line 978) | func (s *Scanner) scanMapDelim(ctx *Context) (bool, error) {
method scanDocumentStart (line 1021) | func (s *Scanner) scanDocumentStart(ctx *Context) bool {
method scanDocumentEnd (line 1046) | func (s *Scanner) scanDocumentEnd(ctx *Context) bool {
method scanMergeKey (line 1064) | func (s *Scanner) scanMergeKey(ctx *Context) bool {
method scanRawFoldedChar (line 1076) | func (s *Scanner) scanRawFoldedChar(ctx *Context) bool {
method scanSequence (line 1091) | func (s *Scanner) scanSequence(ctx *Context) (bool, error) {
method scanMultiLineHeader (line 1117) | func (s *Scanner) scanMultiLineHeader(ctx *Context) (bool, error) {
method validateMultiLineHeaderOption (line 1129) | func (s *Scanner) validateMultiLineHeaderOption(opt string) error {
method scanMultiLineHeaderOption (line 1154) | func (s *Scanner) scanMultiLineHeaderOption(ctx *Context) error {
method scanMapKey (line 1223) | func (s *Scanner) scanMapKey(ctx *Context) bool {
method scanDirective (line 1241) | func (s *Scanner) scanDirective(ctx *Context) bool {
method scanAnchor (line 1258) | func (s *Scanner) scanAnchor(ctx *Context) bool {
method scanAlias (line 1272) | func (s *Scanner) scanAlias(ctx *Context) bool {
method scanReservedChar (line 1286) | func (s *Scanner) scanReservedChar(ctx *Context, c rune) error {
method scanTab (line 1304) | func (s *Scanner) scanTab(ctx *Context, c rune) error {
method scan (line 1326) | func (s *Scanner) scan(ctx *Context) error {
method Init (line 1497) | func (s *Scanner) Init(text string) {
method clearState (line 1509) | func (s *Scanner) clearState() {
method Scan (line 1517) | func (s *Scanner) Scan() (token.Tokens, error) {
function hexToInt (line 294) | func hexToInt(b rune) int {
function hexRunesToInt (line 304) | func hexRunesToInt(b []rune) int {
FILE: vendor/github.com/goccy/go-yaml/stdlib_quote.go
constant lowerhex (line 20) | lowerhex = "0123456789abcdef"
function quoteWith (line 23) | func quoteWith(s string, quote byte) string {
function appendQuotedWith (line 27) | func appendQuotedWith(buf []byte, s string, quote byte) []byte {
function appendEscapedRune (line 54) | func appendEscapedRune(buf []byte, r rune, quote byte) []byte {
FILE: vendor/github.com/goccy/go-yaml/struct.go
constant StructTagName (line 11) | StructTagName = "yaml"
type StructField (line 15) | type StructField struct
function getTag (line 28) | func getTag(field reflect.StructField) string {
function structField (line 39) | func structField(field reflect.StructField) *StructField {
function isIgnoredStructField (line 84) | func isIgnoredStructField(field reflect.StructField) bool {
type StructFieldMap (line 92) | type StructFieldMap
method isIncludedRenderName (line 94) | func (m StructFieldMap) isIncludedRenderName(name string) bool {
method hasMergeProperty (line 103) | func (m StructFieldMap) hasMergeProperty() bool {
function structFieldMap (line 112) | func structFieldMap(structType reflect.Type) (StructFieldMap, error) {
FILE: vendor/github.com/goccy/go-yaml/token/token.go
type Character (line 12) | type Character
constant SequenceEntryCharacter (line 16) | SequenceEntryCharacter Character = '-'
constant MappingKeyCharacter (line 18) | MappingKeyCharacter Character = '?'
constant MappingValueCharacter (line 20) | MappingValueCharacter Character = ':'
constant CollectEntryCharacter (line 22) | CollectEntryCharacter Character = ','
constant SequenceStartCharacter (line 24) | SequenceStartCharacter Character = '['
constant SequenceEndCharacter (line 26) | SequenceEndCharacter Character = ']'
constant MappingStartCharacter (line 28) | MappingStartCharacter Character = '{'
constant MappingEndCharacter (line 30) | MappingEndCharacter Character = '}'
constant CommentCharacter (line 32) | CommentCharacter Character = '#'
constant AnchorCharacter (line 34) | AnchorCharacter Character = '&'
constant AliasCharacter (line 36) | AliasCharacter Character = '*'
constant TagCharacter (line 38) | TagCharacter Character = '!'
constant LiteralCharacter (line 40) | LiteralCharacter Character = '|'
constant FoldedCharacter (line 42) | FoldedCharacter Character = '>'
constant SingleQuoteCharacter (line 44) | SingleQuoteCharacter Character = '\''
constant DoubleQuoteCharacter (line 46) | DoubleQuoteCharacter Character = '"'
constant DirectiveCharacter (line 48) | DirectiveCharacter Character = '%'
constant SpaceCharacter (line 50) | SpaceCharacter Character = ' '
constant LineBreakCharacter (line 52) | LineBreakCharacter Character = '\n'
type Type (line 56) | type Type
method String (line 132) | func (t Type) String() string {
constant UnknownType (line 60) | UnknownType Type = iota
constant DocumentHeaderType (line 62) | DocumentHeaderType
constant DocumentEndType (line 64) | DocumentEndType
constant SequenceEntryType (line 66) | SequenceEntryType
constant MappingKeyType (line 68) | MappingKeyType
constant MappingValueType (line 70) | MappingValueType
constant MergeKeyType (line 72) | MergeKeyType
constant CollectEntryType (line 74) | CollectEntryType
constant SequenceStartType (line 76) | SequenceStartType
constant SequenceEndType (line 78) | SequenceEndType
constant MappingStartType (line 80) | MappingStartType
constant MappingEndType (line 82) | MappingEndType
constant CommentType (line 84) | CommentType
constant AnchorType (line 86) | AnchorType
constant AliasType (line 88) | AliasType
constant TagType (line 90) | TagType
constant LiteralType (line 92) | LiteralType
constant FoldedType (line 94) | FoldedType
constant SingleQuoteType (line 96) | SingleQuoteType
constant DoubleQuoteType (line 98) | DoubleQuoteType
constant DirectiveType (line 100) | DirectiveType
constant SpaceType (line 102) | SpaceType
constant NullType (line 104) | NullType
constant ImplicitNullType (line 108) | ImplicitNullType
constant InfinityType (line 110) | InfinityType
constant NanType (line 112) | NanType
constant IntegerType (line 114) | IntegerType
constant BinaryIntegerType (line 116) | BinaryIntegerType
constant OctetIntegerType (line 118) | OctetIntegerType
constant HexIntegerType (line 120) | HexIntegerType
constant FloatType (line 122) | FloatType
constant StringType (line 124) | StringType
constant BoolType (line 126) | BoolType
constant InvalidType (line 128) | InvalidType
type CharacterType (line 207) | type CharacterType
method String (line 223) | func (c CharacterType) String() string {
constant CharacterTypeIndicator (line 211) | CharacterTypeIndicator CharacterType = iota
constant CharacterTypeWhiteSpace (line 213) | CharacterTypeWhiteSpace
constant CharacterTypeMiscellaneous (line 215) | CharacterTypeMiscellaneous
constant CharacterTypeEscaped (line 217) | CharacterTypeEscaped
constant CharacterTypeInvalid (line 219) | CharacterTypeInvalid
type Indicator (line 238) | type Indicator
method String (line 262) | func (i Indicator) String() string {
constant NotIndicator (line 242) | NotIndicator Indicator = iota
constant BlockStructureIndicator (line 244) | BlockStructureIndicator
constant FlowCollectionIndicator (line 246) | FlowCollectionIndicator
constant CommentIndicator (line 248) | CommentIndicator
constant NodePropertyIndicator (line 250) | NodePropertyIndicator
constant BlockScalarIndicator (line 252) | BlockScalarIndicator
constant QuotedScalarIndicator (line 254) | QuotedScalarIndicator
constant DirectiveIndicator (line 256) | DirectiveIndicator
constant InvalidUseOfReservedIndicator (line 258) | InvalidUseOfReservedIndicator
function reservedKeywordToken (line 344) | func reservedKeywordToken(typ Type, value, org string, pos *Position) *T...
function init (line 355) | func init() {
type ReservedTagKeyword (line 389) | type ReservedTagKeyword
constant IntegerTag (line 393) | IntegerTag ReservedTagKeyword = "!!int"
constant FloatTag (line 395) | FloatTag ReservedTagKeyword = "!!float"
constant NullTag (line 397) | NullTag ReservedTagKeyword = "!!null"
constant SequenceTag (line 399) | SequenceTag ReservedTagKeyword = "!!seq"
constant MappingTag (line 401) | MappingTag ReservedTagKeyword = "!!map"
constant StringTag (line 403) | StringTag ReservedTagKeyword = "!!str"
constant BinaryTag (line 405) | BinaryTag ReservedTagKeyword = "!!binary"
constant OrderedMapTag (line 407) | OrderedMapTag ReservedTagKeyword = "!!omap"
constant SetTag (line 409) | SetTag ReservedTagKeyword = "!!set"
constant TimestampTag (line 411) | TimestampTag ReservedTagKeyword = "!!timestamp"
constant BooleanTag (line 413) | BooleanTag ReservedTagKeyword = "!!bool"
constant MergeTag (line 415) | MergeTag ReservedTagKeyword = "!!merge"
type NumberType (line 544) | type NumberType
constant NumberTypeDecimal (line 547) | NumberTypeDecimal NumberType = "decimal"
constant NumberTypeBinary (line 548) | NumberTypeBinary NumberType = "binary"
constant NumberTypeOctet (line 549) | NumberTypeOctet NumberType = "octet"
constant NumberTypeHex (line 550) | NumberTypeHex NumberType = "hex"
constant NumberTypeFloat (line 551) | NumberTypeFloat NumberType = "float"
type NumberValue (line 554) | type NumberValue struct
function ToNumber (line 560) | func ToNumber(value string) *NumberValue {
function isNumber (line 568) | func isNumber(value string) bool {
function toNumber (line 580) | func toNumber(value string) (*NumberValue, error) {
function isTimestamp (line 668) | func isTimestamp(value string) bool {
function IsNeedQuoted (line 678) | func IsNeedQuoted(value string) bool {
function LiteralBlockHeader (line 718) | func LiteralBlockHeader(value string) string {
function New (line 734) | func New(value string, org string, pos *Position) *Token {
type Position (line 764) | type Position struct
method String (line 773) | func (p *Position) String() string {
type Token (line 778) | type Token struct
method PreviousType (line 800) | func (t *Token) PreviousType() Type {
method NextType (line 808) | func (t *Token) NextType() Type {
method AddColumn (line 816) | func (t *Token) AddColumn(col int) {
method Clone (line 824) | func (t *Token) Clone() *Token {
method Dump (line 837) | func (t *Token) Dump() {
type Tokens (line 845) | type Tokens
method InvalidToken (line 847) | func (t Tokens) InvalidToken() *Token {
method add (line 856) | func (t *Tokens) add(tk *Token) {
method Add (line 870) | func (t *Tokens) Add(tks ...*Token) {
method Dump (line 877) | func (t Tokens) Dump() {
function String (line 885) | func String(value string, org string, pos *Position) *Token {
function SequenceEntry (line 897) | func SequenceEntry(org string, pos *Position) *Token {
function MappingKey (line 909) | func MappingKey(pos *Position) *Token {
function MappingValue (line 921) | func MappingValue(pos *Position) *Token {
function CollectEntry (line 933) | func CollectEntry(org string, pos *Position) *Token {
function SequenceStart (line 945) | func SequenceStart(org string, pos *Position) *Token {
function SequenceEnd (line 957) | func SequenceEnd(org string, pos *Position) *Token {
function MappingStart (line 969) | func MappingStart(org string, pos *Position) *Token {
function MappingEnd (line 981) | func MappingEnd(org string, pos *Position) *Token {
function Comment (line 993) | func Comment(value string, org string, pos *Position) *Token {
function Anchor (line 1005) | func Anchor(org string, pos *Position) *Token {
function Alias (line 1017) | func Alias(org string, pos *Position) *Token {
function Tag (line 1029) | func Tag(value string, org string, pos *Position) *Token {
function Literal (line 1045) | func Literal(value string, org string, pos *Position) *Token {
function Folded (line 1057) | func Folded(value string, org string, pos *Position) *Token {
function SingleQuote (line 1069) | func SingleQuote(value string, org string, pos *Position) *Token {
function DoubleQuote (line 1081) | func DoubleQuote(value string, org string, pos *Position) *Token {
function Directive (line 1093) | func Directive(org string, pos *Position) *Token {
function Space (line 1105) | func Space(pos *Position) *Token {
function MergeKey (line 1117) | func MergeKey(org string, pos *Position) *Token {
function DocumentHeader (line 1129) | func DocumentHeader(org string, pos *Position) *Token {
function DocumentEnd (line 1141) | func DocumentEnd(org string, pos *Position) *Token {
function Invalid (line 1152) | func Invalid(err string, org string, pos *Position) *Token {
function DetectLineBreakCharacter (line 1165) | func DetectLineBreakCharacter(src string) string {
FILE: vendor/github.com/goccy/go-yaml/validate.go
type StructValidator (line 5) | type StructValidator interface
type FieldError (line 11) | type FieldError interface
FILE: vendor/github.com/goccy/go-yaml/yaml.go
type BytesMarshaler (line 20) | type BytesMarshaler interface
type BytesMarshalerContext (line 25) | type BytesMarshalerContext interface
type InterfaceMarshaler (line 30) | type InterfaceMarshaler interface
type InterfaceMarshalerContext (line 35) | type InterfaceMarshalerContext interface
type BytesUnmarshaler (line 41) | type BytesUnmarshaler interface
type BytesUnmarshalerContext (line 46) | type BytesUnmarshalerContext interface
type InterfaceUnmarshaler (line 51) | type InterfaceUnmarshaler interface
type InterfaceUnmarshalerContext (line 56) | type InterfaceUnmarshalerContext interface
type NodeUnmarshaler (line 61) | type NodeUnmarshaler interface
type NodeUnmarshalerContext (line 66) | type NodeUnmarshalerContext interface
type MapItem (line 71) | type MapItem struct
type MapSlice (line 77) | type MapSlice
method ToMap (line 80) | func (s MapSlice) ToMap() map[interface{}]interface{} {
function Marshal (line 144) | func Marshal(v interface{}) ([]byte, error) {
function MarshalWithOptions (line 149) | func MarshalWithOptions(v interface{}, opts ...EncodeOption) ([]byte, er...
function MarshalContext (line 154) | func MarshalContext(ctx context.Context, v interface{}, opts ...EncodeOp...
function ValueToNode (line 163) | func ValueToNode(v interface{}, opts ...EncodeOption) (ast.Node, error) {
function Unmarshal (line 194) | func Unmarshal(data []byte, v interface{}) error {
function UnmarshalWithOptions (line 200) | func UnmarshalWithOptions(data []byte, v interface{}, opts ...DecodeOpti...
function UnmarshalContext (line 205) | func UnmarshalContext(ctx context.Context, data []byte, v interface{}, o...
function NodeToValue (line 217) | func NodeToValue(node ast.Node, v interface{}, opts ...DecodeOption) err...
function FormatError (line 231) | func FormatError(e error, colored, inclSource bool) string {
function YAMLToJSON (line 241) | func YAMLToJSON(bytes []byte) ([]byte, error) {
function JSONToYAML (line 254) | func JSONToYAML(bytes []byte) ([]byte, error) {
function RegisterCustomMarshaler (line 279) | func RegisterCustomMarshaler[T any](marshaler func(T) ([]byte, error)) {
function RegisterCustomMarshalerContext (line 291) | func RegisterCustomMarshalerContext[T any](marshaler func(context.Contex...
function RegisterCustomUnmarshaler (line 306) | func RegisterCustomUnmarshaler[T any](unmarshaler func(*T, []byte) error) {
function RegisterCustomUnmarshalerContext (line 318) | func RegisterCustomUnmarshalerContext[T any](unmarshaler func(context.Co...
type RawMessage (line 334) | type RawMessage
method MarshalYAML (line 336) | func (m RawMessage) MarshalYAML() ([]byte, error) {
method UnmarshalYAML (line 343) | func (m *RawMessage) UnmarshalYAML(dt []byte) error {
method UnmarshalJSON (line 351) | func (m *RawMessage) UnmarshalJSON(b []byte) error {
method MarshalJSON (line 355) | func (m RawMessage) MarshalJSON() ([]byte, error) {
FILE: vendor/github.com/gofrs/uuid/v5/codec.go
function FromBytes (line 28) | func FromBytes(input []byte) (UUID, error) {
function FromBytesOrNil (line 36) | func FromBytesOrNil(input []byte) UUID {
function fromHexChar (line 49) | func fromHexChar(c byte) byte {
function parseBytes (line 68) | func parseBytes(b []byte, u *UUID) error {
method Parse (line 124) | func (u *UUID) Parse(s string) error {
function FromString (line 130) | func FromString(text string) (UUID, error) {
function FromStringOrNil (line 138) | func FromStringOrNil(input string) UUID {
method MarshalText (line 148) | func (u UUID) MarshalText() ([]byte, error) {
method UnmarshalText (line 188) | func (u *UUID) UnmarshalText(b []byte) error {
method MarshalBinary (line 193) | func (u UUID) MarshalBinary() ([]byte, error) {
method UnmarshalBinary (line 199) | func (u *UUID) UnmarshalBinary(data []byte) error {
FILE: vendor/github.com/gofrs/uuid/v5/error.go
type Error (line 4) | type Error
method Error (line 38) | func (e Error) Error() string {
constant ErrInvalidFormat (line 12) | ErrInvalidFormat = Error("uuid: invalid UUID format")
constant ErrIncorrectFormatInString (line 17) | ErrIncorrectFormatInString = Error("uuid: incorrect UUID format in string")
constant ErrIncorrectLength (line 21) | ErrIncorrectLength = Error("uuid: incorrect UUID length")
constant ErrIncorrectByteLength (line 24) | ErrIncorrectByteLength = Error("uuid: UUID must be exactly 16 bytes long")
constant ErrNoHwAddressFound (line 28) | ErrNoHwAddressFound = Error("uuid: no HW address found")
constant ErrTypeConvertError (line 31) | ErrTypeConvertError = Error("uuid: cannot convert")
constant ErrInvalidVersion (line 34) | ErrInvalidVersion = Error("uuid:")
FILE: vendor/github.com/gofrs/uuid/v5/generator.go
constant epochStart (line 37) | epochStart = 122192928000000000
type EpochFunc (line 40) | type EpochFunc
type HWAddrFunc (line 43) | type HWAddrFunc
function NewV1 (line 49) | func NewV1() (UUID, error) {
function NewV1AtTime (line 54) | func NewV1AtTime(atTime time.Time) (UUID, error) {
function NewV3 (line 59) | func NewV3(ns UUID, name string) UUID {
function NewV4 (line 64) | func NewV4() (UUID, error) {
function NewV5 (line 69) | func NewV5(ns UUID, name string) UUID {
function NewV6 (line 76) | func NewV6() (UUID, error) {
function NewV6AtTime (line 83) | func NewV6AtTime(atTime time.Time) (UUID, error) {
function NewV7 (line 90) | func NewV7() (UUID, error) {
function NewV7AtTime (line 97) | func NewV7AtTime(atTime time.Time) (UUID, error) {
type Generator (line 102) | type Generator interface
type Gen (line 125) | type Gen struct
method NewV1 (line 235) | func (g *Gen) NewV1() (UUID, error) {
method NewV1AtTime (line 240) | func (g *Gen) NewV1AtTime(atTime time.Time) (UUID, error) {
method NewV3 (line 265) | func (g *Gen) NewV3(ns UUID, name string) (u UUID) {
method NewV4 (line 278) | func (g *Gen) NewV4() (UUID, error) {
method NewV5 (line 290) | func (g *Gen) NewV5(ns UUID, name string) (u UUID) {
method NewV6 (line 305) | func (g *Gen) NewV6() (UUID, error) {
method NewV6AtTime (line 312) | func (g *Gen) NewV6AtTime(atTime time.Time) (UUID, error) {
method NewV7 (line 353) | func (g *Gen) NewV7() (UUID, error) {
method NewV7AtTime (line 359) | func (g *Gen) NewV7AtTime(atTime time.Time) (UUID, error) {
method getClockSequence (line 412) | func (g *Gen) getClockSequence(useUnixTSMs bool, atTime time.Time) (ui...
method getHardwareAddr (line 445) | func (g *Gen) getHardwareAddr() ([]byte, error) {
method getEpoch (line 470) | func (g *Gen) getEpoch(atTime time.Time) uint64 {
type GenOption (line 140) | type GenOption
function NewGen (line 147) | func NewGen() *Gen {
function NewGenWithHWAF (line 162) | func NewGenWithHWAF(hwaf HWAddrFunc) *Gen {
function NewGenWithOptions (line 181) | func NewGenWithOptions(opts ...GenOption) *Gen {
function WithHWAddrFunc (line 198) | func WithHWAddrFunc(hwaf HWAddrFunc) GenOption {
function WithEpochFunc (line 211) | func WithEpochFunc(epochf EpochFunc) GenOption {
function WithRandomReader (line 224) | func WithRandomReader(reader io.Reader) GenOption {
function defaultHWAddrFunc (line 477) | func defaultHWAddrFunc() (net.HardwareAddr, error) {
FILE: vendor/github.com/gofrs/uuid/v5/sql.go
method Value (line 34) | func (u UUID) Value() (driver.Value, error) {
method Scan (line 41) | func (u *UUID) Scan(src interface{}) error {
type NullUUID (line 64) | type NullUUID struct
method Value (line 70) | func (u NullUUID) Value() (driver.Value, error) {
method Scan (line 79) | func (u *NullUUID) Scan(src interface{}) error {
method MarshalJSON (line 93) | func (u NullUUID) MarshalJSON() ([]byte, error) {
method UnmarshalJSON (line 105) | func (u *NullUUID) UnmarshalJSON(b []byte) error {
FILE: vendor/github.com/gofrs/uuid/v5/uuid.go
constant Size (line 48) | Size = 16
type UUID (line 51) | type UUID
method IsNil (line 191) | func (u UUID) IsNil() bool {
method IsZero (line 198) | func (u UUID) IsZero() bool {
method Version (line 203) | func (u UUID) Version() byte {
method Variant (line 208) | func (u UUID) Variant() byte {
method Bytes (line 224) | func (u UUID) Bytes() []byte {
method String (line 251) | func (u UUID) String() string {
method Format (line 266) | func (u UUID) Format(f fmt.State, c rune) {
method SetVersion (line 306) | func (u *UUID) SetVersion(v byte) {
method SetVariant (line 311) | func (u *UUID) SetVariant(v byte) {
constant _ (line 55) | _ byte = iota
constant V1 (line 56) | V1
constant _ (line 57) | _
constant V3 (line 58) | V3
constant V4 (line 59) | V4
constant V5 (line 60) | V5
constant V6 (line 61) | V6
constant V7 (line 62) | V7
constant _ (line 63) | _
constant VariantNCS (line 68) | VariantNCS byte = iota
constant VariantRFC9562 (line 69) | VariantRFC9562
constant VariantMicrosoft (line 70) | VariantMicrosoft
constant VariantFuture (line 71) | VariantFuture
constant VariantRFC4122 (line 75) | VariantRFC4122 = VariantRFC9562
constant DomainPerson (line 79) | DomainPerson = iota
constant DomainGroup (line 80) | DomainGroup
constant DomainOrg (line 81) | DomainOrg
type Timestamp (line 89) | type Timestamp
method Time (line 98) | func (t Timestamp) Time() (time.Time, error) {
constant _100nsPerSecond (line 91) | _100nsPerSecond = 10000000
function TimestampFromV1 (line 107) | func TimestampFromV1(u UUID) (Timestamp, error) {
function TimestampFromV6 (line 122) | func TimestampFromV6(u UUID) (Timestamp, error) {
function TimestampFromV7 (line 136) | func TimestampFromV7(u UUID) (Timestamp, error) {
function encodeCanonical (line 230) | func encodeCanonical(dst []byte, u UUID) {
function toUpperHex (line 297) | func toUpperHex(b []byte) {
function Must (line 331) | func Must(u UUID, err error) UUID {
FILE: vendor/github.com/inconshreveable/log15/v3/format.go
constant timeFormat (line 15) | timeFormat = "2006-01-02T15:04:05-0700"
constant termTimeFormat (line 16) | termTimeFormat = "01-02|15:04:05"
constant floatFormat (line 17) | floatFormat = 'f'
constant termMsgJust (line 18) | termMsgJust = 40
type Format (line 22) | type Format interface
function FormatFunc (line 28) | func FormatFunc(f func(Record) []byte) Format {
type formatFunc (line 32) | type formatFunc
method Format (line 34) | func (f formatFunc) Format(r Record) []byte {
function TerminalFormat (line 47) | func TerminalFormat() Format {
function LogfmtFormat (line 86) | func LogfmtFormat() Format {
function logfmt (line 95) | func logfmt(buf *bytes.Buffer, ctx []interface{}, color int) {
function JsonFormat (line 122) | func JsonFormat() Format {
function JsonFormatEx (line 129) | func JsonFormatEx(pretty, lineSeparated bool) Format {
function formatShared (line 168) | func formatShared(value interface{}) (result interface{}) {
function formatJSONValue (line 194) | func formatJSONValue(value interface{}) interface{} {
function formatLogfmtValue (line 208) | func formatLogfmtValue(value interface{}) string {
function escapeString (line 240) | func escapeString(s string) string {
FILE: vendor/github.com/inconshreveable/log15/v3/handler.go
type Handler (line 16) | type Handler interface
function FuncHandler (line 22) | func FuncHandler(fn func(r Record) error) Handler {
type funcHandler (line 26) | type funcHandler
method Log (line 28) | func (h funcHandler) Log(r Record) error {
function StreamHandler (line 39) | func StreamHandler(wr io.Writer, fmtr Format) Handler {
function SyncHandler (line 50) | func SyncHandler(h Handler) Handler {
function FileHandler (line 63) | func FileHandler(path string, fmtr Format) (Handler, error) {
function NetHandler (line 73) | func NetHandler(network, addr string, fmtr Format) (Handler, error) {
type closingHandler (line 85) | type closingHandler struct
method Close (line 90) | func (h *closingHandler) Close() error {
function FilterHandler (line 106) | func FilterHandler(fn func(r Record) bool, h Handler) Handler {
function MatchFilterHandler (line 121) | func MatchFilterHandler(key string, value interface{}, h Handler) Handler {
function LvlFilterHandler (line 147) | func LvlFilterHandler(maxLvl Lvl, h Handler) Handler {
function MultiHandler (line 161) | func MultiHandler(hs ...Handler) Handler {
function FailoverHandler (line 186) | func FailoverHandler(hs ...Handler) Handler {
function ChannelHandler (line 203) | func ChannelHandler(recs chan<- Record) Handler {
function BufferedHandler (line 215) | func BufferedHandler(bufSize int, h Handler) Handler {
function LazyHandler (line 229) | func LazyHandler(h Handler) Handler {
function evaluateLazy (line 255) | func evaluateLazy(lz Lazy) (interface{}, error) {
function DiscardHandler (line 285) | func DiscardHandler() Handler {
function must (line 296) | func must(h Handler, err error) Handler {
type muster (line 303) | type muster struct
method FileHandler (line 305) | func (m muster) FileHandler(path string, fmtr Format) Handler {
method NetHandler (line 309) | func (m muster) NetHandler(network, addr string, fmtr Format) Handler {
FILE: vendor/github.com/inconshreveable/log15/v3/handler_go13.go
type swapHandler (line 13) | type swapHandler struct
method Log (line 17) | func (h *swapHandler) Log(r *Record) error {
method Get (line 21) | func (h *swapHandler) Get() Handler {
method Swap (line 25) | func (h *swapHandler) Swap(newHandler Handler) {
FILE: vendor/github.com/inconshreveable/log15/v3/handler_go14.go
type swapHandler (line 10) | type swapHandler struct
method Log (line 14) | func (h *swapHandler) Log(r Record) error {
method Swap (line 18) | func (h *swapHandler) Swap(newHandler Handler) {
method Get (line 22) | func (h *swapHandler) Get() Handler {
FILE: vendor/github.com/inconshreveable/log15/v3/logger.go
constant timeKey (line 9) | timeKey = "t"
constant lvlKey (line 10) | lvlKey = "lvl"
constant msgKey (line 11) | msgKey = "msg"
constant errorKey (line 12) | errorKey = "LOG15_ERROR"
type Lvl (line 15) | type Lvl
method String (line 27) | func (l Lvl) String() string {
constant LvlCrit (line 19) | LvlCrit Lvl = iota
constant LvlError (line 20) | LvlError
constant LvlWarn (line 21) | LvlWarn
constant LvlInfo (line 22) | LvlInfo
constant LvlDebug (line 23) | LvlDebug
function LvlFromString (line 46) | func LvlFromString(lvlString string) (Lvl, error) {
type Record (line 69) | type Record struct
type RecordKeyNames (line 78) | type RecordKeyNames struct
type Logger (line 91) | type Logger interface
type logger (line 109) | type logger struct
method write (line 114) | func (l *logger) write(msg string, lvl Lvl, ctx []interface{}) {
method New (line 124) | func (l *logger) New(ctx ...interface{}) Logger {
method Debug (line 138) | func (l *logger) Debug(msg string, ctx ...interface{}) {
method Info (line 142) | func (l *logger) Info(msg string, ctx ...interface{}) {
method Warn (line 146) | func (l *logger) Warn(msg string, ctx ...interface{}) {
method Error (line 150) | func (l *logger) Error(msg string, ctx ...interface{}) {
method Crit (line 154) | func (l *logger) Crit(msg string, ctx ...interface{}) {
method GetHandler (line 158) | func (l *logger) GetHandler() Handler {
method SetHandler (line 162) | func (l *logger) SetHandler(h Handler) {
function newContext (line 130) | func newContext(prefix []interface{}, suffix []interface{}) []interface{} {
function normalize (line 166) | func normalize(ctx []interface{}) []interface{} {
type Lazy (line 195) | type Lazy struct
type Ctx (line 202) | type Ctx
method toArray (line 204) | func (c Ctx) toArray() []interface{} {
FILE: vendor/github.com/inconshreveable/log15/v3/root.go
function init (line 17) | func init() {
function New (line 32) | func New(ctx ...interface{}) Logger {
function Root (line 37) | func Root() Logger {
function Debug (line 46) | func Debug(msg string, ctx ...interface{}) {
function Info (line 51) | func Info(msg string, ctx ...interface{}) {
function Warn (line 56) | func Warn(msg string, ctx ...interface{}) {
function Error (line 61) | func Error(msg string, ctx ...interface{}) {
function Crit (line 66) | func Crit(msg string, ctx ...interface{}) {
FILE: vendor/github.com/inconshreveable/log15/v3/syslog.go
function SyslogHandler (line 13) | func SyslogHandler(priority syslog.Priority, tag string, fmtr Format) (H...
function SyslogNetHandler (line 20) | func SyslogNetHandler(net, addr string, priority syslog.Priority, tag st...
function sharedSyslog (line 25) | func sharedSyslog(fmtr Format, sysWr *syslog.Writer, err error) (Handler...
method SyslogHandler (line 50) | func (m muster) SyslogHandler(priority syslog.Priority, tag string, fmtr...
method SyslogNetHandler (line 54) | func (m muster) SyslogNetHandler(net, addr string, priority syslog.Prior...
FILE: vendor/github.com/kevinburke/handlers/ctx.go
type ctxVar (line 12) | type ctxVar
function SetRequestID (line 20) | func SetRequestID(r *http.Request, u uuid.UUID) *http.Request {
function GetRequestID (line 29) | func GetRequestID(ctx context.Context) (uuid.UUID, bool) {
function GetDuration (line 40) | func GetDuration(ctx context.Context) time.Duration {
function GetStartTime (line 49) | func GetStartTime(ctx context.Context) time.Time {
function getStart (line 59) | func getStart(ctx context.Context) time.Time {
type startWriter (line 68) | type startWriter struct
method duration (line 74) | func (s *startWriter) duration() string {
method WriteHeader (line 79) | func (s *startWriter) WriteHeader(code int) {
method Write (line 88) | func (s *startWriter) Write(b []byte) (int, error) {
method Header (line 99) | func (s *startWriter) Header() http.Header {
method Push (line 104) | func (s *startWriter) Push(target string, opts *http.PushOptions) error {
function Duration (line 111) | func Duration(h http.Handler) http.Handler {
function WithTimeout (line 131) | func WithTimeout(h http.Handler, timeout time.Duration) http.Handler {
FILE: vendor/github.com/kevinburke/handlers/gzip.go
type compressResponseWriter (line 15) | type compressResponseWriter struct
method WriteHeader (line 22) | func (w *compressResponseWriter) WriteHeader(c int) {
method Header (line 27) | func (w *compressResponseWriter) Header() http.Header {
method Write (line 31) | func (w *compressResponseWriter) Write(b []byte) (int, error) {
method Flush (line 45) | func (w *compressResponseWriter) Flush() {
type flusher (line 41) | type flusher interface
function GZip (line 64) | func GZip(h http.Handler) http.Handler {
function compressHandlerLevel (line 74) | func compressHandlerLevel(h http.Handler, level int) http.Handler {
FILE: vendor/github.com/kevinburke/handlers/lib.go
constant Version (line 33) | Version = "0.48.0"
function push (line 35) | func push(w http.ResponseWriter, target string, opts *http.PushOptions) ...
function All (line 43) | func All(h http.Handler, serverName string) http.Handler {
function JSON (line 48) | func JSON(h http.Handler) http.Handler {
type serverWriter (line 55) | type serverWriter struct
method WriteHeader (line 61) | func (s *serverWriter) WriteHeader(code int) {
method Write (line 70) | func (s *serverWriter) Write(b []byte) (int, error) {
method Header (line 79) | func (s *serverWriter) Header() http.Header {
method Push (line 84) | func (s *serverWriter) Push(target string, opts *http.PushOptions) err...
function TrailingSlashRedirect (line 90) | func TrailingSlashRedirect(h http.Handler) http.Handler {
function Server (line 101) | func Server(h http.Handler, serverName string) http.Handler {
function UUID (line 119) | func UUID(h http.Handler) http.Handler {
function BasicAuth (line 132) | func BasicAuth(h http.Handler, realm string, users map[string]string) ht...
function DebugWriter (line 168) | func DebugWriter(h http.Handler, output io.Writer) http.Handler {
function Debug (line 210) | func Debug(h http.Handler) http.Handler {
type responseLogger (line 216) | type responseLogger struct
method Header (line 222) | func (l *responseLogger) Header() http.Header {
method Write (line 226) | func (l *responseLogger) Write(b []byte) (int, error) {
method WriteHeader (line 236) | func (l *responseLogger) WriteHeader(s int) {
method Status (line 241) | func (l *responseLogger) Status() int {
method Size (line 248) | func (l *responseLogger) Size() int {
method Flush (line 252) | func (l *responseLogger) Flush() {
method Push (line 260) | func (l *responseLogger) Push(target string, opts *http.PushOptions) e...
type hijackLogger (line 264) | type hijackLogger struct
function makeLogger (line 268) | func makeLogger(w http.ResponseWriter) loggingResponseWriter {
type loggingResponseWriter (line 276) | type loggingResponseWriter interface
method ServeHTTP (line 283) | func (l logHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
function getRemoteIP (line 292) | func getRemoteIP(r *http.Request) string {
function timeSinceMs (line 301) | func timeSinceMs(t time.Time) int64 {
type logHolder (line 307) | type logHolder struct
function AppendLog (line 315) | func AppendLog(r *http.Request, logctx ...interface{}) {
function Log (line 338) | func Log(h http.Handler) http.Handler {
function RedirectProto (line 344) | func RedirectProto(h http.Handler) http.Handler {
function STS (line 361) | func STS(h http.Handler) http.Handler {
FILE: vendor/github.com/kevinburke/handlers/lib_noslog.go
function init (line 21) | func init() {
type logHandler (line 26) | type logHandler struct
function WithLogger (line 35) | func WithLogger(h http.Handler, logger log15.Logger) http.Handler {
function writeLog (line 39) | func writeLog(l log15.Logger, r *http.Request, u url.URL, t time.Time, s...
FILE: vendor/github.com/kevinburke/handlers/lib_slog.go
type logHandler (line 16) | type logHandler struct
function init (line 23) | func init() {
function WithLogger (line 32) | func WithLogger(h http.Handler, logger *slog.Logger) http.Handler {
function writeLog (line 36) | func writeLog(l *slog.Logger, r *http.Request, u url.URL, t time.Time, s...
FILE: vendor/github.com/kevinburke/handlers/logger_noslog.go
constant timeFormat (line 30) | timeFormat = "2006-01-02T15:04:05.000000-07:00"
constant termTimeFormat (line 31) | termTimeFormat = "15:04:05.000-07:00"
constant termDateTimeFormat (line 32) | termDateTimeFormat = "2006-01-02T15:04:05.000-07:00"
constant floatFormat (line 34) | floatFormat = 'f'
function NewLogger (line 40) | func NewLogger() log15.Logger {
function NewLoggerLevel (line 46) | func NewLoggerLevel(lvl log15.Lvl) log15.Logger {
function logfmtFormat (line 62) | func logfmtFormat() log15.Format {
function termFormat (line 74) | func termFormat() log15.Format {
function formatLogfmtValue (line 108) | func formatLogfmtValue(value interface{}) string {
function formatShared (line 130) | func formatShared(value interface{}) (result interface{}) {
function escapeString (line 156) | func escapeString(s string) string {
function logfmt (line 190) | func logfmt(buf *bytes.Buffer, ctx []interface{}, color int) {
FILE: vendor/github.com/kevinburke/handlers/logger_slog.go
function NewLogger (line 17) | func NewLogger() *slog.Logger {
function NewLoggerLevel (line 23) | func NewLoggerLevel(lvl slog.Level) *slog.Logger {
FILE: vendor/github.com/kevinburke/handlers/regex_handler.go
type route (line 12) | type route struct
type Regexp (line 20) | type Regexp struct
method Handle (line 28) | func (h *Regexp) Handle(pattern *regexp.Regexp, methods []string, hand...
method HandleString (line 38) | func (h *Regexp) HandleString(s string, methods []string, handler http...
method HandleFunc (line 50) | func (h *Regexp) HandleFunc(pattern *regexp.Regexp, methods []string, ...
method HandleStringFunc (line 60) | func (h *Regexp) HandleStringFunc(s string, methods []string, handler ...
method ServeHTTP (line 81) | func (h *Regexp) ServeHTTP(w http.ResponseWriter, r *http.Request) {
FILE: vendor/github.com/kevinburke/nacl/internal/subtle/aliasing.go
function AnyOverlap (line 15) | func AnyOverlap(x, y []byte) bool {
function InexactOverlap (line 27) | func InexactOverlap(x, y []byte) bool {
FILE: vendor/github.com/kevinburke/nacl/internal/subtle/aliasing_appengine.go
function AnyOverlap (line 18) | func AnyOverlap(x, y []byte) bool {
function InexactOverlap (line 30) | func InexactOverlap(x, y []byte) bool {
FILE: vendor/github.com/kevinburke/nacl/nacl.go
constant Version (line 30) | Version = "0.9.0"
constant KeySize (line 33) | KeySize = 32
constant NonceSize (line 36) | NonceSize = 24
type Key (line 41) | type Key
type Nonce (line 50) | type Nonce
function Load (line 55) | func Load(hexkey string) (Key, error) {
function Load64 (line 74) | func Load64(hexkey string) (*[64]byte, error) {
function NewKey (line 92) | func NewKey() Key {
function NewNonce (line 100) | func NewNonce() Nonce {
function Verify (line 110) | func Verify(a, b []byte) bool {
function Verify16 (line 116) | func Verify16(a, b *[16]byte) bool {
function Verify32 (line 125) | func Verify32(a, b *[KeySize]byte) bool {
constant HashSize (line 133) | HashSize = sha512.Size
function Hash (line 146) | func Hash(m []byte) *[HashSize]byte {
function Setup (line 152) | func Setup(nonce Nonce, key Key) (Key, *[16]byte) {
FILE: vendor/github.com/kevinburke/nacl/onetimeauth/onetimeauth.go
constant Size (line 28) | Size = poly1305.TagSize
function Sum (line 34) | func Sum(m []byte, key nacl.Key) *[Size]byte {
function Verify (line 42) | func Verify(mac *[Size]byte, m []byte, key nacl.Key) bool {
FILE: vendor/github.com/kevinburke/nacl/randombytes/randombytes.go
function Read (line 10) | func Read(in []byte) (int, error) {
function MustRead (line 15) | func MustRead(in []byte) {
FILE: vendor/github.com/kevinburke/nacl/secretbox/secretbox.go
constant Overhead (line 47) | Overhead = onetimeauth.Size
function sliceForAppend (line 53) | func sliceForAppend(in []byte, n int) (head, tail []byte) {
function EasySeal (line 68) | func EasySeal(message []byte, key nacl.Key) []byte {
function Seal (line 76) | func Seal(out, message []byte, nonce nacl.Nonce, key nacl.Key) []byte {
function EasyOpen (line 124) | func EasyOpen(box []byte, key nacl.Key) ([]byte, error) {
function Open (line 140) | func Open(out, box []byte, nonce nacl.Nonce, key nacl.Key) ([]byte, bool) {
FILE: vendor/github.com/kevinburke/rest/ctx.go
type ctxVar (line 10) | type ctxVar
function CtxErr (line 16) | func CtxErr(r *http.Request) error {
function ctxSetErr (line 25) | func ctxSetErr(r *http.Request, err error) *http.Request {
function CtxDomain (line 31) | func CtxDomain(r *http.Request) string {
function ctxSetDomain (line 41) | func ctxSetDomain(r *http.Request, domain string) *http.Request {
FILE: vendor/github.com/kevinburke/rest/noctx.go
function CtxErr (line 9) | func CtxErr(r *http.Request) error {
function ctxSetErr (line 14) | func ctxSetErr(r *http.Request, err error) *http.Request {
function CtxDomain (line 21) | func CtxDomain(r *http.Request) string {
function ctxSetDomain (line 27) | func ctxSetDomain(r *http.Request, domain string) *http.Request {
FILE: vendor/github.com/kevinburke/rest/rest.go
constant jsonContentType (line 32) | jsonContentType = "application/json; charset=utf-8"
function RegisterHandler (line 47) | func RegisterHandler(code int, f http.Handler) {
function ServerError (line 60) | func ServerError(w http.ResponseWriter, r *http.Request, err error) {
function defaultServerError (line 78) | func defaultServerError(w http.ResponseWriter, r *http.Request, err erro...
function NotFound (line 97) | func NotFound(w http.ResponseWriter, r *http.Request) {
function defaultNotFound (line 108) | func defaultNotFound(w http.ResponseWriter, r *http.Request) {
function BadRequest (line 119) | func BadRequest(w http.ResponseWriter, r *http.Request, err *Error) {
function Gone (line 138) | func Gone(w http.ResponseWriter, r *http.Request) {
function defaultGone (line 149) | func defaultGone(w http.ResponseWriter, r *http.Request) {
function defaultBadRequest (line 159) | func defaultBadRequest(w http.ResponseWriter, r *http.Request, err *Erro...
function NotAllowed (line 188) | func NotAllowed(w http.ResponseWriter, r *http.Request) {
function defaultNotAllowed (line 199) | func defaultNotAllowed(w http.ResponseWriter, r *http.Request) {
function Forbidden (line 211) | func Forbidden(w http.ResponseWriter, r *http.Request, err *Error) {
function defaultForbidden (line 223) | func defaultForbidden(w http.ResponseWriter, r *http.Request, err *Error) {
function NoContent (line 235) | func NoContent(w http.ResponseWriter) {
function Unauthorized (line 242) | func Unauthorized(w http.ResponseWriter, r *http.Request, domain string) {
function defaultUnauthorized (line 254) | func defaultUnauthorized(w http.ResponseWriter, r *http.Request, domain ...
FILE: vendor/github.com/kevinburke/rest/rest_slog.go
function init (line 11) | func init() {
FILE: vendor/github.com/kevinburke/rest/restclient/client.go
type UploadType (line 18) | type UploadType
constant Version (line 26) | Version = "2.12.0"
function init (line 30) | func init() {
type Client (line 37) | type Client struct
method Token (line 58) | func (c *Client) Token() string {
method UpdateToken (line 93) | func (c *Client) UpdateToken(newToken string) {
method DialSocket (line 107) | func (c *Client) DialSocket(socket string, transport *http.Transport) {
method NewRequestWithContext (line 144) | func (c *Client) NewRequestWithContext(ctx context.Context, method, pa...
method NewRequest (line 177) | func (c *Client) NewRequest(method, path string, body io.Reader) (*htt...
method Do (line 185) | func (c *Client) Do(r *http.Request, v interface{}) error {
function New (line 66) | func New(user, pass, base string) *Client {
function NewBearerClient (line 80) | func NewBearerClient(token, base string) *Client {
function DefaultErrorParser (line 217) | func DefaultErrorParser(resp *http.Response) error {
FILE: vendor/github.com/kevinburke/rest/restclient/transport.go
function init (line 17) | func init() {
type Transport (line 30) | type Transport struct
method RoundTrip (line 40) | func (t *Transport) RoundTrip(req *http.Request) (*http.Response, erro...
FILE: vendor/github.com/kevinburke/rest/resterror/resterror.go
type Error (line 7) | type Error struct
method Error (line 28) | func (e *Error) Error() string {
method String (line 32) | func (e *Error) String() string {
FILE: vendor/github.com/mattn/go-colorable/colorable_others.go
function NewColorable (line 14) | func NewColorable(file *os.File) io.Writer {
function NewColorableStdout (line 23) | func NewColorableStdout() io.Writer {
function NewColorableStderr (line 28) | func NewColorableStderr() io.Writer {
function EnableColorsStdout (line 33) | func EnableColorsStdout(enabled *bool) func() {
FILE: vendor/github.com/mattn/go-colorable/colorable_windows.go
constant foregroundBlue (line 21) | foregroundBlue = 0x1
constant foregroundGreen (line 22) | foregroundGreen = 0x2
constant foregroundRed (line 23) | foregroundRed = 0x4
constant foregroundIntensity (line 24) | foregroundIntensity = 0x8
constant foregroundMask (line 25) | foregroundMask = (foregroundRed | foregroundBlue | foregroundGreen ...
constant backgroundBlue (line 26) | backgroundBlue = 0x10
constant backgroundGreen (line 27) | backgroundGreen = 0x20
constant backgroundRed (line 28) | backgroundRed = 0x40
constant backgroundIntensity (line 29) | backgroundIntensity = 0x80
constant backgroundMask (line 30) | backgroundMask = (backgroundRed | backgroundBlue | backgroundGreen ...
constant commonLvbUnderscore (line 31) | commonLvbUnderscore = 0x8000
constant cENABLE_VIRTUAL_TERMINAL_PROCESSING (line 33) | cENABLE_VIRTUAL_TERMINAL_PROCESSING = 0x4
constant genericRead (line 37) | genericRead = 0x80000000
constant genericWrite (line 38) | genericWrite = 0x40000000
constant consoleTextmodeBuffer (line 42) | consoleTextmodeBuffer = 0x1
type wchar (line 45) | type wchar
type short (line 46) | type short
type dword (line 47) | type dword
type word (line 48) | type word
type coord (line 50) | type coord struct
type smallRect (line 55) | type smallRect struct
type consoleScreenBufferInfo (line 62) | type consoleScreenBufferInfo struct
type consoleCursorInfo (line 70) | type consoleCursorInfo struct
type writer (line 91) | type writer struct
method Write (line 437) | func (w *writer) Write(data []byte) (n int, err error) {
function NewColorable (line 102) | func NewColorable(file *os.File) io.Writer {
function NewColorableStdout (line 121) | func NewColorableStdout() io.Writer {
function NewColorableStderr (line 126) | func NewColorableStderr() io.Writer {
function doTitleSequence (line 390) | func doTitleSequence(er *bytes.Reader) error {
function atoiWithDefault (line 429) | func atoiWithDefault(s string, def int) (int, error) {
type consoleColor (line 869) | type consoleColor struct
method foregroundAttr (line 877) | func (c consoleColor) foregroundAttr() (attr word) {
method backgroundAttr (line 893) | func (c consoleColor) backgroundAttr() (attr word) {
type hsv (line 928) | type hsv struct
method dist (line 932) | func (a hsv) dist(b hsv) float32 {
function toHSV (line 945) | func toHSV(rgb int) hsv {
type hsvTable (line 972) | type hsvTable
method find (line 982) | func (t hsvTable) find(rgb int) consoleColor {
function toHSVTable (line 974) | func toHSVTable(rgbTable []consoleColor) hsvTable {
function minmax3f (line 995) | func minmax3f(a, b, c float32) (min, max float32) {
function n256setup (line 1018) | func n256setup() {
function EnableColorsStdout (line 1030) | func EnableColorsStdout(enabled *bool) func() {
FILE: vendor/github.com/mattn/go-colorable/noncolorable.go
type NonColorable (line 9) | type NonColorable struct
method Write (line 19) | func (w *NonColorable) Write(data []byte) (n int, err error) {
function NewNonColorable (line 14) | func NewNonColorable(w io.Writer) io.Writer {
FILE: vendor/github.com/mattn/go-isatty/isatty_bsd.go
function IsTerminal (line 11) | func IsTerminal(fd uintptr) bool {
function IsCygwinTerminal (line 18) | func IsCygwinTerminal(fd uintptr) bool {
FILE: vendor/github.com/mattn/go-isatty/isatty_others.go
function IsTerminal (line 9) | func IsTerminal(fd uintptr) bool {
function IsCygwinTerminal (line 15) | func IsCygwinTerminal(fd uintptr) bool {
FILE: vendor/github.com/mattn/go-isatty/isatty_plan9.go
function IsTerminal (line 11) | func IsTerminal(fd uintptr) bool {
function IsCygwinTerminal (line 21) | func IsCygwinTerminal(fd uintptr) bool {
FILE: vendor/github.com/mattn/go-isatty/isatty_solaris.go
function IsTerminal (line 12) | func IsTerminal(fd uintptr) bool {
function IsCygwinTerminal (line 19) | func IsCygwinTerminal(fd uintptr) bool {
FILE: vendor/github.com/mattn/go-isatty/isatty_tcgets.go
function IsTerminal (line 11) | func IsTerminal(fd uintptr) bool {
function IsCygwinTerminal (line 18) | func IsCygwinTerminal(fd uintptr) bool {
FILE: vendor/github.com/mattn/go-isatty/isatty_windows.go
constant objectNameInfo (line 15) | objectNameInfo uintptr = 1
constant fileNameInfo (line 16) | fileNameInfo = 2
constant fileTypePipe (line 17) | fileTypePipe = 3
function init (line 29) | func init() {
function IsTerminal (line 37) | func IsTerminal(fd uintptr) bool {
function isCygwinPipeName (line 46) | func isCygwinPipeName(name string) bool {
function getFileNameByHandle (line 83) | func getFileNameByHandle(fd uintptr) (string, error) {
function IsCygwinTerminal (line 100) | func IsCygwinTerminal(fd uintptr) bool {
FILE: vendor/golang.org/x/crypto/internal/poly1305/mac_noasm.go
type mac (line 9) | type mac struct
FILE: vendor/golang.org/x/crypto/internal/poly1305/poly1305.go
constant TagSize (line 23) | TagSize = 16
function Sum (line 28) | func Sum(out *[16]byte, m []byte, key *[32]byte) {
function Verify (line 35) | func Verify(mac *[16]byte, m []byte, key *[32]byte) bool {
function New (line 50) | func New(key *[32]byte) *MAC {
type MAC (line 63) | type MAC struct
method Size (line 70) | func (h *MAC) Size() int { return TagSize }
method Write (line 76) | func (h *MAC) Write(p []byte) (n int, err error) {
method Sum (line 85) | func (h *MAC) Sum(b []byte) []byte {
method Verify (line 94) | func (h *MAC) Verify(expected []byte) bool {
FILE: vendor/golang.org/x/crypto/internal/poly1305/sum_asm.go
function update (line 10) | func update(state *macState, msg []byte)
type mac (line 17) | type mac struct
method Write (line 19) | func (h *mac) Write(p []byte) (int, error) {
method Sum (line 41) | func (h *mac) Sum(out *[16]byte) {
FILE: vendor/golang.org/x/crypto/internal/poly1305/sum_generic.go
function sumGeneric (line 31) | func sumGeneric(out *[TagSize]byte, msg []byte, key *[32]byte) {
function newMACGeneric (line 37) | func newMACGeneric(key *[32]byte) macGeneric {
type macState (line 45) | type macState struct
type macGeneric (line 55) | type macGeneric struct
method Write (line 64) | func (h *macGeneric) Write(p []byte) (int, error) {
method Sum (line 89) | func (h *macGeneric) Sum(out *[TagSize]byte) {
constant rMask0 (line 101) | rMask0 = 0x0FFFFFFC0FFFFFFF
constant rMask1 (line 102) | rMask1 = 0x0FFFFFFC0FFFFFFC
function initialize (line 106) | func initialize(key *[32]byte, m *macState) {
type uint128 (line 115) | type uint128 struct
function mul64 (line 119) | func mul64(a, b uint64) uint128 {
function add128 (line 124) | func add128(a, b uint128) uint128 {
function shiftRightBy2 (line 133) | func shiftRightBy2(a uint128) uint128 {
function updateGeneric (line 146) | func updateGeneric(state *macState, msg []byte) {
constant maskLow2Bits (line 268) | maskLow2Bits uint64 = 0x0000000000000003
constant maskNotLow2Bits (line 269) | maskNotLow2Bits uint64 = ^maskLow2Bits
function select64 (line 273) | func select64(v, x, y uint64) uint64 { return ^(v-1)&x | (v-1)&y }
constant p0 (line 277) | p0 = 0xFFFFFFFFFFFFFFFB
constant p1 (line 278) | p1 = 0xFFFFFFFFFFFFFFFF
constant p2 (line 279) | p2 = 0x0000000000000003
function finalize (line 285) | func finalize(out *[TagSize]byte, h *[3]uint64, s *[2]uint64) {
FILE: vendor/golang.org/x/crypto/internal/poly1305/sum_s390x.go
function updateVX (line 18) | func updateVX(state *macState, msg []byte)
type mac (line 27) | type mac struct
method Write (line 34) | func (h *mac) Write(p []byte) (int, error) {
method Sum (line 64) | func (h *mac) Sum(out *[TagSize]byte) {
FILE: vendor/golang.org/x/crypto/poly1305/poly1305_compat.go
constant TagSize (line 32) | TagSize = 16
function Sum (line 37) | func Sum(out *[16]byte, m []byte, key *[32]byte) {
function Verify (line 42) | func Verify(mac *[16]byte, m []byte, key *[32]byte) bool {
function New (line 55) | func New(key *[32]byte) *MAC {
type MAC (line 66) | type MAC struct
method Size (line 71) | func (h *MAC) Size() int { return TagSize }
method Write (line 77) | func (h *MAC) Write(p []byte) (n int, err error) {
method Sum (line 83) | func (h *MAC) Sum(b []byte) []byte {
method Verify (line 89) | func (h *MAC) Verify(expected []byte) bool {
FILE: vendor/golang.org/x/crypto/salsa20/salsa/hsalsa20.go
function HSalsa20 (line 16) | func HSalsa20(out *[32]byte, in *[16]byte, k *[32]byte, c *[16]byte) {
FILE: vendor/golang.org/x/crypto/salsa20/salsa/salsa208.go
function Core208 (line 11) | func Core208(out *[64]byte, in *[64]byte) {
FILE: vendor/golang.org/x/crypto/salsa20/salsa/salsa20_amd64.go
function salsa2020XORKeyStream (line 12) | func salsa2020XORKeyStream(out, in *byte, n uint64, nonce, key *byte)
function XORKeyStream (line 17) | func XORKeyStream(out, in []byte, counter *[16]byte, key *[32]byte) {
FILE: vendor/golang.org/x/crypto/salsa20/salsa/salsa20_noasm.go
function XORKeyStream (line 12) | func XORKeyStream(out, in []byte, counter *[16]byte, key *[32]byte) {
FILE: vendor/golang.org/x/crypto/salsa20/salsa/salsa20_ref.go
constant rounds (line 9) | rounds = 20
function core (line 13) | func core(out *[64]byte, in *[16]byte, k *[32]byte, c *[16]byte) {
function genericXORKeyStream (line 207) | func genericXORKeyStream(out, in []byte, counter *[16]byte, key *[32]byt...
FILE: vendor/golang.org/x/sys/cpu/byteorder.go
type byteOrder (line 12) | type byteOrder interface
type littleEndian (line 17) | type littleEndian struct
method Uint32 (line 20) | func (littleEndian) Uint32(b []byte) uint32 {
method Uint64 (line 25) | func (littleEndian) Uint64(b []byte) uint64 {
type bigEndian (line 18) | type bigEndian struct
method Uint32 (line 31) | func (bigEndian) Uint32(b []byte) uint32 {
method Uint64 (line 36) | func (bigEndian) Uint64(b []byte) uint64 {
function hostByteOrder (line 44) | func hostByteOrder() byteOrder {
FILE: vendor/golang.org/x/sys/cpu/cpu.go
type CacheLinePad (line 22) | type CacheLinePad struct
function init (line 249) | func init() {
type option (line 262) | type option struct
function processOptions (line 270) | func processOptions() {
FILE: vendor/golang.org/x/sys/cpu/cpu_aix.go
constant _SC_IMPL (line 11) | _SC_IMPL = 2
constant _IMPL_POWER8 (line 12) | _IMPL_POWER8 = 0x10000
constant _IMPL_POWER9 (line 13) | _IMPL_POWER9 = 0x20000
function archInit (line 16) | func archInit() {
function getsystemcfg (line 29) | func getsystemcfg(label int) (n uint64) {
FILE: vendor/golang.org/x/sys/cpu/cpu_arm.go
constant cacheLineSize (line 7) | cacheLineSize = 32
constant hwcap_SWP (line 12) | hwcap_SWP = 1 << 0
constant hwcap_HALF (line 13) | hwcap_HALF = 1 << 1
constant hwcap_THUMB (line 14) | hwcap_THUMB = 1 << 2
constant hwcap_26BIT (line 15) | hwcap_26BIT = 1 << 3
constant hwcap_FAST_MULT (line 16) | hwcap_FAST_MULT = 1 << 4
constant hwcap_FPA (line 17) | hwcap_FPA = 1 << 5
constant hwcap_VFP (line 18) | hwcap_VFP = 1 << 6
constant hwcap_EDSP (line 19) | hwcap_EDSP = 1 << 7
constant hwcap_JAVA (line 20) | hwcap_JAVA = 1 << 8
constant hwcap_IWMMXT (line 21) | hwcap_IWMMXT = 1 << 9
constant hwcap_CRUNCH (line 22) | hwcap_CRUNCH = 1 << 10
constant hwcap_THUMBEE (line 23) | hwcap_THUMBEE = 1 << 11
constant hwcap_NEON (line 24) | hwcap_NEON = 1 << 12
constant hwcap_VFPv3 (line 25) | hwcap_VFPv3 = 1 << 13
constant hwcap_VFPv3D16 (line 26) | hwcap_VFPv3D16 = 1 << 14
constant hwcap_TLS (line 27) | hwcap_TLS = 1 << 15
constant hwcap_VFPv4 (line 28) | hwcap_VFPv4 = 1 << 16
constant hwcap_IDIVA (line 29) | hwcap_IDIVA = 1 << 17
constant hwcap_IDIVT (line 30) | hwcap_IDIVT = 1 << 18
constant hwcap_VFPD32 (line 31) | hwcap_VFPD32 = 1 << 19
constant hwcap_LPAE (line 32) | hwcap_LPAE = 1 << 20
constant hwcap_EVTSTRM (line 33) | hwcap_EVTSTRM = 1 << 21
constant hwcap2_AES (line 35) | hwcap2_AES = 1 << 0
constant hwcap2_PMULL (line 36) | hwcap2_PMULL = 1 << 1
constant hwcap2_SHA1 (line 37) | hwcap2_SHA1 = 1 << 2
constant hwcap2_SHA2 (line 38) | hwcap2_SHA2 = 1 << 3
constant hwcap2_CRC32 (line 39) | hwcap2_CRC32 = 1 << 4
function initOptions (line 42) | func initOptions() {
FILE: vendor/golang.org/x/sys/cpu/cpu_arm64.go
constant cacheLineSize (line 12) | cacheLineSize = 128
function initOptions (line 14) | func initOptions() {
function archInit (line 46) | func archInit() {
function setMinimalFeatures (line 60) | func setMinimalFeatures() {
function readARM64Registers (line 65) | func readARM64Registers() {
function parseARM64SystemRegisters (line 71) | func parseARM64SystemRegisters(isar0, isar1, pfr0 uint64) {
function parseARM64SVERegister (line 185) | func parseARM64SVERegister(zfr0 uint64) {
function extractBits (line 192) | func extractBits(data uint64, start, end uint) uint {
FILE: vendor/golang.org/x/sys/cpu/cpu_darwin_x86.go
function darwinSupportsAVX512 (line 27) | func darwinSupportsAVX512() bool {
function darwinKernelVersionCheck (line 32) | func darwinKernelVersionCheck(major, minor, patch int) bool {
FILE: vendor/golang.org/x/sys/cpu/cpu_gc_arm64.go
function getisar0 (line 9) | func getisar0() uint64
function getisar1 (line 10) | func getisar1() uint64
function getpfr0 (line 11) | func getpfr0() uint64
function getzfr0 (line 12) | func getzfr0() uint64
FILE: vendor/golang.org/x/sys/cpu/cpu_gc_s390x.go
function haveAsmFunctions (line 11) | func haveAsmFunctions() bool { return true }
function stfle (line 15) | func stfle() facilityList
function kmQuery (line 16) | func kmQuery() queryResult
function kmcQuery (line 17) | func kmcQuery() queryResult
function kmctrQuery (line 18) | func kmctrQuery() queryResult
function kmaQuery (line 19) | func kmaQuery() queryResult
function kimdQuery (line 20) | func kimdQuery() queryResult
function klmdQuery (line 21) | func klmdQuery() queryResult
FILE: vendor/golang.org/x/sys/cpu/cpu_gc_x86.go
function cpuid (line 11) | func cpuid(eaxArg, ecxArg uint32) (eax, ebx, ecx, edx uint32)
function xgetbv (line 15) | func xgetbv() (eax, edx uint32)
FILE: vendor/golang.org/x/sys/cpu/cpu_gccgo_arm64.go
function getisar0 (line 9) | func getisar0() uint64 { return 0 }
function getisar1 (line 10) | func getisar1() uint64 { return 0 }
function getpfr0 (line 11) | func getpfr0() uint64 { return 0 }
FILE: vendor/golang.org/x/sys/cpu/cpu_gccgo_s390x.go
function haveAsmFunctions (line 11) | func haveAsmFunctions() bool { return false }
function stfle (line 16) | func stfle() facilityList { panic("not implemented for gccgo") }
function kmQuery (line 17) | func kmQuery() queryResult { panic("not implemented for gccgo") }
function kmcQuery (line 18) | func kmcQuery() queryResult { panic("not implemented for gccgo") }
function kmctrQuery (line 19) | func kmctrQuery() queryResult { panic("not implemented for gccgo") }
function kmaQuery (line 20) | func kmaQuery() queryResult { panic("not implemented for gccgo") }
function kimdQuery (line 21) | func kimdQuery() queryResult { panic("not implemented for gccgo") }
function klmdQuery (line 22) | func klmdQuery() queryResult { panic("not implemented for gccgo") }
FILE: vendor/golang.org/x/sys/cpu/cpu_gccgo_x86.c
function gccgoGetCpuidCount (line 12) | int
function gccgoXgetbv (line 28) | void
FILE: vendor/golang.org/x/sys/cpu/cpu_gccgo_x86.go
function gccgoGetCpuidCount (line 10) | func gccgoGetCpuidCount(eaxArg, ecxArg uint32, eax, ebx, ecx, edx *uint32)
function cpuid (line 12) | func cpuid(eaxArg, ecxArg uint32) (eax, ebx, ecx, edx uint32) {
function gccgoXgetbv (line 19) | func gccgoXgetbv(eax, edx *uint32)
function xgetbv (line 21) | func xgetbv() (eax, edx uint32) {
FILE: vendor/golang.org/x/sys/cpu/cpu_linux.go
function archInit (line 9) | func archInit() {
FILE: vendor/golang.org/x/sys/cpu/cpu_linux_arm.go
function doinit (line 7) | func doinit() {
function isSet (line 37) | func isSet(hwc uint, value uint) bool {
FILE: vendor/golang.org/x/sys/cpu/cpu_linux_arm64.go
constant hwcap_FP (line 14) | hwcap_FP = 1 << 0
constant hwcap_ASIMD (line 15) | hwcap_ASIMD = 1 << 1
constant hwcap_EVTSTRM (line 16) | hwcap_EVTSTRM = 1 << 2
constant hwcap_AES (line 17) | hwcap_AES = 1 << 3
constant hwcap_PMULL (line 18) | hwcap_PMULL = 1 << 4
constant hwcap_SHA1 (line 19) | hwcap_SHA1 = 1 << 5
constant hwcap_SHA2 (line 20) | hwcap_SHA2 = 1 << 6
constant hwcap_CRC32 (line 21) | hwcap_CRC32 = 1 << 7
constant hwcap_ATOMICS (line 22) | hwcap_ATOMICS = 1 << 8
constant hwcap_FPHP (line 23) | hwcap_FPHP = 1 << 9
constant hwcap_ASIMDHP (line 24) | hwcap_ASIMDHP = 1 << 10
constant hwcap_CPUID (line 25) | hwcap_CPUID = 1 << 11
constant hwcap_ASIMDRDM (line 26) | hwcap_ASIMDRDM = 1 << 12
constant hwcap_JSCVT (line 27) | hwcap_JSCVT = 1 << 13
constant hwcap_FCMA (line 28) | hwcap_FCMA = 1 << 14
constant hwcap_LRCPC (line 29) | hwcap_LRCPC = 1 << 15
constant hwcap_DCPOP (line 30) | hwcap_DCPOP = 1 << 16
constant hwcap_SHA3 (line 31) | hwcap_SHA3 = 1 << 17
constant hwcap_SM3 (line 32) | hwcap_SM3 = 1 << 18
constant hwcap_SM4 (line 33) | hwcap_SM4 = 1 << 19
constant hwcap_ASIMDDP (line 34) | hwcap_ASIMDDP = 1 << 20
constant hwcap_SHA512 (line 35) | hwcap_SHA512 = 1 << 21
constant hwcap_SVE (line 36) | hwcap_SVE = 1 << 22
constant hwcap_ASIMDFHM (line 37) | hwcap_ASIMDFHM = 1 << 23
constant hwcap_DIT (line 38) | hwcap_DIT = 1 << 24
constant hwcap2_SVE2 (line 40) | hwcap2_SVE2 = 1 << 1
constant hwcap2_I8MM (line 41) | hwcap2_I8MM = 1 << 13
function linuxKernelCanEmulateCPUID (line 49) | func linuxKernelCanEmulateCPUID() bool {
function doinit (line 63) | func doinit() {
function isSet (line 118) | func isSet(hwc uint, value uint) bool {
FILE: vendor/golang.org/x/sys/cpu/cpu_linux_loong64.go
constant hwcap_LOONGARCH_LSX (line 9) | hwcap_LOONGARCH_LSX = 1 << 4
constant hwcap_LOONGARCH_LASX (line 10) | hwcap_LOONGARCH_LASX = 1 << 5
function doinit (line 13) | func doinit() {
function hwcIsSet (line 20) | func hwcIsSet(hwc uint, val uint) bool {
FILE: vendor/golang.org/x/sys/cpu/cpu_linux_mips64x.go
constant hwcap_MIPS_MSA (line 12) | hwcap_MIPS_MSA = 1 << 1
function doinit (line 15) | func doinit() {
function isSet (line 20) | func isSet(hwc uint, value uint) bool {
FILE: vendor/golang.org/x/sys/cpu/cpu_linux_noinit.go
function doinit (line 9) | func doinit() {}
FILE: vendor/golang.org/x/sys/cpu/cpu_linux_ppc64x.go
constant _PPC_FEATURE2_ARCH_2_07 (line 12) | _PPC_FEATURE2_ARCH_2_07 = 0x80000000
constant _PPC_FEATURE2_ARCH_3_00 (line 13) | _PPC_FEATURE2_ARCH_3_00 = 0x00800000
constant _PPC_FEATURE2_DARN (line 16) | _PPC_FEATURE2_DARN = 0x00200000
constant _PPC_FEATURE2_SCV (line 17) | _PPC_FEATURE2_SCV = 0x00100000
function doinit (line 20) | func doinit() {
function isSet (line 28) | func isSet(hwc uint, value uint) bool {
FILE: vendor/golang.org/x/sys/cpu/cpu_linux_riscv64.go
constant riscv_HWPROBE_KEY_IMA_EXT_0 (line 55) | riscv_HWPROBE_KEY_IMA_EXT_0 = 0x4
constant riscv_HWPROBE_IMA_C (line 56) | riscv_HWPROBE_IMA_C = 0x2
constant riscv_HWPROBE_IMA_V (line 57) | riscv_HWPROBE_IMA_V = 0x4
constant riscv_HWPROBE_EXT_ZBA (line 58) | riscv_HWPROBE_EXT_ZBA = 0x8
constant riscv_HWPROBE_EXT_ZBB (line 59) | riscv_HWPROBE_EXT_ZBB = 0x10
constant riscv_HWPROBE_EXT_ZBS (line 60) | riscv_HWPROBE_EXT_ZBS = 0x20
constant riscv_HWPROBE_EXT_ZVBB (line 61) | riscv_HWPROBE_EXT_ZVBB = 0x20000
constant riscv_HWPROBE_EXT_ZVBC (line 62) | riscv_HWPROBE_EXT_ZVBC = 0x40000
constant riscv_HWPROBE_EXT_ZVKB (line 63) | riscv_HWPROBE_EXT_ZVKB = 0x80000
constant riscv_HWPROBE_EXT_ZVKG (line 64) | riscv_HWPROBE_EXT_ZVKG = 0x100000
constant riscv_HWPROBE_EXT_ZVKNED (line 65) | riscv_HWPROBE_EXT_ZVKNED = 0x200000
constant riscv_HWPROBE_EXT_ZVKNHB (line 66) | riscv_HWPROBE_EXT_ZVKNHB = 0x800000
constant riscv_HWPROBE_EXT_ZVKSED (line 67) | riscv_HWPROBE_EXT_ZVKSED = 0x1000000
constant riscv_HWPROBE_EXT_ZVKSH (line 68) | riscv_HWPROBE_EXT_ZVKSH = 0x2000000
constant riscv_HWPROBE_EXT_ZVKT (line 69) | riscv_HWPROBE_EXT_ZVKT = 0x4000000
constant riscv_HWPROBE_KEY_CPUPERF_0 (line 70) | riscv_HWPROBE_KEY_CPUPERF_0 = 0x5
constant riscv_HWPROBE_MISALIGNED_FAST (line 71) | riscv_HWPROBE_MISALIGNED_FAST = 0x3
constant riscv_HWPROBE_MISALIGNED_MASK (line 72) | riscv_HWPROBE_MISALIGNED_MASK = 0x7
constant sys_RISCV_HWPROBE (line 77) | sys_RISCV_HWPROBE = 258
type riscvHWProbePairs (line 81) | type riscvHWProbePairs struct
constant hwcap_RISCV_ISA_C (line 88) | hwcap_RISCV_ISA_C = 1 << ('C' - 'A')
function doinit (line 91) | func doinit() {
function isSet (line 140) | func isSet(hwc uint, value uint) bool {
function riscvHWProbe (line 149) | func riscvHWProbe(pairs []riscvHWProbePairs, flags uint) bool {
FILE: vendor/golang.org/x/sys/cpu/cpu_linux_s390x.go
constant hwcap_ZARCH (line 9) | hwcap_ZARCH = 2
constant hwcap_STFLE (line 10) | hwcap_STFLE = 4
constant hwcap_MSA (line 11) | hwcap_MSA = 8
constant hwcap_LDISP (line 12) | hwcap_LDISP = 16
constant hwcap_EIMM (line 13) | hwcap_EIMM = 32
constant hwcap_DFP (line 14) | hwcap_DFP = 64
constant hwcap_ETF3EH (line 15) | hwcap_ETF3EH = 256
constant hwcap_VX (line 16) | hwcap_VX = 2048
constant hwcap_VXE (line 17) | hwcap_VXE = 8192
function initS390Xbase (line 20) | func initS390Xbase() {
FILE: vendor/golang.org/x/sys/cpu/cpu_loong64.go
constant cacheLineSize (line 9) | cacheLineSize = 64
constant cpucfg1_CRC32 (line 15) | cpucfg1_CRC32 = 1 << 25
constant cpucfg2_LAM_BH (line 18) | cpucfg2_LAM_BH = 1 << 27
constant cpucfg2_LAMCAS (line 19) | cpucfg2_LAMCAS = 1 << 28
function initOptions (line 22) | func initOptions() {
function get_cpucfg (line 46) | func get_cpucfg(reg uint32) uint32
function cfgIsSet (line 48) | func cfgIsSet(cfg uint32, val uint32) bool {
FILE: vendor/golang.org/x/sys/cpu/cpu_mips64x.go
constant cacheLineSize (line 9) | cacheLineSize = 32
function initOptions (line 11) | func initOptions() {
FILE: vendor/golang.org/x/sys/cpu/cpu_mipsx.go
constant cacheLineSize (line 9) | cacheLineSize = 32
function initOptions (line 11) | func initOptions() {}
FILE: vendor/golang.org/x/sys/cpu/cpu_netbsd_arm64.go
constant _CTL_QUERY (line 16) | _CTL_QUERY = -2
constant _SYSCTL_VERS_1 (line 18) | _SYSCTL_VERS_1 = 0x1000000
function sysctl (line 23) | func sysctl(mib []int32, old *byte, oldlen *uintptr, new *byte, newlen u...
type sysctlNode (line 44) | type sysctlNode struct
function sysctlNodes (line 57) | func sysctlNodes(mib []int32) ([]sysctlNode, error) {
function nametomib (line 80) | func nametomib(name string) ([]int32, error) {
type aarch64SysctlCPUID (line 120) | type aarch64SysctlCPUID struct
function sysctlCPUID (line 142) | func sysctlCPUID(name string) (*aarch64SysctlCPUID, error) {
function doinit (line 164) | func doinit() {
FILE: vendor/golang.org/x/sys/cpu/cpu_openbsd_arm64.go
constant _CTL_MACHDEP (line 17) | _CTL_MACHDEP = 7
constant _CPU_ID_AA64ISAR0 (line 20) | _CPU_ID_AA64ISAR0 = 2
constant _CPU_ID_AA64ISAR1 (line 21) | _CPU_ID_AA64ISAR1 = 3
function syscall_syscall6 (line 25) | func syscall_syscall6(fn, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintpt...
function sysctl (line 29) | func sysctl(mib []uint32, old *byte, oldlen *uintptr, new *byte, newlen ...
function sysctlUint64 (line 41) | func sysctlUint64(mib []uint32) (uint64, bool) {
function doinit (line 50) | func doinit() {
FILE: vendor/golang.org/x/sys/cpu/cpu_other_arm.go
function archInit (line 9) | func archInit() {}
FILE: vendor/golang.org/x/sys/cpu/cpu_other_arm64.go
function doinit (line 9) | func doinit() {}
FILE: vendor/golang.org/x/sys/cpu/cpu_other_mips64x.go
function archInit (line 9) | func archInit() {
FILE: vendor/golang.org/x/sys/cpu/cpu_other_ppc64x.go
function archInit (line 9) | func archInit() {
FILE: vendor/golang.org/x/sys/cpu/cpu_other_riscv64.go
function archInit (line 9) | func archInit() {
FILE: vendor/golang.org/x/sys/cpu/cpu_other_x86.go
function darwinSupportsAVX512 (line 9) | func darwinSupportsAVX512() bool {
FILE: vendor/golang.org/x/sys/cpu/cpu_ppc64x.go
constant cacheLineSize (line 9) | cacheLineSize = 128
function initOptions (line 11) | func initOptions() {
FILE: vendor/golang.org/x/sys/cpu/cpu_riscv64.go
constant cacheLineSize (line 9) | cacheLineSize = 64
function initOptions (line 11) | func initOptions() {
FILE: vendor/golang.org/x/sys/cpu/cpu_s390x.go
constant cacheLineSize (line 7) | cacheLineSize = 256
function initOptions (line 9) | func initOptions() {
function bitIsSet (line 34) | func bitIsSet(bits []uint64, index uint) bool {
type facility (line 39) | type facility
constant zarch (line 43) | zarch facility = 1
constant stflef (line 44) | stflef facility = 7
constant ldisp (line 45) | ldisp facility = 18
constant eimm (line 46) | eimm facility = 21
constant dfp (line 49) | dfp facility = 42
constant etf3eh (line 50) | etf3eh facility = 30
constant msa (line 53) | msa facility = 17
constant msa3 (line 54) | msa3 facility = 76
constant msa4 (line 55) | msa4 facility = 77
constant msa5 (line 56) | msa5 facility = 57
constant msa8 (line 57) | msa8 facility = 146
constant msa9 (line 58) | msa9 facility = 155
constant vx (line 61) | vx facility = 129
constant vxe (line 62) | vxe facility = 135
constant vxe2 (line 63) | vxe2 facility = 148
type facilityList (line 69) | type facilityList struct
method Has (line 74) | func (s *facilityList) Has(fs ...facility) bool {
type function (line 87) | type function
constant aes128 (line 91) | aes128 function = 18
constant aes192 (line 92) | aes192 function = 19
constant aes256 (line 93) | aes256 function = 20
constant sha1 (line 96) | sha1 function = 1
constant sha256 (line 97) | sha256 function = 2
constant sha512 (line 98) | sha512 function = 3
constant sha3_224 (line 99) | sha3_224 function = 32
constant sha3_256 (line 100) | sha3_256 function = 33
constant sha3_384 (line 101) | sha3_384 function = 34
constant sha3_512 (line 102) | sha3_512 function = 35
constant shake128 (line 103) | shake128 function = 36
constant shake256 (line 104) | shake256 function = 37
constant ghash (line 107) | ghash function = 65
type queryResult (line 113) | type queryResult struct
method Has (line 118) | func (q *queryResult) Has(fns ...function) bool {
function doinit (line 130) | func doinit() {
FILE: vendor/golang.org/x/sys/cpu/cpu_wasm.go
constant cacheLineSize (line 13) | cacheLineSize = 0
function initOptions (line 15) | func initOptions() {}
function archInit (line 17) | func archInit() {}
FILE: vendor/golang.org/x/sys/cpu/cpu_windows_arm64.go
function doinit (line 11) | func doinit() {
FILE: vendor/golang.org/x/sys/cpu/cpu_x86.go
constant cacheLineSize (line 11) | cacheLineSize = 64
function initOptions (line 13) | func initOptions() {
function archInit (line 65) | func archInit() {
function isSet (line 234) | func isSet(hwc uint32, value uint32) bool {
FILE: vendor/golang.org/x/sys/cpu/cpu_zos.go
function archInit (line 7) | func archInit() {
FILE: vendor/golang.org/x/sys/cpu/cpu_zos_s390x.go
function initS390Xbase (line 7) | func initS390Xbase() {
FILE: vendor/golang.org/x/sys/cpu/endian_big.go
constant IsBigEndian (line 10) | IsBigEndian = true
FILE: vendor/golang.org/x/sys/cpu/endian_little.go
constant IsBigEndian (line 10) | IsBigEndian = false
FILE: vendor/golang.org/x/sys/cpu/hwcap_linux.go
constant _AT_HWCAP (line 12) | _AT_HWCAP = 16
constant _AT_HWCAP2 (line 13) | _AT_HWCAP2 = 26
constant procAuxv (line 15) | procAuxv = "/proc/self/auxv"
constant uintSize (line 17) | uintSize = int(32 << (^uint(0) >> 63))
function readHWCAP (line 26) | func readHWCAP() error {
FILE: vendor/golang.org/x/sys/cpu/parse.go
function parseRelease (line 14) | func parseRelease(rel string) (major, minor, patch int, ok bool) {
FILE: vendor/golang.org/x/sys/cpu/proc_cpuinfo_linux.go
function readLinuxProcCPUInfo (line 16) | func readLinuxProcCPUInfo() error {
FILE: vendor/golang.org/x/sys/cpu/runtime_auxv.go
function getAuxv (line 11) | func getAuxv() []uintptr {
FILE: vendor/golang.org/x/sys/cpu/runtime_auxv_go121.go
function runtime_getAuxv (line 14) | func runtime_getAuxv() []uintptr
function init (line 16) | func init() {
FILE: vendor/golang.org/x/sys/cpu/syscall_aix_gccgo.go
function gccgoGetsystemcfg (line 20) | func gccgoGetsystemcfg(label uint32) (r uint64)
function callgetsystemcfg (line 22) | func callgetsystemcfg(label int) (r1 uintptr, e1 syscall.Errno) {
FILE: vendor/golang.org/x/sys/cpu/syscall_aix_ppc64_gc.go
type syscallFunc (line 22) | type syscallFunc
function rawSyscall6 (line 29) | func rawSyscall6(trap, nargs, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 ui...
function syscall6 (line 30) | func syscall6(trap, nargs, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintp...
function callgetsystemcfg (line 32) | func callgetsystemcfg(label int) (r1 uintptr, e1 errno) {
FILE: vendor/golang.org/x/sys/cpu/syscall_darwin_x86_gc.go
type _C_int (line 17) | type _C_int
function darwinOSRelease (line 20) | func darwinOSRelease(release *[256]byte) error {
function sysctl (line 38) | func sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen ...
function darwinSysctlEnabled (line 63) | func darwinSysctlEnabled(name []byte) bool {
function sysctlbyname (line 77) | func sysctlbyname(name *byte, old *byte, oldlen *uintptr, new *byte, new...
function syscall_syscall6 (line 96) | func syscall_syscall6(fn, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintpt...
FILE: vendor/golang.org/x/sys/plan9/const_plan9.go
constant O_RDONLY (line 7) | O_RDONLY = 0
constant O_WRONLY (line 8) | O_WRONLY = 1
constant O_RDWR (line 9) | O_RDWR = 2
constant O_TRUNC (line 10) | O_TRUNC = 16
constant O_CLOEXEC (line 11) | O_CLOEXEC = 32
constant O_EXCL (line 12) | O_EXCL = 0x1000
constant RFNAMEG (line 17) | RFNAMEG = 1 << 0
constant RFENVG (line 18) | RFENVG = 1 << 1
constant RFFDG (line 19) | RFFDG = 1 << 2
constant RFNOTEG (line 20) | RFNOTEG = 1 << 3
constant RFPROC (line 21) | RFPROC = 1 << 4
constant RFMEM (line 22) | RFMEM = 1 << 5
constant RFNOWAIT (line 23) | RFNOWAIT = 1 << 6
constant RFCNAMEG (line 24) | RFCNAMEG = 1 << 10
constant RFCENVG (line 25) | RFCENVG = 1 << 11
constant RFCFDG (line 26) | RFCFDG = 1 << 12
constant RFREND (line 27) | RFREND = 1 << 13
constant RFNOMNT (line 28) | RFNOMNT = 1 << 14
constant QTDIR (line 33) | QTDIR = 0x80
constant QTAPPEND (line 34) | QTAPPEND = 0x40
constant QTEXCL (line 35) | QTEXCL = 0x20
constant QTMOUNT (line 36) | QTMOUNT = 0x10
constant QTAUTH (line 37) | QTAUTH = 0x08
constant QTTMP (line 38) | QTTMP = 0x04
constant QTFILE (line 39) | QTFILE = 0x00
constant DMDIR (line 44) | DMDIR = 0x80000000
constant DMAPPEND (line 45) | DMAPPEND = 0x40000000
constant DMEXCL (line 46) | DMEXCL = 0x20000000
constant DMMOUNT (line 47) | DMMOUNT = 0x10000000
constant DMAUTH (line 48) | DMAUTH = 0x08000000
constant DMTMP (line 49) | DMTMP = 0x04000000
constant DMREAD (line 50) | DMREAD = 0x4
constant DMWRITE (line 51) | DMWRITE = 0x2
constant DMEXEC (line 52) | DMEXEC = 0x1
constant STATMAX (line 56) | STATMAX = 65535
constant ERRMAX (line 57) | ERRMAX = 128
constant STATFIXLEN (line 58) | STATFIXLEN = 49
constant MREPL (line 63) | MREPL = 0x0000
constant MBEFORE (line 64) | MBEFORE = 0x0001
constant MAFTER (line 65) | MAFTER = 0x0002
constant MORDER (line 66) | MORDER = 0x0003
constant MCREATE (line 67) | MCREATE = 0x0004
constant MCACHE (line 68) | MCACHE = 0x0010
constant MMASK (line 69) | MMASK = 0x0017
FILE: vendor/golang.org/x/sys/plan9/dir_plan9.go
type Qid (line 18) | type Qid struct
type Dir (line 25) | type Dir struct
method Null (line 58) | func (d *Dir) Null() { *d = nullDir }
method Marshal (line 63) | func (d *Dir) Marshal(b []byte) (n int, err error) {
function UnmarshalDir (line 98) | func UnmarshalDir(b []byte) (*Dir, error) {
function pbit8 (line 139) | func pbit8(b []byte, v uint8) []byte {
function pbit16 (line 145) | func pbit16(b []byte, v uint16) []byte {
function pbit32 (line 152) | func pbit32(b []byte, v uint32) []byte {
function pbit64 (line 161) | func pbit64(b []byte, v uint64) []byte {
function pstring (line 175) | func pstring(b []byte, s string) []byte {
function gbit8 (line 182) | func gbit8(b []byte) (uint8, []byte) {
function gbit16 (line 187) | func gbit16(b []byte) (uint16, []byte) {
function gbit32 (line 192) | func gbit32(b []byte) (uint32, []byte) {
function gbit64 (line 197) | func gbit64(b []byte) (uint64, []byte) {
function gstring (line 206) | func gstring(b []byte) (string, []byte, bool) {
FILE: vendor/golang.org/x/sys/plan9/env_plan9.go
function Getenv (line 13) | func Getenv(key string) (value string, found bool) {
function Setenv (line 17) | func Setenv(key, value string) error {
function Clearenv (line 21) | func Clearenv() {
function Environ (line 25) | func Environ() []string {
function Unsetenv (line 29) | func Unsetenv(key string) error {
FILE: vendor/golang.org/x/sys/plan9/errors_plan9.go
constant O_CREAT (line 12) | O_CREAT = 0x02000
constant O_APPEND (line 13) | O_APPEND = 0x00400
constant O_NOCTTY (line 14) | O_NOCTTY = 0x00000
constant O_NONBLOCK (line 15) | O_NONBLOCK = 0x00000
constant O_SYNC (line 16) | O_SYNC = 0x00000
constant O_ASYNC (line 17) | O_ASYNC = 0x00000
constant S_IFMT (line 19) | S_IFMT = 0x1f000
constant S_IFIFO (line 20) | S_IFIFO = 0x1000
constant S_IFCHR (line 21) | S_IFCHR = 0x2000
constant S_IFDIR (line 22) | S_IFDIR = 0x4000
constant S_IFBLK (line 23) | S_IFBLK = 0x6000
constant S_IFREG (line 24) | S_IFREG = 0x8000
constant S_IFLNK (line 25) | S_IFLNK = 0xa000
constant S_IFSOCK (line 26) | S_IFSOCK = 0xc000
FILE: vendor/golang.org/x/sys/plan9/pwd_plan9.go
function fixwd (line 9) | func fixwd() {
function Getwd (line 13) | func Getwd() (wd string, err error) {
function Chdir (line 17) | func Chdir(path string) error {
FILE: vendor/golang.org/x/sys/plan9/race.go
constant raceenabled (line 14) | raceenabled = true
function raceAcquire (line 16) | func raceAcquire(addr unsafe.Pointer) {
function raceReleaseMerge (line 20) | func raceReleaseMerge(addr unsafe.Pointer) {
function raceReadRange (line 24) | func raceReadRange(addr unsafe.Pointer, len int) {
function raceWriteRange (line 28) | func raceWriteRange(addr unsafe.Pointer, len int) {
FILE: vendor/golang.org/x/sys/plan9/race0.go
constant raceenabled (line 13) | raceenabled = false
function raceAcquire (line 15) | func raceAcquire(addr unsafe.Pointer) {
function raceReleaseMerge (line 18) | func raceReleaseMerge(addr unsafe.Pointer) {
function raceReadRange (line 21) | func raceReadRange(addr unsafe.Pointer, len int) {
function raceWriteRange (line 24) | func raceWriteRange(addr unsafe.Pointer, len int) {
FILE: vendor/golang.org/x/sys/plan9/str.go
function itoa (line 9) | func itoa(val int) string { // do it here rather than with fmt to avoid ...
FILE: vendor/golang.org/x/sys/plan9/syscall.go
function ByteSliceFromString (line 36) | func ByteSliceFromString(s string) ([]byte, error) {
function BytePtrFromString (line 48) | func BytePtrFromString(s string) (*byte, error) {
function ByteSliceToString (line 58) | func ByteSliceToString(s []byte) string {
function BytePtrToString (line 68) | func BytePtrToString(p *byte) string {
method Unix (line 89) | func (ts *Timespec) Unix() (sec int64, nsec int64) {
method Unix (line 93) | func (tv *Timeval) Unix() (sec int64, nsec int64) {
method Nano (line 97) | func (ts *Timespec) Nano() int64 {
method Nano (line 101) | func (tv *Timeval) Nano() int64 {
function use (line 109) | func use(p unsafe.Pointer)
FILE: vendor/golang.org/x/sys/plan9/syscall_plan9.go
type Note (line 22) | type Note
method Signal (line 24) | func (n Note) Signal() {}
method String (line 26) | func (n Note) String() string {
function Syscall (line 40) | func Syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Erro...
function Syscall6 (line 41) | func Syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err...
function RawSyscall (line 42) | func RawSyscall(trap, a1, a2, a3 uintptr) (r1, r2, err uintptr)
function RawSyscall6 (line 43) | func RawSyscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err uint...
function atoi (line 45) | func atoi(b []byte) (n uint) {
function cstring (line 53) | func cstring(s []byte) string {
function errstr (line 61) | func errstr() string {
function exit (line 71) | func exit(code int)
function Exit (line 73) | func Exit(code int) { exit(code) }
function readnum (line 75) | func readnum(path string) (uint, error) {
function Getpid (line 97) | func Getpid() (pid int) {
function Getppid (line 102) | func Getppid() (ppid int) {
function Read (line 107) | func Read(fd int, p []byte) (n int, err error) {
function Write (line 111) | func Write(fd int, p []byte) (n int, err error) {
function Fd2path (line 119) | func Fd2path(fd int) (path string, err error) {
function Pipe (line 131) | func Pipe(p []int) (err error) {
function seek (line 146) | func seek(placeholder uintptr, fd int, offset int64, whence int) (newoff...
function Seek (line 148) | func Seek(fd int, offset int64, whence int) (newoffset int64, err error) {
function Mkdir (line 157) | func Mkdir(path string, mode uint32) (err error) {
type Waitmsg (line 167) | type Waitmsg struct
method Exited (line 173) | func (w Waitmsg) Exited() bool { return true }
method Signaled (line 174) | func (w Waitmsg) Signaled() bool { return false }
method ExitStatus (line 176) | func (w Waitmsg) ExitStatus() int {
function Await (line 186) | func Await(w *Waitmsg) (err error) {
function Unmount (line 223) | func Unmount(name, old string) (err error) {
function Fchdir (line 251) | func Fchdir(fd int) (err error) {
type Timespec (line 261) | type Timespec struct
type Timeval (line 266) | type Timeval struct
function NsecToTimeval (line 271) | func NsecToTimeval(nsec int64) (tv Timeval) {
function nsec (line 278) | func nsec() int64 {
function Gettimeofday (line 289) | func Gettimeofday(tv *Timeval) error {
function Getpagesize (line 295) | func Getpagesize() int { return 0x1000 }
function Getegid (line 297) | func Getegid() (egid int) { return -1 }
function Geteuid (line 298) | func Geteuid() (euid int) { return -1 }
function Getgid (line 299) | func Getgid() (gid int) { return -1 }
function Getuid (line 300) | func Getuid() (uid int) { return -1 }
function Getgroups (line 302) | func Getgroups() (gids []int, err error) {
function Open (line 308) | func Open(path string, mode int) (fd int, err error) {
function Create (line 315) | func Create(path string, mode int, perm uint32) (fd int, err error) {
function Remove (line 322) | func Remove(path string) error {
function Stat (line 329) | func Stat(path string, edir []byte) (n int, err error) {
function Bind (line 336) | func Bind(name string, old string, flag int) (err error) {
function Mount (line 343) | func Mount(fd int, afd int, old string, flag int, aname string) (err err...
function Wstat (line 350) | func Wstat(path string, edir []byte) (err error) {
FILE: vendor/golang.org/x/sys/plan9/zsyscall_plan9_386.go
function fd2path (line 12) | func fd2path(fd int, buf []byte) (err error) {
function pipe (line 28) | func pipe(p *[2]int32) (err error) {
function await (line 38) | func await(s []byte) (n int, err error) {
function open (line 55) | func open(path string, mode int) (fd int, err error) {
function create (line 71) | func create(path string, mode int, perm uint32) (fd int, err error) {
function remove (line 87) | func remove(path string) (err error) {
function stat (line 102) | func stat(path string, edir []byte) (n int, err error) {
function bind (line 124) | func bind(name string, old string, flag int) (err error) {
function mount (line 144) | func mount(fd int, afd int, old string, flag int, aname string) (err err...
function wstat (line 164) | func wstat(path string, edir []byte) (err error) {
function chdir (line 185) | func chdir(path string) (err error) {
function Dup (line 200) | func Dup(oldfd int, newfd int) (fd int, err error) {
function Pread (line 211) | func Pread(fd int, p []byte, offset int64) (n int, err error) {
function Pwrite (line 228) | func Pwrite(fd int, p []byte, offset int64) (n int, err error) {
function Close (line 245) | func Close(fd int) (err error) {
function Fstat (line 255) | func Fstat(fd int, edir []byte) (n int, err error) {
function Fwstat (line 272) | func Fwstat(fd int, edir []byte) (err error) {
FILE: vendor/golang.org/x/sys/plan9/zsyscall_plan9_amd64.go
function fd2path (line 12) | func fd2path(fd int, buf []byte) (err error) {
function pipe (line 28) | func pipe(p *[2]int32) (err error) {
function await (line 38) | func await(s []byte) (n int, err error) {
function open (line 55) | func open(path string, mode int) (fd int, err error) {
function create (line 71) | func create(path string, mode int, perm uint32) (fd int, err error) {
function remove (line 87) | func remove(path string) (err error) {
function stat (line 102) | func stat(path string, edir []byte) (n int, err error) {
function bind (line 124) | func bind(name string, old string, flag int) (err error) {
function mount (line 144) | func mount(fd int, afd int, old string, flag int, aname string) (err err...
function wstat (line 164) | func wstat(path string, edir []byte) (err error) {
function chdir (line 185) | func chdir(path string) (err error) {
function Dup (line 200) | func Dup(oldfd int, newfd int) (fd int, err error) {
function Pread (line 211) | func Pread(fd int, p []byte, offset int64) (n int, err error) {
function Pwrite (line 228) | func Pwrite(fd int, p []byte, offset int64) (n int, err error) {
function Close (line 245) | func Close(fd int) (err error) {
function Fstat (line 255) | func Fstat(fd int, edir []byte) (n int, err error) {
function Fwstat (line 272) | func Fwstat(fd int, edir []byte) (err error) {
FILE: vendor/golang.org/x/sys/plan9/zsyscall_plan9_arm.go
function fd2path (line 12) | func fd2path(fd int, buf []byte) (err error) {
function pipe (line 28) | func pipe(p *[2]int32) (err error) {
function await (line 38) | func await(s []byte) (n int, err error) {
function open (line 55) | func open(path string, mode int) (fd int, err error) {
function create (line 71) | func create(path string, mode int, perm uint32) (fd int, err error) {
function remove (line 87) | func remove(path string) (err error) {
function stat (line 102) | func stat(path string, edir []byte) (n int, err error) {
function bind (line 124) | func bind(name string, old string, flag int) (err error) {
function mount (line 144) | func mount(fd int, afd int, old string, flag int, aname string) (err err...
function wstat (line 164) | func wstat(path string, edir []byte) (err error) {
function chdir (line 185) | func chdir(path string) (err error) {
function Dup (line 200) | func Dup(oldfd int, newfd int) (fd int, err error) {
function Pread (line 211) | func Pread(fd int, p []byte, offset int64) (n int, err error) {
function Pwrite (line 228) | func Pwrite(fd int, p []byte, offset int64) (n int, err error) {
function Close (line 245) | func Close(fd int) (err error) {
function Fstat (line 255) | func Fstat(fd int, edir []byte) (n int, err error) {
function Fwstat (line 272) | func Fwstat(fd int, edir []byte) (err error) {
FILE: vendor/golang.org/x/sys/plan9/zsysnum_plan9.go
constant SYS_SYSR1 (line 7) | SYS_SYSR1 = 0
constant SYS_BIND (line 8) | SYS_BIND = 2
constant SYS_CHDIR (line 9) | SYS_CHDIR = 3
constant SYS_CLOSE (line 10) | SYS_CLOSE = 4
constant SYS_DUP (line 11) | SYS_DUP = 5
constant SYS_ALARM (line 12) | SYS_ALARM = 6
constant SYS_EXEC (line 13) | SYS_EXEC = 7
constant SYS_EXITS (line 14) | SYS_EXITS = 8
constant SYS_FAUTH (line 15) | SYS_FAUTH = 10
constant SYS_SEGBRK (line 16) | SYS_SEGBRK = 12
constant SYS_OPEN (line 17) | SYS_OPEN = 14
constant SYS_OSEEK (line 18) | SYS_OSEEK = 16
constant SYS_SLEEP (line 19) | SYS_SLEEP = 17
constant SYS_RFORK (line 20) | SYS_RFORK = 19
constant SYS_PIPE (line 21) | SYS_PIPE = 21
constant SYS_CREATE (line 22) | SYS_CREATE = 22
constant SYS_FD2PATH (line 23) | SYS_FD2PATH = 23
constant SYS_BRK_ (line 24) | SYS_BRK_ = 24
constant SYS_REMOVE (line 25) | SYS_REMOVE = 25
constant SYS_NOTIFY (line 26) | SYS_NOTIFY = 28
constant SYS_NOTED (line 27) | SYS_NOTED = 29
constant SYS_SEGATTACH (line 28) | SYS_SEGATTACH = 30
constant SYS_SEGDETACH (line 29) | SYS_SEGDETACH = 31
constant SYS_SEGFREE (line 30) | SYS_SEGFREE = 32
constant SYS_SEGFLUSH (line 31) | SYS_SEGFLUSH = 33
constant SYS_RENDEZVOUS (line 32) | SYS_RENDEZVOUS = 34
constant SYS_UNMOUNT (line 33) | SYS_UNMOUNT = 35
constant SYS_SEMACQUIRE (line 34) | SYS_SEMACQUIRE = 37
constant SYS_SEMRELEASE (line 35) | SYS_SEMRELEASE = 38
constant SYS_SEEK (line 36) | SYS_SEEK = 39
constant SYS_FVERSION (line 37) | SYS_FVERSION = 40
constant SYS_ERRSTR (line 38) | SYS_ERRSTR = 41
constant SYS_STAT (line 39) | SYS_STAT = 42
constant SYS_FSTAT (line 40) | SYS_FSTAT = 43
constant SYS_WSTAT (line 41) | SYS_WSTAT = 44
constant SYS_FWSTAT (line 42) | SYS_FWSTAT = 45
constant SYS_MOUNT (line 43) | SYS_MOUNT = 46
constant SYS_AWAIT (line 44) | SYS_AWAIT = 47
constant SYS_PREAD (line 45) | SYS_PREAD = 50
constant SYS_PWRITE (line 46) | SYS_PWRITE = 51
constant SYS_TSEMACQUIRE (line 47) | SYS_TSEMACQUIRE = 52
constant SYS_NSEC (line 48) | SYS_NSEC = 53
FILE: vendor/golang.org/x/sys/unix/affinity_linux.go
constant cpuSetSize (line 14) | cpuSetSize = _CPU_SETSIZE / _NCPUBITS
type CPUSet (line 17) | type CPUSet
method Zero (line 40) | func (s *CPUSet) Zero() {
method Fill (line 47) | func (s *CPUSet) Fill() {
method Set (line 62) | func (s *CPUSet) Set(cpu int) {
method Clear (line 70) | func (s *CPUSet) Clear(cpu int) {
method IsSet (line 78) | func (s *CPUSet) IsSet(cpu int) bool {
method Count (line 87) | func (s *CPUSet) Count() int {
function schedAffinity (line 19) | func schedAffinity(trap uintptr, pid int, set *CPUSet) error {
function SchedGetaffinity (line 29) | func SchedGetaffinity(pid int, set *CPUSet) error {
function SchedSetaffinity (line 35) | func SchedSetaffinity(pid int, set *CPUSet) error {
function cpuBitsIndex (line 53) | func cpuBitsIndex(cpu int) int {
function cpuBitsMask (line 57) | func cpuBitsMask(cpu int) cpuMask {
FILE: vendor/golang.org/x/sys/unix/auxv.go
function runtime_getAuxv (line 15) | func runtime_getAuxv() []uintptr
function Auxv (line 21) | func Auxv() ([][2]uintptr, error) {
FILE: vendor/golang.org/x/sys/unix/auxv_unsupported.go
function Auxv (line 11) | func Auxv() ([][2]uintptr, error) {
FILE: vendor/golang.org/x/sys/unix/bluetooth_linux.go
constant BTPROTO_L2CAP (line 11) | BTPROTO_L2CAP = 0
constant BTPROTO_HCI (line 12) | BTPROTO_HCI = 1
constant BTPROTO_SCO (line 13) | BTPROTO_SCO = 2
constant BTPROTO_RFCOMM (line 14) | BTPROTO_RFCOMM = 3
constant BTPROTO_BNEP (line 15) | BTPROTO_BNEP = 4
constant BTPROTO_CMTP (line 16) | BTPROTO_CMTP = 5
constant BTPROTO_HIDP (line 17) | BTPROTO_HIDP = 6
constant BTPROTO_AVDTP (line 18) | BTPROTO_AVDTP = 7
constant HCI_CHANNEL_RAW (line 22) | HCI_CHANNEL_RAW = 0
constant HCI_CHANNEL_USER (line 23) | HCI_CHANNEL_USER = 1
constant HCI_CHANNEL_MONITOR (line 24) | HCI_CHANNEL_MONITOR = 2
constant HCI_CHANNEL_CONTROL (line 25) | HCI_CHANNEL_CONTROL = 3
constant HCI_CHANNEL_LOGGING (line 26) | HCI_CHANNEL_LOGGING = 4
constant SOL_BLUETOOTH (line 31) | SOL_BLUETOOTH = 0x112
constant SOL_HCI (line 32) | SOL_HCI = 0x0
constant SOL_L2CAP (line 33) | SOL_L2CAP = 0x6
constant SOL_RFCOMM (line 34) | SOL_RFCOMM = 0x12
constant SOL_SCO (line 35) | SOL_SCO = 0x11
FILE: vendor/golang.org/x/sys/unix/bpxsvc_zos.go
function bpxcall (line 16) | func bpxcall(plist []unsafe.Pointer, bpx_offset int64)
function A2e (line 19) | func A2e([]byte)
function E2a (line 22) | func E2a([]byte)
constant BPX4STA (line 25) | BPX4STA = 192
constant BPX4FST (line 26) | BPX4FST = 104
constant BPX4LST (line 27) | BPX4LST = 132
constant BPX4OPN (line 28) | BPX4OPN = 156
constant BPX4CLO (line 29) | BPX4CLO = 72
constant BPX4CHR (line 30) | BPX4CHR = 500
constant BPX4FCR (line 31) | BPX4FCR = 504
constant BPX4LCR (line 32) | BPX4LCR = 1180
constant BPX4CTW (line 33) | BPX4CTW = 492
constant BPX4GTH (line 34) | BPX4GTH = 1056
constant BPX4PTQ (line 35) | BPX4PTQ = 412
constant BPX4PTR (line 36) | BPX4PTR = 320
constant BPX_OPNFHIGH (line 42) | BPX_OPNFHIGH = 0x80
constant BPX_OPNFEXEC (line 44) | BPX_OPNFEXEC = 0x80
constant BPX_O_NOLARGEFILE (line 46) | BPX_O_NOLARGEFILE = 0x08
constant BPX_O_LARGEFILE (line 47) | BPX_O_LARGEFILE = 0x04
constant BPX_O_ASYNCSIG (line 48) | BPX_O_ASYNCSIG = 0x02
constant BPX_O_SYNC (line 49) | BPX_O_SYNC = 0x01
constant BPX_O_CREXCL (line 51) | BPX_O_CREXCL = 0xc0
constant BPX_O_CREAT (line 52) | BPX_O_CREAT = 0x80
constant BPX_O_EXCL (line 53) | BPX_O_EXCL = 0x40
constant BPX_O_NOCTTY (line 54) | BPX_O_NOCTTY = 0x20
constant BPX_O_TRUNC (line 55) | BPX_O_TRUNC = 0x10
constant BPX_O_APPEND (line 56) | BPX_O_APPEND = 0x08
constant BPX_O_NONBLOCK (line 57) | BPX_O_NONBLOCK = 0x04
constant BPX_FNDELAY (line 58) | BPX_FNDELAY = 0x04
constant BPX_O_RDWR (line 59) | BPX_O_RDWR = 0x03
constant BPX_O_RDONLY (line 60) | BPX_O_RDONLY = 0x02
constant BPX_O_WRONLY (line 61) | BPX_O_WRONLY = 0x01
constant BPX_O_ACCMODE (line 62) | BPX_O_ACCMODE = 0x03
constant BPX_O_GETFL (line 63) | BPX_O_GETFL = 0x0f
constant BPX_FT_DIR (line 67) | BPX_FT_DIR = 1
constant BPX_FT_CHARSPEC (line 68) | BPX_FT_CHARSPEC = 2
constant BPX_FT_REGFILE (line 69) | BPX_FT_REGFILE = 3
constant BPX_FT_FIFO (line 70) | BPX_FT_FIFO = 4
constant BPX_FT_SYMLINK (line 71) | BPX_FT_SYMLINK = 5
constant BPX_FT_SOCKET (line 72) | BPX_FT_SOCKET = 6
constant BPX_S_ISUID (line 74) | BPX_S_ISUID = 0x08
constant BPX_S_ISGID (line 75) | BPX_S_ISGID = 0x04
constant BPX_S_ISVTX (line 76) | BPX_S_ISVTX = 0x02
constant BPX_S_IRWXU1 (line 77) | BPX_S_IRWXU1 = 0x01
constant BPX_S_IRUSR (line 78) | BPX_S_IRUSR = 0x01
constant BPX_S_IRWXU2 (line 80) | BPX_S_IRWXU2 = 0xc0
constant BPX_S_IWUSR (line 81) | BPX_S_IWUSR = 0x80
constant BPX_S_IXUSR (line 82) | BPX_S_IXUSR = 0x40
constant BPX_S_IRWXG (line 83) | BPX_S_IRWXG = 0x38
constant BPX_S_IRGRP (line 84) | BPX_S_IRGRP = 0x20
constant BPX_S_IWGRP (line 85) | BPX_S_IWGRP = 0x10
constant BPX_S_IXGRP (line 86) | BPX_S_IXGRP = 0x08
constant BPX_S_IRWXOX (line 87) | BPX_S_IRWXOX = 0x07
constant BPX_S_IROTH (line 88) | BPX_S_IROTH = 0x04
constant BPX_S_IWOTH (line 89) | BPX_S_IWOTH = 0x02
constant BPX_S_IXOTH (line 90) | BPX_S_IXOTH = 0x01
constant CW_INTRPT (line 92) | CW_INTRPT = 1
constant CW_CONDVAR (line 93) | CW_CONDVAR = 32
constant CW_TIMEOUT (line 94) | CW_TIMEOUT = 64
constant PGTHA_NEXT (line 96) | PGTHA_NEXT = 2
constant PGTHA_CURRENT (line 97) | PGTHA_CURRENT = 1
constant PGTHA_FIRST (line 98) | PGTHA_FIRST = 0
constant PGTHA_LAST (line 99) | PGTHA_LAST = 3
constant PGTHA_PROCESS (line 100) | PGTHA_PROCESS = 0x80
constant PGTHA_CONTTY (line 101) | PGTHA_CONTTY = 0x40
constant PGTHA_PATH (line 102) | PGTHA_PATH = 0x20
constant PGTHA_COMMAND (line 103) | PGTHA_COMMAND = 0x10
constant PGTHA_FILEDATA (line 104) | PGTHA_FILEDATA = 0x08
constant PGTHA_THREAD (line 105) | PGTHA_THREAD = 0x04
constant PGTHA_PTAG (line 106) | PGTHA_PTAG = 0x02
constant PGTHA_COMMANDLONG (line 107) | PGTHA_COMMANDLONG = 0x01
constant PGTHA_THREADFAST (line 108) | PGTHA_THREADFAST = 0x80
constant PGTHA_FILEPATH (line 109) | PGTHA_FILEPATH = 0x40
constant PGTHA_THDSIGMASK (line 110) | PGTHA_THDSIGMASK = 0x20
constant QUIESCE_TERM (line 112) | QUIESCE_TERM int32 = 1
constant QUIESCE_FORCE (line 113) | QUIESCE_FORCE int32 = 2
constant QUIESCE_QUERY (line 114) | QUIESCE_QUERY int32 = 3
constant QUIESCE_FREEZE (line 115) | QUIESCE_FREEZE int32 = 4
constant QUIESCE_UNFREEZE (line 116) | QUIESCE_UNFREEZE int32 = 5
constant FREEZE_THIS_THREAD (line 117) | FREEZE_THIS_THREAD int32 = 6
constant FREEZE_EXIT (line 118) | FREEZE_EXIT int32 = 8
constant QUIESCE_SRB (line 119) | QUIESCE_SRB int32 = 9
type Pgtha (line 122) | type Pgtha struct
type Bpxystat_t (line 134) | type Bpxystat_t struct
type BpxFilestatus (line 182) | type BpxFilestatus struct
type BpxMode (line 189) | type BpxMode struct
type Bpxyatt_t (line 197) | type Bpxyatt_t struct
function BpxOpen (line 235) | func BpxOpen(name string, options *BpxFilestatus, mode *BpxMode) (rv int...
function BpxClose (line 254) | func BpxClose(fd int32) (rv int32, rc int32, rn int32) {
function BpxFileFStat (line 264) | func BpxFileFStat(fd int32, st *Bpxystat_t) (rv int32, rc int32, rn int3...
function BpxFileStat (line 279) | func BpxFileStat(name string, st *Bpxystat_t) (rv int32, rc int32, rn in...
function BpxFileLStat (line 301) | func BpxFileLStat(name string, st *Bpxystat_t) (rv int32, rc int32, rn i...
function BpxChattr (line 323) | func BpxChattr(path string, attr *Bpxyatt_t) (rv int32, rc int32, rn int...
function BpxLchattr (line 343) | func BpxLchattr(path string, attr *Bpxyatt_t) (rv int32, rc int32, rn in...
function BpxFchattr (line 363) | func BpxFchattr(fd int32, attr *Bpxyatt_t) (rv int32, rc int32, rn int32) {
function BpxCondTimedWait (line 376) | func BpxCondTimedWait(sec uint32, nsec uint32, events uint32, secrem *ui...
function BpxGetthent (line 389) | func BpxGetthent(in *Pgtha, outlen *uint32, out unsafe.Pointer) (rv int3...
function ZosJobname (line 402) | func ZosJobname() (jobname string, err error) {
function Bpx4ptq (line 427) | func Bpx4ptq(code int32, data string) (rv int32, rc int32, rn int32) {
constant PT_TRACE_ME (line 442) | PT_TRACE_ME = 0
constant PT_READ_I (line 443) | PT_READ_I = 1
constant PT_READ_D (line 444) | PT_READ_D = 2
constant PT_READ_U (line 445) | PT_READ_U = 3
constant PT_WRITE_I (line 446) | PT_WRITE_I = 4
constant PT_WRITE_D (line 447) | PT_WRITE_D = 5
constant PT_CONTINUE (line 448) | PT_CONTINUE = 7
constant PT_KILL (line 449) | PT_KILL = 8
constant PT_READ_GPR (line 450) | PT_READ_GPR = 11
constant PT_READ_FPR (line 451) | PT_READ_FPR = 12
constant PT_READ_VR (line 452) | PT_READ_VR = 13
constant PT_WRITE_GPR (line 453) | PT_WRITE_GPR = 14
constant PT_WRITE_FPR (line 454) | PT_WRITE_FPR = 15
constant PT_WRITE_VR (line 455) | PT_WRITE_VR = 16
constant PT_READ_BLOCK (line 456) | PT_READ_BLOCK = 17
constant PT_WRITE_BLOCK (line 457) | PT_WRITE_BLOCK = 19
constant PT_READ_GPRH (line 458) | PT_READ_GPRH = 20
constant PT_WRITE_GPRH (line 459) | PT_WRITE_GPRH = 21
constant PT_REGHSET (line 460) | PT_REGHSET = 22
constant PT_ATTACH (line 461) | PT_ATTACH = 30
constant PT_DETACH (line 462) | PT_DETACH = 31
constant PT_REGSET (line 463) | PT_REGSET = 32
constant PT_REATTACH (line 464) | PT_REATTACH = 33
constant PT_LDINFO (line 465) | PT_LDINFO = 34
constant PT_MULTI (line 466) | PT_MULTI = 35
constant PT_LD64INFO (line 467) | PT_LD64INFO = 36
constant PT_BLOCKREQ (line 468) | PT_BLOCKREQ = 40
constant PT_THREAD_INFO (line 469) | PT_THREAD_INFO = 60
constant PT_THREAD_MODIFY (line 470) | PT_THREAD_MODIFY = 61
constant PT_THREAD_READ_FOCUS (line 471) | PT_THREAD_READ_FOCUS = 62
constant PT_THREAD_WRITE_FOCUS (line 472) | PT_THREAD_WRITE_FOCUS = 63
constant PT_THREAD_HOLD (line 473) | PT_THREAD_HOLD = 64
constant PT_THREAD_SIGNAL (line 474) | PT_THREAD_SIGNAL = 65
constant PT_EXPLAIN (line 475) | PT_EXPLAIN = 66
constant PT_EVENTS (line 476) | PT_EVENTS = 67
constant PT_THREAD_INFO_EXTENDED (line 477) | PT_THREAD_INFO_EXTENDED = 68
constant PT_REATTACH2 (line 478) | PT_REATTACH2 = 71
constant PT_CAPTURE (line 479) | PT_CAPTURE = 72
constant PT_UNCAPTURE (line 480) | PT_UNCAPTURE = 73
constant PT_GET_THREAD_TCB (line 481) | PT_GET_THREAD_TCB = 74
constant PT_GET_ALET (line 482) | PT_GET_ALET = 75
constant PT_SWAPIN (line 483) | PT_SWAPIN = 76
constant PT_EXTENDED_EVENT (line 484) | PT_EXTENDED_EVENT = 98
constant PT_RECOVER (line 485) | PT_RECOVER = 99
constant PT_GPR0 (line 486) | PT_GPR0 = 0
constant PT_GPR1 (line 487) | PT_GPR1 = 1
constant PT_GPR2 (line 488) | PT_GPR2 = 2
constant PT_GPR3 (line 489) | PT_GPR3 = 3
constant PT_GPR4 (line 490) | PT_GPR4 = 4
constant PT_GPR5 (line 491) | PT_GPR5 = 5
constant PT_GPR6 (line 492) | PT_GPR6 = 6
constant PT_GPR7 (line 493) | PT_GPR7 = 7
constant PT_GPR8 (line 494) | PT_GPR8 = 8
constant PT_GPR9 (line 495) | PT_GPR9 = 9
constant PT_GPR10 (line 496) | PT_GPR10 = 10
constant PT_GPR11 (line 497) | PT_GPR11 = 11
constant PT_GPR12 (line 498) | PT_GPR12 = 12
constant PT_GPR13 (line 499) | PT_GPR13 = 13
constant PT_GPR14 (line 500) | PT_GPR14 = 14
constant PT_GPR15 (line 501) | PT_GPR15 = 15
constant PT_FPR0 (line 502) | PT_FPR0 = 16
constant PT_FPR1 (line 503) | PT_FPR1 = 17
constant PT_FPR2 (line 504) | PT_FPR2 = 18
constant PT_FPR3 (line 505) | PT_FPR3 = 19
constant PT_FPR4 (line 506) | PT_FPR4 = 20
constant PT_FPR5 (line 507) | PT_FPR5 = 21
constant PT_FPR6 (line 508) | PT_FPR6 = 22
constant PT_FPR7 (line 509) | PT_FPR7 = 23
constant PT_FPR8 (line 510) | PT_FPR8 = 24
constant PT_FPR9 (line 511) | PT_FPR9 = 25
constant PT_FPR10 (line 512) | PT_FPR10 = 26
constant PT_FPR11 (line 513) | PT_FPR11 = 27
constant PT_FPR12 (line 514) | PT_FPR12 = 28
constant PT_FPR13 (line 515) | PT_FPR13 = 29
constant PT_FPR14 (line 516) | PT_FPR14 = 30
constant PT_FPR15 (line 517) | PT_FPR15 = 31
constant PT_FPC (line 518) | PT_FPC = 32
constant PT_PSW (line 519) | PT_PSW = 40
constant PT_PSW0 (line 520) | PT_PSW0 = 40
constant PT_PSW1 (line 521) | PT_PSW1 = 41
constant PT_CR0 (line 522) | PT_CR0 = 42
constant PT_CR1 (line 523) | PT_CR1 = 43
constant PT_CR2 (line 524) | PT_CR2 = 44
constant PT_CR3 (line 525) | PT_CR3 = 45
constant PT_CR4 (line 526) | PT_CR4 = 46
constant PT_CR5 (line 527) | PT_CR5 = 47
constant PT_CR6 (line 528) | PT_CR6 = 48
constant PT_CR7 (line 529) | PT_CR7 = 49
constant PT_CR8 (line 530) | PT_CR8 = 50
constant PT_CR9 (line 531) | PT_CR9 = 51
constant PT_CR10 (line 532) | PT_CR10 = 52
constant PT_CR11 (line 533) | PT_CR11 = 53
constant PT_CR12 (line 534) | PT_CR12 = 54
constant PT_CR13 (line 535) | PT_CR13 = 55
constant PT_CR14 (line 536) | PT_CR14 = 56
constant PT_CR15 (line 537) | PT_CR15 = 57
constant PT_GPRH0 (line 538) | PT_GPRH0 = 58
constant PT_GPRH1 (line 539) | PT_GPRH1 = 59
constant PT_GPRH2 (line 540) | PT_GPRH2 = 60
constant PT_GPRH3 (line 541) | PT_GPRH3 = 61
constant PT_GPRH4 (line 542) | PT_GPRH4 = 62
constant PT_GPRH5 (line 543) | PT_GPRH5 = 63
constant PT_GPRH6 (line 544) | PT_GPRH6 = 64
constant PT_GPRH7 (line 545) | PT_GPRH7 = 65
constant PT_GPRH8 (line 546) | PT_GPRH8 = 66
constant PT_GPRH9 (line 547) | PT_GPRH9 = 67
constant PT_GPRH10 (line 548) | PT_GPRH10 = 68
constant PT_GPRH11 (line 549) | PT_GPRH11 = 69
constant PT_GPRH12 (line 550) | PT_GPRH12 = 70
constant PT_GPRH13 (line 551) | PT_GPRH13 = 71
constant PT_GPRH14 (line 552) | PT_GPRH14 = 72
constant PT_GPRH15 (line 553) | PT_GPRH15 = 73
constant PT_VR0 (line 554) | PT_VR0 = 74
constant PT_VR1 (line 555) | PT_VR1 = 75
constant PT_VR2 (line 556) | PT_VR2 = 76
constant PT_VR3 (line 557) | PT_VR3 = 77
constant PT_VR4 (line 558) | PT_VR4 = 78
constant PT_VR5 (line 559) | PT_VR5 = 79
constant PT_VR6 (line 560) | PT_VR6 = 80
constant PT_VR7 (line 561) | PT_VR7 = 81
constant PT_VR8 (line 562) | PT_VR8 = 82
constant PT_VR9 (line 563) | PT_VR9 = 83
constant PT_VR10 (line 564) | PT_VR10 = 84
constant PT_VR11 (line 565) | PT_VR11 = 85
constant PT_VR12 (line 566) | PT_VR12 = 86
constant PT_VR13 (line 567) | PT_VR13 = 87
constant PT_VR14 (line 568) | PT_VR14 = 88
constant PT_VR15 (line 569) | PT_VR15 = 89
constant PT_VR16 (line 570) | PT_VR16 = 90
constant PT_VR17 (line 571) | PT_VR17 = 91
constant PT_VR18 (line 572) | PT_VR18 = 92
constant PT_VR19 (line 573) | PT_VR19 = 93
constant PT_VR20 (line 574) | PT_VR20 = 94
constant PT_VR21 (line 575) | PT_VR21 = 95
constant PT_VR22 (line 576) | PT_VR22 = 96
constant PT_VR23 (line 577) | PT_VR23 = 97
constant PT_VR24 (line 578) | PT_VR24 = 98
constant PT_VR25 (line 579) | PT_VR25 = 99
constant PT_VR26 (line 580) | PT_VR26 = 100
constant PT_VR27 (line 581) | PT_VR27 = 101
constant PT_VR28 (line 582) | PT_VR28 = 102
constant PT_VR29 (line 583) | PT_VR29 = 103
constant PT_VR30 (line 584) | PT_VR30 = 104
constant PT_VR31 (line 585) | PT_VR31 = 105
constant PT_PSWG (line 586) | PT_PSWG = 106
constant PT_PSWG0 (line 587) | PT_PSWG0 = 106
constant PT_PSWG1 (line 588) | PT_PSWG1 = 107
constant PT_PSWG2 (line 589) | PT_PSWG2 = 108
constant PT_PSWG3 (line 590) | PT_PSWG3 = 109
function Bpx4ptr (line 593) | func Bpx4ptr(request int32, pid int32, addr unsafe.Pointer, data unsafe....
function copyU8 (line 607) | func copyU8(val uint8, dest []uint8) int {
function copyU8Arr (line 615) | func copyU8Arr(src, dest []uint8) int {
function copyU16 (line 625) | func copyU16(val uint16, dest []uint16) int {
function copyU32 (line 633) | func copyU32(val uint32, dest []uint32) int {
function copyU32Arr (line 641) | func copyU32Arr(src, dest []uint32) int {
function copyU64 (line 651) | func copyU64(val uint64, dest []uint64) int {
FILE: vendor/golang.org/x/sys/unix/cap_freebsd.go
constant capRightsGoVersion (line 18) | capRightsGoVersion = CAP_RIGHTS_VERSION_00
constant capArSizeMin (line 19) | capArSizeMin = CAP_RIGHTS_VERSION_00 + 2
constant capArSizeMax (line 20) | capArSizeMax = capRightsGoVersion + 2
function capidxbit (line 30) | func capidxbit(right uint64) int {
function rightToIndex (line 34) | func rightToIndex(right uint64) (int, error) {
function caprver (line 42) | func caprver(right uint64) int {
function capver (line 46) | func capver(rights *CapRights) int {
function caparsize (line 50) | func caparsize(rights *CapRights) int {
function CapRightsSet (line 55) | func CapRightsSet(rights *CapRights, setrights []uint64) error {
function CapRightsClear (line 90) | func CapRightsClear(rights *CapRights, clearrights []uint64) error {
function CapRightsIsSet (line 125) | func CapRightsIsSet(rights *CapRights, setrights []uint64) (bool, error) {
function capright (line 158) | func capright(idx uint64, bit uint64) uint64 {
function CapRightsInit (line 164) | func CapRightsInit(rights []uint64) (*CapRights, error) {
function CapRightsLimit (line 179) | func CapRightsLimit(fd uintptr, rights *CapRights) error {
function CapRightsGet (line 185) | func CapRightsGet(fd uintptr) (*CapRights, error) {
FILE: vendor/golang.org/x/sys/unix/constants.go
constant R_OK (line 10) | R_OK = 0x4
constant W_OK (line 11) | W_OK = 0x2
constant X_OK (line 12) | X_OK = 0x1
FILE: vendor/golang.org/x/sys/unix/dev_aix_ppc.go
function Major (line 13) | func Major(dev uint64) uint32 {
function Minor (line 18) | func Minor(dev uint64) uint32 {
function Mkdev (line 24) | func Mkdev(major, minor uint32) uint64 {
FILE: vendor/golang.org/x/sys/unix/dev_aix_ppc64.go
function Major (line 13) | func Major(dev uint64) uint32 {
function Minor (line 18) | func Minor(dev uint64) uint32 {
function Mkdev (line 24) | func Mkdev(major, minor uint32) uint64 {
FILE: vendor/golang.org/x/sys/unix/dev_darwin.go
function Major (line 11) | func Major(dev uint64) uint32 {
function Minor (line 16) | func Minor(dev uint64) uint32 {
function Mkdev (line 22) | func Mkdev(major, minor uint32) uint64 {
FILE: vendor/golang.org/x/sys/unix/dev_dragonfly.go
function Major (line 17) | func Major(dev uint64) uint32 {
function Minor (line 22) | func Minor(dev uint64) uint32 {
function Mkdev (line 28) | func Mkdev(major, minor uint32) uint64 {
FILE: vendor/golang.org/x/sys/unix/dev_freebsd.go
function Major (line 17) | func Major(dev uint64) uint32 {
function Minor (line 22) | func Minor(dev uint64) uint32 {
function Mkdev (line 28) | func Mkdev(major, minor uint32) uint64 {
FILE: vendor/golang.org/x/sys/unix/dev_linux.go
function Major (line 21) | func Major(dev uint64) uint32 {
function Minor (line 28) | func Minor(dev uint64) uint32 {
function Mkdev (line 36) | func Mkdev(major, minor uint32) uint64 {
FILE: vendor/golang.org/x/sys/unix/dev_netbsd.go
function Major (line 11) | func Major(dev uint64) uint32 {
function Minor (line 16) | func Minor(dev uint64) uint32 {
function Mkdev (line 24) | func Mkdev(major, minor uint32) uint64 {
FILE: vendor/golang.org/x/sys/unix/dev_openbsd.go
function Major (line 11) | func Major(dev uint64) uint32 {
function Minor (line 16) | func Minor(dev uint64) uint32 {
function Mkdev (line 24) | func Mkdev(major, minor uint32) uint64 {
FILE: vendor/golang.org/x/sys/unix/dev_zos.go
function Major (line 15) | func Major(dev uint64) uint32 {
function Minor (line 20) | func Minor(dev uint64) uint32 {
function Mkdev (line 26) | func Mkdev(major, minor uint32) uint64 {
FILE: vendor/golang.org/x/sys/unix/dirent.go
function readInt (line 12) | func readInt(b []byte, off, size uintptr) (u uint64, ok bool) {
function readIntBE (line 22) | func readIntBE(b []byte, size uintptr) uint64 {
function readIntLE (line 41) | func readIntLE(b []byte, size uintptr) uint64 {
function ParseDirent (line 64) | func ParseDirent(buf []byte, max int, names []string) (consumed int, cou...
FILE: vendor/golang.org/x/sys/unix/endian_big.go
constant isBigEndian (line 9) | isBigEndian = true
FILE: vendor/golang.org/x/sys/unix/endian_little.go
constant isBigEndian (line 9) | isBigEndian = false
FILE: vendor/golang.org/x/sys/unix/env_unix.go
function Getenv (line 13) | func Getenv(key string) (value string, found bool) {
function Setenv (line 17) | func Setenv(key, value string) error {
function Clearenv (line 21) | func Clearenv() {
function Environ (line 25) | func Environ() []string {
function Unsetenv (line 29) | func Unsetenv(key string) error {
FILE: vendor/golang.org/x/sys/unix/fcntl.go
function fcntl (line 15) | func fcntl(fd int, cmd, arg int) (int, error) {
function FcntlInt (line 25) | func FcntlInt(fd uintptr, cmd, arg int) (int, error) {
function FcntlFlock (line 30) | func FcntlFlock(fd uintptr, cmd int, lk *Flock_t) error {
FILE: vendor/golang.org/x/sys/unix/fcntl_darwin.go
function FcntlInt (line 10) | func FcntlInt(fd uintptr, cmd, arg int) (int, error) {
function FcntlFlock (line 15) | func FcntlFlock(fd uintptr, cmd int, lk *Flock_t) error {
function FcntlFstore (line 21) | func FcntlFstore(fd uintptr, cmd int, fstore *Fstore_t) error {
FILE: vendor/golang.org/x/sys/unix/fcntl_linux_32bit.go
function init (line 9) | func init() {
FILE: vendor/golang.org/x/sys/unix/fdset.go
method Set (line 10) | func (fds *FdSet) Set(fd int) {
method Clear (line 15) | func (fds *FdSet) Clear(fd int) {
method IsSet (line 20) | func (fds *FdSet) IsSet(fd int) bool {
method Zero (line 25) | func (fds *FdSet) Zero() {
FILE: vendor/golang.org/x/sys/unix/gccgo.go
function realSyscallNoError (line 14) | func realSyscallNoError(trap, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr...
function realSyscall (line 16) | func realSyscall(trap, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r, e...
function SyscallNoError (line 18) | func SyscallNoError(trap, a1, a2, a3 uintptr) (r1, r2 uintptr) {
function Syscall (line 25) | func Syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errn...
function Syscall6 (line 32) | func Syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err...
function Syscall9 (line 39) | func Syscall9(trap, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 ...
function RawSyscallNoError (line 46) | func RawSyscallNoError(trap, a1, a2, a3 uintptr) (r1, r2 uintptr) {
function RawSyscall (line 51) | func RawSyscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.E...
function RawSyscall6 (line 56) | func RawSyscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, ...
FILE: vendor/golang.org/x/sys/unix/gccgo_c.c
type ret (line 18) | struct ret {
type ret (line 23) | struct ret
function gccgoRealSyscall (line 26) | struct ret
function gccgoRealSyscallNoError (line 40) | uintptr_t
FILE: vendor/golang.org/x/sys/unix/gccgo_linux_amd64.go
function realGettimeofday (line 12) | func realGettimeofday(*Timeval, *byte) int32
function gettimeofday (line 14) | func gettimeofday(tv *Timeval) (err syscall.Errno) {
FILE: vendor/golang.org/x/sys/unix/ifreq_linux.go
type Ifreq (line 25) | type Ifreq struct
method Name (line 45) | func (ifr *Ifreq) Name() string {
method Inet4Addr (line 56) | func (ifr *Ifreq) Inet4Addr() ([]byte, error) {
method SetInet4Addr (line 69) | func (ifr *Ifreq) SetInet4Addr(v []byte) error {
method Uint16 (line 90) | func (ifr *Ifreq) Uint16() uint16 {
method SetUint16 (line 95) | func (ifr *Ifreq) SetUint16(v uint16) {
method Uint32 (line 101) | func (ifr *Ifreq) Uint32() uint32 {
method SetUint32 (line 106) | func (ifr *Ifreq) SetUint32(v uint32) {
method clear (line 113) | func (ifr *Ifreq) clear() {
method withData (line 134) | func (ifr Ifreq) withData(p unsafe.Pointer) ifreqData {
function NewIfreq (line 30) | func NewIfreq(name string) (*Ifreq, error) {
type ifreqData (line 122) | type ifreqData struct
FILE: vendor/golang.org/x/sys/unix/ioctl_linux.go
function IoctlRetInt (line 12) | func IoctlRetInt(fd int, req uint) (int, error) {
function IoctlGetUint32 (line 20) | func IoctlGetUint32(fd int, req uint) (uint32, error) {
function IoctlGetRT
Condensed preview — 578 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (9,636K chars).
[
{
"path": ".github/dependabot.yml",
"chars": 409,
"preview": "version: 2\nupdates:\n - package-ecosystem: gomod\n directory: /\n schedule:\n interval: weekly\n day: monday"
},
{
"path": ".github/workflows/ci.yml",
"chars": 825,
"preview": "name: CI\n\non:\n push:\n pull_request:\n\npermissions:\n contents: read\n\nconcurrency:\n group: ci-${{ github.workflow }}-${"
},
{
"path": ".gitignore",
"chars": 111,
"preview": "/certs\n/releases\n\n# These aren't generated anymore but might have been generated by an older\n# release.\n/*.pem\n"
},
{
"path": "LICENSE",
"chars": 1055,
"preview": "Copyright (c) 2019 Kevin Burke\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this sof"
},
{
"path": "Makefile",
"chars": 2236,
"preview": ".PHONY: assets static templates\n\nSHELL = /bin/bash -o pipefail\n\nBENCHSTAT := $(GOPATH)/bin/benchstat\nBUMP_VERSION := $(G"
},
{
"path": "README.md",
"chars": 1741,
"preview": "# Go html boilerplate\n\nThis is a starter pack for doing [web development with Go][post], with support\nfor some of the th"
},
{
"path": "assets/bindata.go",
"chars": 8088,
"preview": "// Code generated by go-bindata. DO NOT EDIT.\n// sources:\n// templates/index.html (502B)\n// static/style.css (99B)\n\npack"
},
{
"path": "config.yml",
"chars": 115,
"preview": "port: 7065\n\n# Run \"make generate_cert\" to generate these files.\ncert_file: certs/leaf.pem\nkey_file: certs/leaf.key\n"
},
{
"path": "crypto.go",
"chars": 1033,
"preview": "package main\n\n// Helpers for two-way encryption with a secret key.\n\nimport (\n\t\"encoding/base64\"\n\n\t\"github.com/kevinburke"
},
{
"path": "flash.go",
"chars": 1985,
"preview": "package main\n\n// Helper functions for setting a flash message as a cookie, and then reading\n// that flash message in ano"
},
{
"path": "go.mod",
"chars": 576,
"preview": "module github.com/kevinburke/go-html-boilerplate\n\ngo 1.24.0\n\nrequire (\n\tgithub.com/goccy/go-yaml v1.19.2\n\tgithub.com/kev"
},
{
"path": "go.sum",
"chars": 2002,
"preview": "github.com/goccy/go-yaml v1.19.2 h1:PmFC1S6h8ljIz6gMRBopkjP1TVT7xuwrButHID66PoM=\ngithub.com/goccy/go-yaml v1.19.2/go.mod"
},
{
"path": "main.go",
"chars": 7630,
"preview": "// go-html-boilerplate loads configuration from a file and starts a HTTP server\n// that can render HTML templates and st"
},
{
"path": "main_test.go",
"chars": 1263,
"preview": "package main\n\nimport (\n\t\"io\"\n\t\"net/http\"\n\t\"net/http/httptest\"\n\t\"strings\"\n\t\"testing\"\n\n\t\"github.com/kevinburke/nacl\"\n)\n\nfu"
},
{
"path": "static/style.css",
"chars": 99,
"preview": "body {\n max-width: 1200px;\n margin: 0 auto;\n font-family: Helvetica, Arial, sans-serif;\n}\n"
},
{
"path": "templates/index.html",
"chars": 502,
"preview": "<!doctype html>\n<html>\n <head>\n <meta charset=\"utf-8\">\n <meta http-equiv=\"X-UA-Compatible\" content=\"IE=edge\">\n "
},
{
"path": "vendor/github.com/goccy/go-yaml/.codecov.yml",
"chars": 412,
"preview": "codecov:\n require_ci_to_pass: yes\n\ncoverage:\n precision: 2\n round: down\n range: \"70...100\"\n\n status:\n project:\n "
},
{
"path": "vendor/github.com/goccy/go-yaml/.gitignore",
"chars": 22,
"preview": "bin/\n.idea/\ncover.out\n"
},
{
"path": "vendor/github.com/goccy/go-yaml/.golangci.yml",
"chars": 1095,
"preview": "version: \"2\"\nlinters:\n default: none\n enable:\n - errcheck\n - govet\n - ineffassign\n - misspell\n - perfsp"
},
{
"path": "vendor/github.com/goccy/go-yaml/CHANGELOG.md",
"chars": 5265,
"preview": "# 1.11.2 - 2023-09-15\n\n### Fix bugs\n\n- Fix quoted comments ( #370 )\n- Fix handle of space at start or last ( #376 )\n- Fi"
},
{
"path": "vendor/github.com/goccy/go-yaml/LICENSE",
"chars": 1072,
"preview": "MIT License\n\nCopyright (c) 2019 Masaaki Goshima\n\nPermission is hereby granted, free of charge, to any person obtaining a"
},
{
"path": "vendor/github.com/goccy/go-yaml/Makefile",
"chars": 1408,
"preview": "## Location to install dependencies to\nLOCALBIN ?= $(shell pwd)/bin\nTESTMOD := testdata/go_test.mod\n\n$(LOCALBIN):\n\tmkdir"
},
{
"path": "vendor/github.com/goccy/go-yaml/README.md",
"chars": 13515,
"preview": "# YAML support for the Go language\n\n[](https://pkg.go.dev/"
},
{
"path": "vendor/github.com/goccy/go-yaml/ast/ast.go",
"chars": 56376,
"preview": "package ast\n\nimport (\n\t\"errors\"\n\t\"fmt\"\n\t\"io\"\n\t\"math\"\n\t\"strconv\"\n\t\"strings\"\n\n\t\"github.com/goccy/go-yaml/token\"\n)\n\nvar (\n\t"
},
{
"path": "vendor/github.com/goccy/go-yaml/context.go",
"chars": 735,
"preview": "package yaml\n\nimport \"context\"\n\ntype (\n\tctxMergeKey struct{}\n\tctxAnchorKey struct{}\n)\n\nfunc withMerge(ctx context.Conte"
},
{
"path": "vendor/github.com/goccy/go-yaml/decode.go",
"chars": 51147,
"preview": "package yaml\n\nimport (\n\t\"bytes\"\n\t\"context\"\n\t\"encoding\"\n\t\"encoding/base64\"\n\t\"fmt\"\n\t\"io\"\n\t\"maps\"\n\t\"math\"\n\t\"os\"\n\t\"path/file"
},
{
"path": "vendor/github.com/goccy/go-yaml/encode.go",
"chars": 29184,
"preview": "package yaml\n\nimport (\n\t\"context\"\n\t\"encoding\"\n\t\"fmt\"\n\t\"io\"\n\t\"math\"\n\t\"reflect\"\n\t\"sort\"\n\t\"strconv\"\n\t\"strings\"\n\t\"time\"\n\n\t\"g"
},
{
"path": "vendor/github.com/goccy/go-yaml/error.go",
"chars": 2638,
"preview": "package yaml\n\nimport (\n\t\"fmt\"\n\n\t\"github.com/goccy/go-yaml/ast\"\n\t\"github.com/goccy/go-yaml/internal/errors\"\n)\n\nvar (\n\tErr"
},
{
"path": "vendor/github.com/goccy/go-yaml/internal/errors/error.go",
"chars": 5739,
"preview": "package errors\n\nimport (\n\t\"errors\"\n\t\"fmt\"\n\t\"reflect\"\n\n\t\"github.com/goccy/go-yaml/ast\"\n\t\"github.com/goccy/go-yaml/printer"
},
{
"path": "vendor/github.com/goccy/go-yaml/internal/format/format.go",
"chars": 12866,
"preview": "package format\n\nimport (\n\t\"strings\"\n\n\t\"github.com/goccy/go-yaml/ast\"\n\t\"github.com/goccy/go-yaml/token\"\n)\n\nfunc FormatNod"
},
{
"path": "vendor/github.com/goccy/go-yaml/lexer/lexer.go",
"chars": 372,
"preview": "package lexer\n\nimport (\n\t\"io\"\n\n\t\"github.com/goccy/go-yaml/scanner\"\n\t\"github.com/goccy/go-yaml/token\"\n)\n\n// Tokenize spli"
},
{
"path": "vendor/github.com/goccy/go-yaml/option.go",
"chars": 10219,
"preview": "package yaml\n\nimport (\n\t\"context\"\n\t\"io\"\n\t\"reflect\"\n\n\t\"github.com/goccy/go-yaml/ast\"\n)\n\n// DecodeOption functional option"
},
{
"path": "vendor/github.com/goccy/go-yaml/parser/color.go",
"chars": 478,
"preview": "package parser\n\nimport \"fmt\"\n\nconst (\n\tcolorFgHiBlack int = iota + 90\n\tcolorFgHiRed\n\tcolorFgHiGreen\n\tcolorFgHiYellow\n\tco"
},
{
"path": "vendor/github.com/goccy/go-yaml/parser/context.go",
"chars": 3561,
"preview": "package parser\n\nimport (\n\t\"fmt\"\n\t\"strings\"\n\n\t\"github.com/goccy/go-yaml/token\"\n)\n\n// context context at parsing\ntype cont"
},
{
"path": "vendor/github.com/goccy/go-yaml/parser/node.go",
"chars": 6637,
"preview": "package parser\n\nimport (\n\t\"fmt\"\n\n\t\"github.com/goccy/go-yaml/ast\"\n\t\"github.com/goccy/go-yaml/internal/errors\"\n\t\"github.co"
},
{
"path": "vendor/github.com/goccy/go-yaml/parser/option.go",
"chars": 307,
"preview": "package parser\n\n// Option represents parser's option.\ntype Option func(p *parser)\n\n// AllowDuplicateMapKey allow the use"
},
{
"path": "vendor/github.com/goccy/go-yaml/parser/parser.go",
"chars": 35921,
"preview": "package parser\n\nimport (\n\t\"fmt\"\n\t\"os\"\n\t\"strings\"\n\n\t\"github.com/goccy/go-yaml/ast\"\n\t\"github.com/goccy/go-yaml/internal/er"
},
{
"path": "vendor/github.com/goccy/go-yaml/parser/token.go",
"chars": 16717,
"preview": "package parser\n\nimport (\n\t\"fmt\"\n\t\"os\"\n\t\"strings\"\n\n\t\"github.com/goccy/go-yaml/internal/errors\"\n\t\"github.com/goccy/go-yaml"
},
{
"path": "vendor/github.com/goccy/go-yaml/path.go",
"chars": 20577,
"preview": "package yaml\n\nimport (\n\t\"bytes\"\n\t\"fmt\"\n\t\"io\"\n\t\"strconv\"\n\t\"strings\"\n\n\t\"github.com/goccy/go-yaml/ast\"\n\t\"github.com/goccy/g"
},
{
"path": "vendor/github.com/goccy/go-yaml/printer/color.go",
"chars": 1764,
"preview": "// This source inspired by https://github.com/fatih/color.\npackage printer\n\nimport (\n\t\"fmt\"\n\t\"strings\"\n)\n\ntype ColorAttr"
},
{
"path": "vendor/github.com/goccy/go-yaml/printer/printer.go",
"chars": 8120,
"preview": "package printer\n\nimport (\n\t\"fmt\"\n\t\"math\"\n\t\"strings\"\n\n\t\"github.com/goccy/go-yaml/ast\"\n\t\"github.com/goccy/go-yaml/token\"\n)"
},
{
"path": "vendor/github.com/goccy/go-yaml/scanner/context.go",
"chars": 9995,
"preview": "package scanner\n\nimport (\n\t\"errors\"\n\t\"strconv\"\n\t\"strings\"\n\t\"sync\"\n\n\t\"github.com/goccy/go-yaml/token\"\n)\n\n// Context conte"
},
{
"path": "vendor/github.com/goccy/go-yaml/scanner/error.go",
"chars": 288,
"preview": "package scanner\n\nimport \"github.com/goccy/go-yaml/token\"\n\ntype InvalidTokenError struct {\n\tToken *token.Token\n}\n\nfunc (e"
},
{
"path": "vendor/github.com/goccy/go-yaml/scanner/scanner.go",
"chars": 35797,
"preview": "package scanner\n\nimport (\n\t\"errors\"\n\t\"fmt\"\n\t\"io\"\n\t\"strconv\"\n\t\"strings\"\n\n\t\"github.com/goccy/go-yaml/token\"\n)\n\n// IndentSt"
},
{
"path": "vendor/github.com/goccy/go-yaml/stdlib_quote.go",
"chars": 3268,
"preview": "// Copied and trimmed down from https://github.com/golang/go/blob/e3769299cd3484e018e0e2a6e1b95c2b18ce4f41/src/strconv/q"
},
{
"path": "vendor/github.com/goccy/go-yaml/struct.go",
"chars": 2782,
"preview": "package yaml\n\nimport (\n\t\"fmt\"\n\t\"reflect\"\n\t\"strings\"\n)\n\nconst (\n\t// StructTagName tag keyword for Marshal/Unmarshal\n\tStru"
},
{
"path": "vendor/github.com/goccy/go-yaml/token/token.go",
"chars": 29511,
"preview": "package token\n\nimport (\n\t\"errors\"\n\t\"fmt\"\n\t\"strconv\"\n\t\"strings\"\n\t\"time\"\n)\n\n// Character type for character\ntype Character"
},
{
"path": "vendor/github.com/goccy/go-yaml/validate.go",
"chars": 406,
"preview": "package yaml\n\n// StructValidator need to implement Struct method only\n// ( see https://pkg.go.dev/github.com/go-playgrou"
},
{
"path": "vendor/github.com/goccy/go-yaml/yaml.go",
"chars": 13082,
"preview": "package yaml\n\nimport (\n\t\"bytes\"\n\t\"context\"\n\t\"io\"\n\t\"reflect\"\n\t\"sync\"\n\n\t\"github.com/goccy/go-yaml/ast\"\n\t\"github.com/goccy/"
},
{
"path": "vendor/github.com/gofrs/uuid/v5/.gitignore",
"chars": 244,
"preview": "# Binaries for programs and plugins\n*.exe\n*.exe~\n*.dll\n*.so\n*.dylib\n\n# Test binary, build with `go test -c`\n*.test\n\n# Ou"
},
{
"path": "vendor/github.com/gofrs/uuid/v5/.pre-commit-config.yaml",
"chars": 321,
"preview": "repos:\n- repo: https://github.com/gitleaks/gitleaks\n rev: v8.16.3\n hooks:\n - id: gitleaks\n- repo: https://github.com/"
},
{
"path": "vendor/github.com/gofrs/uuid/v5/LICENSE",
"chars": 1082,
"preview": "Copyright (C) 2013-2018 by Maxim Bublis <b@codemonkey.ru>\n\nPermission is hereby granted, free of charge, to any person o"
},
{
"path": "vendor/github.com/gofrs/uuid/v5/README.md",
"chars": 3563,
"preview": "# UUID\n\n[](https://github.com/gofrs/uuid/blob/master/LIC"
},
{
"path": "vendor/github.com/gofrs/uuid/v5/SECURITY.md",
"chars": 1281,
"preview": "# Security Policy\n\n## Supported Versions\n\nWe support the latest version of this library. We do not guarantee support of "
},
{
"path": "vendor/github.com/gofrs/uuid/v5/codec.go",
"chars": 6303,
"preview": "// Copyright (C) 2013-2018 by Maxim Bublis <b@codemonkey.ru>\n//\n// Permission is hereby granted, free of charge, to any "
},
{
"path": "vendor/github.com/gofrs/uuid/v5/error.go",
"chars": 1665,
"preview": "package uuid\n\n// Error is a custom error type for UUID-related errors\ntype Error string\n\n// The strings defined in the e"
},
{
"path": "vendor/github.com/gofrs/uuid/v5/generator.go",
"chars": 16209,
"preview": "// Copyright (C) 2013-2018 by Maxim Bublis <b@codemonkey.ru>\n//\n// Permission is hereby granted, free of charge, to any "
},
{
"path": "vendor/github.com/gofrs/uuid/v5/sql.go",
"chars": 3159,
"preview": "// Copyright (C) 2013-2018 by Maxim Bublis <b@codemonkey.ru>\n//\n// Permission is hereby granted, free of charge, to any "
},
{
"path": "vendor/github.com/gofrs/uuid/v5/uuid.go",
"chars": 10106,
"preview": "// Copyright (C) 2013-2018 by Maxim Bublis <b@codemonkey.ru>\n//\n// Permission is hereby granted, free of charge, to any "
},
{
"path": "vendor/github.com/inconshreveable/log15/v3/LICENSE",
"chars": 551,
"preview": "Copyright 2014 Alan Shreve\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file ex"
},
{
"path": "vendor/github.com/inconshreveable/log15/v3/doc.go",
"chars": 10872,
"preview": "/*\nPackage log15 provides an opinionated, simple toolkit for best-practice logging that is\nboth human and machine readab"
},
{
"path": "vendor/github.com/inconshreveable/log15/v3/format.go",
"chars": 6469,
"preview": "package log15\n\nimport (\n\t\"bytes\"\n\t\"encoding/json\"\n\t\"fmt\"\n\t\"reflect\"\n\t\"strconv\"\n\t\"strings\"\n\t\"sync\"\n\t\"time\"\n)\n\nconst (\n\tti"
},
{
"path": "vendor/github.com/inconshreveable/log15/v3/handler.go",
"chars": 8799,
"preview": "package log15\n\nimport (\n\t\"fmt\"\n\t\"io\"\n\t\"net\"\n\t\"os\"\n\t\"reflect\"\n\t\"sync\"\n)\n\n// Handler interface defines where and how log r"
},
{
"path": "vendor/github.com/inconshreveable/log15/v3/handler_go13.go",
"chars": 531,
"preview": "//go:build !go1.4\n// +build !go1.4\n\npackage log15\n\nimport (\n\t\"sync/atomic\"\n\t\"unsafe\"\n)\n\n// swapHandler wraps another han"
},
{
"path": "vendor/github.com/inconshreveable/log15/v3/handler_go14.go",
"chars": 487,
"preview": "//go:build go1.4\n// +build go1.4\n\npackage log15\n\nimport \"sync/atomic\"\n\n// swapHandler wraps another handler that may be "
},
{
"path": "vendor/github.com/inconshreveable/log15/v3/logger.go",
"chars": 5019,
"preview": "package log15\n\nimport (\n\t\"fmt\"\n\t\"strings\"\n\t\"time\"\n)\n\nconst timeKey = \"t\"\nconst lvlKey = \"lvl\"\nconst msgKey = \"msg\"\nconst"
},
{
"path": "vendor/github.com/inconshreveable/log15/v3/root.go",
"chars": 1695,
"preview": "package log15\n\nimport (\n\t\"os\"\n\n\t\"github.com/mattn/go-colorable\"\n\t\"golang.org/x/term\"\n)\n\n// Predefined handlers\nvar (\n\tro"
},
{
"path": "vendor/github.com/inconshreveable/log15/v3/syslog.go",
"chars": 1573,
"preview": "//go:build !windows && !plan9\n// +build !windows,!plan9\n\npackage log15\n\nimport (\n\t\"log/syslog\"\n\t\"strings\"\n)\n\n// SyslogHa"
},
{
"path": "vendor/github.com/kevinburke/handlers/.gitignore",
"chars": 9,
"preview": "/bazel-*\n"
},
{
"path": "vendor/github.com/kevinburke/handlers/CHANGELOG.md",
"chars": 709,
"preview": "### 0.38\n\nIf WriteHeader is never called, Log will log status=200 to the log, instead of\nstatus=0.\n\n### 0.37\n\nSupport OP"
},
{
"path": "vendor/github.com/kevinburke/handlers/LICENSE",
"chars": 3536,
"preview": "There are three licenses in this file; the Log code was taken from two\ndifferent places. I believe you should include al"
},
{
"path": "vendor/github.com/kevinburke/handlers/Makefile",
"chars": 823,
"preview": "SHELL = /bin/bash -o pipefail\n\nBUMP_VERSION := $(GOPATH)/bin/bump_version\n\nvet:\n\tgo vet ./...\n\tstaticcheck ./...\n\ntest: "
},
{
"path": "vendor/github.com/kevinburke/handlers/README.md",
"chars": 713,
"preview": "This project contains middlewares that I often found myself reimplementing\nin new projects. In addition, it includes a m"
},
{
"path": "vendor/github.com/kevinburke/handlers/ctx.go",
"chars": 3677,
"preview": "package handlers\n\nimport (\n\t\"context\"\n\t\"net/http\"\n\t\"strings\"\n\t\"time\"\n\n\t\"github.com/gofrs/uuid/v5\"\n)\n\ntype ctxVar int\n\nva"
},
{
"path": "vendor/github.com/kevinburke/handlers/gzip.go",
"chars": 3388,
"preview": "// Copyright 2013 The Gorilla Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// lic"
},
{
"path": "vendor/github.com/kevinburke/handlers/lib.go",
"chars": 9919,
"preview": "// Package handlers implements a number of useful HTTP middlewares.\n//\n// The general format of the middlewares in this "
},
{
"path": "vendor/github.com/kevinburke/handlers/lib_noslog.go",
"chars": 1585,
"preview": "//go:build !go1.21\n// +build !go1.21\n\npackage handlers\n\nimport (\n\t\"net/http\"\n\t\"net/url\"\n\t\"strconv\"\n\t\"time\"\n\n\t\"github.com"
},
{
"path": "vendor/github.com/kevinburke/handlers/lib_slog.go",
"chars": 1389,
"preview": "//go:build go1.21\n// +build go1.21\n\npackage handlers\n\nimport (\n\t\"log/slog\"\n\t\"net/http\"\n\t\"net/url\"\n\t\"strconv\"\n\t\"time\"\n\n\t\""
},
{
"path": "vendor/github.com/kevinburke/handlers/logger_noslog.go",
"chars": 4944,
"preview": "//go:build !go1.21\n// +build !go1.21\n\n// Most of this is copied from github.com/inconshreveable/log15/format.go, with\n//"
},
{
"path": "vendor/github.com/kevinburke/handlers/logger_slog.go",
"chars": 836,
"preview": "//go:build go1.21\n// +build go1.21\n\npackage handlers\n\nimport (\n\t\"log/slog\"\n\t\"os\"\n\n\t\"golang.org/x/term\"\n)\n\n// NewLogger r"
},
{
"path": "vendor/github.com/kevinburke/handlers/regex_handler.go",
"chars": 3435,
"preview": "package handlers\n\nimport (\n\t\"fmt\"\n\t\"net/http\"\n\t\"regexp\"\n\t\"strings\"\n\n\t\"github.com/kevinburke/rest\"\n)\n\ntype route struct {"
},
{
"path": "vendor/github.com/kevinburke/nacl/.gitignore",
"chars": 9,
"preview": "/bazel-*\n"
},
{
"path": "vendor/github.com/kevinburke/nacl/CHANGELOG.md",
"chars": 206,
"preview": "# Changelog\n\n## 0.7\n\nReplace golang.org/x/crypto/ed25519 with crypto/ed25519.\n\n## 0.4\n\nAdd KeySize, NonceSize constants."
},
{
"path": "vendor/github.com/kevinburke/nacl/LICENSE",
"chars": 1479,
"preview": "Copyright (c) 2017 The Go Authors. All rights reserved.\n\nRedistribution and use in source and binary forms, with or with"
},
{
"path": "vendor/github.com/kevinburke/nacl/Makefile",
"chars": 905,
"preview": "SHELL = /bin/bash -o pipefail\n\nBENCHSTAT := $(GOPATH)/bin/benchstat\nBUMP_VERSION := $(GOPATH)/bin/bump_version\nGODOCDOC "
},
{
"path": "vendor/github.com/kevinburke/nacl/README.md",
"chars": 4070,
"preview": "# go-nacl\n\n[](https://godoc.org/github.com/kevinburke/n"
},
{
"path": "vendor/github.com/kevinburke/nacl/internal/subtle/aliasing.go",
"chars": 1269,
"preview": "// Copyright 2018 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/github.com/kevinburke/nacl/internal/subtle/aliasing_appengine.go",
"chars": 1399,
"preview": "// Copyright 2018 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/github.com/kevinburke/nacl/nacl.go",
"chars": 5804,
"preview": "// Package nacl is a pure Go implementation of the NaCL cryptography library.\n//\n// Compared with the implementation in "
},
{
"path": "vendor/github.com/kevinburke/nacl/onetimeauth/onetimeauth.go",
"chars": 1787,
"preview": "// Package onetimeauth provides primitives for secret-key, single-message\n// authentication.\n//\n// The onetimeauth funct"
},
{
"path": "vendor/github.com/kevinburke/nacl/randombytes/randombytes.go",
"chars": 464,
"preview": "// Package randombytes implements helpers for reading random data.\npackage randombytes\n\nimport (\n\t\"crypto/rand\"\n\t\"strcon"
},
{
"path": "vendor/github.com/kevinburke/nacl/secretbox/secretbox.go",
"chars": 6030,
"preview": "// Copyright 2012 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/github.com/kevinburke/rest/.gitignore",
"chars": 16,
"preview": "/bazel-*\n/*.out\n"
},
{
"path": "vendor/github.com/kevinburke/rest/CHANGELOG.md",
"chars": 1372,
"preview": "## 2.8\n\nReplace Client.Token with Client.Token(). Add new SetToken() method to allow\nupdating the token.\n\nReplace handle"
},
{
"path": "vendor/github.com/kevinburke/rest/LICENSE",
"chars": 1054,
"preview": "Copyright (c) 2016 Shyp, Inc.\n\nPermission is hereby granted, free of charge, to any person\nobtaining a copy of this soft"
},
{
"path": "vendor/github.com/kevinburke/rest/Makefile",
"chars": 559,
"preview": "SHELL = /bin/bash -o pipefail\n\nBUMP_VERSION := $(GOPATH)/bin/bump_version\nSTATICCHECK := $(GOPATH)/bin/staticcheck\n\ndeps"
},
{
"path": "vendor/github.com/kevinburke/rest/README.md",
"chars": 2328,
"preview": "# rest\n\nThis library contains a HTTP client, and a number of useful middlewares for\nwriting a HTTP client and server in "
},
{
"path": "vendor/github.com/kevinburke/rest/ctx.go",
"chars": 1011,
"preview": "// +build go1.7\n\npackage rest\n\nimport (\n\t\"context\"\n\t\"net/http\"\n)\n\ntype ctxVar int\n\nvar errCtx ctxVar = 0\nvar domainCtx c"
},
{
"path": "vendor/github.com/kevinburke/rest/noctx.go",
"chars": 808,
"preview": "// +build !go1.7\n\npackage rest\n\nimport \"net/http\"\n\n// CtxErr returns an error that's been stored in the Request context."
},
{
"path": "vendor/github.com/kevinburke/rest/rest.go",
"chars": 7368,
"preview": "// Package rest implements responses and a HTTP client for API consumption.\npackage rest\n\nimport (\n\t\"encoding/json\"\n\t\"fm"
},
{
"path": "vendor/github.com/kevinburke/rest/rest_noslog.go",
"chars": 188,
"preview": "//go:build !go1.21\n// +build !go1.21\n\npackage rest\n\nimport log \"github.com/inconshreveable/log15/v3\"\n\n// Logger logs inf"
},
{
"path": "vendor/github.com/kevinburke/rest/rest_slog.go",
"chars": 237,
"preview": "//go:build go1.21\n// +build go1.21\n\npackage rest\n\nimport (\n\t\"log/slog\"\n\t\"os\"\n)\n\nfunc init() {\n\th := slog.NewTextHandler("
},
{
"path": "vendor/github.com/kevinburke/rest/restclient/client.go",
"chars": 6546,
"preview": "package restclient\n\nimport (\n\t\"context\"\n\t\"encoding/json\"\n\t\"fmt\"\n\t\"io\"\n\t\"net\"\n\t\"net/http\"\n\t\"runtime\"\n\t\"strings\"\n\t\"sync/at"
},
{
"path": "vendor/github.com/kevinburke/rest/restclient/transport.go",
"chars": 1913,
"preview": "package restclient\n\nimport (\n\t\"bytes\"\n\t\"io\"\n\t\"net/http\"\n\t\"net/http/httputil\"\n\t\"os\"\n)\n\n// DefaultTransport is like http.D"
},
{
"path": "vendor/github.com/kevinburke/rest/resterror/resterror.go",
"chars": 974,
"preview": "package resterror\n\nimport \"fmt\"\n\n// Error implements the HTTP Problem spec laid out here:\n// https://tools.ietf.org/html"
},
{
"path": "vendor/github.com/mattn/go-colorable/LICENSE",
"chars": 1085,
"preview": "The MIT License (MIT)\n\nCopyright (c) 2016 Yasuhiro Matsumoto\n\nPermission is hereby granted, free of charge, to any perso"
},
{
"path": "vendor/github.com/mattn/go-colorable/README.md",
"chars": 1361,
"preview": "# go-colorable\n\n[](https://github.com/mat"
},
{
"path": "vendor/github.com/mattn/go-colorable/colorable_others.go",
"chars": 827,
"preview": "//go:build !windows || appengine\n// +build !windows appengine\n\npackage colorable\n\nimport (\n\t\"io\"\n\t\"os\"\n\n\t_ \"github.com/m"
},
{
"path": "vendor/github.com/mattn/go-colorable/colorable_windows.go",
"chars": 25265,
"preview": "//go:build windows && !appengine\n// +build windows,!appengine\n\npackage colorable\n\nimport (\n\t\"bytes\"\n\t\"io\"\n\t\"math\"\n\t\"os\"\n"
},
{
"path": "vendor/github.com/mattn/go-colorable/go.test.sh",
"chars": 273,
"preview": "#!/usr/bin/env bash\n\nset -e\necho \"\" > coverage.txt\n\nfor d in $(go list ./... | grep -v vendor); do\n go test -race -co"
},
{
"path": "vendor/github.com/mattn/go-colorable/noncolorable.go",
"chars": 999,
"preview": "package colorable\n\nimport (\n\t\"bytes\"\n\t\"io\"\n)\n\n// NonColorable holds writer but removes escape sequence.\ntype NonColorabl"
},
{
"path": "vendor/github.com/mattn/go-isatty/LICENSE",
"chars": 1099,
"preview": "Copyright (c) Yasuhiro MATSUMOTO <mattn.jp@gmail.com>\n\nMIT License (Expat)\n\nPermission is hereby granted, free of charge"
},
{
"path": "vendor/github.com/mattn/go-isatty/README.md",
"chars": 1088,
"preview": "# go-isatty\n\n[](http://godoc.org/github.com/m"
},
{
"path": "vendor/github.com/mattn/go-isatty/doc.go",
"chars": 64,
"preview": "// Package isatty implements interface to isatty\npackage isatty\n"
},
{
"path": "vendor/github.com/mattn/go-isatty/go.test.sh",
"chars": 273,
"preview": "#!/usr/bin/env bash\n\nset -e\necho \"\" > coverage.txt\n\nfor d in $(go list ./... | grep -v vendor); do\n go test -race -co"
},
{
"path": "vendor/github.com/mattn/go-isatty/isatty_bsd.go",
"chars": 609,
"preview": "//go:build (darwin || freebsd || openbsd || netbsd || dragonfly || hurd) && !appengine && !tinygo\n// +build darwin freeb"
},
{
"path": "vendor/github.com/mattn/go-isatty/isatty_others.go",
"chars": 532,
"preview": "//go:build (appengine || js || nacl || tinygo || wasm) && !windows\n// +build appengine js nacl tinygo wasm\n// +build !wi"
},
{
"path": "vendor/github.com/mattn/go-isatty/isatty_plan9.go",
"chars": 509,
"preview": "//go:build plan9\n// +build plan9\n\npackage isatty\n\nimport (\n\t\"syscall\"\n)\n\n// IsTerminal returns true if the given file de"
},
{
"path": "vendor/github.com/mattn/go-isatty/isatty_solaris.go",
"chars": 582,
"preview": "//go:build solaris && !appengine\n// +build solaris,!appengine\n\npackage isatty\n\nimport (\n\t\"golang.org/x/sys/unix\"\n)\n\n// I"
},
{
"path": "vendor/github.com/mattn/go-isatty/isatty_tcgets.go",
"chars": 536,
"preview": "//go:build (linux || aix || zos) && !appengine && !tinygo\n// +build linux aix zos\n// +build !appengine\n// +build !tinygo"
},
{
"path": "vendor/github.com/mattn/go-isatty/isatty_windows.go",
"chars": 3370,
"preview": "//go:build windows && !appengine\n// +build windows,!appengine\n\npackage isatty\n\nimport (\n\t\"errors\"\n\t\"strings\"\n\t\"syscall\"\n"
},
{
"path": "vendor/golang.org/x/crypto/LICENSE",
"chars": 1453,
"preview": "Copyright 2009 The Go Authors.\n\nRedistribution and use in source and binary forms, with or without\nmodification, are per"
},
{
"path": "vendor/golang.org/x/crypto/PATENTS",
"chars": 1303,
"preview": "Additional IP Rights Grant (Patents)\n\n\"This implementation\" means the copyrightable works distributed by\nGoogle as part "
},
{
"path": "vendor/golang.org/x/crypto/internal/poly1305/mac_noasm.go",
"chars": 290,
"preview": "// Copyright 2018 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/crypto/internal/poly1305/poly1305.go",
"chars": 3386,
"preview": "// Copyright 2012 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/crypto/internal/poly1305/sum_amd64.s",
"chars": 1490,
"preview": "// Code generated by command: go run sum_amd64_asm.go -out ../sum_amd64.s -pkg poly1305. DO NOT EDIT.\n\n//go:build gc && "
},
{
"path": "vendor/golang.org/x/crypto/internal/poly1305/sum_asm.go",
"chars": 1161,
"preview": "// Copyright 2012 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/crypto/internal/poly1305/sum_generic.go",
"chars": 9682,
"preview": "// Copyright 2018 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/crypto/internal/poly1305/sum_loong64.s",
"chars": 2435,
"preview": "// Copyright 2025 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/crypto/internal/poly1305/sum_ppc64x.s",
"chars": 3389,
"preview": "// Copyright 2019 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/crypto/internal/poly1305/sum_s390x.go",
"chars": 2026,
"preview": "// Copyright 2018 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/crypto/internal/poly1305/sum_s390x.s",
"chars": 17106,
"preview": "// Copyright 2018 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/crypto/poly1305/poly1305_compat.go",
"chars": 3505,
"preview": "// Copyright 2012 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/crypto/salsa20/salsa/hsalsa20.go",
"chars": 4280,
"preview": "// Copyright 2012 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/crypto/salsa20/salsa/salsa208.go",
"chars": 5211,
"preview": "// Copyright 2012 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/crypto/salsa20/salsa/salsa20_amd64.go",
"chars": 769,
"preview": "// Copyright 2012 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/crypto/salsa20/salsa/salsa20_amd64.s",
"chars": 15946,
"preview": "// Code generated by command: go run salsa20_amd64_asm.go -out ../salsa20_amd64.s -pkg salsa. DO NOT EDIT.\n\n//go:build a"
},
{
"path": "vendor/golang.org/x/crypto/salsa20/salsa/salsa20_noasm.go",
"chars": 538,
"preview": "// Copyright 2019 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/crypto/salsa20/salsa/salsa20_ref.go",
"chars": 5852,
"preview": "// Copyright 2012 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/sys/LICENSE",
"chars": 1453,
"preview": "Copyright 2009 The Go Authors.\n\nRedistribution and use in source and binary forms, with or without\nmodification, are per"
},
{
"path": "vendor/golang.org/x/sys/PATENTS",
"chars": 1303,
"preview": "Additional IP Rights Grant (Patents)\n\n\"This implementation\" means the copyrightable works distributed by\nGoogle as part "
},
{
"path": "vendor/golang.org/x/sys/cpu/asm_aix_ppc64.s",
"chars": 403,
"preview": "// Copyright 2018 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/sys/cpu/asm_darwin_x86_gc.s",
"chars": 628,
"preview": "// Copyright 2024 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/sys/cpu/byteorder.go",
"chars": 1868,
"preview": "// Copyright 2019 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/sys/cpu/cpu.go",
"chars": 14963,
"preview": "// Copyright 2018 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/sys/cpu/cpu_aix.go",
"chars": 605,
"preview": "// Copyright 2019 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/sys/cpu/cpu_arm.go",
"chars": 2163,
"preview": "// Copyright 2018 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/sys/cpu/cpu_arm64.go",
"chars": 4199,
"preview": "// Copyright 2019 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/sys/cpu/cpu_arm64.s",
"chars": 805,
"preview": "// Copyright 2019 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/sys/cpu/cpu_darwin_x86.go",
"chars": 2113,
"preview": "// Copyright 2024 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/sys/cpu/cpu_gc_arm64.go",
"chars": 278,
"preview": "// Copyright 2019 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/sys/cpu/cpu_gc_s390x.go",
"chars": 674,
"preview": "// Copyright 2019 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/sys/cpu/cpu_gc_x86.go",
"chars": 505,
"preview": "// Copyright 2018 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/sys/cpu/cpu_gc_x86.s",
"chars": 600,
"preview": "// Copyright 2018 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/sys/cpu/cpu_gccgo_arm64.go",
"chars": 299,
"preview": "// Copyright 2019 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/sys/cpu/cpu_gccgo_s390x.go",
"chars": 1029,
"preview": "// Copyright 2019 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/sys/cpu/cpu_gccgo_x86.c",
"chars": 1095,
"preview": "// Copyright 2018 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/sys/cpu/cpu_gccgo_x86.go",
"chars": 630,
"preview": "// Copyright 2018 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/sys/cpu/cpu_linux.go",
"chars": 322,
"preview": "// Copyright 2018 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/sys/cpu/cpu_linux_arm.go",
"chars": 1393,
"preview": "// Copyright 2019 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/sys/cpu/cpu_linux_arm64.go",
"chars": 3662,
"preview": "// Copyright 2018 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/sys/cpu/cpu_linux_loong64.go",
"chars": 632,
"preview": "// Copyright 2025 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/sys/cpu/cpu_linux_mips64x.go",
"chars": 480,
"preview": "// Copyright 2020 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/sys/cpu/cpu_linux_noinit.go",
"chars": 306,
"preview": "// Copyright 2019 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/sys/cpu/cpu_linux_ppc64x.go",
"chars": 775,
"preview": "// Copyright 2018 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/sys/cpu/cpu_linux_riscv64.go",
"chars": 7107,
"preview": "// Copyright 2024 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/sys/cpu/cpu_linux_s390x.go",
"chars": 890,
"preview": "// Copyright 2019 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/sys/cpu/cpu_loong64.go",
"chars": 1456,
"preview": "// Copyright 2022 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/sys/cpu/cpu_loong64.s",
"chars": 357,
"preview": "// Copyright 2025 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/sys/cpu/cpu_mips64x.go",
"chars": 320,
"preview": "// Copyright 2018 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/sys/cpu/cpu_mipsx.go",
"chars": 248,
"preview": "// Copyright 2018 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/sys/cpu/cpu_netbsd_arm64.go",
"chars": 4359,
"preview": "// Copyright 2020 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/sys/cpu/cpu_openbsd_arm64.go",
"chars": 1702,
"preview": "// Copyright 2022 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/sys/cpu/cpu_openbsd_arm64.s",
"chars": 374,
"preview": "// Copyright 2022 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/sys/cpu/cpu_other_arm.go",
"chars": 218,
"preview": "// Copyright 2020 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/sys/cpu/cpu_other_arm64.go",
"chars": 253,
"preview": "// Copyright 2019 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/sys/cpu/cpu_other_mips64x.go",
"chars": 256,
"preview": "// Copyright 2020 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/sys/cpu/cpu_other_ppc64x.go",
"chars": 285,
"preview": "// Copyright 2022 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/sys/cpu/cpu_other_riscv64.go",
"chars": 243,
"preview": "// Copyright 2022 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/sys/cpu/cpu_other_x86.go",
"chars": 322,
"preview": "// Copyright 2024 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/sys/cpu/cpu_ppc64x.go",
"chars": 360,
"preview": "// Copyright 2020 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/sys/cpu/cpu_riscv64.go",
"chars": 1077,
"preview": "// Copyright 2019 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/sys/cpu/cpu_s390x.go",
"chars": 4993,
"preview": "// Copyright 2020 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/sys/cpu/cpu_s390x.s",
"chars": 2000,
"preview": "// Copyright 2019 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/sys/cpu/cpu_wasm.go",
"chars": 439,
"preview": "// Copyright 2019 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/sys/cpu/cpu_windows_arm64.go",
"chars": 1772,
"preview": "// Copyright 2026 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/sys/cpu/cpu_x86.go",
"chars": 7775,
"preview": "// Copyright 2018 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/sys/cpu/cpu_zos.go",
"chars": 223,
"preview": "// Copyright 2020 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/sys/cpu/cpu_zos_s390x.go",
"chars": 643,
"preview": "// Copyright 2020 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/sys/cpu/endian_big.go",
"chars": 397,
"preview": "// Copyright 2023 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/sys/cpu/endian_little.go",
"chars": 433,
"preview": "// Copyright 2023 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/sys/cpu/hwcap_linux.go",
"chars": 1510,
"preview": "// Copyright 2019 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/sys/cpu/parse.go",
"chars": 1017,
"preview": "// Copyright 2022 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/sys/cpu/proc_cpuinfo_linux.go",
"chars": 1113,
"preview": "// Copyright 2022 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/sys/cpu/runtime_auxv.go",
"chars": 393,
"preview": "// Copyright 2023 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/sys/cpu/runtime_auxv_go121.go",
"chars": 357,
"preview": "// Copyright 2023 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/sys/cpu/syscall_aix_gccgo.go",
"chars": 726,
"preview": "// Copyright 2020 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/sys/cpu/syscall_aix_ppc64_gc.go",
"chars": 988,
"preview": "// Copyright 2019 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/sys/cpu/syscall_darwin_x86_gc.go",
"chars": 2542,
"preview": "// Copyright 2024 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "vendor/golang.org/x/sys/plan9/asm.s",
"chars": 213,
"preview": "// Copyright 2014 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
}
]
// ... and 378 more files (download for full content)
About this extraction
This page contains the full source code of the kevinburke/go-html-boilerplate GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 578 files (8.7 MB), approximately 2.3M tokens, and a symbol index with 98854 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.