mirror of
https://gitea.com/gitea/runner.git
synced 2026-11-17 05:13:42 +00:00
update vendor
This commit is contained in:
29 files changed
+2463
-9966
No files matched your search
@@ -45,7 +45,7 @@ require (
|
|||||||
gopkg.in/src-d/go-billy.v4 v4.3.0 // indirect
|
gopkg.in/src-d/go-billy.v4 v4.3.0 // indirect
|
||||||
gopkg.in/src-d/go-git-fixtures.v3 v3.3.0 // indirect
|
gopkg.in/src-d/go-git-fixtures.v3 v3.3.0 // indirect
|
||||||
gopkg.in/src-d/go-git.v4 v4.9.1
|
gopkg.in/src-d/go-git.v4 v4.9.1
|
||||||
gopkg.in/yaml.v2 v2.2.2
|
gopkg.in/yaml.v2 v2.2.2 // indirect
|
||||||
gotest.tools v2.2.0+incompatible
|
gotest.tools v2.2.0+incompatible
|
||||||
)
|
)
|
||||||
|
|
||||||
|
|||||||
+190
@@ -0,0 +1,190 @@
|
|||||||
|
package stdcopy // import "github.com/docker/docker/pkg/stdcopy"
|
||||||
|
|
||||||
|
import (
|
||||||
|
"bytes"
|
||||||
|
"encoding/binary"
|
||||||
|
"errors"
|
||||||
|
"fmt"
|
||||||
|
"io"
|
||||||
|
"sync"
|
||||||
|
)
|
||||||
|
|
||||||
|
// StdType is the type of standard stream
|
||||||
|
// a writer can multiplex to.
|
||||||
|
type StdType byte
|
||||||
|
|
||||||
|
const (
|
||||||
|
// Stdin represents standard input stream type.
|
||||||
|
Stdin StdType = iota
|
||||||
|
// Stdout represents standard output stream type.
|
||||||
|
Stdout
|
||||||
|
// Stderr represents standard error steam type.
|
||||||
|
Stderr
|
||||||
|
// Systemerr represents errors originating from the system that make it
|
||||||
|
// into the multiplexed stream.
|
||||||
|
Systemerr
|
||||||
|
|
||||||
|
stdWriterPrefixLen = 8
|
||||||
|
stdWriterFdIndex = 0
|
||||||
|
stdWriterSizeIndex = 4
|
||||||
|
|
||||||
|
startingBufLen = 32*1024 + stdWriterPrefixLen + 1
|
||||||
|
)
|
||||||
|
|
||||||
|
var bufPool = &sync.Pool{New: func() interface{} { return bytes.NewBuffer(nil) }}
|
||||||
|
|
||||||
|
// stdWriter is wrapper of io.Writer with extra customized info.
|
||||||
|
type stdWriter struct {
|
||||||
|
io.Writer
|
||||||
|
prefix byte
|
||||||
|
}
|
||||||
|
|
||||||
|
// Write sends the buffer to the underneath writer.
|
||||||
|
// It inserts the prefix header before the buffer,
|
||||||
|
// so stdcopy.StdCopy knows where to multiplex the output.
|
||||||
|
// It makes stdWriter to implement io.Writer.
|
||||||
|
func (w *stdWriter) Write(p []byte) (n int, err error) {
|
||||||
|
if w == nil || w.Writer == nil {
|
||||||
|
return 0, errors.New("Writer not instantiated")
|
||||||
|
}
|
||||||
|
if p == nil {
|
||||||
|
return 0, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
header := [stdWriterPrefixLen]byte{stdWriterFdIndex: w.prefix}
|
||||||
|
binary.BigEndian.PutUint32(header[stdWriterSizeIndex:], uint32(len(p)))
|
||||||
|
buf := bufPool.Get().(*bytes.Buffer)
|
||||||
|
buf.Write(header[:])
|
||||||
|
buf.Write(p)
|
||||||
|
|
||||||
|
n, err = w.Writer.Write(buf.Bytes())
|
||||||
|
n -= stdWriterPrefixLen
|
||||||
|
if n < 0 {
|
||||||
|
n = 0
|
||||||
|
}
|
||||||
|
|
||||||
|
buf.Reset()
|
||||||
|
bufPool.Put(buf)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
// NewStdWriter instantiates a new Writer.
|
||||||
|
// Everything written to it will be encapsulated using a custom format,
|
||||||
|
// and written to the underlying `w` stream.
|
||||||
|
// This allows multiple write streams (e.g. stdout and stderr) to be muxed into a single connection.
|
||||||
|
// `t` indicates the id of the stream to encapsulate.
|
||||||
|
// It can be stdcopy.Stdin, stdcopy.Stdout, stdcopy.Stderr.
|
||||||
|
func NewStdWriter(w io.Writer, t StdType) io.Writer {
|
||||||
|
return &stdWriter{
|
||||||
|
Writer: w,
|
||||||
|
prefix: byte(t),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// StdCopy is a modified version of io.Copy.
|
||||||
|
//
|
||||||
|
// StdCopy will demultiplex `src`, assuming that it contains two streams,
|
||||||
|
// previously multiplexed together using a StdWriter instance.
|
||||||
|
// As it reads from `src`, StdCopy will write to `dstout` and `dsterr`.
|
||||||
|
//
|
||||||
|
// StdCopy will read until it hits EOF on `src`. It will then return a nil error.
|
||||||
|
// In other words: if `err` is non nil, it indicates a real underlying error.
|
||||||
|
//
|
||||||
|
// `written` will hold the total number of bytes written to `dstout` and `dsterr`.
|
||||||
|
func StdCopy(dstout, dsterr io.Writer, src io.Reader) (written int64, err error) {
|
||||||
|
var (
|
||||||
|
buf = make([]byte, startingBufLen)
|
||||||
|
bufLen = len(buf)
|
||||||
|
nr, nw int
|
||||||
|
er, ew error
|
||||||
|
out io.Writer
|
||||||
|
frameSize int
|
||||||
|
)
|
||||||
|
|
||||||
|
for {
|
||||||
|
// Make sure we have at least a full header
|
||||||
|
for nr < stdWriterPrefixLen {
|
||||||
|
var nr2 int
|
||||||
|
nr2, er = src.Read(buf[nr:])
|
||||||
|
nr += nr2
|
||||||
|
if er == io.EOF {
|
||||||
|
if nr < stdWriterPrefixLen {
|
||||||
|
return written, nil
|
||||||
|
}
|
||||||
|
break
|
||||||
|
}
|
||||||
|
if er != nil {
|
||||||
|
return 0, er
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
stream := StdType(buf[stdWriterFdIndex])
|
||||||
|
// Check the first byte to know where to write
|
||||||
|
switch stream {
|
||||||
|
case Stdin:
|
||||||
|
fallthrough
|
||||||
|
case Stdout:
|
||||||
|
// Write on stdout
|
||||||
|
out = dstout
|
||||||
|
case Stderr:
|
||||||
|
// Write on stderr
|
||||||
|
out = dsterr
|
||||||
|
case Systemerr:
|
||||||
|
// If we're on Systemerr, we won't write anywhere.
|
||||||
|
// NB: if this code changes later, make sure you don't try to write
|
||||||
|
// to outstream if Systemerr is the stream
|
||||||
|
out = nil
|
||||||
|
default:
|
||||||
|
return 0, fmt.Errorf("Unrecognized input header: %d", buf[stdWriterFdIndex])
|
||||||
|
}
|
||||||
|
|
||||||
|
// Retrieve the size of the frame
|
||||||
|
frameSize = int(binary.BigEndian.Uint32(buf[stdWriterSizeIndex : stdWriterSizeIndex+4]))
|
||||||
|
|
||||||
|
// Check if the buffer is big enough to read the frame.
|
||||||
|
// Extend it if necessary.
|
||||||
|
if frameSize+stdWriterPrefixLen > bufLen {
|
||||||
|
buf = append(buf, make([]byte, frameSize+stdWriterPrefixLen-bufLen+1)...)
|
||||||
|
bufLen = len(buf)
|
||||||
|
}
|
||||||
|
|
||||||
|
// While the amount of bytes read is less than the size of the frame + header, we keep reading
|
||||||
|
for nr < frameSize+stdWriterPrefixLen {
|
||||||
|
var nr2 int
|
||||||
|
nr2, er = src.Read(buf[nr:])
|
||||||
|
nr += nr2
|
||||||
|
if er == io.EOF {
|
||||||
|
if nr < frameSize+stdWriterPrefixLen {
|
||||||
|
return written, nil
|
||||||
|
}
|
||||||
|
break
|
||||||
|
}
|
||||||
|
if er != nil {
|
||||||
|
return 0, er
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// we might have an error from the source mixed up in our multiplexed
|
||||||
|
// stream. if we do, return it.
|
||||||
|
if stream == Systemerr {
|
||||||
|
return written, fmt.Errorf("error from daemon in stream: %s", string(buf[stdWriterPrefixLen:frameSize+stdWriterPrefixLen]))
|
||||||
|
}
|
||||||
|
|
||||||
|
// Write the retrieved frame (without header)
|
||||||
|
nw, ew = out.Write(buf[stdWriterPrefixLen : frameSize+stdWriterPrefixLen])
|
||||||
|
if ew != nil {
|
||||||
|
return 0, ew
|
||||||
|
}
|
||||||
|
|
||||||
|
// If the frame has not been fully written: error
|
||||||
|
if nw != frameSize {
|
||||||
|
return 0, io.ErrShortWrite
|
||||||
|
}
|
||||||
|
written += int64(nw)
|
||||||
|
|
||||||
|
// Move the rest of the buffer to the beginning
|
||||||
|
copy(buf, buf[frameSize+stdWriterPrefixLen:])
|
||||||
|
// Move the index
|
||||||
|
nr -= frameSize + stdWriterPrefixLen
|
||||||
|
}
|
||||||
|
}
|
||||||
+28
@@ -0,0 +1,28 @@
|
|||||||
|
// Package require implements the same assertions as the `assert` package but
|
||||||
|
// stops test execution when a test fails.
|
||||||
|
//
|
||||||
|
// Example Usage
|
||||||
|
//
|
||||||
|
// The following is a complete example using require in a standard test function:
|
||||||
|
// import (
|
||||||
|
// "testing"
|
||||||
|
// "github.com/stretchr/testify/require"
|
||||||
|
// )
|
||||||
|
//
|
||||||
|
// func TestSomething(t *testing.T) {
|
||||||
|
//
|
||||||
|
// var a string = "Hello"
|
||||||
|
// var b string = "Hello"
|
||||||
|
//
|
||||||
|
// require.Equal(t, a, b, "The two words should be the same.")
|
||||||
|
//
|
||||||
|
// }
|
||||||
|
//
|
||||||
|
// Assertions
|
||||||
|
//
|
||||||
|
// The `require` package have same global functions as in the `assert` package,
|
||||||
|
// but instead of returning a boolean result they call `t.FailNow()`.
|
||||||
|
//
|
||||||
|
// Every assertion function also takes an optional string message as the final argument,
|
||||||
|
// allowing custom error messages to be appended to the message the assertion method outputs.
|
||||||
|
package require
|
||||||
+16
@@ -0,0 +1,16 @@
|
|||||||
|
package require
|
||||||
|
|
||||||
|
// Assertions provides assertion methods around the
|
||||||
|
// TestingT interface.
|
||||||
|
type Assertions struct {
|
||||||
|
t TestingT
|
||||||
|
}
|
||||||
|
|
||||||
|
// New makes a new Assertions object for the specified TestingT.
|
||||||
|
func New(t TestingT) *Assertions {
|
||||||
|
return &Assertions{
|
||||||
|
t: t,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
//go:generate go run ../_codegen/main.go -output-package=require -template=require_forward.go.tmpl -include-format-funcs
|
||||||
+1227
File diff suppressed because it is too large.
Load diff
+6
@@ -0,0 +1,6 @@
|
|||||||
|
{{.Comment}}
|
||||||
|
func {{.DocInfo.Name}}(t TestingT, {{.Params}}) {
|
||||||
|
if assert.{{.DocInfo.Name}}(t, {{.ForwardedParams}}) { return }
|
||||||
|
if h, ok := t.(tHelper); ok { h.Helper() }
|
||||||
|
t.FailNow()
|
||||||
|
}
|
||||||
+957
File diff suppressed because it is too large.
Load diff
+5
@@ -0,0 +1,5 @@
|
|||||||
|
{{.CommentWithoutT "a"}}
|
||||||
|
func (a *Assertions) {{.DocInfo.Name}}({{.Params}}) {
|
||||||
|
if h, ok := a.t.(tHelper); ok { h.Helper() }
|
||||||
|
{{.DocInfo.Name}}(a.t, {{.ForwardedParams}})
|
||||||
|
}
|
||||||
+29
@@ -0,0 +1,29 @@
|
|||||||
|
package require
|
||||||
|
|
||||||
|
// TestingT is an interface wrapper around *testing.T
|
||||||
|
type TestingT interface {
|
||||||
|
Errorf(format string, args ...interface{})
|
||||||
|
FailNow()
|
||||||
|
}
|
||||||
|
|
||||||
|
type tHelper interface {
|
||||||
|
Helper()
|
||||||
|
}
|
||||||
|
|
||||||
|
// ComparisonAssertionFunc is a common function prototype when comparing two values. Can be useful
|
||||||
|
// for table driven tests.
|
||||||
|
type ComparisonAssertionFunc func(TestingT, interface{}, interface{}, ...interface{})
|
||||||
|
|
||||||
|
// ValueAssertionFunc is a common function prototype when validating a single value. Can be useful
|
||||||
|
// for table driven tests.
|
||||||
|
type ValueAssertionFunc func(TestingT, interface{}, ...interface{})
|
||||||
|
|
||||||
|
// BoolAssertionFunc is a common function prototype when validating a bool value. Can be useful
|
||||||
|
// for table driven tests.
|
||||||
|
type BoolAssertionFunc func(TestingT, bool, ...interface{})
|
||||||
|
|
||||||
|
// ErrorAssertionFunc is a common function prototype when validating an error value. Can be useful
|
||||||
|
// for table driven tests.
|
||||||
|
type ErrorAssertionFunc func(TestingT, error, ...interface{})
|
||||||
|
|
||||||
|
//go:generate go run ../_codegen/main.go -output-package=require -template=require.go.tmpl -include-format-funcs
|
||||||
-12
@@ -1,12 +0,0 @@
|
|||||||
language: go
|
|
||||||
|
|
||||||
go:
|
|
||||||
- 1.4
|
|
||||||
- 1.5
|
|
||||||
- 1.6
|
|
||||||
- 1.7
|
|
||||||
- 1.8
|
|
||||||
- 1.9
|
|
||||||
- tip
|
|
||||||
|
|
||||||
go_import_path: gopkg.in/yaml.v2
|
|
||||||
-201
@@ -1,201 +0,0 @@
|
|||||||
Apache License
|
|
||||||
Version 2.0, January 2004
|
|
||||||
http://www.apache.org/licenses/
|
|
||||||
|
|
||||||
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
|
|
||||||
|
|
||||||
1. Definitions.
|
|
||||||
|
|
||||||
"License" shall mean the terms and conditions for use, reproduction,
|
|
||||||
and distribution as defined by Sections 1 through 9 of this document.
|
|
||||||
|
|
||||||
"Licensor" shall mean the copyright owner or entity authorized by
|
|
||||||
the copyright owner that is granting the License.
|
|
||||||
|
|
||||||
"Legal Entity" shall mean the union of the acting entity and all
|
|
||||||
other entities that control, are controlled by, or are under common
|
|
||||||
control with that entity. For the purposes of this definition,
|
|
||||||
"control" means (i) the power, direct or indirect, to cause the
|
|
||||||
direction or management of such entity, whether by contract or
|
|
||||||
otherwise, or (ii) ownership of fifty percent (50%) or more of the
|
|
||||||
outstanding shares, or (iii) beneficial ownership of such entity.
|
|
||||||
|
|
||||||
"You" (or "Your") shall mean an individual or Legal Entity
|
|
||||||
exercising permissions granted by this License.
|
|
||||||
|
|
||||||
"Source" form shall mean the preferred form for making modifications,
|
|
||||||
including but not limited to software source code, documentation
|
|
||||||
source, and configuration files.
|
|
||||||
|
|
||||||
"Object" form shall mean any form resulting from mechanical
|
|
||||||
transformation or translation of a Source form, including but
|
|
||||||
not limited to compiled object code, generated documentation,
|
|
||||||
and conversions to other media types.
|
|
||||||
|
|
||||||
"Work" shall mean the work of authorship, whether in Source or
|
|
||||||
Object form, made available under the License, as indicated by a
|
|
||||||
copyright notice that is included in or attached to the work
|
|
||||||
(an example is provided in the Appendix below).
|
|
||||||
|
|
||||||
"Derivative Works" shall mean any work, whether in Source or Object
|
|
||||||
form, that is based on (or derived from) the Work and for which the
|
|
||||||
editorial revisions, annotations, elaborations, or other modifications
|
|
||||||
represent, as a whole, an original work of authorship. For the purposes
|
|
||||||
of this License, Derivative Works shall not include works that remain
|
|
||||||
separable from, or merely link (or bind by name) to the interfaces of,
|
|
||||||
the Work and Derivative Works thereof.
|
|
||||||
|
|
||||||
"Contribution" shall mean any work of authorship, including
|
|
||||||
the original version of the Work and any modifications or additions
|
|
||||||
to that Work or Derivative Works thereof, that is intentionally
|
|
||||||
submitted to Licensor for inclusion in the Work by the copyright owner
|
|
||||||
or by an individual or Legal Entity authorized to submit on behalf of
|
|
||||||
the copyright owner. For the purposes of this definition, "submitted"
|
|
||||||
means any form of electronic, verbal, or written communication sent
|
|
||||||
to the Licensor or its representatives, including but not limited to
|
|
||||||
communication on electronic mailing lists, source code control systems,
|
|
||||||
and issue tracking systems that are managed by, or on behalf of, the
|
|
||||||
Licensor for the purpose of discussing and improving the Work, but
|
|
||||||
excluding communication that is conspicuously marked or otherwise
|
|
||||||
designated in writing by the copyright owner as "Not a Contribution."
|
|
||||||
|
|
||||||
"Contributor" shall mean Licensor and any individual or Legal Entity
|
|
||||||
on behalf of whom a Contribution has been received by Licensor and
|
|
||||||
subsequently incorporated within the Work.
|
|
||||||
|
|
||||||
2. Grant of Copyright License. Subject to the terms and conditions of
|
|
||||||
this License, each Contributor hereby grants to You a perpetual,
|
|
||||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
|
||||||
copyright license to reproduce, prepare Derivative Works of,
|
|
||||||
publicly display, publicly perform, sublicense, and distribute the
|
|
||||||
Work and such Derivative Works in Source or Object form.
|
|
||||||
|
|
||||||
3. Grant of Patent License. Subject to the terms and conditions of
|
|
||||||
this License, each Contributor hereby grants to You a perpetual,
|
|
||||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
|
||||||
(except as stated in this section) patent license to make, have made,
|
|
||||||
use, offer to sell, sell, import, and otherwise transfer the Work,
|
|
||||||
where such license applies only to those patent claims licensable
|
|
||||||
by such Contributor that are necessarily infringed by their
|
|
||||||
Contribution(s) alone or by combination of their Contribution(s)
|
|
||||||
with the Work to which such Contribution(s) was submitted. If You
|
|
||||||
institute patent litigation against any entity (including a
|
|
||||||
cross-claim or counterclaim in a lawsuit) alleging that the Work
|
|
||||||
or a Contribution incorporated within the Work constitutes direct
|
|
||||||
or contributory patent infringement, then any patent licenses
|
|
||||||
granted to You under this License for that Work shall terminate
|
|
||||||
as of the date such litigation is filed.
|
|
||||||
|
|
||||||
4. Redistribution. You may reproduce and distribute copies of the
|
|
||||||
Work or Derivative Works thereof in any medium, with or without
|
|
||||||
modifications, and in Source or Object form, provided that You
|
|
||||||
meet the following conditions:
|
|
||||||
|
|
||||||
(a) You must give any other recipients of the Work or
|
|
||||||
Derivative Works a copy of this License; and
|
|
||||||
|
|
||||||
(b) You must cause any modified files to carry prominent notices
|
|
||||||
stating that You changed the files; and
|
|
||||||
|
|
||||||
(c) You must retain, in the Source form of any Derivative Works
|
|
||||||
that You distribute, all copyright, patent, trademark, and
|
|
||||||
attribution notices from the Source form of the Work,
|
|
||||||
excluding those notices that do not pertain to any part of
|
|
||||||
the Derivative Works; and
|
|
||||||
|
|
||||||
(d) If the Work includes a "NOTICE" text file as part of its
|
|
||||||
distribution, then any Derivative Works that You distribute must
|
|
||||||
include a readable copy of the attribution notices contained
|
|
||||||
within such NOTICE file, excluding those notices that do not
|
|
||||||
pertain to any part of the Derivative Works, in at least one
|
|
||||||
of the following places: within a NOTICE text file distributed
|
|
||||||
as part of the Derivative Works; within the Source form or
|
|
||||||
documentation, if provided along with the Derivative Works; or,
|
|
||||||
within a display generated by the Derivative Works, if and
|
|
||||||
wherever such third-party notices normally appear. The contents
|
|
||||||
of the NOTICE file are for informational purposes only and
|
|
||||||
do not modify the License. You may add Your own attribution
|
|
||||||
notices within Derivative Works that You distribute, alongside
|
|
||||||
or as an addendum to the NOTICE text from the Work, provided
|
|
||||||
that such additional attribution notices cannot be construed
|
|
||||||
as modifying the License.
|
|
||||||
|
|
||||||
You may add Your own copyright statement to Your modifications and
|
|
||||||
may provide additional or different license terms and conditions
|
|
||||||
for use, reproduction, or distribution of Your modifications, or
|
|
||||||
for any such Derivative Works as a whole, provided Your use,
|
|
||||||
reproduction, and distribution of the Work otherwise complies with
|
|
||||||
the conditions stated in this License.
|
|
||||||
|
|
||||||
5. Submission of Contributions. Unless You explicitly state otherwise,
|
|
||||||
any Contribution intentionally submitted for inclusion in the Work
|
|
||||||
by You to the Licensor shall be under the terms and conditions of
|
|
||||||
this License, without any additional terms or conditions.
|
|
||||||
Notwithstanding the above, nothing herein shall supersede or modify
|
|
||||||
the terms of any separate license agreement you may have executed
|
|
||||||
with Licensor regarding such Contributions.
|
|
||||||
|
|
||||||
6. Trademarks. This License does not grant permission to use the trade
|
|
||||||
names, trademarks, service marks, or product names of the Licensor,
|
|
||||||
except as required for reasonable and customary use in describing the
|
|
||||||
origin of the Work and reproducing the content of the NOTICE file.
|
|
||||||
|
|
||||||
7. Disclaimer of Warranty. Unless required by applicable law or
|
|
||||||
agreed to in writing, Licensor provides the Work (and each
|
|
||||||
Contributor provides its Contributions) on an "AS IS" BASIS,
|
|
||||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
|
|
||||||
implied, including, without limitation, any warranties or conditions
|
|
||||||
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
|
|
||||||
PARTICULAR PURPOSE. You are solely responsible for determining the
|
|
||||||
appropriateness of using or redistributing the Work and assume any
|
|
||||||
risks associated with Your exercise of permissions under this License.
|
|
||||||
|
|
||||||
8. Limitation of Liability. In no event and under no legal theory,
|
|
||||||
whether in tort (including negligence), contract, or otherwise,
|
|
||||||
unless required by applicable law (such as deliberate and grossly
|
|
||||||
negligent acts) or agreed to in writing, shall any Contributor be
|
|
||||||
liable to You for damages, including any direct, indirect, special,
|
|
||||||
incidental, or consequential damages of any character arising as a
|
|
||||||
result of this License or out of the use or inability to use the
|
|
||||||
Work (including but not limited to damages for loss of goodwill,
|
|
||||||
work stoppage, computer failure or malfunction, or any and all
|
|
||||||
other commercial damages or losses), even if such Contributor
|
|
||||||
has been advised of the possibility of such damages.
|
|
||||||
|
|
||||||
9. Accepting Warranty or Additional Liability. While redistributing
|
|
||||||
the Work or Derivative Works thereof, You may choose to offer,
|
|
||||||
and charge a fee for, acceptance of support, warranty, indemnity,
|
|
||||||
or other liability obligations and/or rights consistent with this
|
|
||||||
License. However, in accepting such obligations, You may act only
|
|
||||||
on Your own behalf and on Your sole responsibility, not on behalf
|
|
||||||
of any other Contributor, and only if You agree to indemnify,
|
|
||||||
defend, and hold each Contributor harmless for any liability
|
|
||||||
incurred by, or claims asserted against, such Contributor by reason
|
|
||||||
of your accepting any such warranty or additional liability.
|
|
||||||
|
|
||||||
END OF TERMS AND CONDITIONS
|
|
||||||
|
|
||||||
APPENDIX: How to apply the Apache License to your work.
|
|
||||||
|
|
||||||
To apply the Apache License to your work, attach the following
|
|
||||||
boilerplate notice, with the fields enclosed by brackets "{}"
|
|
||||||
replaced with your own identifying information. (Don't include
|
|
||||||
the brackets!) The text should be enclosed in the appropriate
|
|
||||||
comment syntax for the file format. We also recommend that a
|
|
||||||
file or class name and description of purpose be included on the
|
|
||||||
same "printed page" as the copyright notice for easier
|
|
||||||
identification within third-party archives.
|
|
||||||
|
|
||||||
Copyright {yyyy} {name of copyright owner}
|
|
||||||
|
|
||||||
Licensed under the Apache License, Version 2.0 (the "License");
|
|
||||||
you may not use this file except in compliance with the License.
|
|
||||||
You may obtain a copy of the License at
|
|
||||||
|
|
||||||
http://www.apache.org/licenses/LICENSE-2.0
|
|
||||||
|
|
||||||
Unless required by applicable law or agreed to in writing, software
|
|
||||||
distributed under the License is distributed on an "AS IS" BASIS,
|
|
||||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
||||||
See the License for the specific language governing permissions and
|
|
||||||
limitations under the License.
|
|
||||||
-31
@@ -1,31 +0,0 @@
|
|||||||
The following files were ported to Go from C files of libyaml, and thus
|
|
||||||
are still covered by their original copyright and license:
|
|
||||||
|
|
||||||
apic.go
|
|
||||||
emitterc.go
|
|
||||||
parserc.go
|
|
||||||
readerc.go
|
|
||||||
scannerc.go
|
|
||||||
writerc.go
|
|
||||||
yamlh.go
|
|
||||||
yamlprivateh.go
|
|
||||||
|
|
||||||
Copyright (c) 2006 Kirill Simonov
|
|
||||||
|
|
||||||
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.
|
|
||||||
-13
@@ -1,13 +0,0 @@
|
|||||||
Copyright 2011-2016 Canonical Ltd.
|
|
||||||
|
|
||||||
Licensed under the Apache License, Version 2.0 (the "License");
|
|
||||||
you may not use this file except in compliance with the License.
|
|
||||||
You may obtain a copy of the License at
|
|
||||||
|
|
||||||
http://www.apache.org/licenses/LICENSE-2.0
|
|
||||||
|
|
||||||
Unless required by applicable law or agreed to in writing, software
|
|
||||||
distributed under the License is distributed on an "AS IS" BASIS,
|
|
||||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
||||||
See the License for the specific language governing permissions and
|
|
||||||
limitations under the License.
|
|
||||||
-133
@@ -1,133 +0,0 @@
|
|||||||
# YAML support for the Go language
|
|
||||||
|
|
||||||
Introduction
|
|
||||||
------------
|
|
||||||
|
|
||||||
The yaml package enables Go programs to comfortably encode and decode YAML
|
|
||||||
values. It was developed within [Canonical](https://www.canonical.com) as
|
|
||||||
part of the [juju](https://juju.ubuntu.com) project, and is based on a
|
|
||||||
pure Go port of the well-known [libyaml](http://pyyaml.org/wiki/LibYAML)
|
|
||||||
C library to parse and generate YAML data quickly and reliably.
|
|
||||||
|
|
||||||
Compatibility
|
|
||||||
-------------
|
|
||||||
|
|
||||||
The yaml package supports most of YAML 1.1 and 1.2, including support for
|
|
||||||
anchors, tags, map merging, etc. Multi-document unmarshalling is not yet
|
|
||||||
implemented, and base-60 floats from YAML 1.1 are purposefully not
|
|
||||||
supported since they're a poor design and are gone in YAML 1.2.
|
|
||||||
|
|
||||||
Installation and usage
|
|
||||||
----------------------
|
|
||||||
|
|
||||||
The import path for the package is *gopkg.in/yaml.v2*.
|
|
||||||
|
|
||||||
To install it, run:
|
|
||||||
|
|
||||||
go get gopkg.in/yaml.v2
|
|
||||||
|
|
||||||
API documentation
|
|
||||||
-----------------
|
|
||||||
|
|
||||||
If opened in a browser, the import path itself leads to the API documentation:
|
|
||||||
|
|
||||||
* [https://gopkg.in/yaml.v2](https://gopkg.in/yaml.v2)
|
|
||||||
|
|
||||||
API stability
|
|
||||||
-------------
|
|
||||||
|
|
||||||
The package API for yaml v2 will remain stable as described in [gopkg.in](https://gopkg.in).
|
|
||||||
|
|
||||||
|
|
||||||
License
|
|
||||||
-------
|
|
||||||
|
|
||||||
The yaml package is licensed under the Apache License 2.0. Please see the LICENSE file for details.
|
|
||||||
|
|
||||||
|
|
||||||
Example
|
|
||||||
-------
|
|
||||||
|
|
||||||
```Go
|
|
||||||
package main
|
|
||||||
|
|
||||||
import (
|
|
||||||
"fmt"
|
|
||||||
"log"
|
|
||||||
|
|
||||||
"gopkg.in/yaml.v2"
|
|
||||||
)
|
|
||||||
|
|
||||||
var data = `
|
|
||||||
a: Easy!
|
|
||||||
b:
|
|
||||||
c: 2
|
|
||||||
d: [3, 4]
|
|
||||||
`
|
|
||||||
|
|
||||||
// Note: struct fields must be public in order for unmarshal to
|
|
||||||
// correctly populate the data.
|
|
||||||
type T struct {
|
|
||||||
A string
|
|
||||||
B struct {
|
|
||||||
RenamedC int `yaml:"c"`
|
|
||||||
D []int `yaml:",flow"`
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func main() {
|
|
||||||
t := T{}
|
|
||||||
|
|
||||||
err := yaml.Unmarshal([]byte(data), &t)
|
|
||||||
if err != nil {
|
|
||||||
log.Fatalf("error: %v", err)
|
|
||||||
}
|
|
||||||
fmt.Printf("--- t:\n%v\n\n", t)
|
|
||||||
|
|
||||||
d, err := yaml.Marshal(&t)
|
|
||||||
if err != nil {
|
|
||||||
log.Fatalf("error: %v", err)
|
|
||||||
}
|
|
||||||
fmt.Printf("--- t dump:\n%s\n\n", string(d))
|
|
||||||
|
|
||||||
m := make(map[interface{}]interface{})
|
|
||||||
|
|
||||||
err = yaml.Unmarshal([]byte(data), &m)
|
|
||||||
if err != nil {
|
|
||||||
log.Fatalf("error: %v", err)
|
|
||||||
}
|
|
||||||
fmt.Printf("--- m:\n%v\n\n", m)
|
|
||||||
|
|
||||||
d, err = yaml.Marshal(&m)
|
|
||||||
if err != nil {
|
|
||||||
log.Fatalf("error: %v", err)
|
|
||||||
}
|
|
||||||
fmt.Printf("--- m dump:\n%s\n\n", string(d))
|
|
||||||
}
|
|
||||||
```
|
|
||||||
|
|
||||||
This example will generate the following output:
|
|
||||||
|
|
||||||
```
|
|
||||||
--- t:
|
|
||||||
{Easy! {2 [3 4]}}
|
|
||||||
|
|
||||||
--- t dump:
|
|
||||||
a: Easy!
|
|
||||||
b:
|
|
||||||
c: 2
|
|
||||||
d: [3, 4]
|
|
||||||
|
|
||||||
|
|
||||||
--- m:
|
|
||||||
map[a:Easy! b:map[c:2 d:[3 4]]]
|
|
||||||
|
|
||||||
--- m dump:
|
|
||||||
a: Easy!
|
|
||||||
b:
|
|
||||||
c: 2
|
|
||||||
d:
|
|
||||||
- 3
|
|
||||||
- 4
|
|
||||||
```
|
|
||||||
|
|
||||||
-739
File diff suppressed because it is too large.
Load diff
-775
File diff suppressed because it is too large.
Load diff
-1685
File diff suppressed because it is too large.
Load diff
-390
@@ -1,390 +0,0 @@
|
|||||||
package yaml
|
|
||||||
|
|
||||||
import (
|
|
||||||
"encoding"
|
|
||||||
"fmt"
|
|
||||||
"io"
|
|
||||||
"reflect"
|
|
||||||
"regexp"
|
|
||||||
"sort"
|
|
||||||
"strconv"
|
|
||||||
"strings"
|
|
||||||
"time"
|
|
||||||
"unicode/utf8"
|
|
||||||
)
|
|
||||||
|
|
||||||
// jsonNumber is the interface of the encoding/json.Number datatype.
|
|
||||||
// Repeating the interface here avoids a dependency on encoding/json, and also
|
|
||||||
// supports other libraries like jsoniter, which use a similar datatype with
|
|
||||||
// the same interface. Detecting this interface is useful when dealing with
|
|
||||||
// structures containing json.Number, which is a string under the hood. The
|
|
||||||
// encoder should prefer the use of Int64(), Float64() and string(), in that
|
|
||||||
// order, when encoding this type.
|
|
||||||
type jsonNumber interface {
|
|
||||||
Float64() (float64, error)
|
|
||||||
Int64() (int64, error)
|
|
||||||
String() string
|
|
||||||
}
|
|
||||||
|
|
||||||
type encoder struct {
|
|
||||||
emitter yaml_emitter_t
|
|
||||||
event yaml_event_t
|
|
||||||
out []byte
|
|
||||||
flow bool
|
|
||||||
// doneInit holds whether the initial stream_start_event has been
|
|
||||||
// emitted.
|
|
||||||
doneInit bool
|
|
||||||
}
|
|
||||||
|
|
||||||
func newEncoder() *encoder {
|
|
||||||
e := &encoder{}
|
|
||||||
yaml_emitter_initialize(&e.emitter)
|
|
||||||
yaml_emitter_set_output_string(&e.emitter, &e.out)
|
|
||||||
yaml_emitter_set_unicode(&e.emitter, true)
|
|
||||||
return e
|
|
||||||
}
|
|
||||||
|
|
||||||
func newEncoderWithWriter(w io.Writer) *encoder {
|
|
||||||
e := &encoder{}
|
|
||||||
yaml_emitter_initialize(&e.emitter)
|
|
||||||
yaml_emitter_set_output_writer(&e.emitter, w)
|
|
||||||
yaml_emitter_set_unicode(&e.emitter, true)
|
|
||||||
return e
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *encoder) init() {
|
|
||||||
if e.doneInit {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
yaml_stream_start_event_initialize(&e.event, yaml_UTF8_ENCODING)
|
|
||||||
e.emit()
|
|
||||||
e.doneInit = true
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *encoder) finish() {
|
|
||||||
e.emitter.open_ended = false
|
|
||||||
yaml_stream_end_event_initialize(&e.event)
|
|
||||||
e.emit()
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *encoder) destroy() {
|
|
||||||
yaml_emitter_delete(&e.emitter)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *encoder) emit() {
|
|
||||||
// This will internally delete the e.event value.
|
|
||||||
e.must(yaml_emitter_emit(&e.emitter, &e.event))
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *encoder) must(ok bool) {
|
|
||||||
if !ok {
|
|
||||||
msg := e.emitter.problem
|
|
||||||
if msg == "" {
|
|
||||||
msg = "unknown problem generating YAML content"
|
|
||||||
}
|
|
||||||
failf("%s", msg)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *encoder) marshalDoc(tag string, in reflect.Value) {
|
|
||||||
e.init()
|
|
||||||
yaml_document_start_event_initialize(&e.event, nil, nil, true)
|
|
||||||
e.emit()
|
|
||||||
e.marshal(tag, in)
|
|
||||||
yaml_document_end_event_initialize(&e.event, true)
|
|
||||||
e.emit()
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *encoder) marshal(tag string, in reflect.Value) {
|
|
||||||
if !in.IsValid() || in.Kind() == reflect.Ptr && in.IsNil() {
|
|
||||||
e.nilv()
|
|
||||||
return
|
|
||||||
}
|
|
||||||
iface := in.Interface()
|
|
||||||
switch m := iface.(type) {
|
|
||||||
case jsonNumber:
|
|
||||||
integer, err := m.Int64()
|
|
||||||
if err == nil {
|
|
||||||
// In this case the json.Number is a valid int64
|
|
||||||
in = reflect.ValueOf(integer)
|
|
||||||
break
|
|
||||||
}
|
|
||||||
float, err := m.Float64()
|
|
||||||
if err == nil {
|
|
||||||
// In this case the json.Number is a valid float64
|
|
||||||
in = reflect.ValueOf(float)
|
|
||||||
break
|
|
||||||
}
|
|
||||||
// fallback case - no number could be obtained
|
|
||||||
in = reflect.ValueOf(m.String())
|
|
||||||
case time.Time, *time.Time:
|
|
||||||
// Although time.Time implements TextMarshaler,
|
|
||||||
// we don't want to treat it as a string for YAML
|
|
||||||
// purposes because YAML has special support for
|
|
||||||
// timestamps.
|
|
||||||
case Marshaler:
|
|
||||||
v, err := m.MarshalYAML()
|
|
||||||
if err != nil {
|
|
||||||
fail(err)
|
|
||||||
}
|
|
||||||
if v == nil {
|
|
||||||
e.nilv()
|
|
||||||
return
|
|
||||||
}
|
|
||||||
in = reflect.ValueOf(v)
|
|
||||||
case encoding.TextMarshaler:
|
|
||||||
text, err := m.MarshalText()
|
|
||||||
if err != nil {
|
|
||||||
fail(err)
|
|
||||||
}
|
|
||||||
in = reflect.ValueOf(string(text))
|
|
||||||
case nil:
|
|
||||||
e.nilv()
|
|
||||||
return
|
|
||||||
}
|
|
||||||
switch in.Kind() {
|
|
||||||
case reflect.Interface:
|
|
||||||
e.marshal(tag, in.Elem())
|
|
||||||
case reflect.Map:
|
|
||||||
e.mapv(tag, in)
|
|
||||||
case reflect.Ptr:
|
|
||||||
if in.Type() == ptrTimeType {
|
|
||||||
e.timev(tag, in.Elem())
|
|
||||||
} else {
|
|
||||||
e.marshal(tag, in.Elem())
|
|
||||||
}
|
|
||||||
case reflect.Struct:
|
|
||||||
if in.Type() == timeType {
|
|
||||||
e.timev(tag, in)
|
|
||||||
} else {
|
|
||||||
e.structv(tag, in)
|
|
||||||
}
|
|
||||||
case reflect.Slice, reflect.Array:
|
|
||||||
if in.Type().Elem() == mapItemType {
|
|
||||||
e.itemsv(tag, in)
|
|
||||||
} else {
|
|
||||||
e.slicev(tag, in)
|
|
||||||
}
|
|
||||||
case reflect.String:
|
|
||||||
e.stringv(tag, in)
|
|
||||||
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
|
|
||||||
if in.Type() == durationType {
|
|
||||||
e.stringv(tag, reflect.ValueOf(iface.(time.Duration).String()))
|
|
||||||
} else {
|
|
||||||
e.intv(tag, in)
|
|
||||||
}
|
|
||||||
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
|
|
||||||
e.uintv(tag, in)
|
|
||||||
case reflect.Float32, reflect.Float64:
|
|
||||||
e.floatv(tag, in)
|
|
||||||
case reflect.Bool:
|
|
||||||
e.boolv(tag, in)
|
|
||||||
default:
|
|
||||||
panic("cannot marshal type: " + in.Type().String())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *encoder) mapv(tag string, in reflect.Value) {
|
|
||||||
e.mappingv(tag, func() {
|
|
||||||
keys := keyList(in.MapKeys())
|
|
||||||
sort.Sort(keys)
|
|
||||||
for _, k := range keys {
|
|
||||||
e.marshal("", k)
|
|
||||||
e.marshal("", in.MapIndex(k))
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *encoder) itemsv(tag string, in reflect.Value) {
|
|
||||||
e.mappingv(tag, func() {
|
|
||||||
slice := in.Convert(reflect.TypeOf([]MapItem{})).Interface().([]MapItem)
|
|
||||||
for _, item := range slice {
|
|
||||||
e.marshal("", reflect.ValueOf(item.Key))
|
|
||||||
e.marshal("", reflect.ValueOf(item.Value))
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *encoder) structv(tag string, in reflect.Value) {
|
|
||||||
sinfo, err := getStructInfo(in.Type())
|
|
||||||
if err != nil {
|
|
||||||
panic(err)
|
|
||||||
}
|
|
||||||
e.mappingv(tag, func() {
|
|
||||||
for _, info := range sinfo.FieldsList {
|
|
||||||
var value reflect.Value
|
|
||||||
if info.Inline == nil {
|
|
||||||
value = in.Field(info.Num)
|
|
||||||
} else {
|
|
||||||
value = in.FieldByIndex(info.Inline)
|
|
||||||
}
|
|
||||||
if info.OmitEmpty && isZero(value) {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
e.marshal("", reflect.ValueOf(info.Key))
|
|
||||||
e.flow = info.Flow
|
|
||||||
e.marshal("", value)
|
|
||||||
}
|
|
||||||
if sinfo.InlineMap >= 0 {
|
|
||||||
m := in.Field(sinfo.InlineMap)
|
|
||||||
if m.Len() > 0 {
|
|
||||||
e.flow = false
|
|
||||||
keys := keyList(m.MapKeys())
|
|
||||||
sort.Sort(keys)
|
|
||||||
for _, k := range keys {
|
|
||||||
if _, found := sinfo.FieldsMap[k.String()]; found {
|
|
||||||
panic(fmt.Sprintf("Can't have key %q in inlined map; conflicts with struct field", k.String()))
|
|
||||||
}
|
|
||||||
e.marshal("", k)
|
|
||||||
e.flow = false
|
|
||||||
e.marshal("", m.MapIndex(k))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *encoder) mappingv(tag string, f func()) {
|
|
||||||
implicit := tag == ""
|
|
||||||
style := yaml_BLOCK_MAPPING_STYLE
|
|
||||||
if e.flow {
|
|
||||||
e.flow = false
|
|
||||||
style = yaml_FLOW_MAPPING_STYLE
|
|
||||||
}
|
|
||||||
yaml_mapping_start_event_initialize(&e.event, nil, []byte(tag), implicit, style)
|
|
||||||
e.emit()
|
|
||||||
f()
|
|
||||||
yaml_mapping_end_event_initialize(&e.event)
|
|
||||||
e.emit()
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *encoder) slicev(tag string, in reflect.Value) {
|
|
||||||
implicit := tag == ""
|
|
||||||
style := yaml_BLOCK_SEQUENCE_STYLE
|
|
||||||
if e.flow {
|
|
||||||
e.flow = false
|
|
||||||
style = yaml_FLOW_SEQUENCE_STYLE
|
|
||||||
}
|
|
||||||
e.must(yaml_sequence_start_event_initialize(&e.event, nil, []byte(tag), implicit, style))
|
|
||||||
e.emit()
|
|
||||||
n := in.Len()
|
|
||||||
for i := 0; i < n; i++ {
|
|
||||||
e.marshal("", in.Index(i))
|
|
||||||
}
|
|
||||||
e.must(yaml_sequence_end_event_initialize(&e.event))
|
|
||||||
e.emit()
|
|
||||||
}
|
|
||||||
|
|
||||||
// isBase60 returns whether s is in base 60 notation as defined in YAML 1.1.
|
|
||||||
//
|
|
||||||
// The base 60 float notation in YAML 1.1 is a terrible idea and is unsupported
|
|
||||||
// in YAML 1.2 and by this package, but these should be marshalled quoted for
|
|
||||||
// the time being for compatibility with other parsers.
|
|
||||||
func isBase60Float(s string) (result bool) {
|
|
||||||
// Fast path.
|
|
||||||
if s == "" {
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
c := s[0]
|
|
||||||
if !(c == '+' || c == '-' || c >= '0' && c <= '9') || strings.IndexByte(s, ':') < 0 {
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
// Do the full match.
|
|
||||||
return base60float.MatchString(s)
|
|
||||||
}
|
|
||||||
|
|
||||||
// From http://yaml.org/type/float.html, except the regular expression there
|
|
||||||
// is bogus. In practice parsers do not enforce the "\.[0-9_]*" suffix.
|
|
||||||
var base60float = regexp.MustCompile(`^[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+(?:\.[0-9_]*)?$`)
|
|
||||||
|
|
||||||
func (e *encoder) stringv(tag string, in reflect.Value) {
|
|
||||||
var style yaml_scalar_style_t
|
|
||||||
s := in.String()
|
|
||||||
canUsePlain := true
|
|
||||||
switch {
|
|
||||||
case !utf8.ValidString(s):
|
|
||||||
if tag == yaml_BINARY_TAG {
|
|
||||||
failf("explicitly tagged !!binary data must be base64-encoded")
|
|
||||||
}
|
|
||||||
if tag != "" {
|
|
||||||
failf("cannot marshal invalid UTF-8 data as %s", shortTag(tag))
|
|
||||||
}
|
|
||||||
// It can't be encoded directly as YAML so use a binary tag
|
|
||||||
// and encode it as base64.
|
|
||||||
tag = yaml_BINARY_TAG
|
|
||||||
s = encodeBase64(s)
|
|
||||||
case tag == "":
|
|
||||||
// Check to see if it would resolve to a specific
|
|
||||||
// tag when encoded unquoted. If it doesn't,
|
|
||||||
// there's no need to quote it.
|
|
||||||
rtag, _ := resolve("", s)
|
|
||||||
canUsePlain = rtag == yaml_STR_TAG && !isBase60Float(s)
|
|
||||||
}
|
|
||||||
// Note: it's possible for user code to emit invalid YAML
|
|
||||||
// if they explicitly specify a tag and a string containing
|
|
||||||
// text that's incompatible with that tag.
|
|
||||||
switch {
|
|
||||||
case strings.Contains(s, "\n"):
|
|
||||||
style = yaml_LITERAL_SCALAR_STYLE
|
|
||||||
case canUsePlain:
|
|
||||||
style = yaml_PLAIN_SCALAR_STYLE
|
|
||||||
default:
|
|
||||||
style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
|
|
||||||
}
|
|
||||||
e.emitScalar(s, "", tag, style)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *encoder) boolv(tag string, in reflect.Value) {
|
|
||||||
var s string
|
|
||||||
if in.Bool() {
|
|
||||||
s = "true"
|
|
||||||
} else {
|
|
||||||
s = "false"
|
|
||||||
}
|
|
||||||
e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *encoder) intv(tag string, in reflect.Value) {
|
|
||||||
s := strconv.FormatInt(in.Int(), 10)
|
|
||||||
e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *encoder) uintv(tag string, in reflect.Value) {
|
|
||||||
s := strconv.FormatUint(in.Uint(), 10)
|
|
||||||
e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *encoder) timev(tag string, in reflect.Value) {
|
|
||||||
t := in.Interface().(time.Time)
|
|
||||||
s := t.Format(time.RFC3339Nano)
|
|
||||||
e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *encoder) floatv(tag string, in reflect.Value) {
|
|
||||||
// Issue #352: When formatting, use the precision of the underlying value
|
|
||||||
precision := 64
|
|
||||||
if in.Kind() == reflect.Float32 {
|
|
||||||
precision = 32
|
|
||||||
}
|
|
||||||
|
|
||||||
s := strconv.FormatFloat(in.Float(), 'g', -1, precision)
|
|
||||||
switch s {
|
|
||||||
case "+Inf":
|
|
||||||
s = ".inf"
|
|
||||||
case "-Inf":
|
|
||||||
s = "-.inf"
|
|
||||||
case "NaN":
|
|
||||||
s = ".nan"
|
|
||||||
}
|
|
||||||
e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *encoder) nilv() {
|
|
||||||
e.emitScalar("null", "", "", yaml_PLAIN_SCALAR_STYLE)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *encoder) emitScalar(value, anchor, tag string, style yaml_scalar_style_t) {
|
|
||||||
implicit := tag == ""
|
|
||||||
e.must(yaml_scalar_event_initialize(&e.event, []byte(anchor), []byte(tag), []byte(value), implicit, implicit, style))
|
|
||||||
e.emit()
|
|
||||||
}
|
|
||||||
-5
@@ -1,5 +0,0 @@
|
|||||||
module "gopkg.in/yaml.v2"
|
|
||||||
|
|
||||||
require (
|
|
||||||
"gopkg.in/check.v1" v0.0.0-20161208181325-20d25e280405
|
|
||||||
)
|
|
||||||
-1095
File diff suppressed because it is too large.
Load diff
-412
@@ -1,412 +0,0 @@
|
|||||||
package yaml
|
|
||||||
|
|
||||||
import (
|
|
||||||
"io"
|
|
||||||
)
|
|
||||||
|
|
||||||
// Set the reader error and return 0.
|
|
||||||
func yaml_parser_set_reader_error(parser *yaml_parser_t, problem string, offset int, value int) bool {
|
|
||||||
parser.error = yaml_READER_ERROR
|
|
||||||
parser.problem = problem
|
|
||||||
parser.problem_offset = offset
|
|
||||||
parser.problem_value = value
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
|
|
||||||
// Byte order marks.
|
|
||||||
const (
|
|
||||||
bom_UTF8 = "\xef\xbb\xbf"
|
|
||||||
bom_UTF16LE = "\xff\xfe"
|
|
||||||
bom_UTF16BE = "\xfe\xff"
|
|
||||||
)
|
|
||||||
|
|
||||||
// Determine the input stream encoding by checking the BOM symbol. If no BOM is
|
|
||||||
// found, the UTF-8 encoding is assumed. Return 1 on success, 0 on failure.
|
|
||||||
func yaml_parser_determine_encoding(parser *yaml_parser_t) bool {
|
|
||||||
// Ensure that we had enough bytes in the raw buffer.
|
|
||||||
for !parser.eof && len(parser.raw_buffer)-parser.raw_buffer_pos < 3 {
|
|
||||||
if !yaml_parser_update_raw_buffer(parser) {
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Determine the encoding.
|
|
||||||
buf := parser.raw_buffer
|
|
||||||
pos := parser.raw_buffer_pos
|
|
||||||
avail := len(buf) - pos
|
|
||||||
if avail >= 2 && buf[pos] == bom_UTF16LE[0] && buf[pos+1] == bom_UTF16LE[1] {
|
|
||||||
parser.encoding = yaml_UTF16LE_ENCODING
|
|
||||||
parser.raw_buffer_pos += 2
|
|
||||||
parser.offset += 2
|
|
||||||
} else if avail >= 2 && buf[pos] == bom_UTF16BE[0] && buf[pos+1] == bom_UTF16BE[1] {
|
|
||||||
parser.encoding = yaml_UTF16BE_ENCODING
|
|
||||||
parser.raw_buffer_pos += 2
|
|
||||||
parser.offset += 2
|
|
||||||
} else if avail >= 3 && buf[pos] == bom_UTF8[0] && buf[pos+1] == bom_UTF8[1] && buf[pos+2] == bom_UTF8[2] {
|
|
||||||
parser.encoding = yaml_UTF8_ENCODING
|
|
||||||
parser.raw_buffer_pos += 3
|
|
||||||
parser.offset += 3
|
|
||||||
} else {
|
|
||||||
parser.encoding = yaml_UTF8_ENCODING
|
|
||||||
}
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
|
|
||||||
// Update the raw buffer.
|
|
||||||
func yaml_parser_update_raw_buffer(parser *yaml_parser_t) bool {
|
|
||||||
size_read := 0
|
|
||||||
|
|
||||||
// Return if the raw buffer is full.
|
|
||||||
if parser.raw_buffer_pos == 0 && len(parser.raw_buffer) == cap(parser.raw_buffer) {
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
|
|
||||||
// Return on EOF.
|
|
||||||
if parser.eof {
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
|
|
||||||
// Move the remaining bytes in the raw buffer to the beginning.
|
|
||||||
if parser.raw_buffer_pos > 0 && parser.raw_buffer_pos < len(parser.raw_buffer) {
|
|
||||||
copy(parser.raw_buffer, parser.raw_buffer[parser.raw_buffer_pos:])
|
|
||||||
}
|
|
||||||
parser.raw_buffer = parser.raw_buffer[:len(parser.raw_buffer)-parser.raw_buffer_pos]
|
|
||||||
parser.raw_buffer_pos = 0
|
|
||||||
|
|
||||||
// Call the read handler to fill the buffer.
|
|
||||||
size_read, err := parser.read_handler(parser, parser.raw_buffer[len(parser.raw_buffer):cap(parser.raw_buffer)])
|
|
||||||
parser.raw_buffer = parser.raw_buffer[:len(parser.raw_buffer)+size_read]
|
|
||||||
if err == io.EOF {
|
|
||||||
parser.eof = true
|
|
||||||
} else if err != nil {
|
|
||||||
return yaml_parser_set_reader_error(parser, "input error: "+err.Error(), parser.offset, -1)
|
|
||||||
}
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
|
|
||||||
// Ensure that the buffer contains at least `length` characters.
|
|
||||||
// Return true on success, false on failure.
|
|
||||||
//
|
|
||||||
// The length is supposed to be significantly less that the buffer size.
|
|
||||||
func yaml_parser_update_buffer(parser *yaml_parser_t, length int) bool {
|
|
||||||
if parser.read_handler == nil {
|
|
||||||
panic("read handler must be set")
|
|
||||||
}
|
|
||||||
|
|
||||||
// [Go] This function was changed to guarantee the requested length size at EOF.
|
|
||||||
// The fact we need to do this is pretty awful, but the description above implies
|
|
||||||
// for that to be the case, and there are tests
|
|
||||||
|
|
||||||
// If the EOF flag is set and the raw buffer is empty, do nothing.
|
|
||||||
if parser.eof && parser.raw_buffer_pos == len(parser.raw_buffer) {
|
|
||||||
// [Go] ACTUALLY! Read the documentation of this function above.
|
|
||||||
// This is just broken. To return true, we need to have the
|
|
||||||
// given length in the buffer. Not doing that means every single
|
|
||||||
// check that calls this function to make sure the buffer has a
|
|
||||||
// given length is Go) panicking; or C) accessing invalid memory.
|
|
||||||
//return true
|
|
||||||
}
|
|
||||||
|
|
||||||
// Return if the buffer contains enough characters.
|
|
||||||
if parser.unread >= length {
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
|
|
||||||
// Determine the input encoding if it is not known yet.
|
|
||||||
if parser.encoding == yaml_ANY_ENCODING {
|
|
||||||
if !yaml_parser_determine_encoding(parser) {
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Move the unread characters to the beginning of the buffer.
|
|
||||||
buffer_len := len(parser.buffer)
|
|
||||||
if parser.buffer_pos > 0 && parser.buffer_pos < buffer_len {
|
|
||||||
copy(parser.buffer, parser.buffer[parser.buffer_pos:])
|
|
||||||
buffer_len -= parser.buffer_pos
|
|
||||||
parser.buffer_pos = 0
|
|
||||||
} else if parser.buffer_pos == buffer_len {
|
|
||||||
buffer_len = 0
|
|
||||||
parser.buffer_pos = 0
|
|
||||||
}
|
|
||||||
|
|
||||||
// Open the whole buffer for writing, and cut it before returning.
|
|
||||||
parser.buffer = parser.buffer[:cap(parser.buffer)]
|
|
||||||
|
|
||||||
// Fill the buffer until it has enough characters.
|
|
||||||
first := true
|
|
||||||
for parser.unread < length {
|
|
||||||
|
|
||||||
// Fill the raw buffer if necessary.
|
|
||||||
if !first || parser.raw_buffer_pos == len(parser.raw_buffer) {
|
|
||||||
if !yaml_parser_update_raw_buffer(parser) {
|
|
||||||
parser.buffer = parser.buffer[:buffer_len]
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
}
|
|
||||||
first = false
|
|
||||||
|
|
||||||
// Decode the raw buffer.
|
|
||||||
inner:
|
|
||||||
for parser.raw_buffer_pos != len(parser.raw_buffer) {
|
|
||||||
var value rune
|
|
||||||
var width int
|
|
||||||
|
|
||||||
raw_unread := len(parser.raw_buffer) - parser.raw_buffer_pos
|
|
||||||
|
|
||||||
// Decode the next character.
|
|
||||||
switch parser.encoding {
|
|
||||||
case yaml_UTF8_ENCODING:
|
|
||||||
// Decode a UTF-8 character. Check RFC 3629
|
|
||||||
// (http://www.ietf.org/rfc/rfc3629.txt) for more details.
|
|
||||||
//
|
|
||||||
// The following table (taken from the RFC) is used for
|
|
||||||
// decoding.
|
|
||||||
//
|
|
||||||
// Char. number range | UTF-8 octet sequence
|
|
||||||
// (hexadecimal) | (binary)
|
|
||||||
// --------------------+------------------------------------
|
|
||||||
// 0000 0000-0000 007F | 0xxxxxxx
|
|
||||||
// 0000 0080-0000 07FF | 110xxxxx 10xxxxxx
|
|
||||||
// 0000 0800-0000 FFFF | 1110xxxx 10xxxxxx 10xxxxxx
|
|
||||||
// 0001 0000-0010 FFFF | 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
|
|
||||||
//
|
|
||||||
// Additionally, the characters in the range 0xD800-0xDFFF
|
|
||||||
// are prohibited as they are reserved for use with UTF-16
|
|
||||||
// surrogate pairs.
|
|
||||||
|
|
||||||
// Determine the length of the UTF-8 sequence.
|
|
||||||
octet := parser.raw_buffer[parser.raw_buffer_pos]
|
|
||||||
switch {
|
|
||||||
case octet&0x80 == 0x00:
|
|
||||||
width = 1
|
|
||||||
case octet&0xE0 == 0xC0:
|
|
||||||
width = 2
|
|
||||||
case octet&0xF0 == 0xE0:
|
|
||||||
width = 3
|
|
||||||
case octet&0xF8 == 0xF0:
|
|
||||||
width = 4
|
|
||||||
default:
|
|
||||||
// The leading octet is invalid.
|
|
||||||
return yaml_parser_set_reader_error(parser,
|
|
||||||
"invalid leading UTF-8 octet",
|
|
||||||
parser.offset, int(octet))
|
|
||||||
}
|
|
||||||
|
|
||||||
// Check if the raw buffer contains an incomplete character.
|
|
||||||
if width > raw_unread {
|
|
||||||
if parser.eof {
|
|
||||||
return yaml_parser_set_reader_error(parser,
|
|
||||||
"incomplete UTF-8 octet sequence",
|
|
||||||
parser.offset, -1)
|
|
||||||
}
|
|
||||||
break inner
|
|
||||||
}
|
|
||||||
|
|
||||||
// Decode the leading octet.
|
|
||||||
switch {
|
|
||||||
case octet&0x80 == 0x00:
|
|
||||||
value = rune(octet & 0x7F)
|
|
||||||
case octet&0xE0 == 0xC0:
|
|
||||||
value = rune(octet & 0x1F)
|
|
||||||
case octet&0xF0 == 0xE0:
|
|
||||||
value = rune(octet & 0x0F)
|
|
||||||
case octet&0xF8 == 0xF0:
|
|
||||||
value = rune(octet & 0x07)
|
|
||||||
default:
|
|
||||||
value = 0
|
|
||||||
}
|
|
||||||
|
|
||||||
// Check and decode the trailing octets.
|
|
||||||
for k := 1; k < width; k++ {
|
|
||||||
octet = parser.raw_buffer[parser.raw_buffer_pos+k]
|
|
||||||
|
|
||||||
// Check if the octet is valid.
|
|
||||||
if (octet & 0xC0) != 0x80 {
|
|
||||||
return yaml_parser_set_reader_error(parser,
|
|
||||||
"invalid trailing UTF-8 octet",
|
|
||||||
parser.offset+k, int(octet))
|
|
||||||
}
|
|
||||||
|
|
||||||
// Decode the octet.
|
|
||||||
value = (value << 6) + rune(octet&0x3F)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Check the length of the sequence against the value.
|
|
||||||
switch {
|
|
||||||
case width == 1:
|
|
||||||
case width == 2 && value >= 0x80:
|
|
||||||
case width == 3 && value >= 0x800:
|
|
||||||
case width == 4 && value >= 0x10000:
|
|
||||||
default:
|
|
||||||
return yaml_parser_set_reader_error(parser,
|
|
||||||
"invalid length of a UTF-8 sequence",
|
|
||||||
parser.offset, -1)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Check the range of the value.
|
|
||||||
if value >= 0xD800 && value <= 0xDFFF || value > 0x10FFFF {
|
|
||||||
return yaml_parser_set_reader_error(parser,
|
|
||||||
"invalid Unicode character",
|
|
||||||
parser.offset, int(value))
|
|
||||||
}
|
|
||||||
|
|
||||||
case yaml_UTF16LE_ENCODING, yaml_UTF16BE_ENCODING:
|
|
||||||
var low, high int
|
|
||||||
if parser.encoding == yaml_UTF16LE_ENCODING {
|
|
||||||
low, high = 0, 1
|
|
||||||
} else {
|
|
||||||
low, high = 1, 0
|
|
||||||
}
|
|
||||||
|
|
||||||
// The UTF-16 encoding is not as simple as one might
|
|
||||||
// naively think. Check RFC 2781
|
|
||||||
// (http://www.ietf.org/rfc/rfc2781.txt).
|
|
||||||
//
|
|
||||||
// Normally, two subsequent bytes describe a Unicode
|
|
||||||
// character. However a special technique (called a
|
|
||||||
// surrogate pair) is used for specifying character
|
|
||||||
// values larger than 0xFFFF.
|
|
||||||
//
|
|
||||||
// A surrogate pair consists of two pseudo-characters:
|
|
||||||
// high surrogate area (0xD800-0xDBFF)
|
|
||||||
// low surrogate area (0xDC00-0xDFFF)
|
|
||||||
//
|
|
||||||
// The following formulas are used for decoding
|
|
||||||
// and encoding characters using surrogate pairs:
|
|
||||||
//
|
|
||||||
// U = U' + 0x10000 (0x01 00 00 <= U <= 0x10 FF FF)
|
|
||||||
// U' = yyyyyyyyyyxxxxxxxxxx (0 <= U' <= 0x0F FF FF)
|
|
||||||
// W1 = 110110yyyyyyyyyy
|
|
||||||
// W2 = 110111xxxxxxxxxx
|
|
||||||
//
|
|
||||||
// where U is the character value, W1 is the high surrogate
|
|
||||||
// area, W2 is the low surrogate area.
|
|
||||||
|
|
||||||
// Check for incomplete UTF-16 character.
|
|
||||||
if raw_unread < 2 {
|
|
||||||
if parser.eof {
|
|
||||||
return yaml_parser_set_reader_error(parser,
|
|
||||||
"incomplete UTF-16 character",
|
|
||||||
parser.offset, -1)
|
|
||||||
}
|
|
||||||
break inner
|
|
||||||
}
|
|
||||||
|
|
||||||
// Get the character.
|
|
||||||
value = rune(parser.raw_buffer[parser.raw_buffer_pos+low]) +
|
|
||||||
(rune(parser.raw_buffer[parser.raw_buffer_pos+high]) << 8)
|
|
||||||
|
|
||||||
// Check for unexpected low surrogate area.
|
|
||||||
if value&0xFC00 == 0xDC00 {
|
|
||||||
return yaml_parser_set_reader_error(parser,
|
|
||||||
"unexpected low surrogate area",
|
|
||||||
parser.offset, int(value))
|
|
||||||
}
|
|
||||||
|
|
||||||
// Check for a high surrogate area.
|
|
||||||
if value&0xFC00 == 0xD800 {
|
|
||||||
width = 4
|
|
||||||
|
|
||||||
// Check for incomplete surrogate pair.
|
|
||||||
if raw_unread < 4 {
|
|
||||||
if parser.eof {
|
|
||||||
return yaml_parser_set_reader_error(parser,
|
|
||||||
"incomplete UTF-16 surrogate pair",
|
|
||||||
parser.offset, -1)
|
|
||||||
}
|
|
||||||
break inner
|
|
||||||
}
|
|
||||||
|
|
||||||
// Get the next character.
|
|
||||||
value2 := rune(parser.raw_buffer[parser.raw_buffer_pos+low+2]) +
|
|
||||||
(rune(parser.raw_buffer[parser.raw_buffer_pos+high+2]) << 8)
|
|
||||||
|
|
||||||
// Check for a low surrogate area.
|
|
||||||
if value2&0xFC00 != 0xDC00 {
|
|
||||||
return yaml_parser_set_reader_error(parser,
|
|
||||||
"expected low surrogate area",
|
|
||||||
parser.offset+2, int(value2))
|
|
||||||
}
|
|
||||||
|
|
||||||
// Generate the value of the surrogate pair.
|
|
||||||
value = 0x10000 + ((value & 0x3FF) << 10) + (value2 & 0x3FF)
|
|
||||||
} else {
|
|
||||||
width = 2
|
|
||||||
}
|
|
||||||
|
|
||||||
default:
|
|
||||||
panic("impossible")
|
|
||||||
}
|
|
||||||
|
|
||||||
// Check if the character is in the allowed range:
|
|
||||||
// #x9 | #xA | #xD | [#x20-#x7E] (8 bit)
|
|
||||||
// | #x85 | [#xA0-#xD7FF] | [#xE000-#xFFFD] (16 bit)
|
|
||||||
// | [#x10000-#x10FFFF] (32 bit)
|
|
||||||
switch {
|
|
||||||
case value == 0x09:
|
|
||||||
case value == 0x0A:
|
|
||||||
case value == 0x0D:
|
|
||||||
case value >= 0x20 && value <= 0x7E:
|
|
||||||
case value == 0x85:
|
|
||||||
case value >= 0xA0 && value <= 0xD7FF:
|
|
||||||
case value >= 0xE000 && value <= 0xFFFD:
|
|
||||||
case value >= 0x10000 && value <= 0x10FFFF:
|
|
||||||
default:
|
|
||||||
return yaml_parser_set_reader_error(parser,
|
|
||||||
"control characters are not allowed",
|
|
||||||
parser.offset, int(value))
|
|
||||||
}
|
|
||||||
|
|
||||||
// Move the raw pointers.
|
|
||||||
parser.raw_buffer_pos += width
|
|
||||||
parser.offset += width
|
|
||||||
|
|
||||||
// Finally put the character into the buffer.
|
|
||||||
if value <= 0x7F {
|
|
||||||
// 0000 0000-0000 007F . 0xxxxxxx
|
|
||||||
parser.buffer[buffer_len+0] = byte(value)
|
|
||||||
buffer_len += 1
|
|
||||||
} else if value <= 0x7FF {
|
|
||||||
// 0000 0080-0000 07FF . 110xxxxx 10xxxxxx
|
|
||||||
parser.buffer[buffer_len+0] = byte(0xC0 + (value >> 6))
|
|
||||||
parser.buffer[buffer_len+1] = byte(0x80 + (value & 0x3F))
|
|
||||||
buffer_len += 2
|
|
||||||
} else if value <= 0xFFFF {
|
|
||||||
// 0000 0800-0000 FFFF . 1110xxxx 10xxxxxx 10xxxxxx
|
|
||||||
parser.buffer[buffer_len+0] = byte(0xE0 + (value >> 12))
|
|
||||||
parser.buffer[buffer_len+1] = byte(0x80 + ((value >> 6) & 0x3F))
|
|
||||||
parser.buffer[buffer_len+2] = byte(0x80 + (value & 0x3F))
|
|
||||||
buffer_len += 3
|
|
||||||
} else {
|
|
||||||
// 0001 0000-0010 FFFF . 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
|
|
||||||
parser.buffer[buffer_len+0] = byte(0xF0 + (value >> 18))
|
|
||||||
parser.buffer[buffer_len+1] = byte(0x80 + ((value >> 12) & 0x3F))
|
|
||||||
parser.buffer[buffer_len+2] = byte(0x80 + ((value >> 6) & 0x3F))
|
|
||||||
parser.buffer[buffer_len+3] = byte(0x80 + (value & 0x3F))
|
|
||||||
buffer_len += 4
|
|
||||||
}
|
|
||||||
|
|
||||||
parser.unread++
|
|
||||||
}
|
|
||||||
|
|
||||||
// On EOF, put NUL into the buffer and return.
|
|
||||||
if parser.eof {
|
|
||||||
parser.buffer[buffer_len] = 0
|
|
||||||
buffer_len++
|
|
||||||
parser.unread++
|
|
||||||
break
|
|
||||||
}
|
|
||||||
}
|
|
||||||
// [Go] Read the documentation of this function above. To return true,
|
|
||||||
// we need to have the given length in the buffer. Not doing that means
|
|
||||||
// every single check that calls this function to make sure the buffer
|
|
||||||
// has a given length is Go) panicking; or C) accessing invalid memory.
|
|
||||||
// This happens here due to the EOF above breaking early.
|
|
||||||
for buffer_len < length {
|
|
||||||
parser.buffer[buffer_len] = 0
|
|
||||||
buffer_len++
|
|
||||||
}
|
|
||||||
parser.buffer = parser.buffer[:buffer_len]
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
-258
@@ -1,258 +0,0 @@
|
|||||||
package yaml
|
|
||||||
|
|
||||||
import (
|
|
||||||
"encoding/base64"
|
|
||||||
"math"
|
|
||||||
"regexp"
|
|
||||||
"strconv"
|
|
||||||
"strings"
|
|
||||||
"time"
|
|
||||||
)
|
|
||||||
|
|
||||||
type resolveMapItem struct {
|
|
||||||
value interface{}
|
|
||||||
tag string
|
|
||||||
}
|
|
||||||
|
|
||||||
var resolveTable = make([]byte, 256)
|
|
||||||
var resolveMap = make(map[string]resolveMapItem)
|
|
||||||
|
|
||||||
func init() {
|
|
||||||
t := resolveTable
|
|
||||||
t[int('+')] = 'S' // Sign
|
|
||||||
t[int('-')] = 'S'
|
|
||||||
for _, c := range "0123456789" {
|
|
||||||
t[int(c)] = 'D' // Digit
|
|
||||||
}
|
|
||||||
for _, c := range "yYnNtTfFoO~" {
|
|
||||||
t[int(c)] = 'M' // In map
|
|
||||||
}
|
|
||||||
t[int('.')] = '.' // Float (potentially in map)
|
|
||||||
|
|
||||||
var resolveMapList = []struct {
|
|
||||||
v interface{}
|
|
||||||
tag string
|
|
||||||
l []string
|
|
||||||
}{
|
|
||||||
{true, yaml_BOOL_TAG, []string{"y", "Y", "yes", "Yes", "YES"}},
|
|
||||||
{true, yaml_BOOL_TAG, []string{"true", "True", "TRUE"}},
|
|
||||||
{true, yaml_BOOL_TAG, []string{"on", "On", "ON"}},
|
|
||||||
{false, yaml_BOOL_TAG, []string{"n", "N", "no", "No", "NO"}},
|
|
||||||
{false, yaml_BOOL_TAG, []string{"false", "False", "FALSE"}},
|
|
||||||
{false, yaml_BOOL_TAG, []string{"off", "Off", "OFF"}},
|
|
||||||
{nil, yaml_NULL_TAG, []string{"", "~", "null", "Null", "NULL"}},
|
|
||||||
{math.NaN(), yaml_FLOAT_TAG, []string{".nan", ".NaN", ".NAN"}},
|
|
||||||
{math.Inf(+1), yaml_FLOAT_TAG, []string{".inf", ".Inf", ".INF"}},
|
|
||||||
{math.Inf(+1), yaml_FLOAT_TAG, []string{"+.inf", "+.Inf", "+.INF"}},
|
|
||||||
{math.Inf(-1), yaml_FLOAT_TAG, []string{"-.inf", "-.Inf", "-.INF"}},
|
|
||||||
{"<<", yaml_MERGE_TAG, []string{"<<"}},
|
|
||||||
}
|
|
||||||
|
|
||||||
m := resolveMap
|
|
||||||
for _, item := range resolveMapList {
|
|
||||||
for _, s := range item.l {
|
|
||||||
m[s] = resolveMapItem{item.v, item.tag}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
const longTagPrefix = "tag:yaml.org,2002:"
|
|
||||||
|
|
||||||
func shortTag(tag string) string {
|
|
||||||
// TODO This can easily be made faster and produce less garbage.
|
|
||||||
if strings.HasPrefix(tag, longTagPrefix) {
|
|
||||||
return "!!" + tag[len(longTagPrefix):]
|
|
||||||
}
|
|
||||||
return tag
|
|
||||||
}
|
|
||||||
|
|
||||||
func longTag(tag string) string {
|
|
||||||
if strings.HasPrefix(tag, "!!") {
|
|
||||||
return longTagPrefix + tag[2:]
|
|
||||||
}
|
|
||||||
return tag
|
|
||||||
}
|
|
||||||
|
|
||||||
func resolvableTag(tag string) bool {
|
|
||||||
switch tag {
|
|
||||||
case "", yaml_STR_TAG, yaml_BOOL_TAG, yaml_INT_TAG, yaml_FLOAT_TAG, yaml_NULL_TAG, yaml_TIMESTAMP_TAG:
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
|
|
||||||
var yamlStyleFloat = regexp.MustCompile(`^[-+]?[0-9]*\.?[0-9]+([eE][-+][0-9]+)?$`)
|
|
||||||
|
|
||||||
func resolve(tag string, in string) (rtag string, out interface{}) {
|
|
||||||
if !resolvableTag(tag) {
|
|
||||||
return tag, in
|
|
||||||
}
|
|
||||||
|
|
||||||
defer func() {
|
|
||||||
switch tag {
|
|
||||||
case "", rtag, yaml_STR_TAG, yaml_BINARY_TAG:
|
|
||||||
return
|
|
||||||
case yaml_FLOAT_TAG:
|
|
||||||
if rtag == yaml_INT_TAG {
|
|
||||||
switch v := out.(type) {
|
|
||||||
case int64:
|
|
||||||
rtag = yaml_FLOAT_TAG
|
|
||||||
out = float64(v)
|
|
||||||
return
|
|
||||||
case int:
|
|
||||||
rtag = yaml_FLOAT_TAG
|
|
||||||
out = float64(v)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
failf("cannot decode %s `%s` as a %s", shortTag(rtag), in, shortTag(tag))
|
|
||||||
}()
|
|
||||||
|
|
||||||
// Any data is accepted as a !!str or !!binary.
|
|
||||||
// Otherwise, the prefix is enough of a hint about what it might be.
|
|
||||||
hint := byte('N')
|
|
||||||
if in != "" {
|
|
||||||
hint = resolveTable[in[0]]
|
|
||||||
}
|
|
||||||
if hint != 0 && tag != yaml_STR_TAG && tag != yaml_BINARY_TAG {
|
|
||||||
// Handle things we can lookup in a map.
|
|
||||||
if item, ok := resolveMap[in]; ok {
|
|
||||||
return item.tag, item.value
|
|
||||||
}
|
|
||||||
|
|
||||||
// Base 60 floats are a bad idea, were dropped in YAML 1.2, and
|
|
||||||
// are purposefully unsupported here. They're still quoted on
|
|
||||||
// the way out for compatibility with other parser, though.
|
|
||||||
|
|
||||||
switch hint {
|
|
||||||
case 'M':
|
|
||||||
// We've already checked the map above.
|
|
||||||
|
|
||||||
case '.':
|
|
||||||
// Not in the map, so maybe a normal float.
|
|
||||||
floatv, err := strconv.ParseFloat(in, 64)
|
|
||||||
if err == nil {
|
|
||||||
return yaml_FLOAT_TAG, floatv
|
|
||||||
}
|
|
||||||
|
|
||||||
case 'D', 'S':
|
|
||||||
// Int, float, or timestamp.
|
|
||||||
// Only try values as a timestamp if the value is unquoted or there's an explicit
|
|
||||||
// !!timestamp tag.
|
|
||||||
if tag == "" || tag == yaml_TIMESTAMP_TAG {
|
|
||||||
t, ok := parseTimestamp(in)
|
|
||||||
if ok {
|
|
||||||
return yaml_TIMESTAMP_TAG, t
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
plain := strings.Replace(in, "_", "", -1)
|
|
||||||
intv, err := strconv.ParseInt(plain, 0, 64)
|
|
||||||
if err == nil {
|
|
||||||
if intv == int64(int(intv)) {
|
|
||||||
return yaml_INT_TAG, int(intv)
|
|
||||||
} else {
|
|
||||||
return yaml_INT_TAG, intv
|
|
||||||
}
|
|
||||||
}
|
|
||||||
uintv, err := strconv.ParseUint(plain, 0, 64)
|
|
||||||
if err == nil {
|
|
||||||
return yaml_INT_TAG, uintv
|
|
||||||
}
|
|
||||||
if yamlStyleFloat.MatchString(plain) {
|
|
||||||
floatv, err := strconv.ParseFloat(plain, 64)
|
|
||||||
if err == nil {
|
|
||||||
return yaml_FLOAT_TAG, floatv
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if strings.HasPrefix(plain, "0b") {
|
|
||||||
intv, err := strconv.ParseInt(plain[2:], 2, 64)
|
|
||||||
if err == nil {
|
|
||||||
if intv == int64(int(intv)) {
|
|
||||||
return yaml_INT_TAG, int(intv)
|
|
||||||
} else {
|
|
||||||
return yaml_INT_TAG, intv
|
|
||||||
}
|
|
||||||
}
|
|
||||||
uintv, err := strconv.ParseUint(plain[2:], 2, 64)
|
|
||||||
if err == nil {
|
|
||||||
return yaml_INT_TAG, uintv
|
|
||||||
}
|
|
||||||
} else if strings.HasPrefix(plain, "-0b") {
|
|
||||||
intv, err := strconv.ParseInt("-" + plain[3:], 2, 64)
|
|
||||||
if err == nil {
|
|
||||||
if true || intv == int64(int(intv)) {
|
|
||||||
return yaml_INT_TAG, int(intv)
|
|
||||||
} else {
|
|
||||||
return yaml_INT_TAG, intv
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
default:
|
|
||||||
panic("resolveTable item not yet handled: " + string(rune(hint)) + " (with " + in + ")")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return yaml_STR_TAG, in
|
|
||||||
}
|
|
||||||
|
|
||||||
// encodeBase64 encodes s as base64 that is broken up into multiple lines
|
|
||||||
// as appropriate for the resulting length.
|
|
||||||
func encodeBase64(s string) string {
|
|
||||||
const lineLen = 70
|
|
||||||
encLen := base64.StdEncoding.EncodedLen(len(s))
|
|
||||||
lines := encLen/lineLen + 1
|
|
||||||
buf := make([]byte, encLen*2+lines)
|
|
||||||
in := buf[0:encLen]
|
|
||||||
out := buf[encLen:]
|
|
||||||
base64.StdEncoding.Encode(in, []byte(s))
|
|
||||||
k := 0
|
|
||||||
for i := 0; i < len(in); i += lineLen {
|
|
||||||
j := i + lineLen
|
|
||||||
if j > len(in) {
|
|
||||||
j = len(in)
|
|
||||||
}
|
|
||||||
k += copy(out[k:], in[i:j])
|
|
||||||
if lines > 1 {
|
|
||||||
out[k] = '\n'
|
|
||||||
k++
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return string(out[:k])
|
|
||||||
}
|
|
||||||
|
|
||||||
// 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
|
|
||||||
// Notable exception: time.Parse cannot handle: "2001-12-14 21:59:43.10 -5"
|
|
||||||
// from the set of examples.
|
|
||||||
}
|
|
||||||
|
|
||||||
// parseTimestamp parses s as a timestamp string and
|
|
||||||
// returns the timestamp and reports whether it succeeded.
|
|
||||||
// Timestamp formats are defined at http://yaml.org/type/timestamp.html
|
|
||||||
func parseTimestamp(s string) (time.Time, bool) {
|
|
||||||
// TODO write code to check all the formats supported by
|
|
||||||
// http://yaml.org/type/timestamp.html instead of using time.Parse.
|
|
||||||
|
|
||||||
// Quick check: all date formats start with YYYY-.
|
|
||||||
i := 0
|
|
||||||
for ; i < len(s); i++ {
|
|
||||||
if c := s[i]; c < '0' || c > '9' {
|
|
||||||
break
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if i != 4 || i == len(s) || s[i] != '-' {
|
|
||||||
return time.Time{}, false
|
|
||||||
}
|
|
||||||
for _, format := range allowedTimestampFormats {
|
|
||||||
if t, err := time.Parse(format, s); err == nil {
|
|
||||||
return t, true
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return time.Time{}, false
|
|
||||||
}
|
|
||||||
-2696
File diff suppressed because it is too large.
Load diff
-113
@@ -1,113 +0,0 @@
|
|||||||
package yaml
|
|
||||||
|
|
||||||
import (
|
|
||||||
"reflect"
|
|
||||||
"unicode"
|
|
||||||
)
|
|
||||||
|
|
||||||
type keyList []reflect.Value
|
|
||||||
|
|
||||||
func (l keyList) Len() int { return len(l) }
|
|
||||||
func (l keyList) Swap(i, j int) { l[i], l[j] = l[j], l[i] }
|
|
||||||
func (l keyList) Less(i, j int) bool {
|
|
||||||
a := l[i]
|
|
||||||
b := l[j]
|
|
||||||
ak := a.Kind()
|
|
||||||
bk := b.Kind()
|
|
||||||
for (ak == reflect.Interface || ak == reflect.Ptr) && !a.IsNil() {
|
|
||||||
a = a.Elem()
|
|
||||||
ak = a.Kind()
|
|
||||||
}
|
|
||||||
for (bk == reflect.Interface || bk == reflect.Ptr) && !b.IsNil() {
|
|
||||||
b = b.Elem()
|
|
||||||
bk = b.Kind()
|
|
||||||
}
|
|
||||||
af, aok := keyFloat(a)
|
|
||||||
bf, bok := keyFloat(b)
|
|
||||||
if aok && bok {
|
|
||||||
if af != bf {
|
|
||||||
return af < bf
|
|
||||||
}
|
|
||||||
if ak != bk {
|
|
||||||
return ak < bk
|
|
||||||
}
|
|
||||||
return numLess(a, b)
|
|
||||||
}
|
|
||||||
if ak != reflect.String || bk != reflect.String {
|
|
||||||
return ak < bk
|
|
||||||
}
|
|
||||||
ar, br := []rune(a.String()), []rune(b.String())
|
|
||||||
for i := 0; i < len(ar) && i < len(br); i++ {
|
|
||||||
if ar[i] == br[i] {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
al := unicode.IsLetter(ar[i])
|
|
||||||
bl := unicode.IsLetter(br[i])
|
|
||||||
if al && bl {
|
|
||||||
return ar[i] < br[i]
|
|
||||||
}
|
|
||||||
if al || bl {
|
|
||||||
return bl
|
|
||||||
}
|
|
||||||
var ai, bi int
|
|
||||||
var an, bn int64
|
|
||||||
if ar[i] == '0' || br[i] == '0' {
|
|
||||||
for j := i-1; j >= 0 && unicode.IsDigit(ar[j]); j-- {
|
|
||||||
if ar[j] != '0' {
|
|
||||||
an = 1
|
|
||||||
bn = 1
|
|
||||||
break
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
for ai = i; ai < len(ar) && unicode.IsDigit(ar[ai]); ai++ {
|
|
||||||
an = an*10 + int64(ar[ai]-'0')
|
|
||||||
}
|
|
||||||
for bi = i; bi < len(br) && unicode.IsDigit(br[bi]); bi++ {
|
|
||||||
bn = bn*10 + int64(br[bi]-'0')
|
|
||||||
}
|
|
||||||
if an != bn {
|
|
||||||
return an < bn
|
|
||||||
}
|
|
||||||
if ai != bi {
|
|
||||||
return ai < bi
|
|
||||||
}
|
|
||||||
return ar[i] < br[i]
|
|
||||||
}
|
|
||||||
return len(ar) < len(br)
|
|
||||||
}
|
|
||||||
|
|
||||||
// keyFloat returns a float value for v if it is a number/bool
|
|
||||||
// and whether it is a number/bool or not.
|
|
||||||
func keyFloat(v reflect.Value) (f float64, ok bool) {
|
|
||||||
switch v.Kind() {
|
|
||||||
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
|
|
||||||
return float64(v.Int()), true
|
|
||||||
case reflect.Float32, reflect.Float64:
|
|
||||||
return v.Float(), true
|
|
||||||
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
|
|
||||||
return float64(v.Uint()), true
|
|
||||||
case reflect.Bool:
|
|
||||||
if v.Bool() {
|
|
||||||
return 1, true
|
|
||||||
}
|
|
||||||
return 0, true
|
|
||||||
}
|
|
||||||
return 0, false
|
|
||||||
}
|
|
||||||
|
|
||||||
// numLess returns whether a < b.
|
|
||||||
// a and b must necessarily have the same kind.
|
|
||||||
func numLess(a, b reflect.Value) bool {
|
|
||||||
switch a.Kind() {
|
|
||||||
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
|
|
||||||
return a.Int() < b.Int()
|
|
||||||
case reflect.Float32, reflect.Float64:
|
|
||||||
return a.Float() < b.Float()
|
|
||||||
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
|
|
||||||
return a.Uint() < b.Uint()
|
|
||||||
case reflect.Bool:
|
|
||||||
return !a.Bool() && b.Bool()
|
|
||||||
}
|
|
||||||
panic("not a number")
|
|
||||||
}
|
|
||||||
-26
@@ -1,26 +0,0 @@
|
|||||||
package yaml
|
|
||||||
|
|
||||||
// Set the writer error and return false.
|
|
||||||
func yaml_emitter_set_writer_error(emitter *yaml_emitter_t, problem string) bool {
|
|
||||||
emitter.error = yaml_WRITER_ERROR
|
|
||||||
emitter.problem = problem
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
|
|
||||||
// Flush the output buffer.
|
|
||||||
func yaml_emitter_flush(emitter *yaml_emitter_t) bool {
|
|
||||||
if emitter.write_handler == nil {
|
|
||||||
panic("write handler not set")
|
|
||||||
}
|
|
||||||
|
|
||||||
// Check if the buffer is empty.
|
|
||||||
if emitter.buffer_pos == 0 {
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
|
|
||||||
if err := emitter.write_handler(emitter, emitter.buffer[:emitter.buffer_pos]); err != nil {
|
|
||||||
return yaml_emitter_set_writer_error(emitter, "write error: "+err.Error())
|
|
||||||
}
|
|
||||||
emitter.buffer_pos = 0
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
-466
@@ -1,466 +0,0 @@
|
|||||||
// Package yaml implements YAML support for the Go language.
|
|
||||||
//
|
|
||||||
// Source code and other details for the project are available at GitHub:
|
|
||||||
//
|
|
||||||
// https://github.com/go-yaml/yaml
|
|
||||||
//
|
|
||||||
package yaml
|
|
||||||
|
|
||||||
import (
|
|
||||||
"errors"
|
|
||||||
"fmt"
|
|
||||||
"io"
|
|
||||||
"reflect"
|
|
||||||
"strings"
|
|
||||||
"sync"
|
|
||||||
)
|
|
||||||
|
|
||||||
// MapSlice encodes and decodes as a YAML map.
|
|
||||||
// The order of keys is preserved when encoding and decoding.
|
|
||||||
type MapSlice []MapItem
|
|
||||||
|
|
||||||
// MapItem is an item in a MapSlice.
|
|
||||||
type MapItem struct {
|
|
||||||
Key, Value interface{}
|
|
||||||
}
|
|
||||||
|
|
||||||
// The Unmarshaler interface may be implemented by types to customize their
|
|
||||||
// behavior when being unmarshaled from a YAML document. The UnmarshalYAML
|
|
||||||
// method receives a function that may be called to unmarshal the original
|
|
||||||
// YAML value into a field or variable. It is safe to call the unmarshal
|
|
||||||
// function parameter more than once if necessary.
|
|
||||||
type Unmarshaler interface {
|
|
||||||
UnmarshalYAML(unmarshal func(interface{}) error) error
|
|
||||||
}
|
|
||||||
|
|
||||||
// The Marshaler interface may be implemented by types to customize their
|
|
||||||
// behavior when being marshaled into a YAML document. The returned value
|
|
||||||
// is marshaled in place of the original value implementing Marshaler.
|
|
||||||
//
|
|
||||||
// If an error is returned by MarshalYAML, the marshaling procedure stops
|
|
||||||
// and returns with the provided error.
|
|
||||||
type Marshaler interface {
|
|
||||||
MarshalYAML() (interface{}, error)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Unmarshal decodes the first document found within the in byte slice
|
|
||||||
// and assigns decoded values into the out value.
|
|
||||||
//
|
|
||||||
// Maps and pointers (to a struct, string, int, etc) are accepted as out
|
|
||||||
// values. If an internal pointer within a struct is not initialized,
|
|
||||||
// the yaml package will initialize it if necessary for unmarshalling
|
|
||||||
// the provided data. The out parameter must not be nil.
|
|
||||||
//
|
|
||||||
// The type of the decoded values should be compatible with the respective
|
|
||||||
// values in out. If one or more values cannot be decoded due to a type
|
|
||||||
// mismatches, decoding continues partially until the end of the YAML
|
|
||||||
// content, and a *yaml.TypeError is returned with details for all
|
|
||||||
// missed values.
|
|
||||||
//
|
|
||||||
// Struct fields are only unmarshalled if they are exported (have an
|
|
||||||
// upper case first letter), and are unmarshalled using the field name
|
|
||||||
// lowercased as the default key. Custom keys may be defined via the
|
|
||||||
// "yaml" name in the field tag: the content preceding the first comma
|
|
||||||
// is used as the key, and the following comma-separated options are
|
|
||||||
// used to tweak the marshalling process (see Marshal).
|
|
||||||
// Conflicting names result in a runtime error.
|
|
||||||
//
|
|
||||||
// For example:
|
|
||||||
//
|
|
||||||
// type T struct {
|
|
||||||
// F int `yaml:"a,omitempty"`
|
|
||||||
// B int
|
|
||||||
// }
|
|
||||||
// var t T
|
|
||||||
// yaml.Unmarshal([]byte("a: 1\nb: 2"), &t)
|
|
||||||
//
|
|
||||||
// See the documentation of Marshal for the format of tags and a list of
|
|
||||||
// supported tag options.
|
|
||||||
//
|
|
||||||
func Unmarshal(in []byte, out interface{}) (err error) {
|
|
||||||
return unmarshal(in, out, false)
|
|
||||||
}
|
|
||||||
|
|
||||||
// UnmarshalStrict is like Unmarshal except that any fields that are found
|
|
||||||
// in the data that do not have corresponding struct members, or mapping
|
|
||||||
// keys that are duplicates, will result in
|
|
||||||
// an error.
|
|
||||||
func UnmarshalStrict(in []byte, out interface{}) (err error) {
|
|
||||||
return unmarshal(in, out, true)
|
|
||||||
}
|
|
||||||
|
|
||||||
// A Decorder reads and decodes YAML values from an input stream.
|
|
||||||
type Decoder struct {
|
|
||||||
strict bool
|
|
||||||
parser *parser
|
|
||||||
}
|
|
||||||
|
|
||||||
// NewDecoder returns a new decoder that reads from r.
|
|
||||||
//
|
|
||||||
// The decoder introduces its own buffering and may read
|
|
||||||
// data from r beyond the YAML values requested.
|
|
||||||
func NewDecoder(r io.Reader) *Decoder {
|
|
||||||
return &Decoder{
|
|
||||||
parser: newParserFromReader(r),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// SetStrict sets whether strict decoding behaviour is enabled when
|
|
||||||
// decoding items in the data (see UnmarshalStrict). By default, decoding is not strict.
|
|
||||||
func (dec *Decoder) SetStrict(strict bool) {
|
|
||||||
dec.strict = strict
|
|
||||||
}
|
|
||||||
|
|
||||||
// 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 (dec *Decoder) Decode(v interface{}) (err error) {
|
|
||||||
d := newDecoder(dec.strict)
|
|
||||||
defer handleErr(&err)
|
|
||||||
node := dec.parser.parse()
|
|
||||||
if node == nil {
|
|
||||||
return io.EOF
|
|
||||||
}
|
|
||||||
out := reflect.ValueOf(v)
|
|
||||||
if out.Kind() == reflect.Ptr && !out.IsNil() {
|
|
||||||
out = out.Elem()
|
|
||||||
}
|
|
||||||
d.unmarshal(node, out)
|
|
||||||
if len(d.terrors) > 0 {
|
|
||||||
return &TypeError{d.terrors}
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func unmarshal(in []byte, out interface{}, strict bool) (err error) {
|
|
||||||
defer handleErr(&err)
|
|
||||||
d := newDecoder(strict)
|
|
||||||
p := newParser(in)
|
|
||||||
defer p.destroy()
|
|
||||||
node := p.parse()
|
|
||||||
if node != nil {
|
|
||||||
v := reflect.ValueOf(out)
|
|
||||||
if v.Kind() == reflect.Ptr && !v.IsNil() {
|
|
||||||
v = v.Elem()
|
|
||||||
}
|
|
||||||
d.unmarshal(node, v)
|
|
||||||
}
|
|
||||||
if len(d.terrors) > 0 {
|
|
||||||
return &TypeError{d.terrors}
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// Marshal serializes the value provided into a YAML document. The structure
|
|
||||||
// of the generated document will reflect the structure of the value itself.
|
|
||||||
// Maps and pointers (to struct, string, int, etc) are accepted as the in value.
|
|
||||||
//
|
|
||||||
// Struct fields are only marshalled if they are exported (have an upper case
|
|
||||||
// first letter), and are marshalled using the field name lowercased as the
|
|
||||||
// default key. Custom keys may be defined via the "yaml" name in the field
|
|
||||||
// tag: the content preceding the first comma is used as the key, and the
|
|
||||||
// following comma-separated options are used to tweak the marshalling process.
|
|
||||||
// Conflicting names result in a runtime error.
|
|
||||||
//
|
|
||||||
// The field tag format accepted is:
|
|
||||||
//
|
|
||||||
// `(...) yaml:"[<key>][,<flag1>[,<flag2>]]" (...)`
|
|
||||||
//
|
|
||||||
// The following flags are currently supported:
|
|
||||||
//
|
|
||||||
// omitempty Only include the field if it's not set to the zero
|
|
||||||
// value for the type or to empty slices or maps.
|
|
||||||
// Zero valued structs will be omitted if all their public
|
|
||||||
// fields are zero, unless they implement an IsZero
|
|
||||||
// method (see the IsZeroer interface type), in which
|
|
||||||
// case the field will be included if that method returns true.
|
|
||||||
//
|
|
||||||
// flow Marshal using a flow style (useful for structs,
|
|
||||||
// sequences and maps).
|
|
||||||
//
|
|
||||||
// inline Inline the field, which must be a struct or a map,
|
|
||||||
// causing all of its fields or keys to be processed as if
|
|
||||||
// they were part of the outer struct. For maps, keys must
|
|
||||||
// not conflict with the yaml keys of other struct fields.
|
|
||||||
//
|
|
||||||
// In addition, if the key is "-", the field is ignored.
|
|
||||||
//
|
|
||||||
// For example:
|
|
||||||
//
|
|
||||||
// type T struct {
|
|
||||||
// F int `yaml:"a,omitempty"`
|
|
||||||
// B int
|
|
||||||
// }
|
|
||||||
// yaml.Marshal(&T{B: 2}) // Returns "b: 2\n"
|
|
||||||
// yaml.Marshal(&T{F: 1}} // Returns "a: 1\nb: 0\n"
|
|
||||||
//
|
|
||||||
func Marshal(in interface{}) (out []byte, err error) {
|
|
||||||
defer handleErr(&err)
|
|
||||||
e := newEncoder()
|
|
||||||
defer e.destroy()
|
|
||||||
e.marshalDoc("", reflect.ValueOf(in))
|
|
||||||
e.finish()
|
|
||||||
out = e.out
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
// An Encoder writes YAML values to an output stream.
|
|
||||||
type Encoder struct {
|
|
||||||
encoder *encoder
|
|
||||||
}
|
|
||||||
|
|
||||||
// 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) *Encoder {
|
|
||||||
return &Encoder{
|
|
||||||
encoder: newEncoderWithWriter(w),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// 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{}) (err error) {
|
|
||||||
defer handleErr(&err)
|
|
||||||
e.encoder.marshalDoc("", reflect.ValueOf(v))
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// Close closes the encoder by writing any remaining data.
|
|
||||||
// It does not write a stream terminating string "...".
|
|
||||||
func (e *Encoder) Close() (err error) {
|
|
||||||
defer handleErr(&err)
|
|
||||||
e.encoder.finish()
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func handleErr(err *error) {
|
|
||||||
if v := recover(); v != nil {
|
|
||||||
if e, ok := v.(yamlError); ok {
|
|
||||||
*err = e.err
|
|
||||||
} else {
|
|
||||||
panic(v)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
type yamlError struct {
|
|
||||||
err error
|
|
||||||
}
|
|
||||||
|
|
||||||
func fail(err error) {
|
|
||||||
panic(yamlError{err})
|
|
||||||
}
|
|
||||||
|
|
||||||
func failf(format string, args ...interface{}) {
|
|
||||||
panic(yamlError{fmt.Errorf("yaml: "+format, args...)})
|
|
||||||
}
|
|
||||||
|
|
||||||
// A TypeError is returned by Unmarshal when one or more fields in
|
|
||||||
// the YAML document cannot be properly decoded into the requested
|
|
||||||
// types. When this error is returned, the value is still
|
|
||||||
// unmarshaled partially.
|
|
||||||
type TypeError struct {
|
|
||||||
Errors []string
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *TypeError) Error() string {
|
|
||||||
return fmt.Sprintf("yaml: unmarshal errors:\n %s", strings.Join(e.Errors, "\n "))
|
|
||||||
}
|
|
||||||
|
|
||||||
// --------------------------------------------------------------------------
|
|
||||||
// Maintain a mapping of keys to structure field indexes
|
|
||||||
|
|
||||||
// The code in this section was copied from mgo/bson.
|
|
||||||
|
|
||||||
// structInfo holds details for the serialization of fields of
|
|
||||||
// a given struct.
|
|
||||||
type structInfo struct {
|
|
||||||
FieldsMap map[string]fieldInfo
|
|
||||||
FieldsList []fieldInfo
|
|
||||||
|
|
||||||
// InlineMap is the number of the field in the struct that
|
|
||||||
// contains an ,inline map, or -1 if there's none.
|
|
||||||
InlineMap int
|
|
||||||
}
|
|
||||||
|
|
||||||
type fieldInfo struct {
|
|
||||||
Key string
|
|
||||||
Num int
|
|
||||||
OmitEmpty bool
|
|
||||||
Flow bool
|
|
||||||
// Id holds the unique field identifier, so we can cheaply
|
|
||||||
// check for field duplicates without maintaining an extra map.
|
|
||||||
Id int
|
|
||||||
|
|
||||||
// Inline holds the field index if the field is part of an inlined struct.
|
|
||||||
Inline []int
|
|
||||||
}
|
|
||||||
|
|
||||||
var structMap = make(map[reflect.Type]*structInfo)
|
|
||||||
var fieldMapMutex sync.RWMutex
|
|
||||||
|
|
||||||
func getStructInfo(st reflect.Type) (*structInfo, error) {
|
|
||||||
fieldMapMutex.RLock()
|
|
||||||
sinfo, found := structMap[st]
|
|
||||||
fieldMapMutex.RUnlock()
|
|
||||||
if found {
|
|
||||||
return sinfo, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
n := st.NumField()
|
|
||||||
fieldsMap := make(map[string]fieldInfo)
|
|
||||||
fieldsList := make([]fieldInfo, 0, n)
|
|
||||||
inlineMap := -1
|
|
||||||
for i := 0; i != n; i++ {
|
|
||||||
field := st.Field(i)
|
|
||||||
if field.PkgPath != "" && !field.Anonymous {
|
|
||||||
continue // Private field
|
|
||||||
}
|
|
||||||
|
|
||||||
info := fieldInfo{Num: i}
|
|
||||||
|
|
||||||
tag := field.Tag.Get("yaml")
|
|
||||||
if tag == "" && strings.Index(string(field.Tag), ":") < 0 {
|
|
||||||
tag = string(field.Tag)
|
|
||||||
}
|
|
||||||
if tag == "-" {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
|
|
||||||
inline := false
|
|
||||||
fields := strings.Split(tag, ",")
|
|
||||||
if len(fields) > 1 {
|
|
||||||
for _, flag := range fields[1:] {
|
|
||||||
switch flag {
|
|
||||||
case "omitempty":
|
|
||||||
info.OmitEmpty = true
|
|
||||||
case "flow":
|
|
||||||
info.Flow = true
|
|
||||||
case "inline":
|
|
||||||
inline = true
|
|
||||||
default:
|
|
||||||
return nil, errors.New(fmt.Sprintf("Unsupported flag %q in tag %q of type %s", flag, tag, st))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
tag = fields[0]
|
|
||||||
}
|
|
||||||
|
|
||||||
if inline {
|
|
||||||
switch field.Type.Kind() {
|
|
||||||
case reflect.Map:
|
|
||||||
if inlineMap >= 0 {
|
|
||||||
return nil, errors.New("Multiple ,inline maps in struct " + st.String())
|
|
||||||
}
|
|
||||||
if field.Type.Key() != reflect.TypeOf("") {
|
|
||||||
return nil, errors.New("Option ,inline needs a map with string keys in struct " + st.String())
|
|
||||||
}
|
|
||||||
inlineMap = info.Num
|
|
||||||
case reflect.Struct:
|
|
||||||
sinfo, err := getStructInfo(field.Type)
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
for _, finfo := range sinfo.FieldsList {
|
|
||||||
if _, found := fieldsMap[finfo.Key]; found {
|
|
||||||
msg := "Duplicated key '" + finfo.Key + "' in struct " + st.String()
|
|
||||||
return nil, errors.New(msg)
|
|
||||||
}
|
|
||||||
if finfo.Inline == nil {
|
|
||||||
finfo.Inline = []int{i, finfo.Num}
|
|
||||||
} else {
|
|
||||||
finfo.Inline = append([]int{i}, finfo.Inline...)
|
|
||||||
}
|
|
||||||
finfo.Id = len(fieldsList)
|
|
||||||
fieldsMap[finfo.Key] = finfo
|
|
||||||
fieldsList = append(fieldsList, finfo)
|
|
||||||
}
|
|
||||||
default:
|
|
||||||
//return nil, errors.New("Option ,inline needs a struct value or map field")
|
|
||||||
return nil, errors.New("Option ,inline needs a struct value field")
|
|
||||||
}
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
|
|
||||||
if tag != "" {
|
|
||||||
info.Key = tag
|
|
||||||
} else {
|
|
||||||
info.Key = strings.ToLower(field.Name)
|
|
||||||
}
|
|
||||||
|
|
||||||
if _, found = fieldsMap[info.Key]; found {
|
|
||||||
msg := "Duplicated key '" + info.Key + "' in struct " + st.String()
|
|
||||||
return nil, errors.New(msg)
|
|
||||||
}
|
|
||||||
|
|
||||||
info.Id = len(fieldsList)
|
|
||||||
fieldsList = append(fieldsList, info)
|
|
||||||
fieldsMap[info.Key] = info
|
|
||||||
}
|
|
||||||
|
|
||||||
sinfo = &structInfo{
|
|
||||||
FieldsMap: fieldsMap,
|
|
||||||
FieldsList: fieldsList,
|
|
||||||
InlineMap: inlineMap,
|
|
||||||
}
|
|
||||||
|
|
||||||
fieldMapMutex.Lock()
|
|
||||||
structMap[st] = sinfo
|
|
||||||
fieldMapMutex.Unlock()
|
|
||||||
return sinfo, 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 isZero(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:
|
|
||||||
return v.Len() == 0
|
|
||||||
case 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 !isZero(v.Field(i)) {
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
-738
File diff suppressed because it is too large.
Load diff
-173
@@ -1,173 +0,0 @@
|
|||||||
package yaml
|
|
||||||
|
|
||||||
const (
|
|
||||||
// The size of the input raw buffer.
|
|
||||||
input_raw_buffer_size = 512
|
|
||||||
|
|
||||||
// The size of the input buffer.
|
|
||||||
// It should be possible to decode the whole raw buffer.
|
|
||||||
input_buffer_size = input_raw_buffer_size * 3
|
|
||||||
|
|
||||||
// The size of the output buffer.
|
|
||||||
output_buffer_size = 128
|
|
||||||
|
|
||||||
// The size of the output raw buffer.
|
|
||||||
// It should be possible to encode the whole output buffer.
|
|
||||||
output_raw_buffer_size = (output_buffer_size*2 + 2)
|
|
||||||
|
|
||||||
// The size of other stacks and queues.
|
|
||||||
initial_stack_size = 16
|
|
||||||
initial_queue_size = 16
|
|
||||||
initial_string_size = 16
|
|
||||||
)
|
|
||||||
|
|
||||||
// Check if the character at the specified position is an alphabetical
|
|
||||||
// character, a digit, '_', or '-'.
|
|
||||||
func is_alpha(b []byte, i int) bool {
|
|
||||||
return b[i] >= '0' && b[i] <= '9' || b[i] >= 'A' && b[i] <= 'Z' || b[i] >= 'a' && b[i] <= 'z' || b[i] == '_' || b[i] == '-'
|
|
||||||
}
|
|
||||||
|
|
||||||
// Check if the character at the specified position is a digit.
|
|
||||||
func is_digit(b []byte, i int) bool {
|
|
||||||
return b[i] >= '0' && b[i] <= '9'
|
|
||||||
}
|
|
||||||
|
|
||||||
// Get the value of a digit.
|
|
||||||
func as_digit(b []byte, i int) int {
|
|
||||||
return int(b[i]) - '0'
|
|
||||||
}
|
|
||||||
|
|
||||||
// Check if the character at the specified position is a hex-digit.
|
|
||||||
func is_hex(b []byte, i int) bool {
|
|
||||||
return b[i] >= '0' && b[i] <= '9' || b[i] >= 'A' && b[i] <= 'F' || b[i] >= 'a' && b[i] <= 'f'
|
|
||||||
}
|
|
||||||
|
|
||||||
// Get the value of a hex-digit.
|
|
||||||
func as_hex(b []byte, i int) int {
|
|
||||||
bi := b[i]
|
|
||||||
if bi >= 'A' && bi <= 'F' {
|
|
||||||
return int(bi) - 'A' + 10
|
|
||||||
}
|
|
||||||
if bi >= 'a' && bi <= 'f' {
|
|
||||||
return int(bi) - 'a' + 10
|
|
||||||
}
|
|
||||||
return int(bi) - '0'
|
|
||||||
}
|
|
||||||
|
|
||||||
// Check if the character is ASCII.
|
|
||||||
func is_ascii(b []byte, i int) bool {
|
|
||||||
return b[i] <= 0x7F
|
|
||||||
}
|
|
||||||
|
|
||||||
// Check if the character at the start of the buffer can be printed unescaped.
|
|
||||||
func is_printable(b []byte, i int) bool {
|
|
||||||
return ((b[i] == 0x0A) || // . == #x0A
|
|
||||||
(b[i] >= 0x20 && b[i] <= 0x7E) || // #x20 <= . <= #x7E
|
|
||||||
(b[i] == 0xC2 && b[i+1] >= 0xA0) || // #0xA0 <= . <= #xD7FF
|
|
||||||
(b[i] > 0xC2 && b[i] < 0xED) ||
|
|
||||||
(b[i] == 0xED && b[i+1] < 0xA0) ||
|
|
||||||
(b[i] == 0xEE) ||
|
|
||||||
(b[i] == 0xEF && // #xE000 <= . <= #xFFFD
|
|
||||||
!(b[i+1] == 0xBB && b[i+2] == 0xBF) && // && . != #xFEFF
|
|
||||||
!(b[i+1] == 0xBF && (b[i+2] == 0xBE || b[i+2] == 0xBF))))
|
|
||||||
}
|
|
||||||
|
|
||||||
// Check if the character at the specified position is NUL.
|
|
||||||
func is_z(b []byte, i int) bool {
|
|
||||||
return b[i] == 0x00
|
|
||||||
}
|
|
||||||
|
|
||||||
// Check if the beginning of the buffer is a BOM.
|
|
||||||
func is_bom(b []byte, i int) bool {
|
|
||||||
return b[0] == 0xEF && b[1] == 0xBB && b[2] == 0xBF
|
|
||||||
}
|
|
||||||
|
|
||||||
// Check if the character at the specified position is space.
|
|
||||||
func is_space(b []byte, i int) bool {
|
|
||||||
return b[i] == ' '
|
|
||||||
}
|
|
||||||
|
|
||||||
// Check if the character at the specified position is tab.
|
|
||||||
func is_tab(b []byte, i int) bool {
|
|
||||||
return b[i] == '\t'
|
|
||||||
}
|
|
||||||
|
|
||||||
// Check if the character at the specified position is blank (space or tab).
|
|
||||||
func is_blank(b []byte, i int) bool {
|
|
||||||
//return is_space(b, i) || is_tab(b, i)
|
|
||||||
return b[i] == ' ' || b[i] == '\t'
|
|
||||||
}
|
|
||||||
|
|
||||||
// Check if the character at the specified position is a line break.
|
|
||||||
func is_break(b []byte, i int) bool {
|
|
||||||
return (b[i] == '\r' || // CR (#xD)
|
|
||||||
b[i] == '\n' || // LF (#xA)
|
|
||||||
b[i] == 0xC2 && b[i+1] == 0x85 || // NEL (#x85)
|
|
||||||
b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA8 || // LS (#x2028)
|
|
||||||
b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA9) // PS (#x2029)
|
|
||||||
}
|
|
||||||
|
|
||||||
func is_crlf(b []byte, i int) bool {
|
|
||||||
return b[i] == '\r' && b[i+1] == '\n'
|
|
||||||
}
|
|
||||||
|
|
||||||
// Check if the character is a line break or NUL.
|
|
||||||
func is_breakz(b []byte, i int) bool {
|
|
||||||
//return is_break(b, i) || is_z(b, i)
|
|
||||||
return ( // is_break:
|
|
||||||
b[i] == '\r' || // CR (#xD)
|
|
||||||
b[i] == '\n' || // LF (#xA)
|
|
||||||
b[i] == 0xC2 && b[i+1] == 0x85 || // NEL (#x85)
|
|
||||||
b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA8 || // LS (#x2028)
|
|
||||||
b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA9 || // PS (#x2029)
|
|
||||||
// is_z:
|
|
||||||
b[i] == 0)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Check if the character is a line break, space, or NUL.
|
|
||||||
func is_spacez(b []byte, i int) bool {
|
|
||||||
//return is_space(b, i) || is_breakz(b, i)
|
|
||||||
return ( // is_space:
|
|
||||||
b[i] == ' ' ||
|
|
||||||
// is_breakz:
|
|
||||||
b[i] == '\r' || // CR (#xD)
|
|
||||||
b[i] == '\n' || // LF (#xA)
|
|
||||||
b[i] == 0xC2 && b[i+1] == 0x85 || // NEL (#x85)
|
|
||||||
b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA8 || // LS (#x2028)
|
|
||||||
b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA9 || // PS (#x2029)
|
|
||||||
b[i] == 0)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Check if the character is a line break, space, tab, or NUL.
|
|
||||||
func is_blankz(b []byte, i int) bool {
|
|
||||||
//return is_blank(b, i) || is_breakz(b, i)
|
|
||||||
return ( // is_blank:
|
|
||||||
b[i] == ' ' || b[i] == '\t' ||
|
|
||||||
// is_breakz:
|
|
||||||
b[i] == '\r' || // CR (#xD)
|
|
||||||
b[i] == '\n' || // LF (#xA)
|
|
||||||
b[i] == 0xC2 && b[i+1] == 0x85 || // NEL (#x85)
|
|
||||||
b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA8 || // LS (#x2028)
|
|
||||||
b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA9 || // PS (#x2029)
|
|
||||||
b[i] == 0)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Determine the width of the character.
|
|
||||||
func width(b byte) int {
|
|
||||||
// Don't replace these by a switch without first
|
|
||||||
// confirming that it is being inlined.
|
|
||||||
if b&0x80 == 0x00 {
|
|
||||||
return 1
|
|
||||||
}
|
|
||||||
if b&0xE0 == 0xC0 {
|
|
||||||
return 2
|
|
||||||
}
|
|
||||||
if b&0xF0 == 0xE0 {
|
|
||||||
return 3
|
|
||||||
}
|
|
||||||
if b&0xF8 == 0xF0 {
|
|
||||||
return 4
|
|
||||||
}
|
|
||||||
return 0
|
|
||||||
|
|
||||||
}
|
|
||||||
Vendored
+4
-4
@@ -15,22 +15,23 @@ github.com/docker/distribution/digestset
|
|||||||
# github.com/docker/docker v1.13.1 => github.com/docker/engine v0.0.0-20181106193140-f5749085e9cb
|
# github.com/docker/docker v1.13.1 => github.com/docker/engine v0.0.0-20181106193140-f5749085e9cb
|
||||||
github.com/docker/docker/api/types
|
github.com/docker/docker/api/types
|
||||||
github.com/docker/docker/api/types/container
|
github.com/docker/docker/api/types/container
|
||||||
|
github.com/docker/docker/api/types/filters
|
||||||
github.com/docker/docker/builder/dockerignore
|
github.com/docker/docker/builder/dockerignore
|
||||||
github.com/docker/docker/client
|
github.com/docker/docker/client
|
||||||
github.com/docker/docker/pkg/archive
|
github.com/docker/docker/pkg/archive
|
||||||
github.com/docker/docker/pkg/fileutils
|
github.com/docker/docker/pkg/fileutils
|
||||||
github.com/docker/docker/api/types/filters
|
github.com/docker/docker/pkg/stdcopy
|
||||||
github.com/docker/docker/api/types/mount
|
github.com/docker/docker/api/types/mount
|
||||||
github.com/docker/docker/api/types/network
|
github.com/docker/docker/api/types/network
|
||||||
github.com/docker/docker/api/types/registry
|
github.com/docker/docker/api/types/registry
|
||||||
github.com/docker/docker/api/types/swarm
|
github.com/docker/docker/api/types/swarm
|
||||||
github.com/docker/docker/api/types/blkiodev
|
github.com/docker/docker/api/types/blkiodev
|
||||||
github.com/docker/docker/api/types/strslice
|
github.com/docker/docker/api/types/strslice
|
||||||
|
github.com/docker/docker/api/types/versions
|
||||||
github.com/docker/docker/api
|
github.com/docker/docker/api
|
||||||
github.com/docker/docker/api/types/events
|
github.com/docker/docker/api/types/events
|
||||||
github.com/docker/docker/api/types/image
|
github.com/docker/docker/api/types/image
|
||||||
github.com/docker/docker/api/types/time
|
github.com/docker/docker/api/types/time
|
||||||
github.com/docker/docker/api/types/versions
|
|
||||||
github.com/docker/docker/api/types/volume
|
github.com/docker/docker/api/types/volume
|
||||||
github.com/docker/docker/pkg/idtools
|
github.com/docker/docker/pkg/idtools
|
||||||
github.com/docker/docker/pkg/ioutils
|
github.com/docker/docker/pkg/ioutils
|
||||||
@@ -119,6 +120,7 @@ github.com/src-d/gcfg/token
|
|||||||
github.com/src-d/gcfg/types
|
github.com/src-d/gcfg/types
|
||||||
# github.com/stretchr/testify v1.3.0
|
# github.com/stretchr/testify v1.3.0
|
||||||
github.com/stretchr/testify/assert
|
github.com/stretchr/testify/assert
|
||||||
|
github.com/stretchr/testify/require
|
||||||
# github.com/xanzy/ssh-agent v0.2.0
|
# github.com/xanzy/ssh-agent v0.2.0
|
||||||
github.com/xanzy/ssh-agent
|
github.com/xanzy/ssh-agent
|
||||||
# golang.org/x/crypto v0.0.0-20190131182504-b8fe1690c613
|
# golang.org/x/crypto v0.0.0-20190131182504-b8fe1690c613
|
||||||
@@ -199,8 +201,6 @@ gopkg.in/src-d/go-git.v4/plumbing/transport/internal/common
|
|||||||
gopkg.in/src-d/go-git.v4/plumbing/transport/server
|
gopkg.in/src-d/go-git.v4/plumbing/transport/server
|
||||||
# gopkg.in/warnings.v0 v0.1.2
|
# gopkg.in/warnings.v0 v0.1.2
|
||||||
gopkg.in/warnings.v0
|
gopkg.in/warnings.v0
|
||||||
# gopkg.in/yaml.v2 v2.2.2
|
|
||||||
gopkg.in/yaml.v2
|
|
||||||
# gotest.tools v2.2.0+incompatible
|
# gotest.tools v2.2.0+incompatible
|
||||||
gotest.tools/assert
|
gotest.tools/assert
|
||||||
gotest.tools/assert/cmp
|
gotest.tools/assert/cmp
|
||||||
|
|||||||
Reference in new issue
Block a user