@@ -0,0 +1,23 @@ | |||
- | |||
id: 1 | |||
uid: 1 | |||
name: Token A | |||
sha1: hash1 | |||
created_unix: 946687980 | |||
updated_unix: 946687980 | |||
- | |||
id: 2 | |||
uid: 1 | |||
name: Token B | |||
sha1: hash2 | |||
created_unix: 946687980 | |||
updated_unix: 946687980 | |||
- | |||
id: 3 | |||
uid: 2 | |||
name: Token A | |||
sha1: hash3 | |||
created_unix: 946687980 | |||
updated_unix: 946687980 |
@@ -0,0 +1,20 @@ | |||
- | |||
id: 1 | |||
uuid: uuid1 | |||
ref_name: refName1 | |||
old_commit_id: oldCommitId1 | |||
new_commit_id: newCommitId1 | |||
- | |||
id: 2 | |||
uuid: uuid2 | |||
ref_name: refName2 | |||
old_commit_id: oldCommitId2 | |||
new_commit_id: newCommitId2 | |||
- | |||
id: 3 | |||
uuid: uuid3 | |||
ref_name: refName3 | |||
old_commit_id: oldCommitId3 | |||
new_commit_id: newCommitId3 |
@@ -0,0 +1,47 @@ | |||
// Copyright 2016 The Gitea Authors. All rights reserved. | |||
// Use of this source code is governed by a MIT-style | |||
// license that can be found in the LICENSE file. | |||
package models | |||
import ( | |||
"fmt" | |||
"os" | |||
"testing" | |||
"github.com/go-xorm/core" | |||
"github.com/go-xorm/xorm" | |||
_ "github.com/mattn/go-sqlite3" // for the test engine | |||
"gopkg.in/testfixtures.v2" | |||
) | |||
func TestMain(m *testing.M) { | |||
if err := CreateTestEngine(); err != nil { | |||
fmt.Printf("Error creating test engine: %v\n", err) | |||
os.Exit(1) | |||
} | |||
os.Exit(m.Run()) | |||
} | |||
var fixtures *testfixtures.Context | |||
// CreateTestEngine create an xorm engine for testing | |||
func CreateTestEngine() error { | |||
testfixtures.SkipDatabaseNameCheck(true) | |||
var err error | |||
x, err = xorm.NewEngine("sqlite3", "file::memory:?cache=shared") | |||
if err != nil { | |||
return err | |||
} | |||
x.SetMapper(core.GonicMapper{}) | |||
if err = x.StoreEngine("InnoDB").Sync2(tables...); err != nil { | |||
return err | |||
} | |||
fixtures, err = testfixtures.NewFolder(x.DB().DB, &testfixtures.SQLite{}, "fixtures/") | |||
return err | |||
} | |||
// PrepareTestDatabase load test fixtures into test database | |||
func PrepareTestDatabase() error { | |||
return fixtures.Load() | |||
} |
@@ -0,0 +1,107 @@ | |||
// Copyright 2016 The Gitea Authors. All rights reserved. | |||
// Use of this source code is governed by a MIT-style | |||
// license that can be found in the LICENSE file. | |||
package models | |||
import ( | |||
"testing" | |||
"github.com/stretchr/testify/assert" | |||
) | |||
func TestNewAccessToken(t *testing.T) { | |||
assert.NoError(t, PrepareTestDatabase()) | |||
token := &AccessToken{ | |||
UID: 3, | |||
Name: "Token C", | |||
} | |||
assert.NoError(t, NewAccessToken(token)) | |||
sess := x.NewSession() | |||
defer sess.Close() | |||
has, err := sess.Get(*token) | |||
assert.NoError(t, err) | |||
assert.True(t, has) | |||
assert.Equal(t, int64(3), token.UID) | |||
assert.Equal(t, "Token C", token.Name) | |||
invalidToken := &AccessToken{ | |||
ID: token.ID, // duplicate | |||
UID: 2, | |||
Name: "Token F", | |||
} | |||
assert.Error(t, NewAccessToken(invalidToken)) | |||
} | |||
func TestGetAccessTokenBySHA(t *testing.T) { | |||
assert.NoError(t, PrepareTestDatabase()) | |||
token, err := GetAccessTokenBySHA("hash1") | |||
assert.NoError(t, err) | |||
assert.Equal(t, int64(1), token.UID) | |||
assert.Equal(t, "Token A", token.Name) | |||
assert.Equal(t, "hash1", token.Sha1) | |||
token, err = GetAccessTokenBySHA("notahash") | |||
assert.Error(t, err) | |||
assert.True(t, IsErrAccessTokenNotExist(err)) | |||
token, err = GetAccessTokenBySHA("") | |||
assert.Error(t, err) | |||
assert.True(t, IsErrAccessTokenEmpty(err)) | |||
} | |||
func TestListAccessTokens(t *testing.T) { | |||
assert.NoError(t, PrepareTestDatabase()) | |||
tokens, err := ListAccessTokens(1) | |||
assert.NoError(t, err) | |||
assert.Len(t, tokens, 2) | |||
assert.Equal(t, int64(1), tokens[0].UID) | |||
assert.Equal(t, int64(1), tokens[1].UID) | |||
assert.Contains(t, []string{tokens[0].Name, tokens[1].Name}, "Token A") | |||
assert.Contains(t, []string{tokens[0].Name, tokens[1].Name}, "Token B") | |||
tokens, err = ListAccessTokens(2) | |||
assert.NoError(t, err) | |||
assert.Len(t, tokens, 1) | |||
assert.Equal(t, int64(2), tokens[0].UID) | |||
assert.Equal(t, "Token A", tokens[0].Name) | |||
tokens, err = ListAccessTokens(100) | |||
assert.NoError(t, err) | |||
assert.Empty(t, tokens) | |||
} | |||
func TestUpdateAccessToken(t *testing.T) { | |||
assert.NoError(t, PrepareTestDatabase()) | |||
token, err := GetAccessTokenBySHA("hash2") | |||
assert.NoError(t, err) | |||
token.Name = "Token Z" | |||
assert.NoError(t, UpdateAccessToken(token)) | |||
sess := x.NewSession() | |||
defer sess.Close() | |||
has, err := sess.Get(token) | |||
assert.NoError(t, err) | |||
assert.True(t, has) | |||
assert.Equal(t, token.Name, "Token Z") | |||
} | |||
func TestDeleteAccessTokenByID(t *testing.T) { | |||
assert.NoError(t, PrepareTestDatabase()) | |||
token, err := GetAccessTokenBySHA("hash2") | |||
assert.NoError(t, err) | |||
assert.Equal(t, int64(1), token.UID) | |||
assert.NoError(t, DeleteAccessTokenByID(token.ID, 1)) | |||
sess := x.NewSession() | |||
defer sess.Close() | |||
has, err := sess.Get(token) | |||
assert.NoError(t, err) | |||
assert.False(t, has) | |||
err = DeleteAccessTokenByID(100, 100) | |||
assert.Error(t, err) | |||
assert.True(t, IsErrAccessTokenNotExist(err)) | |||
} |
@@ -0,0 +1,124 @@ | |||
// Copyright 2016 The Gitea Authors. All rights reserved. | |||
// Use of this source code is governed by a MIT-style | |||
// license that can be found in the LICENSE file. | |||
package models | |||
import ( | |||
"container/list" | |||
"testing" | |||
"time" | |||
"code.gitea.io/git" | |||
"github.com/stretchr/testify/assert" | |||
) | |||
func TestAddUpdateTask(t *testing.T) { | |||
assert.NoError(t, PrepareTestDatabase()) | |||
task := &UpdateTask{ | |||
UUID: "uuid4", | |||
RefName: "refName4", | |||
OldCommitID: "oldCommitId4", | |||
NewCommitID: "newCommitId4", | |||
} | |||
assert.NoError(t, AddUpdateTask(task)) | |||
sess := x.NewSession() | |||
defer sess.Close() | |||
has, err := sess.Get(task) | |||
assert.NoError(t, err) | |||
assert.True(t, has) | |||
assert.Equal(t, "uuid4", task.UUID) | |||
} | |||
func TestGetUpdateTaskByUUID(t *testing.T) { | |||
assert.NoError(t, PrepareTestDatabase()) | |||
task, err := GetUpdateTaskByUUID("uuid1") | |||
assert.NoError(t, err) | |||
assert.Equal(t, "uuid1", task.UUID) | |||
assert.Equal(t, "refName1", task.RefName) | |||
assert.Equal(t, "oldCommitId1", task.OldCommitID) | |||
assert.Equal(t, "newCommitId1", task.NewCommitID) | |||
} | |||
func TestDeleteUpdateTaskByUUID(t *testing.T) { | |||
assert.NoError(t, PrepareTestDatabase()) | |||
assert.NoError(t, DeleteUpdateTaskByUUID("uuid1")) | |||
sess := x.NewSession() | |||
defer sess.Close() | |||
has, err := sess.Get(&UpdateTask{UUID: "uuid1"}) | |||
assert.NoError(t, err) | |||
assert.False(t, has) | |||
assert.NoError(t, DeleteUpdateTaskByUUID("invalid")) | |||
} | |||
func TestCommitToPushCommit(t *testing.T) { | |||
now := time.Now() | |||
sig := &git.Signature{ | |||
Email: "example@example.com", | |||
Name: "John Doe", | |||
When: now, | |||
} | |||
const hexString = "0123456789abcdef0123456789abcdef01234567" | |||
sha1, err := git.NewIDFromString(hexString) | |||
assert.NoError(t, err) | |||
pushCommit := CommitToPushCommit(&git.Commit{ | |||
ID: sha1, | |||
Author: sig, | |||
Committer: sig, | |||
CommitMessage: "Commit Message", | |||
}) | |||
assert.Equal(t, hexString, pushCommit.Sha1) | |||
assert.Equal(t, "Commit Message", pushCommit.Message) | |||
assert.Equal(t, "example@example.com", pushCommit.AuthorEmail) | |||
assert.Equal(t, "John Doe", pushCommit.AuthorName) | |||
assert.Equal(t, "example@example.com", pushCommit.CommitterEmail) | |||
assert.Equal(t, "John Doe", pushCommit.CommitterName) | |||
assert.Equal(t, now, pushCommit.Timestamp) | |||
} | |||
func TestListToPushCommits(t *testing.T) { | |||
now := time.Now() | |||
sig := &git.Signature{ | |||
Email: "example@example.com", | |||
Name: "John Doe", | |||
When: now, | |||
} | |||
const hexString1 = "0123456789abcdef0123456789abcdef01234567" | |||
hash1, err := git.NewIDFromString(hexString1) | |||
assert.NoError(t, err) | |||
const hexString2 = "fedcba9876543210fedcba9876543210fedcba98" | |||
hash2, err := git.NewIDFromString(hexString2) | |||
assert.NoError(t, err) | |||
l := list.New() | |||
l.PushBack(&git.Commit{ | |||
ID: hash1, | |||
Author: sig, | |||
Committer: sig, | |||
CommitMessage: "Message1", | |||
}) | |||
l.PushBack(&git.Commit{ | |||
ID: hash2, | |||
Author: sig, | |||
Committer: sig, | |||
CommitMessage: "Message2", | |||
}) | |||
pushCommits := ListToPushCommits(l) | |||
assert.Equal(t, 2, pushCommits.Len) | |||
assert.Equal(t, 2, len(pushCommits.Commits)) | |||
assert.Equal(t, "Message1", pushCommits.Commits[0].Message) | |||
assert.Equal(t, hexString1, pushCommits.Commits[0].Sha1) | |||
assert.Equal(t, "example@example.com", pushCommits.Commits[0].AuthorEmail) | |||
assert.Equal(t, now, pushCommits.Commits[0].Timestamp) | |||
assert.Equal(t, "Message2", pushCommits.Commits[1].Message) | |||
assert.Equal(t, hexString2, pushCommits.Commits[1].Sha1) | |||
assert.Equal(t, "example@example.com", pushCommits.Commits[1].AuthorEmail) | |||
assert.Equal(t, now, pushCommits.Commits[1].Timestamp) | |||
} |
@@ -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 |
@@ -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 |
@@ -0,0 +1,429 @@ | |||
/* | |||
* CODE GENERATED AUTOMATICALLY WITH github.com/stretchr/testify/_codegen | |||
* THIS FILE MUST NOT BE EDITED BY HAND | |||
*/ | |||
package require | |||
import ( | |||
assert "github.com/stretchr/testify/assert" | |||
http "net/http" | |||
url "net/url" | |||
time "time" | |||
) | |||
// Condition uses a Comparison to assert a complex condition. | |||
func Condition(t TestingT, comp assert.Comparison, msgAndArgs ...interface{}) { | |||
if !assert.Condition(t, comp, msgAndArgs...) { | |||
t.FailNow() | |||
} | |||
} | |||
// Contains asserts that the specified string, list(array, slice...) or map contains the | |||
// specified substring or element. | |||
// | |||
// assert.Contains(t, "Hello World", "World", "But 'Hello World' does contain 'World'") | |||
// assert.Contains(t, ["Hello", "World"], "World", "But ["Hello", "World"] does contain 'World'") | |||
// assert.Contains(t, {"Hello": "World"}, "Hello", "But {'Hello': 'World'} does contain 'Hello'") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func Contains(t TestingT, s interface{}, contains interface{}, msgAndArgs ...interface{}) { | |||
if !assert.Contains(t, s, contains, msgAndArgs...) { | |||
t.FailNow() | |||
} | |||
} | |||
// Empty asserts that the specified object is empty. I.e. nil, "", false, 0 or either | |||
// a slice or a channel with len == 0. | |||
// | |||
// assert.Empty(t, obj) | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func Empty(t TestingT, object interface{}, msgAndArgs ...interface{}) { | |||
if !assert.Empty(t, object, msgAndArgs...) { | |||
t.FailNow() | |||
} | |||
} | |||
// Equal asserts that two objects are equal. | |||
// | |||
// assert.Equal(t, 123, 123, "123 and 123 should be equal") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
// | |||
// Pointer variable equality is determined based on the equality of the | |||
// referenced values (as opposed to the memory addresses). | |||
func Equal(t TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) { | |||
if !assert.Equal(t, expected, actual, msgAndArgs...) { | |||
t.FailNow() | |||
} | |||
} | |||
// EqualError asserts that a function returned an error (i.e. not `nil`) | |||
// and that it is equal to the provided error. | |||
// | |||
// actualObj, err := SomeFunction() | |||
// assert.EqualError(t, err, expectedErrorString, "An error was expected") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func EqualError(t TestingT, theError error, errString string, msgAndArgs ...interface{}) { | |||
if !assert.EqualError(t, theError, errString, msgAndArgs...) { | |||
t.FailNow() | |||
} | |||
} | |||
// EqualValues asserts that two objects are equal or convertable to the same types | |||
// and equal. | |||
// | |||
// assert.EqualValues(t, uint32(123), int32(123), "123 and 123 should be equal") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func EqualValues(t TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) { | |||
if !assert.EqualValues(t, expected, actual, msgAndArgs...) { | |||
t.FailNow() | |||
} | |||
} | |||
// Error asserts that a function returned an error (i.e. not `nil`). | |||
// | |||
// actualObj, err := SomeFunction() | |||
// if assert.Error(t, err, "An error was expected") { | |||
// assert.Equal(t, err, expectedError) | |||
// } | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func Error(t TestingT, err error, msgAndArgs ...interface{}) { | |||
if !assert.Error(t, err, msgAndArgs...) { | |||
t.FailNow() | |||
} | |||
} | |||
// Exactly asserts that two objects are equal is value and type. | |||
// | |||
// assert.Exactly(t, int32(123), int64(123), "123 and 123 should NOT be equal") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func Exactly(t TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) { | |||
if !assert.Exactly(t, expected, actual, msgAndArgs...) { | |||
t.FailNow() | |||
} | |||
} | |||
// Fail reports a failure through | |||
func Fail(t TestingT, failureMessage string, msgAndArgs ...interface{}) { | |||
if !assert.Fail(t, failureMessage, msgAndArgs...) { | |||
t.FailNow() | |||
} | |||
} | |||
// FailNow fails test | |||
func FailNow(t TestingT, failureMessage string, msgAndArgs ...interface{}) { | |||
if !assert.FailNow(t, failureMessage, msgAndArgs...) { | |||
t.FailNow() | |||
} | |||
} | |||
// False asserts that the specified value is false. | |||
// | |||
// assert.False(t, myBool, "myBool should be false") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func False(t TestingT, value bool, msgAndArgs ...interface{}) { | |||
if !assert.False(t, value, msgAndArgs...) { | |||
t.FailNow() | |||
} | |||
} | |||
// HTTPBodyContains asserts that a specified handler returns a | |||
// body that contains a string. | |||
// | |||
// assert.HTTPBodyContains(t, myHandler, "www.google.com", nil, "I'm Feeling Lucky") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func HTTPBodyContains(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{}) { | |||
if !assert.HTTPBodyContains(t, handler, method, url, values, str) { | |||
t.FailNow() | |||
} | |||
} | |||
// HTTPBodyNotContains asserts that a specified handler returns a | |||
// body that does not contain a string. | |||
// | |||
// assert.HTTPBodyNotContains(t, myHandler, "www.google.com", nil, "I'm Feeling Lucky") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func HTTPBodyNotContains(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{}) { | |||
if !assert.HTTPBodyNotContains(t, handler, method, url, values, str) { | |||
t.FailNow() | |||
} | |||
} | |||
// HTTPError asserts that a specified handler returns an error status code. | |||
// | |||
// assert.HTTPError(t, myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}} | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func HTTPError(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values) { | |||
if !assert.HTTPError(t, handler, method, url, values) { | |||
t.FailNow() | |||
} | |||
} | |||
// HTTPRedirect asserts that a specified handler returns a redirect status code. | |||
// | |||
// assert.HTTPRedirect(t, myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}} | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func HTTPRedirect(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values) { | |||
if !assert.HTTPRedirect(t, handler, method, url, values) { | |||
t.FailNow() | |||
} | |||
} | |||
// HTTPSuccess asserts that a specified handler returns a success status code. | |||
// | |||
// assert.HTTPSuccess(t, myHandler, "POST", "http://www.google.com", nil) | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func HTTPSuccess(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values) { | |||
if !assert.HTTPSuccess(t, handler, method, url, values) { | |||
t.FailNow() | |||
} | |||
} | |||
// Implements asserts that an object is implemented by the specified interface. | |||
// | |||
// assert.Implements(t, (*MyInterface)(nil), new(MyObject), "MyObject") | |||
func Implements(t TestingT, interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) { | |||
if !assert.Implements(t, interfaceObject, object, msgAndArgs...) { | |||
t.FailNow() | |||
} | |||
} | |||
// InDelta asserts that the two numerals are within delta of each other. | |||
// | |||
// assert.InDelta(t, math.Pi, (22 / 7.0), 0.01) | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func InDelta(t TestingT, expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) { | |||
if !assert.InDelta(t, expected, actual, delta, msgAndArgs...) { | |||
t.FailNow() | |||
} | |||
} | |||
// InDeltaSlice is the same as InDelta, except it compares two slices. | |||
func InDeltaSlice(t TestingT, expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) { | |||
if !assert.InDeltaSlice(t, expected, actual, delta, msgAndArgs...) { | |||
t.FailNow() | |||
} | |||
} | |||
// InEpsilon asserts that expected and actual have a relative error less than epsilon | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func InEpsilon(t TestingT, expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{}) { | |||
if !assert.InEpsilon(t, expected, actual, epsilon, msgAndArgs...) { | |||
t.FailNow() | |||
} | |||
} | |||
// InEpsilonSlice is the same as InEpsilon, except it compares each value from two slices. | |||
func InEpsilonSlice(t TestingT, expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{}) { | |||
if !assert.InEpsilonSlice(t, expected, actual, epsilon, msgAndArgs...) { | |||
t.FailNow() | |||
} | |||
} | |||
// IsType asserts that the specified objects are of the same type. | |||
func IsType(t TestingT, expectedType interface{}, object interface{}, msgAndArgs ...interface{}) { | |||
if !assert.IsType(t, expectedType, object, msgAndArgs...) { | |||
t.FailNow() | |||
} | |||
} | |||
// JSONEq asserts that two JSON strings are equivalent. | |||
// | |||
// assert.JSONEq(t, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`) | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func JSONEq(t TestingT, expected string, actual string, msgAndArgs ...interface{}) { | |||
if !assert.JSONEq(t, expected, actual, msgAndArgs...) { | |||
t.FailNow() | |||
} | |||
} | |||
// Len asserts that the specified object has specific length. | |||
// Len also fails if the object has a type that len() not accept. | |||
// | |||
// assert.Len(t, mySlice, 3, "The size of slice is not 3") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func Len(t TestingT, object interface{}, length int, msgAndArgs ...interface{}) { | |||
if !assert.Len(t, object, length, msgAndArgs...) { | |||
t.FailNow() | |||
} | |||
} | |||
// Nil asserts that the specified object is nil. | |||
// | |||
// assert.Nil(t, err, "err should be nothing") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func Nil(t TestingT, object interface{}, msgAndArgs ...interface{}) { | |||
if !assert.Nil(t, object, msgAndArgs...) { | |||
t.FailNow() | |||
} | |||
} | |||
// NoError asserts that a function returned no error (i.e. `nil`). | |||
// | |||
// actualObj, err := SomeFunction() | |||
// if assert.NoError(t, err) { | |||
// assert.Equal(t, actualObj, expectedObj) | |||
// } | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func NoError(t TestingT, err error, msgAndArgs ...interface{}) { | |||
if !assert.NoError(t, err, msgAndArgs...) { | |||
t.FailNow() | |||
} | |||
} | |||
// NotContains asserts that the specified string, list(array, slice...) or map does NOT contain the | |||
// specified substring or element. | |||
// | |||
// assert.NotContains(t, "Hello World", "Earth", "But 'Hello World' does NOT contain 'Earth'") | |||
// assert.NotContains(t, ["Hello", "World"], "Earth", "But ['Hello', 'World'] does NOT contain 'Earth'") | |||
// assert.NotContains(t, {"Hello": "World"}, "Earth", "But {'Hello': 'World'} does NOT contain 'Earth'") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func NotContains(t TestingT, s interface{}, contains interface{}, msgAndArgs ...interface{}) { | |||
if !assert.NotContains(t, s, contains, msgAndArgs...) { | |||
t.FailNow() | |||
} | |||
} | |||
// NotEmpty asserts that the specified object is NOT empty. I.e. not nil, "", false, 0 or either | |||
// a slice or a channel with len == 0. | |||
// | |||
// if assert.NotEmpty(t, obj) { | |||
// assert.Equal(t, "two", obj[1]) | |||
// } | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func NotEmpty(t TestingT, object interface{}, msgAndArgs ...interface{}) { | |||
if !assert.NotEmpty(t, object, msgAndArgs...) { | |||
t.FailNow() | |||
} | |||
} | |||
// NotEqual asserts that the specified values are NOT equal. | |||
// | |||
// assert.NotEqual(t, obj1, obj2, "two objects shouldn't be equal") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
// | |||
// Pointer variable equality is determined based on the equality of the | |||
// referenced values (as opposed to the memory addresses). | |||
func NotEqual(t TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) { | |||
if !assert.NotEqual(t, expected, actual, msgAndArgs...) { | |||
t.FailNow() | |||
} | |||
} | |||
// NotNil asserts that the specified object is not nil. | |||
// | |||
// assert.NotNil(t, err, "err should be something") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func NotNil(t TestingT, object interface{}, msgAndArgs ...interface{}) { | |||
if !assert.NotNil(t, object, msgAndArgs...) { | |||
t.FailNow() | |||
} | |||
} | |||
// NotPanics asserts that the code inside the specified PanicTestFunc does NOT panic. | |||
// | |||
// assert.NotPanics(t, func(){ | |||
// RemainCalm() | |||
// }, "Calling RemainCalm() should NOT panic") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func NotPanics(t TestingT, f assert.PanicTestFunc, msgAndArgs ...interface{}) { | |||
if !assert.NotPanics(t, f, msgAndArgs...) { | |||
t.FailNow() | |||
} | |||
} | |||
// NotRegexp asserts that a specified regexp does not match a string. | |||
// | |||
// assert.NotRegexp(t, regexp.MustCompile("starts"), "it's starting") | |||
// assert.NotRegexp(t, "^start", "it's not starting") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func NotRegexp(t TestingT, rx interface{}, str interface{}, msgAndArgs ...interface{}) { | |||
if !assert.NotRegexp(t, rx, str, msgAndArgs...) { | |||
t.FailNow() | |||
} | |||
} | |||
// NotZero asserts that i is not the zero value for its type and returns the truth. | |||
func NotZero(t TestingT, i interface{}, msgAndArgs ...interface{}) { | |||
if !assert.NotZero(t, i, msgAndArgs...) { | |||
t.FailNow() | |||
} | |||
} | |||
// Panics asserts that the code inside the specified PanicTestFunc panics. | |||
// | |||
// assert.Panics(t, func(){ | |||
// GoCrazy() | |||
// }, "Calling GoCrazy() should panic") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func Panics(t TestingT, f assert.PanicTestFunc, msgAndArgs ...interface{}) { | |||
if !assert.Panics(t, f, msgAndArgs...) { | |||
t.FailNow() | |||
} | |||
} | |||
// Regexp asserts that a specified regexp matches a string. | |||
// | |||
// assert.Regexp(t, regexp.MustCompile("start"), "it's starting") | |||
// assert.Regexp(t, "start...$", "it's not starting") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func Regexp(t TestingT, rx interface{}, str interface{}, msgAndArgs ...interface{}) { | |||
if !assert.Regexp(t, rx, str, msgAndArgs...) { | |||
t.FailNow() | |||
} | |||
} | |||
// True asserts that the specified value is true. | |||
// | |||
// assert.True(t, myBool, "myBool should be true") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func True(t TestingT, value bool, msgAndArgs ...interface{}) { | |||
if !assert.True(t, value, msgAndArgs...) { | |||
t.FailNow() | |||
} | |||
} | |||
// WithinDuration asserts that the two times are within duration delta of each other. | |||
// | |||
// assert.WithinDuration(t, time.Now(), time.Now(), 10*time.Second, "The difference should not be more than 10s") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func WithinDuration(t TestingT, expected time.Time, actual time.Time, delta time.Duration, msgAndArgs ...interface{}) { | |||
if !assert.WithinDuration(t, expected, actual, delta, msgAndArgs...) { | |||
t.FailNow() | |||
} | |||
} | |||
// Zero asserts that i is the zero value for its type and returns the truth. | |||
func Zero(t TestingT, i interface{}, msgAndArgs ...interface{}) { | |||
if !assert.Zero(t, i, msgAndArgs...) { | |||
t.FailNow() | |||
} | |||
} |
@@ -0,0 +1,6 @@ | |||
{{.Comment}} | |||
func {{.DocInfo.Name}}(t TestingT, {{.Params}}) { | |||
if !assert.{{.DocInfo.Name}}(t, {{.ForwardedParams}}) { | |||
t.FailNow() | |||
} | |||
} |
@@ -0,0 +1,353 @@ | |||
/* | |||
* CODE GENERATED AUTOMATICALLY WITH github.com/stretchr/testify/_codegen | |||
* THIS FILE MUST NOT BE EDITED BY HAND | |||
*/ | |||
package require | |||
import ( | |||
assert "github.com/stretchr/testify/assert" | |||
http "net/http" | |||
url "net/url" | |||
time "time" | |||
) | |||
// Condition uses a Comparison to assert a complex condition. | |||
func (a *Assertions) Condition(comp assert.Comparison, msgAndArgs ...interface{}) { | |||
Condition(a.t, comp, msgAndArgs...) | |||
} | |||
// Contains asserts that the specified string, list(array, slice...) or map contains the | |||
// specified substring or element. | |||
// | |||
// a.Contains("Hello World", "World", "But 'Hello World' does contain 'World'") | |||
// a.Contains(["Hello", "World"], "World", "But ["Hello", "World"] does contain 'World'") | |||
// a.Contains({"Hello": "World"}, "Hello", "But {'Hello': 'World'} does contain 'Hello'") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) Contains(s interface{}, contains interface{}, msgAndArgs ...interface{}) { | |||
Contains(a.t, s, contains, msgAndArgs...) | |||
} | |||
// Empty asserts that the specified object is empty. I.e. nil, "", false, 0 or either | |||
// a slice or a channel with len == 0. | |||
// | |||
// a.Empty(obj) | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) Empty(object interface{}, msgAndArgs ...interface{}) { | |||
Empty(a.t, object, msgAndArgs...) | |||
} | |||
// Equal asserts that two objects are equal. | |||
// | |||
// a.Equal(123, 123, "123 and 123 should be equal") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
// | |||
// Pointer variable equality is determined based on the equality of the | |||
// referenced values (as opposed to the memory addresses). | |||
func (a *Assertions) Equal(expected interface{}, actual interface{}, msgAndArgs ...interface{}) { | |||
Equal(a.t, expected, actual, msgAndArgs...) | |||
} | |||
// EqualError asserts that a function returned an error (i.e. not `nil`) | |||
// and that it is equal to the provided error. | |||
// | |||
// actualObj, err := SomeFunction() | |||
// a.EqualError(err, expectedErrorString, "An error was expected") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) EqualError(theError error, errString string, msgAndArgs ...interface{}) { | |||
EqualError(a.t, theError, errString, msgAndArgs...) | |||
} | |||
// EqualValues asserts that two objects are equal or convertable to the same types | |||
// and equal. | |||
// | |||
// a.EqualValues(uint32(123), int32(123), "123 and 123 should be equal") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) EqualValues(expected interface{}, actual interface{}, msgAndArgs ...interface{}) { | |||
EqualValues(a.t, expected, actual, msgAndArgs...) | |||
} | |||
// Error asserts that a function returned an error (i.e. not `nil`). | |||
// | |||
// actualObj, err := SomeFunction() | |||
// if a.Error(err, "An error was expected") { | |||
// assert.Equal(t, err, expectedError) | |||
// } | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) Error(err error, msgAndArgs ...interface{}) { | |||
Error(a.t, err, msgAndArgs...) | |||
} | |||
// Exactly asserts that two objects are equal is value and type. | |||
// | |||
// a.Exactly(int32(123), int64(123), "123 and 123 should NOT be equal") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) Exactly(expected interface{}, actual interface{}, msgAndArgs ...interface{}) { | |||
Exactly(a.t, expected, actual, msgAndArgs...) | |||
} | |||
// Fail reports a failure through | |||
func (a *Assertions) Fail(failureMessage string, msgAndArgs ...interface{}) { | |||
Fail(a.t, failureMessage, msgAndArgs...) | |||
} | |||
// FailNow fails test | |||
func (a *Assertions) FailNow(failureMessage string, msgAndArgs ...interface{}) { | |||
FailNow(a.t, failureMessage, msgAndArgs...) | |||
} | |||
// False asserts that the specified value is false. | |||
// | |||
// a.False(myBool, "myBool should be false") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) False(value bool, msgAndArgs ...interface{}) { | |||
False(a.t, value, msgAndArgs...) | |||
} | |||
// HTTPBodyContains asserts that a specified handler returns a | |||
// body that contains a string. | |||
// | |||
// a.HTTPBodyContains(myHandler, "www.google.com", nil, "I'm Feeling Lucky") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) HTTPBodyContains(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}) { | |||
HTTPBodyContains(a.t, handler, method, url, values, str) | |||
} | |||
// HTTPBodyNotContains asserts that a specified handler returns a | |||
// body that does not contain a string. | |||
// | |||
// a.HTTPBodyNotContains(myHandler, "www.google.com", nil, "I'm Feeling Lucky") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) HTTPBodyNotContains(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}) { | |||
HTTPBodyNotContains(a.t, handler, method, url, values, str) | |||
} | |||
// HTTPError asserts that a specified handler returns an error status code. | |||
// | |||
// a.HTTPError(myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}} | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) HTTPError(handler http.HandlerFunc, method string, url string, values url.Values) { | |||
HTTPError(a.t, handler, method, url, values) | |||
} | |||
// HTTPRedirect asserts that a specified handler returns a redirect status code. | |||
// | |||
// a.HTTPRedirect(myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}} | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) HTTPRedirect(handler http.HandlerFunc, method string, url string, values url.Values) { | |||
HTTPRedirect(a.t, handler, method, url, values) | |||
} | |||
// HTTPSuccess asserts that a specified handler returns a success status code. | |||
// | |||
// a.HTTPSuccess(myHandler, "POST", "http://www.google.com", nil) | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) HTTPSuccess(handler http.HandlerFunc, method string, url string, values url.Values) { | |||
HTTPSuccess(a.t, handler, method, url, values) | |||
} | |||
// Implements asserts that an object is implemented by the specified interface. | |||
// | |||
// a.Implements((*MyInterface)(nil), new(MyObject), "MyObject") | |||
func (a *Assertions) Implements(interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) { | |||
Implements(a.t, interfaceObject, object, msgAndArgs...) | |||
} | |||
// InDelta asserts that the two numerals are within delta of each other. | |||
// | |||
// a.InDelta(math.Pi, (22 / 7.0), 0.01) | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) InDelta(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) { | |||
InDelta(a.t, expected, actual, delta, msgAndArgs...) | |||
} | |||
// InDeltaSlice is the same as InDelta, except it compares two slices. | |||
func (a *Assertions) InDeltaSlice(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) { | |||
InDeltaSlice(a.t, expected, actual, delta, msgAndArgs...) | |||
} | |||
// InEpsilon asserts that expected and actual have a relative error less than epsilon | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) InEpsilon(expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{}) { | |||
InEpsilon(a.t, expected, actual, epsilon, msgAndArgs...) | |||
} | |||
// InEpsilonSlice is the same as InEpsilon, except it compares each value from two slices. | |||
func (a *Assertions) InEpsilonSlice(expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{}) { | |||
InEpsilonSlice(a.t, expected, actual, epsilon, msgAndArgs...) | |||
} | |||
// IsType asserts that the specified objects are of the same type. | |||
func (a *Assertions) IsType(expectedType interface{}, object interface{}, msgAndArgs ...interface{}) { | |||
IsType(a.t, expectedType, object, msgAndArgs...) | |||
} | |||
// JSONEq asserts that two JSON strings are equivalent. | |||
// | |||
// a.JSONEq(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`) | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) JSONEq(expected string, actual string, msgAndArgs ...interface{}) { | |||
JSONEq(a.t, expected, actual, msgAndArgs...) | |||
} | |||
// Len asserts that the specified object has specific length. | |||
// Len also fails if the object has a type that len() not accept. | |||
// | |||
// a.Len(mySlice, 3, "The size of slice is not 3") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) Len(object interface{}, length int, msgAndArgs ...interface{}) { | |||
Len(a.t, object, length, msgAndArgs...) | |||
} | |||
// Nil asserts that the specified object is nil. | |||
// | |||
// a.Nil(err, "err should be nothing") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) Nil(object interface{}, msgAndArgs ...interface{}) { | |||
Nil(a.t, object, msgAndArgs...) | |||
} | |||
// NoError asserts that a function returned no error (i.e. `nil`). | |||
// | |||
// actualObj, err := SomeFunction() | |||
// if a.NoError(err) { | |||
// assert.Equal(t, actualObj, expectedObj) | |||
// } | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) NoError(err error, msgAndArgs ...interface{}) { | |||
NoError(a.t, err, msgAndArgs...) | |||
} | |||
// NotContains asserts that the specified string, list(array, slice...) or map does NOT contain the | |||
// specified substring or element. | |||
// | |||
// a.NotContains("Hello World", "Earth", "But 'Hello World' does NOT contain 'Earth'") | |||
// a.NotContains(["Hello", "World"], "Earth", "But ['Hello', 'World'] does NOT contain 'Earth'") | |||
// a.NotContains({"Hello": "World"}, "Earth", "But {'Hello': 'World'} does NOT contain 'Earth'") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) NotContains(s interface{}, contains interface{}, msgAndArgs ...interface{}) { | |||
NotContains(a.t, s, contains, msgAndArgs...) | |||
} | |||
// NotEmpty asserts that the specified object is NOT empty. I.e. not nil, "", false, 0 or either | |||
// a slice or a channel with len == 0. | |||
// | |||
// if a.NotEmpty(obj) { | |||
// assert.Equal(t, "two", obj[1]) | |||
// } | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) NotEmpty(object interface{}, msgAndArgs ...interface{}) { | |||
NotEmpty(a.t, object, msgAndArgs...) | |||
} | |||
// NotEqual asserts that the specified values are NOT equal. | |||
// | |||
// a.NotEqual(obj1, obj2, "two objects shouldn't be equal") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
// | |||
// Pointer variable equality is determined based on the equality of the | |||
// referenced values (as opposed to the memory addresses). | |||
func (a *Assertions) NotEqual(expected interface{}, actual interface{}, msgAndArgs ...interface{}) { | |||
NotEqual(a.t, expected, actual, msgAndArgs...) | |||
} | |||
// NotNil asserts that the specified object is not nil. | |||
// | |||
// a.NotNil(err, "err should be something") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) NotNil(object interface{}, msgAndArgs ...interface{}) { | |||
NotNil(a.t, object, msgAndArgs...) | |||
} | |||
// NotPanics asserts that the code inside the specified PanicTestFunc does NOT panic. | |||
// | |||
// a.NotPanics(func(){ | |||
// RemainCalm() | |||
// }, "Calling RemainCalm() should NOT panic") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) NotPanics(f assert.PanicTestFunc, msgAndArgs ...interface{}) { | |||
NotPanics(a.t, f, msgAndArgs...) | |||
} | |||
// NotRegexp asserts that a specified regexp does not match a string. | |||
// | |||
// a.NotRegexp(regexp.MustCompile("starts"), "it's starting") | |||
// a.NotRegexp("^start", "it's not starting") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) NotRegexp(rx interface{}, str interface{}, msgAndArgs ...interface{}) { | |||
NotRegexp(a.t, rx, str, msgAndArgs...) | |||
} | |||
// NotZero asserts that i is not the zero value for its type and returns the truth. | |||
func (a *Assertions) NotZero(i interface{}, msgAndArgs ...interface{}) { | |||
NotZero(a.t, i, msgAndArgs...) | |||
} | |||
// Panics asserts that the code inside the specified PanicTestFunc panics. | |||
// | |||
// a.Panics(func(){ | |||
// GoCrazy() | |||
// }, "Calling GoCrazy() should panic") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) Panics(f assert.PanicTestFunc, msgAndArgs ...interface{}) { | |||
Panics(a.t, f, msgAndArgs...) | |||
} | |||
// Regexp asserts that a specified regexp matches a string. | |||
// | |||
// a.Regexp(regexp.MustCompile("start"), "it's starting") | |||
// a.Regexp("start...$", "it's not starting") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) Regexp(rx interface{}, str interface{}, msgAndArgs ...interface{}) { | |||
Regexp(a.t, rx, str, msgAndArgs...) | |||
} | |||
// True asserts that the specified value is true. | |||
// | |||
// a.True(myBool, "myBool should be true") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) True(value bool, msgAndArgs ...interface{}) { | |||
True(a.t, value, msgAndArgs...) | |||
} | |||
// WithinDuration asserts that the two times are within duration delta of each other. | |||
// | |||
// a.WithinDuration(time.Now(), time.Now(), 10*time.Second, "The difference should not be more than 10s") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) WithinDuration(expected time.Time, actual time.Time, delta time.Duration, msgAndArgs ...interface{}) { | |||
WithinDuration(a.t, expected, actual, delta, msgAndArgs...) | |||
} | |||
// Zero asserts that i is the zero value for its type and returns the truth. | |||
func (a *Assertions) Zero(i interface{}, msgAndArgs ...interface{}) { | |||
Zero(a.t, i, msgAndArgs...) | |||
} |
@@ -0,0 +1,4 @@ | |||
{{.CommentWithoutT "a"}} | |||
func (a *Assertions) {{.DocInfo.Name}}({{.Params}}) { | |||
{{.DocInfo.Name}}(a.t, {{.ForwardedParams}}) | |||
} |
@@ -0,0 +1,9 @@ | |||
package require | |||
// TestingT is an interface wrapper around *testing.T | |||
type TestingT interface { | |||
Errorf(format string, args ...interface{}) | |||
FailNow() | |||
} | |||
//go:generate go run ../_codegen/main.go -output-package=require -template=require.go.tmpl |
@@ -0,0 +1,21 @@ | |||
The MIT License (MIT) | |||
Copyright (c) 2016 Andrey Nering | |||
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. |
@@ -0,0 +1,323 @@ | |||
# Go Test Fixtures | |||
[![license](https://img.shields.io/github/license/mashape/apistatus.svg?maxAge=2592000)](https://github.com/go-testfixtures/testfixtures/blob/master/LICENSE) | |||
[![Join the chat at https://gitter.im/go-testfixtures/testfixtures](https://badges.gitter.im/go-testfixtures/testfixtures.svg)](https://gitter.im/go-testfixtures/testfixtures?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) | |||
[![GoDoc](https://godoc.org/gopkg.in/testfixtures.v1?status.svg)](https://godoc.org/gopkg.in/testfixtures.v1) | |||
[![Build Status](https://travis-ci.org/go-testfixtures/testfixtures.svg?branch=master)](https://travis-ci.org/go-testfixtures/testfixtures) | |||
[![Go Report Card](https://goreportcard.com/badge/github.com/go-testfixtures/testfixtures)](https://goreportcard.com/report/github.com/go-testfixtures/testfixtures) | |||
> ***Warning***: this package will wipe the database data before loading the | |||
fixtures! It is supposed to be used on a test database. Please, double check | |||
if you are running it against the correct database. | |||
Writing tests is hard, even more when you have to deal with an SQL database. | |||
This package aims to make writing functional tests for web apps written in | |||
Go easier. | |||
Basically this package mimics the ["Rails' way"][railstests] of writing tests | |||
for database applications, where sample data is kept in fixtures files. Before | |||
the execution of every test, the test database is cleaned and the fixture data | |||
is loaded into the database. | |||
The idea is running tests against a real database, instead of relying in mocks, | |||
which is boring to setup and may lead to production bugs not to being catch in | |||
the tests. | |||
## Installation | |||
First, get it: | |||
```bash | |||
go get -u gopkg.in/testfixtures.v2 | |||
``` | |||
## Usage | |||
Create a folder for the fixture files. Each file should contain data for a | |||
single table and have the name `<table-name>.yml`: | |||
```yml | |||
myapp | |||
- myapp.go | |||
- myapp_test.go | |||
- ... | |||
- fixtures: | |||
- posts.yml | |||
- comments.yml | |||
- tags.yml | |||
- posts_tags.yml | |||
- ... | |||
``` | |||
The file would look like this (it can have as many record you want): | |||
```yml | |||
# comments.yml | |||
- | |||
id: 1 | |||
post_id: 1 | |||
content: This post is awesome! | |||
author_name: John Doe | |||
author_email: john@doe.com | |||
created_at: 2016-01-01 12:30:12 | |||
updated_at: 2016-01-01 12:30:12 | |||
- | |||
id: 2 | |||
post_id: 2 | |||
content: Are you kidding me? | |||
author_name: John Doe | |||
author_email: john@doe.com | |||
created_at: 2016-01-01 12:30:12 | |||
updated_at: 2016-01-01 12:30:12 | |||
# ... | |||
``` | |||
Your tests would look like this: | |||
```go | |||
package myapp | |||
import ( | |||
"database/sql" | |||
"log" | |||
_ "github.com/lib/pq" | |||
"gopkg.in/testfixtures.v2" | |||
) | |||
var ( | |||
db *sql.DB | |||
fixtures *testfixtures.Context | |||
) | |||
func TestMain(m *testing.M) { | |||
var err error | |||
// Open connection with the test database. | |||
// Do NOT import fixtures in a production database! | |||
// Existing data would be deleted | |||
db, err = sql.Open("postgres", "dbname=myapp_test") | |||
if err != nil { | |||
log.Fatal(err) | |||
} | |||
// creating the context that hold the fixtures | |||
// see about all compatible databases in this page below | |||
c, err = testfixtures.NewFolder(db, &testfixtures.PostgreSQL{}, "testdata/fixtures") | |||
if err != nil { | |||
log.Fatal(err) | |||
} | |||
os.Exit(m.Run()) | |||
} | |||
func prepareTestDatabase() { | |||
if err := fixtures.Load(); err != nil { | |||
log.Fatal(err) | |||
} | |||
} | |||
func TestX(t *testing.T) { | |||
prepareTestDatabase() | |||
// your test here ... | |||
} | |||
func TestY(t *testing.T) { | |||
prepareTestDatabase() | |||
// your test here ... | |||
} | |||
func TestZ(t *testing.T) { | |||
prepareTestDatabase() | |||
// your test here ... | |||
} | |||
``` | |||
Alternatively, you can use the `NewFiles` function, to specify which | |||
files you want to load into the database: | |||
```go | |||
fixtures, err := testfixtures.NewFiles(db, &testfixtures.PostgreSQL{}, | |||
"fixtures/orders.yml", | |||
"fixtures/customers.yml", | |||
// add as many files you want | |||
) | |||
if err != nil { | |||
log.Fatal(err) | |||
} | |||
``` | |||
## Security check | |||
In order to prevent you from accidentally wiping the wrong database, this | |||
package will refuse to load fixtures if the database name (or database | |||
filename for SQLite) doesn't contains "test". If you want to disable this | |||
check, use: | |||
```go | |||
testfixtures.SkipDatabaseNameCheck(true) | |||
``` | |||
## Sequences | |||
For PostgreSQL or Oracle, this package also resets all sequences to a high | |||
number to prevent duplicated primary keys while running the tests. | |||
The default is 10000, but you can change that with: | |||
```go | |||
testfixtures.ResetSequencesTo(10000) | |||
``` | |||
## Compatible databases | |||
### PostgreSQL | |||
This package has two approaches to disable foreign keys while importing fixtures | |||
in PostgreSQL databases: | |||
#### With `DISABLE TRIGGER` | |||
This is the default approach. For that use: | |||
```go | |||
&testfixtures.PostgreSQL{} | |||
``` | |||
With the above snippet this package will use `DISABLE TRIGGER` to temporarily | |||
disabling foreign key constraints while loading fixtures. This work with any | |||
version of PostgreSQL, but it is **required** to be connected in the database | |||
as a SUPERUSER. You can make a PostgreSQL user a SUPERUSER with: | |||
```sql | |||
ALTER USER your_user SUPERUSER; | |||
``` | |||
#### With `ALTER CONSTRAINT` | |||
This approach don't require to be connected as a SUPERUSER, but only work with | |||
PostgreSQL versions >= 9.4. Try this if you are getting foreign key violation | |||
errors with the previous approach. It is as simple as using: | |||
```go | |||
&testfixtures.PostgreSQL{UseAlterConstraint: true} | |||
``` | |||
### MySQL | |||
Just make sure the connection string have | |||
[the multistatement parameter](https://github.com/go-sql-driver/mysql#multistatements) | |||
set to true, and use: | |||
```go | |||
&testfixtures.MySQL{} | |||
``` | |||
### SQLite | |||
SQLite is also supported. It is recommended to create foreign keys as | |||
`DEFERRABLE` (the default) to prevent problems. See more | |||
[on the SQLite documentation](https://www.sqlite.org/foreignkeys.html#fk_deferred). | |||
(Foreign key constraints are no-op by default on SQLite, but enabling it is | |||
recommended). | |||
```go | |||
&testfixtures.SQLite{} | |||
``` | |||
### Microsoft SQL Server | |||
SQL Server support requires SQL Server >= 2008. Inserting on `IDENTITY` columns | |||
are handled as well. Just make sure you are logged in with a user with | |||
`ALTER TABLE` permission. | |||
```go | |||
&testfixtures.SQLServer{} | |||
``` | |||
### Oracle | |||
Oracle is supported as well. Use: | |||
```go | |||
&testfixtures.Oracle{} | |||
``` | |||
## Contributing | |||
Tests were written to ensure everything work as expected. You can run the tests | |||
with: | |||
```bash | |||
# running tests for PostgreSQL | |||
go test -tags postgresql | |||
# running test for MySQL | |||
go test -tags mysql | |||
# running tests for SQLite | |||
go test -tags sqlite | |||
# running tests for SQL Server | |||
go test -tags sqlserver | |||
# running tests for Oracle | |||
go test -tags oracle | |||
# running test for multiple databases at once | |||
go test -tags 'sqlite postgresql mysql' | |||
# running tests + benchmark | |||
go test -v -bench=. -tags postgresql | |||
``` | |||
Travis runs tests for PostgreSQL, MySQL and SQLite. | |||
To set the connection string of tests for each database, edit the `.env` | |||
file, but do not include the changes a in pull request. | |||
## Changes in v2 | |||
A context was created to allow cache of some SQL statements. See in the | |||
documentation above how to use it. | |||
The helpers were renamed to have a smaller name: | |||
```go | |||
PostgreSQLHelper{} -> PostgreSQL{} | |||
MySQLHelper{} -> MySQL{} | |||
SQLiteHelper{} -> SQLite{} | |||
SQLServerHelper{} -> SQLServer{} | |||
OracleHelper{} -> Oracle{} | |||
``` | |||
The old functions and helpers are still available for backward compatibility. | |||
See the file [deprecated.go](https://github.com/go-testfixtures/testfixtures/blob/master/LICENSE) | |||
## Alternatives | |||
If you don't think using fixtures is a good idea, you can try one of these | |||
packages instead: | |||
- [factory-go][factorygo]: Factory for Go. Inspired by Python's Factory Boy | |||
and Ruby's Factory Girl | |||
- [go-txdb (Single transaction SQL driver for Go)][gotxdb]: Use a single | |||
database transaction for each functional test, so you can rollback to | |||
previous state between tests to have the same database state in all tests | |||
- [go-sqlmock][gosqlmock]: A mock for the sql.DB interface. This allow you to unit | |||
test database code without having to connect to a real database | |||
There's also these other implementations of test fixtures for Go: | |||
- [go-fixtures][gofixtures]: Django style fixtures for Go | |||
- [mongofixtures][mongofixtures]: Fixtures for MongoDB | |||
- [fixturer][fixturer]: Another fixture loader supporting MySQL | |||
[railstests]: http://guides.rubyonrails.org/testing.html#the-test-database | |||
[gotxdb]: https://github.com/DATA-DOG/go-txdb | |||
[gosqlmock]: https://github.com/DATA-DOG/go-sqlmock | |||
[gofixtures]: https://github.com/AreaHQ/go-fixtures | |||
[mongofixtures]: https://github.com/OwlyCode/mongofixtures | |||
[fixturer]: https://github.com/44hapa/fixturer | |||
[factorygo]: https://github.com/bluele/factory-go |
@@ -0,0 +1,59 @@ | |||
package testfixtures | |||
import ( | |||
"database/sql" | |||
) | |||
type ( | |||
DataBaseHelper Helper // Deprecated: Use Helper instead | |||
PostgreSQLHelper struct { // Deprecated: Use PostgreSQL{} instead | |||
PostgreSQL | |||
UseAlterConstraint bool | |||
} | |||
MySQLHelper struct { // Deprecated: Use MySQL{} instead | |||
MySQL | |||
} | |||
SQLiteHelper struct { // Deprecated: Use SQLite{} instead | |||
SQLite | |||
} | |||
SQLServerHelper struct { // Deprecated: Use SQLServer{} instead | |||
SQLServer | |||
} | |||
OracleHelper struct { // Deprecated: Use Oracle{} instead | |||
Oracle | |||
} | |||
) | |||
func (h *PostgreSQLHelper) disableReferentialIntegrity(db *sql.DB, loadFn loadFunction) error { | |||
h.PostgreSQL.UseAlterConstraint = h.UseAlterConstraint | |||
return h.PostgreSQL.disableReferentialIntegrity(db, loadFn) | |||
} | |||
// LoadFixtureFiles load all specified fixtures files into database: | |||
// LoadFixtureFiles(db, &PostgreSQL{}, | |||
// "fixtures/customers.yml", "fixtures/orders.yml") | |||
// // add as many files you want | |||
// | |||
// Deprecated: Use NewFiles() and Load() instead. | |||
func LoadFixtureFiles(db *sql.DB, helper Helper, files ...string) error { | |||
c, err := NewFiles(db, helper, files...) | |||
if err != nil { | |||
return err | |||
} | |||
return c.Load() | |||
} | |||
// LoadFixtures loads all fixtures in a given folder into the database: | |||
// LoadFixtures("myfixturesfolder", db, &PostgreSQL{}) | |||
// | |||
// Deprecated: Use NewFolder() and Load() instead. | |||
func LoadFixtures(folderName string, db *sql.DB, helper Helper) error { | |||
c, err := NewFolder(db, helper, folderName) | |||
if err != nil { | |||
return err | |||
} | |||
return c.Load() | |||
} |
@@ -0,0 +1,38 @@ | |||
package testfixtures | |||
import ( | |||
"database/sql" | |||
"fmt" | |||
) | |||
const ( | |||
paramTypeDollar = iota + 1 | |||
paramTypeQuestion | |||
paramTypeColon | |||
) | |||
type loadFunction func(tx *sql.Tx) error | |||
// Helper is the generic interface for the database helper | |||
type Helper interface { | |||
init(*sql.DB) error | |||
disableReferentialIntegrity(*sql.DB, loadFunction) error | |||
paramType() int | |||
databaseName(*sql.DB) string | |||
quoteKeyword(string) string | |||
whileInsertOnTable(*sql.Tx, string, func() error) error | |||
} | |||
type baseHelper struct{} | |||
func (*baseHelper) init(_ *sql.DB) error { | |||
return nil | |||
} | |||
func (*baseHelper) quoteKeyword(str string) string { | |||
return fmt.Sprintf(`"%s"`, str) | |||
} | |||
func (*baseHelper) whileInsertOnTable(_ *sql.Tx, _ string, fn func() error) error { | |||
return fn() | |||
} |
@@ -0,0 +1,45 @@ | |||
package testfixtures | |||
import ( | |||
"database/sql" | |||
"fmt" | |||
) | |||
// MySQL is the MySQL helper for this package | |||
type MySQL struct { | |||
baseHelper | |||
} | |||
func (*MySQL) paramType() int { | |||
return paramTypeQuestion | |||
} | |||
func (*MySQL) quoteKeyword(str string) string { | |||
return fmt.Sprintf("`%s`", str) | |||
} | |||
func (*MySQL) databaseName(db *sql.DB) (dbName string) { | |||
db.QueryRow("SELECT DATABASE()").Scan(&dbName) | |||
return | |||
} | |||
func (h *MySQL) disableReferentialIntegrity(db *sql.DB, loadFn loadFunction) error { | |||
// re-enable after load | |||
defer db.Exec("SET FOREIGN_KEY_CHECKS = 1") | |||
tx, err := db.Begin() | |||
if err != nil { | |||
return err | |||
} | |||
if _, err = tx.Exec("SET FOREIGN_KEY_CHECKS = 0"); err != nil { | |||
return err | |||
} | |||
if err = loadFn(tx); err != nil { | |||
tx.Rollback() | |||
return err | |||
} | |||
return tx.Commit() | |||
} |
@@ -0,0 +1,19 @@ | |||
package testfixtures | |||
var ( | |||
skipDatabaseNameCheck bool | |||
resetSequencesTo int64 = 10000 | |||
) | |||
// SkipDatabaseNameCheck If true, loading fixtures will not check if the database | |||
// name constaint "test". Use with caution! | |||
func SkipDatabaseNameCheck(value bool) { | |||
skipDatabaseNameCheck = value | |||
} | |||
// ResetSequencesTo sets the value the sequences will be reset to. | |||
// This is used by PostgreSQL and Oracle. | |||
// Defaults to 10000. | |||
func ResetSequencesTo(value int64) { | |||
resetSequencesTo = value | |||
} |
@@ -0,0 +1,132 @@ | |||
package testfixtures | |||
import ( | |||
"database/sql" | |||
"fmt" | |||
"strings" | |||
) | |||
// Oracle is the Oracle database helper for this package | |||
type Oracle struct { | |||
baseHelper | |||
enabledConstraints []oracleConstraint | |||
sequences []string | |||
} | |||
type oracleConstraint struct { | |||
tableName string | |||
constraintName string | |||
} | |||
func (h *Oracle) init(db *sql.DB) error { | |||
var err error | |||
h.enabledConstraints, err = h.getEnabledConstraints(db) | |||
if err != nil { | |||
return err | |||
} | |||
h.sequences, err = h.getSequences(db) | |||
if err != nil { | |||
return err | |||
} | |||
return nil | |||
} | |||
func (*Oracle) paramType() int { | |||
return paramTypeColon | |||
} | |||
func (*Oracle) quoteKeyword(str string) string { | |||
return fmt.Sprintf("\"%s\"", strings.ToUpper(str)) | |||
} | |||
func (*Oracle) databaseName(db *sql.DB) (dbName string) { | |||
db.QueryRow("SELECT user FROM DUAL").Scan(&dbName) | |||
return | |||
} | |||
func (*Oracle) getEnabledConstraints(db *sql.DB) ([]oracleConstraint, error) { | |||
constraints := make([]oracleConstraint, 0) | |||
rows, err := db.Query(` | |||
SELECT table_name, constraint_name | |||
FROM user_constraints | |||
WHERE constraint_type = 'R' | |||
AND status = 'ENABLED' | |||
`) | |||
if err != nil { | |||
return nil, err | |||
} | |||
defer rows.Close() | |||
for rows.Next() { | |||
var constraint oracleConstraint | |||
rows.Scan(&constraint.tableName, &constraint.constraintName) | |||
constraints = append(constraints, constraint) | |||
} | |||
return constraints, nil | |||
} | |||
func (*Oracle) getSequences(db *sql.DB) ([]string, error) { | |||
sequences := make([]string, 0) | |||
rows, err := db.Query("SELECT sequence_name FROM user_sequences") | |||
if err != nil { | |||
return nil, err | |||
} | |||
defer rows.Close() | |||
for rows.Next() { | |||
var sequence string | |||
rows.Scan(&sequence) | |||
sequences = append(sequences, sequence) | |||
} | |||
return sequences, nil | |||
} | |||
func (h *Oracle) resetSequences(db *sql.DB) error { | |||
for _, sequence := range h.sequences { | |||
_, err := db.Exec(fmt.Sprintf("DROP SEQUENCE %s", h.quoteKeyword(sequence))) | |||
if err != nil { | |||
return err | |||
} | |||
_, err = db.Exec(fmt.Sprintf("CREATE SEQUENCE %s START WITH %d", h.quoteKeyword(sequence), resetSequencesTo)) | |||
if err != nil { | |||
return err | |||
} | |||
} | |||
return nil | |||
} | |||
func (h *Oracle) disableReferentialIntegrity(db *sql.DB, loadFn loadFunction) error { | |||
// re-enable after load | |||
defer func() { | |||
for _, c := range h.enabledConstraints { | |||
db.Exec(fmt.Sprintf("ALTER TABLE %s ENABLE CONSTRAINT %s", h.quoteKeyword(c.tableName), h.quoteKeyword(c.constraintName))) | |||
} | |||
}() | |||
// disable foreign keys | |||
for _, c := range h.enabledConstraints { | |||
_, err := db.Exec(fmt.Sprintf("ALTER TABLE %s DISABLE CONSTRAINT %s", h.quoteKeyword(c.tableName), h.quoteKeyword(c.constraintName))) | |||
if err != nil { | |||
return err | |||
} | |||
} | |||
tx, err := db.Begin() | |||
if err != nil { | |||
return err | |||
} | |||
if err = loadFn(tx); err != nil { | |||
tx.Rollback() | |||
return err | |||
} | |||
if err = tx.Commit(); err != nil { | |||
return err | |||
} | |||
return h.resetSequences(db) | |||
} |
@@ -0,0 +1,211 @@ | |||
package testfixtures | |||
import ( | |||
"database/sql" | |||
"fmt" | |||
) | |||
// PostgreSQL is the PG helper for this package | |||
type PostgreSQL struct { | |||
baseHelper | |||
// UseAlterConstraint If true, the contraint disabling will do | |||
// using ALTER CONTRAINT sintax, only allowed in PG >= 9.4. | |||
// If false, the constraint disabling will use DISABLE TRIGGER ALL, | |||
// which requires SUPERUSER privileges. | |||
UseAlterConstraint bool | |||
tables []string | |||
sequences []string | |||
nonDeferrableConstraints []pgConstraint | |||
} | |||
type pgConstraint struct { | |||
tableName string | |||
constraintName string | |||
} | |||
func (h *PostgreSQL) init(db *sql.DB) error { | |||
var err error | |||
h.tables, err = h.getTables(db) | |||
if err != nil { | |||
return err | |||
} | |||
h.sequences, err = h.getSequences(db) | |||
if err != nil { | |||
return err | |||
} | |||
h.nonDeferrableConstraints, err = h.getNonDeferrableConstraints(db) | |||
if err != nil { | |||
return err | |||
} | |||
return nil | |||
} | |||
func (*PostgreSQL) paramType() int { | |||
return paramTypeDollar | |||
} | |||
func (*PostgreSQL) databaseName(db *sql.DB) (dbName string) { | |||
db.QueryRow("SELECT current_database()").Scan(&dbName) | |||
return | |||
} | |||
func (h *PostgreSQL) getTables(db *sql.DB) ([]string, error) { | |||
var tables []string | |||
sql := ` | |||
SELECT table_name | |||
FROM information_schema.tables | |||
WHERE table_schema = 'public' | |||
AND table_type = 'BASE TABLE'; | |||
` | |||
rows, err := db.Query(sql) | |||
if err != nil { | |||
return nil, err | |||
} | |||
defer rows.Close() | |||
for rows.Next() { | |||
var table string | |||
rows.Scan(&table) | |||
tables = append(tables, table) | |||
} | |||
return tables, nil | |||
} | |||
func (h *PostgreSQL) getSequences(db *sql.DB) ([]string, error) { | |||
var sequences []string | |||
sql := "SELECT relname FROM pg_class WHERE relkind = 'S'" | |||
rows, err := db.Query(sql) | |||
if err != nil { | |||
return nil, err | |||
} | |||
defer rows.Close() | |||
for rows.Next() { | |||
var sequence string | |||
if err = rows.Scan(&sequence); err != nil { | |||
return nil, err | |||
} | |||
sequences = append(sequences, sequence) | |||
} | |||
return sequences, nil | |||
} | |||
func (*PostgreSQL) getNonDeferrableConstraints(db *sql.DB) ([]pgConstraint, error) { | |||
var constraints []pgConstraint | |||
sql := ` | |||
SELECT table_name, constraint_name | |||
FROM information_schema.table_constraints | |||
WHERE constraint_type = 'FOREIGN KEY' | |||
AND is_deferrable = 'NO'` | |||
rows, err := db.Query(sql) | |||
if err != nil { | |||
return nil, err | |||
} | |||
defer rows.Close() | |||
for rows.Next() { | |||
var constraint pgConstraint | |||
err = rows.Scan(&constraint.tableName, &constraint.constraintName) | |||
if err != nil { | |||
return nil, err | |||
} | |||
constraints = append(constraints, constraint) | |||
} | |||
return constraints, nil | |||
} | |||
func (h *PostgreSQL) disableTriggers(db *sql.DB, loadFn loadFunction) error { | |||
defer func() { | |||
// re-enable triggers after load | |||
var sql string | |||
for _, table := range h.tables { | |||
sql += fmt.Sprintf("ALTER TABLE %s ENABLE TRIGGER ALL;", h.quoteKeyword(table)) | |||
} | |||
db.Exec(sql) | |||
}() | |||
tx, err := db.Begin() | |||
if err != nil { | |||
return err | |||
} | |||
var sql string | |||
for _, table := range h.tables { | |||
sql += fmt.Sprintf("ALTER TABLE %s DISABLE TRIGGER ALL;", h.quoteKeyword(table)) | |||
} | |||
if _, err = tx.Exec(sql); err != nil { | |||
return err | |||
} | |||
if err = loadFn(tx); err != nil { | |||
tx.Rollback() | |||
return err | |||
} | |||
return tx.Commit() | |||
} | |||
func (h *PostgreSQL) makeConstraintsDeferrable(db *sql.DB, loadFn loadFunction) error { | |||
defer func() { | |||
// ensure constraint being not deferrable again after load | |||
var sql string | |||
for _, constraint := range h.nonDeferrableConstraints { | |||
sql += fmt.Sprintf("ALTER TABLE %s ALTER CONSTRAINT %s NOT DEFERRABLE;", h.quoteKeyword(constraint.tableName), h.quoteKeyword(constraint.constraintName)) | |||
} | |||
db.Exec(sql) | |||
}() | |||
var sql string | |||
for _, constraint := range h.nonDeferrableConstraints { | |||
sql += fmt.Sprintf("ALTER TABLE %s ALTER CONSTRAINT %s DEFERRABLE;", h.quoteKeyword(constraint.tableName), h.quoteKeyword(constraint.constraintName)) | |||
} | |||
if _, err := db.Exec(sql); err != nil { | |||
return err | |||
} | |||
tx, err := db.Begin() | |||
if err != nil { | |||
return err | |||
} | |||
if _, err = tx.Exec("SET CONSTRAINTS ALL DEFERRED"); err != nil { | |||
return nil | |||
} | |||
if err = loadFn(tx); err != nil { | |||
tx.Rollback() | |||
return err | |||
} | |||
return tx.Commit() | |||
} | |||
func (h *PostgreSQL) disableReferentialIntegrity(db *sql.DB, loadFn loadFunction) error { | |||
// ensure sequences being reset after load | |||
defer h.resetSequences(db) | |||
if h.UseAlterConstraint { | |||
return h.makeConstraintsDeferrable(db, loadFn) | |||
} else { | |||
return h.disableTriggers(db, loadFn) | |||
} | |||
} | |||
func (h *PostgreSQL) resetSequences(db *sql.DB) error { | |||
for _, sequence := range h.sequences { | |||
_, err := db.Exec(fmt.Sprintf("SELECT SETVAL('%s', %d)", sequence, resetSequencesTo)) | |||
if err != nil { | |||
return err | |||
} | |||
} | |||
return nil | |||
} |
@@ -0,0 +1,40 @@ | |||
package testfixtures | |||
import ( | |||
"database/sql" | |||
"path/filepath" | |||
) | |||
// SQLite is the SQLite Helper for this package | |||
type SQLite struct { | |||
baseHelper | |||
} | |||
func (*SQLite) paramType() int { | |||
return paramTypeQuestion | |||
} | |||
func (*SQLite) databaseName(db *sql.DB) (dbName string) { | |||
var seq int | |||
var main string | |||
db.QueryRow("PRAGMA database_list").Scan(&seq, &main, &dbName) | |||
dbName = filepath.Base(dbName) | |||
return | |||
} | |||
func (*SQLite) disableReferentialIntegrity(db *sql.DB, loadFn loadFunction) error { | |||
tx, err := db.Begin() | |||
if err != nil { | |||
return err | |||
} | |||
if _, err = tx.Exec("PRAGMA defer_foreign_keys = ON"); err != nil { | |||
return err | |||
} | |||
if err = loadFn(tx); err != nil { | |||
return err | |||
} | |||
return tx.Commit() | |||
} |
@@ -0,0 +1,110 @@ | |||
package testfixtures | |||
import ( | |||
"database/sql" | |||
"fmt" | |||
) | |||
// SQLServer is the helper for SQL Server for this package. | |||
// SQL Server >= 2008 is required. | |||
type SQLServer struct { | |||
baseHelper | |||
tables []string | |||
} | |||
func (h *SQLServer) init(db *sql.DB) error { | |||
var err error | |||
h.tables, err = h.getTables(db) | |||
if err != nil { | |||
return err | |||
} | |||
return nil | |||
} | |||
func (*SQLServer) paramType() int { | |||
return paramTypeQuestion | |||
} | |||
func (*SQLServer) quoteKeyword(str string) string { | |||
return fmt.Sprintf("[%s]", str) | |||
} | |||
func (*SQLServer) databaseName(db *sql.DB) (dbname string) { | |||
db.QueryRow("SELECT DB_NAME()").Scan(&dbname) | |||
return | |||
} | |||
func (*SQLServer) getTables(db *sql.DB) ([]string, error) { | |||
rows, err := db.Query("SELECT table_name FROM information_schema.tables") | |||
if err != nil { | |||
return nil, err | |||
} | |||
tables := make([]string, 0) | |||
defer rows.Close() | |||
for rows.Next() { | |||
var table string | |||
rows.Scan(&table) | |||
tables = append(tables, table) | |||
} | |||
return tables, nil | |||
} | |||
func (*SQLServer) tableHasIdentityColumn(tx *sql.Tx, tableName string) bool { | |||
sql := ` | |||
SELECT COUNT(*) | |||
FROM SYS.IDENTITY_COLUMNS | |||
WHERE OBJECT_NAME(OBJECT_ID) = ? | |||
` | |||
var count int | |||
tx.QueryRow(sql, tableName).Scan(&count) | |||
return count > 0 | |||
} | |||
func (h *SQLServer) whileInsertOnTable(tx *sql.Tx, tableName string, fn func() error) error { | |||
if h.tableHasIdentityColumn(tx, tableName) { | |||
defer tx.Exec(fmt.Sprintf("SET IDENTITY_INSERT %s OFF", h.quoteKeyword(tableName))) | |||
_, err := tx.Exec(fmt.Sprintf("SET IDENTITY_INSERT %s ON", h.quoteKeyword(tableName))) | |||
if err != nil { | |||
return err | |||
} | |||
} | |||
return fn() | |||
} | |||
func (h *SQLServer) disableReferentialIntegrity(db *sql.DB, loadFn loadFunction) error { | |||
// ensure the triggers are re-enable after all | |||
defer func() { | |||
sql := "" | |||
for _, table := range h.tables { | |||
sql += fmt.Sprintf("ALTER TABLE %s WITH CHECK CHECK CONSTRAINT ALL;", h.quoteKeyword(table)) | |||
} | |||
if _, err := db.Exec(sql); err != nil { | |||
fmt.Printf("Error on re-enabling constraints: %v\n", err) | |||
} | |||
}() | |||
sql := "" | |||
for _, table := range h.tables { | |||
sql += fmt.Sprintf("ALTER TABLE %s NOCHECK CONSTRAINT ALL;", h.quoteKeyword(table)) | |||
} | |||
if _, err := db.Exec(sql); err != nil { | |||
return err | |||
} | |||
tx, err := db.Begin() | |||
if err != nil { | |||
return err | |||
} | |||
if err = loadFn(tx); err != nil { | |||
tx.Rollback() | |||
return err | |||
} | |||
return tx.Commit() | |||
} |
@@ -0,0 +1,279 @@ | |||
package testfixtures | |||
import ( | |||
"database/sql" | |||
"errors" | |||
"fmt" | |||
"io/ioutil" | |||
"path" | |||
"path/filepath" | |||
"regexp" | |||
"strings" | |||
"gopkg.in/yaml.v2" | |||
) | |||
// Context holds the fixtures to be loaded in the database. | |||
type Context struct { | |||
db *sql.DB | |||
helper Helper | |||
fixturesFiles []*fixtureFile | |||
} | |||
type fixtureFile struct { | |||
path string | |||
fileName string | |||
content []byte | |||
insertSQLs []insertSQL | |||
} | |||
type insertSQL struct { | |||
sql string | |||
params []interface{} | |||
} | |||
var ( | |||
// ErrWrongCastNotAMap is returned when a map is not a map[interface{}]interface{} | |||
ErrWrongCastNotAMap = errors.New("Could not cast record: not a map[interface{}]interface{}") | |||
// ErrFileIsNotSliceOrMap is returned the the fixture file is not a slice or map. | |||
ErrFileIsNotSliceOrMap = errors.New("The fixture file is not a slice or map") | |||
// ErrKeyIsNotString is returned when a record is not of type string | |||
ErrKeyIsNotString = errors.New("Record map key is not string") | |||
// ErrNotTestDatabase is returned when the database name doesn't contains "test" | |||
ErrNotTestDatabase = errors.New(`Loading aborted because the database name does not contains "test"`) | |||
dbnameRegexp = regexp.MustCompile("(?i)test") | |||
) | |||
// NewFolder craetes a context for all fixtures in a given folder into the database: | |||
// NewFolder(db, &PostgreSQL{}, "my/fixtures/folder") | |||
func NewFolder(db *sql.DB, helper Helper, folderName string) (*Context, error) { | |||
fixtures, err := fixturesFromFolder(folderName) | |||
if err != nil { | |||
return nil, err | |||
} | |||
c, err := newContext(db, helper, fixtures) | |||
if err != nil { | |||
return nil, err | |||
} | |||
return c, nil | |||
} | |||
// NewFiles craetes a context for all specified fixtures files into database: | |||
// NewFiles(db, &PostgreSQL{}, | |||
// "fixtures/customers.yml", | |||
// "fixtures/orders.yml" | |||
// // add as many files you want | |||
// ) | |||
func NewFiles(db *sql.DB, helper Helper, fileNames ...string) (*Context, error) { | |||
fixtures, err := fixturesFromFiles(fileNames...) | |||
if err != nil { | |||
return nil, err | |||
} | |||
c, err := newContext(db, helper, fixtures) | |||
if err != nil { | |||
return nil, err | |||
} | |||
return c, nil | |||
} | |||
func newContext(db *sql.DB, helper Helper, fixtures []*fixtureFile) (*Context, error) { | |||
c := &Context{ | |||
db: db, | |||
helper: helper, | |||
fixturesFiles: fixtures, | |||
} | |||
if err := c.helper.init(c.db); err != nil { | |||
return nil, err | |||
} | |||
if err := c.buildInsertSQLs(); err != nil { | |||
return nil, err | |||
} | |||
return c, nil | |||
} | |||
// Load wipes and after load all fixtures in the database. | |||
// if err := fixtures.Load(); err != nil { | |||
// log.Fatal(err) | |||
// } | |||
func (c *Context) Load() error { | |||
if !skipDatabaseNameCheck { | |||
if !dbnameRegexp.MatchString(c.helper.databaseName(c.db)) { | |||
return ErrNotTestDatabase | |||
} | |||
} | |||
err := c.helper.disableReferentialIntegrity(c.db, func(tx *sql.Tx) error { | |||
for _, file := range c.fixturesFiles { | |||
if err := file.delete(tx, c.helper); err != nil { | |||
return err | |||
} | |||
err := c.helper.whileInsertOnTable(tx, file.fileNameWithoutExtension(), func() error { | |||
for _, i := range file.insertSQLs { | |||
if _, err := tx.Exec(i.sql, i.params...); err != nil { | |||
return err | |||
} | |||
} | |||
return nil | |||
}) | |||
if err != nil { | |||
return err | |||
} | |||
} | |||
return nil | |||
}) | |||
return err | |||
} | |||
func (c *Context) buildInsertSQLs() error { | |||
for _, f := range c.fixturesFiles { | |||
var records interface{} | |||
if err := yaml.Unmarshal(f.content, &records); err != nil { | |||
return err | |||
} | |||
switch records := records.(type) { | |||
case []interface{}: | |||
for _, record := range records { | |||
recordMap, ok := record.(map[interface{}]interface{}) | |||
if !ok { | |||
return ErrWrongCastNotAMap | |||
} | |||
sql, values, err := f.buildInsertSQL(c.helper, recordMap) | |||
if err != nil { | |||
return err | |||
} | |||
f.insertSQLs = append(f.insertSQLs, insertSQL{sql, values}) | |||
} | |||
case map[interface{}]interface{}: | |||
for _, record := range records { | |||
recordMap, ok := record.(map[interface{}]interface{}) | |||
if !ok { | |||
return ErrWrongCastNotAMap | |||
} | |||
sql, values, err := f.buildInsertSQL(c.helper, recordMap) | |||
if err != nil { | |||
return err | |||
} | |||
f.insertSQLs = append(f.insertSQLs, insertSQL{sql, values}) | |||
} | |||
default: | |||
return ErrFileIsNotSliceOrMap | |||
} | |||
} | |||
return nil | |||
} | |||
func (f *fixtureFile) fileNameWithoutExtension() string { | |||
return strings.Replace(f.fileName, filepath.Ext(f.fileName), "", 1) | |||
} | |||
func (f *fixtureFile) delete(tx *sql.Tx, h Helper) error { | |||
_, err := tx.Exec(fmt.Sprintf("DELETE FROM %s", h.quoteKeyword(f.fileNameWithoutExtension()))) | |||
return err | |||
} | |||
func (f *fixtureFile) buildInsertSQL(h Helper, record map[interface{}]interface{}) (sqlStr string, values []interface{}, err error) { | |||
var ( | |||
sqlColumns []string | |||
sqlValues []string | |||
i = 1 | |||
) | |||
for key, value := range record { | |||
keyStr, ok := key.(string) | |||
if !ok { | |||
err = ErrKeyIsNotString | |||
return | |||
} | |||
sqlColumns = append(sqlColumns, h.quoteKeyword(keyStr)) | |||
switch h.paramType() { | |||
case paramTypeDollar: | |||
sqlValues = append(sqlValues, fmt.Sprintf("$%d", i)) | |||
case paramTypeQuestion: | |||
sqlValues = append(sqlValues, "?") | |||
case paramTypeColon: | |||
switch { | |||
case isDateTime(value): | |||
sqlValues = append(sqlValues, fmt.Sprintf("to_date(:%d, 'YYYY-MM-DD HH24:MI:SS')", i)) | |||
case isDate(value): | |||
sqlValues = append(sqlValues, fmt.Sprintf("to_date(:%d, 'YYYY-MM-DD')", i)) | |||
case isTime(value): | |||
sqlValues = append(sqlValues, fmt.Sprintf("to_date(:%d, 'HH24:MI:SS')", i)) | |||
default: | |||
sqlValues = append(sqlValues, fmt.Sprintf(":%d", i)) | |||
} | |||
} | |||
i++ | |||
values = append(values, value) | |||
} | |||
sqlStr = fmt.Sprintf( | |||
"INSERT INTO %s (%s) VALUES (%s)", | |||
h.quoteKeyword(f.fileNameWithoutExtension()), | |||
strings.Join(sqlColumns, ", "), | |||
strings.Join(sqlValues, ", "), | |||
) | |||
return | |||
} | |||
func fixturesFromFolder(folderName string) ([]*fixtureFile, error) { | |||
var files []*fixtureFile | |||
fileinfos, err := ioutil.ReadDir(folderName) | |||
if err != nil { | |||
return nil, err | |||
} | |||
for _, fileinfo := range fileinfos { | |||
if !fileinfo.IsDir() && filepath.Ext(fileinfo.Name()) == ".yml" { | |||
fixture := &fixtureFile{ | |||
path: path.Join(folderName, fileinfo.Name()), | |||
fileName: fileinfo.Name(), | |||
} | |||
fixture.content, err = ioutil.ReadFile(fixture.path) | |||
if err != nil { | |||
return nil, err | |||
} | |||
files = append(files, fixture) | |||
} | |||
} | |||
return files, nil | |||
} | |||
func fixturesFromFiles(fileNames ...string) ([]*fixtureFile, error) { | |||
var ( | |||
fixtureFiles []*fixtureFile | |||
err error | |||
) | |||
for _, f := range fileNames { | |||
fixture := &fixtureFile{ | |||
path: f, | |||
fileName: filepath.Base(f), | |||
} | |||
fixture.content, err = ioutil.ReadFile(fixture.path) | |||
if err != nil { | |||
return nil, err | |||
} | |||
fixtureFiles = append(fixtureFiles, fixture) | |||
} | |||
return fixtureFiles, nil | |||
} |
@@ -0,0 +1,36 @@ | |||
package testfixtures | |||
import "regexp" | |||
var ( | |||
regexpDate = regexp.MustCompile("\\d\\d\\d\\d-\\d\\d-\\d\\d") | |||
regexpDateTime = regexp.MustCompile("\\d\\d\\d\\d-\\d\\d-\\d\\d \\d\\d:\\d\\d:\\d\\d") | |||
regexpTime = regexp.MustCompile("\\d\\d:\\d\\d:\\d\\d") | |||
) | |||
func isDate(value interface{}) bool { | |||
str, isStr := value.(string) | |||
if !isStr { | |||
return false | |||
} | |||
return regexpDate.MatchString(str) | |||
} | |||
func isDateTime(value interface{}) bool { | |||
str, isStr := value.(string) | |||
if !isStr { | |||
return false | |||
} | |||
return regexpDateTime.MatchString(str) | |||
} | |||
func isTime(value interface{}) bool { | |||
str, isStr := value.(string) | |||
if !isStr { | |||
return false | |||
} | |||
return regexpTime.MatchString(str) | |||
} |
@@ -0,0 +1,13 @@ | |||
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. |
@@ -0,0 +1,31 @@ | |||
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. |
@@ -0,0 +1,131 @@ | |||
# 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] | |||
` | |||
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 | |||
``` | |||
@@ -0,0 +1,742 @@ | |||
package yaml | |||
import ( | |||
"io" | |||
"os" | |||
) | |||
func yaml_insert_token(parser *yaml_parser_t, pos int, token *yaml_token_t) { | |||
//fmt.Println("yaml_insert_token", "pos:", pos, "typ:", token.typ, "head:", parser.tokens_head, "len:", len(parser.tokens)) | |||
// Check if we can move the queue at the beginning of the buffer. | |||
if parser.tokens_head > 0 && len(parser.tokens) == cap(parser.tokens) { | |||
if parser.tokens_head != len(parser.tokens) { | |||
copy(parser.tokens, parser.tokens[parser.tokens_head:]) | |||
} | |||
parser.tokens = parser.tokens[:len(parser.tokens)-parser.tokens_head] | |||
parser.tokens_head = 0 | |||
} | |||
parser.tokens = append(parser.tokens, *token) | |||
if pos < 0 { | |||
return | |||
} | |||
copy(parser.tokens[parser.tokens_head+pos+1:], parser.tokens[parser.tokens_head+pos:]) | |||
parser.tokens[parser.tokens_head+pos] = *token | |||
} | |||
// Create a new parser object. | |||
func yaml_parser_initialize(parser *yaml_parser_t) bool { | |||
*parser = yaml_parser_t{ | |||
raw_buffer: make([]byte, 0, input_raw_buffer_size), | |||
buffer: make([]byte, 0, input_buffer_size), | |||
} | |||
return true | |||
} | |||
// Destroy a parser object. | |||
func yaml_parser_delete(parser *yaml_parser_t) { | |||
*parser = yaml_parser_t{} | |||
} | |||
// String read handler. | |||
func yaml_string_read_handler(parser *yaml_parser_t, buffer []byte) (n int, err error) { | |||
if parser.input_pos == len(parser.input) { | |||
return 0, io.EOF | |||
} | |||
n = copy(buffer, parser.input[parser.input_pos:]) | |||
parser.input_pos += n | |||
return n, nil | |||
} | |||
// File read handler. | |||
func yaml_file_read_handler(parser *yaml_parser_t, buffer []byte) (n int, err error) { | |||
return parser.input_file.Read(buffer) | |||
} | |||
// Set a string input. | |||
func yaml_parser_set_input_string(parser *yaml_parser_t, input []byte) { | |||
if parser.read_handler != nil { | |||
panic("must set the input source only once") | |||
} | |||
parser.read_handler = yaml_string_read_handler | |||
parser.input = input | |||
parser.input_pos = 0 | |||
} | |||
// Set a file input. | |||
func yaml_parser_set_input_file(parser *yaml_parser_t, file *os.File) { | |||
if parser.read_handler != nil { | |||
panic("must set the input source only once") | |||
} | |||
parser.read_handler = yaml_file_read_handler | |||
parser.input_file = file | |||
} | |||
// Set the source encoding. | |||
func yaml_parser_set_encoding(parser *yaml_parser_t, encoding yaml_encoding_t) { | |||
if parser.encoding != yaml_ANY_ENCODING { | |||
panic("must set the encoding only once") | |||
} | |||
parser.encoding = encoding | |||
} | |||
// Create a new emitter object. | |||
func yaml_emitter_initialize(emitter *yaml_emitter_t) bool { | |||
*emitter = yaml_emitter_t{ | |||
buffer: make([]byte, output_buffer_size), | |||
raw_buffer: make([]byte, 0, output_raw_buffer_size), | |||
states: make([]yaml_emitter_state_t, 0, initial_stack_size), | |||
events: make([]yaml_event_t, 0, initial_queue_size), | |||
} | |||
return true | |||
} | |||
// Destroy an emitter object. | |||
func yaml_emitter_delete(emitter *yaml_emitter_t) { | |||
*emitter = yaml_emitter_t{} | |||
} | |||
// String write handler. | |||
func yaml_string_write_handler(emitter *yaml_emitter_t, buffer []byte) error { | |||
*emitter.output_buffer = append(*emitter.output_buffer, buffer...) | |||
return nil | |||
} | |||
// File write handler. | |||
func yaml_file_write_handler(emitter *yaml_emitter_t, buffer []byte) error { | |||
_, err := emitter.output_file.Write(buffer) | |||
return err | |||
} | |||
// Set a string output. | |||
func yaml_emitter_set_output_string(emitter *yaml_emitter_t, output_buffer *[]byte) { | |||
if emitter.write_handler != nil { | |||
panic("must set the output target only once") | |||
} | |||
emitter.write_handler = yaml_string_write_handler | |||
emitter.output_buffer = output_buffer | |||
} | |||
// Set a file output. | |||
func yaml_emitter_set_output_file(emitter *yaml_emitter_t, file io.Writer) { | |||
if emitter.write_handler != nil { | |||
panic("must set the output target only once") | |||
} | |||
emitter.write_handler = yaml_file_write_handler | |||
emitter.output_file = file | |||
} | |||
// Set the output encoding. | |||
func yaml_emitter_set_encoding(emitter *yaml_emitter_t, encoding yaml_encoding_t) { | |||
if emitter.encoding != yaml_ANY_ENCODING { | |||
panic("must set the output encoding only once") | |||
} | |||
emitter.encoding = encoding | |||
} | |||
// Set the canonical output style. | |||
func yaml_emitter_set_canonical(emitter *yaml_emitter_t, canonical bool) { | |||
emitter.canonical = canonical | |||
} | |||
//// Set the indentation increment. | |||
func yaml_emitter_set_indent(emitter *yaml_emitter_t, indent int) { | |||
if indent < 2 || indent > 9 { | |||
indent = 2 | |||
} | |||
emitter.best_indent = indent | |||
} | |||
// Set the preferred line width. | |||
func yaml_emitter_set_width(emitter *yaml_emitter_t, width int) { | |||
if width < 0 { | |||
width = -1 | |||
} | |||
emitter.best_width = width | |||
} | |||
// Set if unescaped non-ASCII characters are allowed. | |||
func yaml_emitter_set_unicode(emitter *yaml_emitter_t, unicode bool) { | |||
emitter.unicode = unicode | |||
} | |||
// Set the preferred line break character. | |||
func yaml_emitter_set_break(emitter *yaml_emitter_t, line_break yaml_break_t) { | |||
emitter.line_break = line_break | |||
} | |||
///* | |||
// * Destroy a token object. | |||
// */ | |||
// | |||
//YAML_DECLARE(void) | |||
//yaml_token_delete(yaml_token_t *token) | |||
//{ | |||
// assert(token); // Non-NULL token object expected. | |||
// | |||
// switch (token.type) | |||
// { | |||
// case YAML_TAG_DIRECTIVE_TOKEN: | |||
// yaml_free(token.data.tag_directive.handle); | |||
// yaml_free(token.data.tag_directive.prefix); | |||
// break; | |||
// | |||
// case YAML_ALIAS_TOKEN: | |||
// yaml_free(token.data.alias.value); | |||
// break; | |||
// | |||
// case YAML_ANCHOR_TOKEN: | |||
// yaml_free(token.data.anchor.value); | |||
// break; | |||
// | |||
// case YAML_TAG_TOKEN: | |||
// yaml_free(token.data.tag.handle); | |||
// yaml_free(token.data.tag.suffix); | |||
// break; | |||
// | |||
// case YAML_SCALAR_TOKEN: | |||
// yaml_free(token.data.scalar.value); | |||
// break; | |||
// | |||
// default: | |||
// break; | |||
// } | |||
// | |||
// memset(token, 0, sizeof(yaml_token_t)); | |||
//} | |||
// | |||
///* | |||
// * Check if a string is a valid UTF-8 sequence. | |||
// * | |||
// * Check 'reader.c' for more details on UTF-8 encoding. | |||
// */ | |||
// | |||
//static int | |||
//yaml_check_utf8(yaml_char_t *start, size_t length) | |||
//{ | |||
// yaml_char_t *end = start+length; | |||
// yaml_char_t *pointer = start; | |||
// | |||
// while (pointer < end) { | |||
// unsigned char octet; | |||
// unsigned int width; | |||
// unsigned int value; | |||
// size_t k; | |||
// | |||
// octet = pointer[0]; | |||
// width = (octet & 0x80) == 0x00 ? 1 : | |||
// (octet & 0xE0) == 0xC0 ? 2 : | |||
// (octet & 0xF0) == 0xE0 ? 3 : | |||
// (octet & 0xF8) == 0xF0 ? 4 : 0; | |||
// value = (octet & 0x80) == 0x00 ? octet & 0x7F : | |||
// (octet & 0xE0) == 0xC0 ? octet & 0x1F : | |||
// (octet & 0xF0) == 0xE0 ? octet & 0x0F : | |||
// (octet & 0xF8) == 0xF0 ? octet & 0x07 : 0; | |||
// if (!width) return 0; | |||
// if (pointer+width > end) return 0; | |||
// for (k = 1; k < width; k ++) { | |||
// octet = pointer[k]; | |||
// if ((octet & 0xC0) != 0x80) return 0; | |||
// value = (value << 6) + (octet & 0x3F); | |||
// } | |||
// if (!((width == 1) || | |||
// (width == 2 && value >= 0x80) || | |||
// (width == 3 && value >= 0x800) || | |||
// (width == 4 && value >= 0x10000))) return 0; | |||
// | |||
// pointer += width; | |||
// } | |||
// | |||
// return 1; | |||
//} | |||
// | |||
// Create STREAM-START. | |||
func yaml_stream_start_event_initialize(event *yaml_event_t, encoding yaml_encoding_t) bool { | |||
*event = yaml_event_t{ | |||
typ: yaml_STREAM_START_EVENT, | |||
encoding: encoding, | |||
} | |||
return true | |||
} | |||
// Create STREAM-END. | |||
func yaml_stream_end_event_initialize(event *yaml_event_t) bool { | |||
*event = yaml_event_t{ | |||
typ: yaml_STREAM_END_EVENT, | |||
} | |||
return true | |||
} | |||
// Create DOCUMENT-START. | |||
func yaml_document_start_event_initialize(event *yaml_event_t, version_directive *yaml_version_directive_t, | |||
tag_directives []yaml_tag_directive_t, implicit bool) bool { | |||
*event = yaml_event_t{ | |||
typ: yaml_DOCUMENT_START_EVENT, | |||
version_directive: version_directive, | |||
tag_directives: tag_directives, | |||
implicit: implicit, | |||
} | |||
return true | |||
} | |||
// Create DOCUMENT-END. | |||
func yaml_document_end_event_initialize(event *yaml_event_t, implicit bool) bool { | |||
*event = yaml_event_t{ | |||
typ: yaml_DOCUMENT_END_EVENT, | |||
implicit: implicit, | |||
} | |||
return true | |||
} | |||
///* | |||
// * Create ALIAS. | |||
// */ | |||
// | |||
//YAML_DECLARE(int) | |||
//yaml_alias_event_initialize(event *yaml_event_t, anchor *yaml_char_t) | |||
//{ | |||
// mark yaml_mark_t = { 0, 0, 0 } | |||
// anchor_copy *yaml_char_t = NULL | |||
// | |||
// assert(event) // Non-NULL event object is expected. | |||
// assert(anchor) // Non-NULL anchor is expected. | |||
// | |||
// if (!yaml_check_utf8(anchor, strlen((char *)anchor))) return 0 | |||
// | |||
// anchor_copy = yaml_strdup(anchor) | |||
// if (!anchor_copy) | |||
// return 0 | |||
// | |||
// ALIAS_EVENT_INIT(*event, anchor_copy, mark, mark) | |||
// | |||
// return 1 | |||
//} | |||
// Create SCALAR. | |||
func yaml_scalar_event_initialize(event *yaml_event_t, anchor, tag, value []byte, plain_implicit, quoted_implicit bool, style yaml_scalar_style_t) bool { | |||
*event = yaml_event_t{ | |||
typ: yaml_SCALAR_EVENT, | |||
anchor: anchor, | |||
tag: tag, | |||
value: value, | |||
implicit: plain_implicit, | |||
quoted_implicit: quoted_implicit, | |||
style: yaml_style_t(style), | |||
} | |||
return true | |||
} | |||
// Create SEQUENCE-START. | |||
func yaml_sequence_start_event_initialize(event *yaml_event_t, anchor, tag []byte, implicit bool, style yaml_sequence_style_t) bool { | |||
*event = yaml_event_t{ | |||
typ: yaml_SEQUENCE_START_EVENT, | |||
anchor: anchor, | |||
tag: tag, | |||
implicit: implicit, | |||
style: yaml_style_t(style), | |||
} | |||
return true | |||
} | |||
// Create SEQUENCE-END. | |||
func yaml_sequence_end_event_initialize(event *yaml_event_t) bool { | |||
*event = yaml_event_t{ | |||
typ: yaml_SEQUENCE_END_EVENT, | |||
} | |||
return true | |||
} | |||
// Create MAPPING-START. | |||
func yaml_mapping_start_event_initialize(event *yaml_event_t, anchor, tag []byte, implicit bool, style yaml_mapping_style_t) bool { | |||
*event = yaml_event_t{ | |||
typ: yaml_MAPPING_START_EVENT, | |||
anchor: anchor, | |||
tag: tag, | |||
implicit: implicit, | |||
style: yaml_style_t(style), | |||
} | |||
return true | |||
} | |||
// Create MAPPING-END. | |||
func yaml_mapping_end_event_initialize(event *yaml_event_t) bool { | |||
*event = yaml_event_t{ | |||
typ: yaml_MAPPING_END_EVENT, | |||
} | |||
return true | |||
} | |||
// Destroy an event object. | |||
func yaml_event_delete(event *yaml_event_t) { | |||
*event = yaml_event_t{} | |||
} | |||
///* | |||
// * Create a document object. | |||
// */ | |||
// | |||
//YAML_DECLARE(int) | |||
//yaml_document_initialize(document *yaml_document_t, | |||
// version_directive *yaml_version_directive_t, | |||
// tag_directives_start *yaml_tag_directive_t, | |||
// tag_directives_end *yaml_tag_directive_t, | |||
// start_implicit int, end_implicit int) | |||
//{ | |||
// struct { | |||
// error yaml_error_type_t | |||
// } context | |||
// struct { | |||
// start *yaml_node_t | |||
// end *yaml_node_t | |||
// top *yaml_node_t | |||
// } nodes = { NULL, NULL, NULL } | |||
// version_directive_copy *yaml_version_directive_t = NULL | |||
// struct { | |||
// start *yaml_tag_directive_t | |||
// end *yaml_tag_directive_t | |||
// top *yaml_tag_directive_t | |||
// } tag_directives_copy = { NULL, NULL, NULL } | |||
// value yaml_tag_directive_t = { NULL, NULL } | |||
// mark yaml_mark_t = { 0, 0, 0 } | |||
// | |||
// assert(document) // Non-NULL document object is expected. | |||
// assert((tag_directives_start && tag_directives_end) || | |||
// (tag_directives_start == tag_directives_end)) | |||
// // Valid tag directives are expected. | |||
// | |||
// if (!STACK_INIT(&context, nodes, INITIAL_STACK_SIZE)) goto error | |||
// | |||
// if (version_directive) { | |||
// version_directive_copy = yaml_malloc(sizeof(yaml_version_directive_t)) | |||
// if (!version_directive_copy) goto error | |||
// version_directive_copy.major = version_directive.major | |||
// version_directive_copy.minor = version_directive.minor | |||
// } | |||
// | |||
// if (tag_directives_start != tag_directives_end) { | |||
// tag_directive *yaml_tag_directive_t | |||
// if (!STACK_INIT(&context, tag_directives_copy, INITIAL_STACK_SIZE)) | |||
// goto error | |||
// for (tag_directive = tag_directives_start | |||
// tag_directive != tag_directives_end; tag_directive ++) { | |||
// assert(tag_directive.handle) | |||
// assert(tag_directive.prefix) | |||
// if (!yaml_check_utf8(tag_directive.handle, | |||
// strlen((char *)tag_directive.handle))) | |||
// goto error | |||
// if (!yaml_check_utf8(tag_directive.prefix, | |||
// strlen((char *)tag_directive.prefix))) | |||
// goto error | |||
// value.handle = yaml_strdup(tag_directive.handle) | |||
// value.prefix = yaml_strdup(tag_directive.prefix) | |||
// if (!value.handle || !value.prefix) goto error | |||
// if (!PUSH(&context, tag_directives_copy, value)) | |||
// goto error | |||
// value.handle = NULL | |||
// value.prefix = NULL | |||
// } | |||
// } | |||
// | |||
// DOCUMENT_INIT(*document, nodes.start, nodes.end, version_directive_copy, | |||
// tag_directives_copy.start, tag_directives_copy.top, | |||
// start_implicit, end_implicit, mark, mark) | |||
// | |||
// return 1 | |||
// | |||
//error: | |||
// STACK_DEL(&context, nodes) | |||
// yaml_free(version_directive_copy) | |||
// while (!STACK_EMPTY(&context, tag_directives_copy)) { | |||
// value yaml_tag_directive_t = POP(&context, tag_directives_copy) | |||
// yaml_free(value.handle) | |||
// yaml_free(value.prefix) | |||
// } | |||
// STACK_DEL(&context, tag_directives_copy) | |||
// yaml_free(value.handle) | |||
// yaml_free(value.prefix) | |||
// | |||
// return 0 | |||
//} | |||
// | |||
///* | |||
// * Destroy a document object. | |||
// */ | |||
// | |||
//YAML_DECLARE(void) | |||
//yaml_document_delete(document *yaml_document_t) | |||
//{ | |||
// struct { | |||
// error yaml_error_type_t | |||
// } context | |||
// tag_directive *yaml_tag_directive_t | |||
// | |||
// context.error = YAML_NO_ERROR // Eliminate a compliler warning. | |||
// | |||
// assert(document) // Non-NULL document object is expected. | |||
// | |||
// while (!STACK_EMPTY(&context, document.nodes)) { | |||
// node yaml_node_t = POP(&context, document.nodes) | |||
// yaml_free(node.tag) | |||
// switch (node.type) { | |||
// case YAML_SCALAR_NODE: | |||
// yaml_free(node.data.scalar.value) | |||
// break | |||
// case YAML_SEQUENCE_NODE: | |||
// STACK_DEL(&context, node.data.sequence.items) | |||
// break | |||
// case YAML_MAPPING_NODE: | |||
// STACK_DEL(&context, node.data.mapping.pairs) | |||
// break | |||
// default: | |||
// assert(0) // Should not happen. | |||
// } | |||
// } | |||
// STACK_DEL(&context, document.nodes) | |||
// | |||
// yaml_free(document.version_directive) | |||
// for (tag_directive = document.tag_directives.start | |||
// tag_directive != document.tag_directives.end | |||
// tag_directive++) { | |||
// yaml_free(tag_directive.handle) | |||
// yaml_free(tag_directive.prefix) | |||
// } | |||
// yaml_free(document.tag_directives.start) | |||
// | |||
// memset(document, 0, sizeof(yaml_document_t)) | |||
//} | |||
// | |||
///** | |||
// * Get a document node. | |||
// */ | |||
// | |||
//YAML_DECLARE(yaml_node_t *) | |||
//yaml_document_get_node(document *yaml_document_t, index int) | |||
//{ | |||
// assert(document) // Non-NULL document object is expected. | |||
// | |||
// if (index > 0 && document.nodes.start + index <= document.nodes.top) { | |||
// return document.nodes.start + index - 1 | |||
// } | |||
// return NULL | |||
//} | |||
// | |||
///** | |||
// * Get the root object. | |||
// */ | |||
// | |||
//YAML_DECLARE(yaml_node_t *) | |||
//yaml_document_get_root_node(document *yaml_document_t) | |||
//{ | |||
// assert(document) // Non-NULL document object is expected. | |||
// | |||
// if (document.nodes.top != document.nodes.start) { | |||
// return document.nodes.start | |||
// } | |||
// return NULL | |||
//} | |||
// | |||
///* | |||
// * Add a scalar node to a document. | |||
// */ | |||
// | |||
//YAML_DECLARE(int) | |||
//yaml_document_add_scalar(document *yaml_document_t, | |||
// tag *yaml_char_t, value *yaml_char_t, length int, | |||
// style yaml_scalar_style_t) | |||
//{ | |||
// struct { | |||
// error yaml_error_type_t | |||
// } context | |||
// mark yaml_mark_t = { 0, 0, 0 } | |||
// tag_copy *yaml_char_t = NULL | |||
// value_copy *yaml_char_t = NULL | |||
// node yaml_node_t | |||
// | |||
// assert(document) // Non-NULL document object is expected. | |||
// assert(value) // Non-NULL value is expected. | |||
// | |||
// if (!tag) { | |||
// tag = (yaml_char_t *)YAML_DEFAULT_SCALAR_TAG | |||
// } | |||
// | |||
// if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error | |||
// tag_copy = yaml_strdup(tag) | |||
// if (!tag_copy) goto error | |||
// | |||
// if (length < 0) { | |||
// length = strlen((char *)value) | |||
// } | |||
// | |||
// if (!yaml_check_utf8(value, length)) goto error | |||
// value_copy = yaml_malloc(length+1) | |||
// if (!value_copy) goto error | |||
// memcpy(value_copy, value, length) | |||
// value_copy[length] = '\0' | |||
// | |||
// SCALAR_NODE_INIT(node, tag_copy, value_copy, length, style, mark, mark) | |||
// if (!PUSH(&context, document.nodes, node)) goto error | |||
// | |||
// return document.nodes.top - document.nodes.start | |||
// | |||
//error: | |||
// yaml_free(tag_copy) | |||
// yaml_free(value_copy) | |||
// | |||
// return 0 | |||
//} | |||
// | |||
///* | |||
// * Add a sequence node to a document. | |||
// */ | |||
// | |||
//YAML_DECLARE(int) | |||
//yaml_document_add_sequence(document *yaml_document_t, | |||
// tag *yaml_char_t, style yaml_sequence_style_t) | |||
//{ | |||
// struct { | |||
// error yaml_error_type_t | |||
// } context | |||
// mark yaml_mark_t = { 0, 0, 0 } | |||
// tag_copy *yaml_char_t = NULL | |||
// struct { | |||
// start *yaml_node_item_t | |||
// end *yaml_node_item_t | |||
// top *yaml_node_item_t | |||
// } items = { NULL, NULL, NULL } | |||
// node yaml_node_t | |||
// | |||
// assert(document) // Non-NULL document object is expected. | |||
// | |||
// if (!tag) { | |||
// tag = (yaml_char_t *)YAML_DEFAULT_SEQUENCE_TAG | |||
// } | |||
// | |||
// if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error | |||
// tag_copy = yaml_strdup(tag) | |||
// if (!tag_copy) goto error | |||
// | |||
// if (!STACK_INIT(&context, items, INITIAL_STACK_SIZE)) goto error | |||
// | |||
// SEQUENCE_NODE_INIT(node, tag_copy, items.start, items.end, | |||
// style, mark, mark) | |||
// if (!PUSH(&context, document.nodes, node)) goto error | |||
// | |||
// return document.nodes.top - document.nodes.start | |||
// | |||
//error: | |||
// STACK_DEL(&context, items) | |||
// yaml_free(tag_copy) | |||
// | |||
// return 0 | |||
//} | |||
// | |||
///* | |||
// * Add a mapping node to a document. | |||
// */ | |||
// | |||
//YAML_DECLARE(int) | |||
//yaml_document_add_mapping(document *yaml_document_t, | |||
// tag *yaml_char_t, style yaml_mapping_style_t) | |||
//{ | |||
// struct { | |||
// error yaml_error_type_t | |||
// } context | |||
// mark yaml_mark_t = { 0, 0, 0 } | |||
// tag_copy *yaml_char_t = NULL | |||
// struct { | |||
// start *yaml_node_pair_t | |||
// end *yaml_node_pair_t | |||
// top *yaml_node_pair_t | |||
// } pairs = { NULL, NULL, NULL } | |||
// node yaml_node_t | |||
// | |||
// assert(document) // Non-NULL document object is expected. | |||
// | |||
// if (!tag) { | |||
// tag = (yaml_char_t *)YAML_DEFAULT_MAPPING_TAG | |||
// } | |||
// | |||
// if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error | |||
// tag_copy = yaml_strdup(tag) | |||
// if (!tag_copy) goto error | |||
// | |||
// if (!STACK_INIT(&context, pairs, INITIAL_STACK_SIZE)) goto error | |||
// | |||
// MAPPING_NODE_INIT(node, tag_copy, pairs.start, pairs.end, | |||
// style, mark, mark) | |||
// if (!PUSH(&context, document.nodes, node)) goto error | |||
// | |||
// return document.nodes.top - document.nodes.start | |||
// | |||
//error: | |||
// STACK_DEL(&context, pairs) | |||
// yaml_free(tag_copy) | |||
// | |||
// return 0 | |||
//} | |||
// | |||
///* | |||
// * Append an item to a sequence node. | |||
// */ | |||
// | |||
//YAML_DECLARE(int) | |||
//yaml_document_append_sequence_item(document *yaml_document_t, | |||
// sequence int, item int) | |||
//{ | |||
// struct { | |||
// error yaml_error_type_t | |||
// } context | |||
// | |||
// assert(document) // Non-NULL document is required. | |||
// assert(sequence > 0 | |||
// && document.nodes.start + sequence <= document.nodes.top) | |||
// // Valid sequence id is required. | |||
// assert(document.nodes.start[sequence-1].type == YAML_SEQUENCE_NODE) | |||
// // A sequence node is required. | |||
// assert(item > 0 && document.nodes.start + item <= document.nodes.top) | |||
// // Valid item id is required. | |||
// | |||
// if (!PUSH(&context, | |||
// document.nodes.start[sequence-1].data.sequence.items, item)) | |||
// return 0 | |||
// | |||
// return 1 | |||
//} | |||
// | |||
///* | |||
// * Append a pair of a key and a value to a mapping node. | |||
// */ | |||
// | |||
//YAML_DECLARE(int) | |||
//yaml_document_append_mapping_pair(document *yaml_document_t, | |||
// mapping int, key int, value int) | |||
//{ | |||
// struct { | |||
// error yaml_error_type_t | |||
// } context | |||
// | |||
// pair yaml_node_pair_t | |||
// | |||
// assert(document) // Non-NULL document is required. | |||
// assert(mapping > 0 | |||
// && document.nodes.start + mapping <= document.nodes.top) | |||
// // Valid mapping id is required. | |||
// assert(document.nodes.start[mapping-1].type == YAML_MAPPING_NODE) | |||
// // A mapping node is required. | |||
// assert(key > 0 && document.nodes.start + key <= document.nodes.top) | |||
// // Valid key id is required. | |||
// assert(value > 0 && document.nodes.start + value <= document.nodes.top) | |||
// // Valid value id is required. | |||
// | |||
// pair.key = key | |||
// pair.value = value | |||
// | |||
// if (!PUSH(&context, | |||
// document.nodes.start[mapping-1].data.mapping.pairs, pair)) | |||
// return 0 | |||
// | |||
// return 1 | |||
//} | |||
// | |||
// |
@@ -0,0 +1,683 @@ | |||
package yaml | |||
import ( | |||
"encoding" | |||
"encoding/base64" | |||
"fmt" | |||
"math" | |||
"reflect" | |||
"strconv" | |||
"time" | |||
) | |||
const ( | |||
documentNode = 1 << iota | |||
mappingNode | |||
sequenceNode | |||
scalarNode | |||
aliasNode | |||
) | |||
type node struct { | |||
kind int | |||
line, column int | |||
tag string | |||
value string | |||
implicit bool | |||
children []*node | |||
anchors map[string]*node | |||
} | |||
// ---------------------------------------------------------------------------- | |||
// Parser, produces a node tree out of a libyaml event stream. | |||
type parser struct { | |||
parser yaml_parser_t | |||
event yaml_event_t | |||
doc *node | |||
} | |||
func newParser(b []byte) *parser { | |||
p := parser{} | |||
if !yaml_parser_initialize(&p.parser) { | |||
panic("failed to initialize YAML emitter") | |||
} | |||
if len(b) == 0 { | |||
b = []byte{'\n'} | |||
} | |||
yaml_parser_set_input_string(&p.parser, b) | |||
p.skip() | |||
if p.event.typ != yaml_STREAM_START_EVENT { | |||
panic("expected stream start event, got " + strconv.Itoa(int(p.event.typ))) | |||
} | |||
p.skip() | |||
return &p | |||
} | |||
func (p *parser) destroy() { | |||
if p.event.typ != yaml_NO_EVENT { | |||
yaml_event_delete(&p.event) | |||
} | |||
yaml_parser_delete(&p.parser) | |||
} | |||
func (p *parser) skip() { | |||
if p.event.typ != yaml_NO_EVENT { | |||
if p.event.typ == yaml_STREAM_END_EVENT { | |||
failf("attempted to go past the end of stream; corrupted value?") | |||
} | |||
yaml_event_delete(&p.event) | |||
} | |||
if !yaml_parser_parse(&p.parser, &p.event) { | |||
p.fail() | |||
} | |||
} | |||
func (p *parser) fail() { | |||
var where string | |||
var line int | |||
if p.parser.problem_mark.line != 0 { | |||
line = p.parser.problem_mark.line | |||
} else if p.parser.context_mark.line != 0 { | |||
line = p.parser.context_mark.line | |||
} | |||
if line != 0 { | |||
where = "line " + strconv.Itoa(line) + ": " | |||
} | |||
var msg string | |||
if len(p.parser.problem) > 0 { | |||
msg = p.parser.problem | |||
} else { | |||
msg = "unknown problem parsing YAML content" | |||
} | |||
failf("%s%s", where, msg) | |||
} | |||
func (p *parser) anchor(n *node, anchor []byte) { | |||
if anchor != nil { | |||
p.doc.anchors[string(anchor)] = n | |||
} | |||
} | |||
func (p *parser) parse() *node { | |||
switch p.event.typ { | |||
case yaml_SCALAR_EVENT: | |||
return p.scalar() | |||
case yaml_ALIAS_EVENT: | |||
return p.alias() | |||
case yaml_MAPPING_START_EVENT: | |||
return p.mapping() | |||
case yaml_SEQUENCE_START_EVENT: | |||
return p.sequence() | |||
case yaml_DOCUMENT_START_EVENT: | |||
return p.document() | |||
case yaml_STREAM_END_EVENT: | |||
// Happens when attempting to decode an empty buffer. | |||
return nil | |||
default: | |||
panic("attempted to parse unknown event: " + strconv.Itoa(int(p.event.typ))) | |||
} | |||
panic("unreachable") | |||
} | |||
func (p *parser) node(kind int) *node { | |||
return &node{ | |||
kind: kind, | |||
line: p.event.start_mark.line, | |||
column: p.event.start_mark.column, | |||
} | |||
} | |||
func (p *parser) document() *node { | |||
n := p.node(documentNode) | |||
n.anchors = make(map[string]*node) | |||
p.doc = n | |||
p.skip() | |||
n.children = append(n.children, p.parse()) | |||
if p.event.typ != yaml_DOCUMENT_END_EVENT { | |||
panic("expected end of document event but got " + strconv.Itoa(int(p.event.typ))) | |||
} | |||
p.skip() | |||
return n | |||
} | |||
func (p *parser) alias() *node { | |||
n := p.node(aliasNode) | |||
n.value = string(p.event.anchor) | |||
p.skip() | |||
return n | |||
} | |||
func (p *parser) scalar() *node { | |||
n := p.node(scalarNode) | |||
n.value = string(p.event.value) | |||
n.tag = string(p.event.tag) | |||
n.implicit = p.event.implicit | |||
p.anchor(n, p.event.anchor) | |||
p.skip() | |||
return n | |||
} | |||
func (p *parser) sequence() *node { | |||
n := p.node(sequenceNode) | |||
p.anchor(n, p.event.anchor) | |||
p.skip() | |||
for p.event.typ != yaml_SEQUENCE_END_EVENT { | |||
n.children = append(n.children, p.parse()) | |||
} | |||
p.skip() | |||
return n | |||
} | |||
func (p *parser) mapping() *node { | |||
n := p.node(mappingNode) | |||
p.anchor(n, p.event.anchor) | |||
p.skip() | |||
for p.event.typ != yaml_MAPPING_END_EVENT { | |||
n.children = append(n.children, p.parse(), p.parse()) | |||
} | |||
p.skip() | |||
return n | |||
} | |||
// ---------------------------------------------------------------------------- | |||
// Decoder, unmarshals a node into a provided value. | |||
type decoder struct { | |||
doc *node | |||
aliases map[string]bool | |||
mapType reflect.Type | |||
terrors []string | |||
} | |||
var ( | |||
mapItemType = reflect.TypeOf(MapItem{}) | |||
durationType = reflect.TypeOf(time.Duration(0)) | |||
defaultMapType = reflect.TypeOf(map[interface{}]interface{}{}) | |||
ifaceType = defaultMapType.Elem() | |||
) | |||
func newDecoder() *decoder { | |||
d := &decoder{mapType: defaultMapType} | |||
d.aliases = make(map[string]bool) | |||
return d | |||
} | |||
func (d *decoder) terror(n *node, tag string, out reflect.Value) { | |||
if n.tag != "" { | |||
tag = n.tag | |||
} | |||
value := n.value | |||
if tag != yaml_SEQ_TAG && tag != yaml_MAP_TAG { | |||
if len(value) > 10 { | |||
value = " `" + value[:7] + "...`" | |||
} else { | |||
value = " `" + value + "`" | |||
} | |||
} | |||
d.terrors = append(d.terrors, fmt.Sprintf("line %d: cannot unmarshal %s%s into %s", n.line+1, shortTag(tag), value, out.Type())) | |||
} | |||
func (d *decoder) callUnmarshaler(n *node, u Unmarshaler) (good bool) { | |||
terrlen := len(d.terrors) | |||
err := u.UnmarshalYAML(func(v interface{}) (err error) { | |||
defer handleErr(&err) | |||
d.unmarshal(n, reflect.ValueOf(v)) | |||
if len(d.terrors) > terrlen { | |||
issues := d.terrors[terrlen:] | |||
d.terrors = d.terrors[:terrlen] | |||
return &TypeError{issues} | |||
} | |||
return nil | |||
}) | |||
if e, ok := err.(*TypeError); ok { | |||
d.terrors = append(d.terrors, e.Errors...) | |||
return false | |||
} | |||
if err != nil { | |||
fail(err) | |||
} | |||
return true | |||
} | |||
// d.prepare initializes and dereferences pointers and calls UnmarshalYAML | |||
// if a value is found to implement it. | |||
// It returns the initialized and dereferenced out value, whether | |||
// unmarshalling was already done by UnmarshalYAML, and if so whether | |||
// its types unmarshalled appropriately. | |||
// | |||
// If n holds a null value, prepare returns before doing anything. | |||
func (d *decoder) prepare(n *node, out reflect.Value) (newout reflect.Value, unmarshaled, good bool) { | |||
if n.tag == yaml_NULL_TAG || n.kind == scalarNode && n.tag == "" && (n.value == "null" || n.value == "" && n.implicit) { | |||
return out, false, false | |||
} | |||
again := true | |||
for again { | |||
again = false | |||
if out.Kind() == reflect.Ptr { | |||
if out.IsNil() { | |||
out.Set(reflect.New(out.Type().Elem())) | |||
} | |||
out = out.Elem() | |||
again = true | |||
} | |||
if out.CanAddr() { | |||
if u, ok := out.Addr().Interface().(Unmarshaler); ok { | |||
good = d.callUnmarshaler(n, u) | |||
return out, true, good | |||
} | |||
} | |||
} | |||
return out, false, false | |||
} | |||
func (d *decoder) unmarshal(n *node, out reflect.Value) (good bool) { | |||
switch n.kind { | |||
case documentNode: | |||
return d.document(n, out) | |||
case aliasNode: | |||
return d.alias(n, out) | |||
} | |||
out, unmarshaled, good := d.prepare(n, out) | |||
if unmarshaled { | |||
return good | |||
} | |||
switch n.kind { | |||
case scalarNode: | |||
good = d.scalar(n, out) | |||
case mappingNode: | |||
good = d.mapping(n, out) | |||
case sequenceNode: | |||
good = d.sequence(n, out) | |||
default: | |||
panic("internal error: unknown node kind: " + strconv.Itoa(n.kind)) | |||
} | |||
return good | |||
} | |||
func (d *decoder) document(n *node, out reflect.Value) (good bool) { | |||
if len(n.children) == 1 { | |||
d.doc = n | |||
d.unmarshal(n.children[0], out) | |||
return true | |||
} | |||
return false | |||
} | |||
func (d *decoder) alias(n *node, out reflect.Value) (good bool) { | |||
an, ok := d.doc.anchors[n.value] | |||
if !ok { | |||
failf("unknown anchor '%s' referenced", n.value) | |||
} | |||
if d.aliases[n.value] { | |||
failf("anchor '%s' value contains itself", n.value) | |||
} | |||
d.aliases[n.value] = true | |||
good = d.unmarshal(an, out) | |||
delete(d.aliases, n.value) | |||
return good | |||
} | |||
var zeroValue reflect.Value | |||
func resetMap(out reflect.Value) { | |||
for _, k := range out.MapKeys() { | |||
out.SetMapIndex(k, zeroValue) | |||
} | |||
} | |||
func (d *decoder) scalar(n *node, out reflect.Value) (good bool) { | |||
var tag string | |||
var resolved interface{} | |||
if n.tag == "" && !n.implicit { | |||
tag = yaml_STR_TAG | |||
resolved = n.value | |||
} else { | |||
tag, resolved = resolve(n.tag, n.value) | |||
if tag == yaml_BINARY_TAG { | |||
data, err := base64.StdEncoding.DecodeString(resolved.(string)) | |||
if err != nil { | |||
failf("!!binary value contains invalid base64 data") | |||
} | |||
resolved = string(data) | |||
} | |||
} | |||
if resolved == nil { | |||
if out.Kind() == reflect.Map && !out.CanAddr() { | |||
resetMap(out) | |||
} else { | |||
out.Set(reflect.Zero(out.Type())) | |||
} | |||
return true | |||
} | |||
if s, ok := resolved.(string); ok && out.CanAddr() { | |||
if u, ok := out.Addr().Interface().(encoding.TextUnmarshaler); ok { | |||
err := u.UnmarshalText([]byte(s)) | |||
if err != nil { | |||
fail(err) | |||
} | |||
return true | |||
} | |||
} | |||
switch out.Kind() { | |||
case reflect.String: | |||
if tag == yaml_BINARY_TAG { | |||
out.SetString(resolved.(string)) | |||
good = true | |||
} else if resolved != nil { | |||
out.SetString(n.value) | |||
good = true | |||
} | |||
case reflect.Interface: | |||
if resolved == nil { | |||
out.Set(reflect.Zero(out.Type())) | |||
} else { | |||
out.Set(reflect.ValueOf(resolved)) | |||
} | |||
good = true | |||
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: | |||
switch resolved := resolved.(type) { | |||
case int: | |||
if !out.OverflowInt(int64(resolved)) { | |||
out.SetInt(int64(resolved)) | |||
good = true | |||
} | |||
case int64: | |||
if !out.OverflowInt(resolved) { | |||
out.SetInt(resolved) | |||
good = true | |||
} | |||
case uint64: | |||
if resolved <= math.MaxInt64 && !out.OverflowInt(int64(resolved)) { | |||
out.SetInt(int64(resolved)) | |||
good = true | |||
} | |||
case float64: | |||
if resolved <= math.MaxInt64 && !out.OverflowInt(int64(resolved)) { | |||
out.SetInt(int64(resolved)) | |||
good = true | |||
} | |||
case string: | |||
if out.Type() == durationType { | |||
d, err := time.ParseDuration(resolved) | |||
if err == nil { | |||
out.SetInt(int64(d)) | |||
good = true | |||
} | |||
} | |||
} | |||
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: | |||
switch resolved := resolved.(type) { | |||
case int: | |||
if resolved >= 0 && !out.OverflowUint(uint64(resolved)) { | |||
out.SetUint(uint64(resolved)) | |||
good = true | |||
} | |||
case int64: | |||
if resolved >= 0 && !out.OverflowUint(uint64(resolved)) { | |||
out.SetUint(uint64(resolved)) | |||
good = true | |||
} | |||
case uint64: | |||
if !out.OverflowUint(uint64(resolved)) { | |||
out.SetUint(uint64(resolved)) | |||
good = true | |||
} | |||
case float64: | |||
if resolved <= math.MaxUint64 && !out.OverflowUint(uint64(resolved)) { | |||
out.SetUint(uint64(resolved)) | |||
good = true | |||
} | |||
} | |||
case reflect.Bool: | |||
switch resolved := resolved.(type) { | |||
case bool: | |||
out.SetBool(resolved) | |||
good = true | |||
} | |||
case reflect.Float32, reflect.Float64: | |||
switch resolved := resolved.(type) { | |||
case int: | |||
out.SetFloat(float64(resolved)) | |||
good = true | |||
case int64: | |||
out.SetFloat(float64(resolved)) | |||
good = true | |||
case uint64: | |||
out.SetFloat(float64(resolved)) | |||
good = true | |||
case float64: | |||
out.SetFloat(resolved) | |||
good = true | |||
} | |||
case reflect.Ptr: | |||
if out.Type().Elem() == reflect.TypeOf(resolved) { | |||
// TODO DOes this make sense? When is out a Ptr except when decoding a nil value? | |||
elem := reflect.New(out.Type().Elem()) | |||
elem.Elem().Set(reflect.ValueOf(resolved)) | |||
out.Set(elem) | |||
good = true | |||
} | |||
} | |||
if !good { | |||
d.terror(n, tag, out) | |||
} | |||
return good | |||
} | |||
func settableValueOf(i interface{}) reflect.Value { | |||
v := reflect.ValueOf(i) | |||
sv := reflect.New(v.Type()).Elem() | |||
sv.Set(v) | |||
return sv | |||
} | |||
func (d *decoder) sequence(n *node, out reflect.Value) (good bool) { | |||
l := len(n.children) | |||
var iface reflect.Value | |||
switch out.Kind() { | |||
case reflect.Slice: | |||
out.Set(reflect.MakeSlice(out.Type(), l, l)) | |||
case reflect.Interface: | |||
// No type hints. Will have to use a generic sequence. | |||
iface = out | |||
out = settableValueOf(make([]interface{}, l)) | |||
default: | |||
d.terror(n, yaml_SEQ_TAG, out) | |||
return false | |||
} | |||
et := out.Type().Elem() | |||
j := 0 | |||
for i := 0; i < l; i++ { | |||
e := reflect.New(et).Elem() | |||
if ok := d.unmarshal(n.children[i], e); ok { | |||
out.Index(j).Set(e) | |||
j++ | |||
} | |||
} | |||
out.Set(out.Slice(0, j)) | |||
if iface.IsValid() { | |||
iface.Set(out) | |||
} | |||
return true | |||
} | |||
func (d *decoder) mapping(n *node, out reflect.Value) (good bool) { | |||
switch out.Kind() { | |||
case reflect.Struct: | |||
return d.mappingStruct(n, out) | |||
case reflect.Slice: | |||
return d.mappingSlice(n, out) | |||
case reflect.Map: | |||
// okay | |||
case reflect.Interface: | |||
if d.mapType.Kind() == reflect.Map { | |||
iface := out | |||
out = reflect.MakeMap(d.mapType) | |||
iface.Set(out) | |||
} else { | |||
slicev := reflect.New(d.mapType).Elem() | |||
if !d.mappingSlice(n, slicev) { | |||
return false | |||
} | |||
out.Set(slicev) | |||
return true | |||
} | |||
default: | |||
d.terror(n, yaml_MAP_TAG, out) | |||
return false | |||
} | |||
outt := out.Type() | |||
kt := outt.Key() | |||
et := outt.Elem() | |||
mapType := d.mapType | |||
if outt.Key() == ifaceType && outt.Elem() == ifaceType { | |||
d.mapType = outt | |||
} | |||
if out.IsNil() { | |||
out.Set(reflect.MakeMap(outt)) | |||
} | |||
l := len(n.children) | |||
for i := 0; i < l; i += 2 { | |||
if isMerge(n.children[i]) { | |||
d.merge(n.children[i+1], out) | |||
continue | |||
} | |||
k := reflect.New(kt).Elem() | |||
if d.unmarshal(n.children[i], k) { | |||
kkind := k.Kind() | |||
if kkind == reflect.Interface { | |||
kkind = k.Elem().Kind() | |||
} | |||
if kkind == reflect.Map || kkind == reflect.Slice { | |||
failf("invalid map key: %#v", k.Interface()) | |||
} | |||
e := reflect.New(et).Elem() | |||
if d.unmarshal(n.children[i+1], e) { | |||
out.SetMapIndex(k, e) | |||
} | |||
} | |||
} | |||
d.mapType = mapType | |||
return true | |||
} | |||
func (d *decoder) mappingSlice(n *node, out reflect.Value) (good bool) { | |||
outt := out.Type() | |||
if outt.Elem() != mapItemType { | |||
d.terror(n, yaml_MAP_TAG, out) | |||
return false | |||
} | |||
mapType := d.mapType | |||
d.mapType = outt | |||
var slice []MapItem | |||
var l = len(n.children) | |||
for i := 0; i < l; i += 2 { | |||
if isMerge(n.children[i]) { | |||
d.merge(n.children[i+1], out) | |||
continue | |||
} | |||
item := MapItem{} | |||
k := reflect.ValueOf(&item.Key).Elem() | |||
if d.unmarshal(n.children[i], k) { | |||
v := reflect.ValueOf(&item.Value).Elem() | |||
if d.unmarshal(n.children[i+1], v) { | |||
slice = append(slice, item) | |||
} | |||
} | |||
} | |||
out.Set(reflect.ValueOf(slice)) | |||
d.mapType = mapType | |||
return true | |||
} | |||
func (d *decoder) mappingStruct(n *node, out reflect.Value) (good bool) { | |||
sinfo, err := getStructInfo(out.Type()) | |||
if err != nil { | |||
panic(err) | |||
} | |||
name := settableValueOf("") | |||
l := len(n.children) | |||
var inlineMap reflect.Value | |||
var elemType reflect.Type | |||
if sinfo.InlineMap != -1 { | |||
inlineMap = out.Field(sinfo.InlineMap) | |||
inlineMap.Set(reflect.New(inlineMap.Type()).Elem()) | |||
elemType = inlineMap.Type().Elem() | |||
} | |||
for i := 0; i < l; i += 2 { | |||
ni := n.children[i] | |||
if isMerge(ni) { | |||
d.merge(n.children[i+1], out) | |||
continue | |||
} | |||
if !d.unmarshal(ni, name) { | |||
continue | |||
} | |||
if info, ok := sinfo.FieldsMap[name.String()]; ok { | |||
var field reflect.Value | |||
if info.Inline == nil { | |||
field = out.Field(info.Num) | |||
} else { | |||
field = out.FieldByIndex(info.Inline) | |||
} | |||
d.unmarshal(n.children[i+1], field) | |||
} else if sinfo.InlineMap != -1 { | |||
if inlineMap.IsNil() { | |||
inlineMap.Set(reflect.MakeMap(inlineMap.Type())) | |||
} | |||
value := reflect.New(elemType).Elem() | |||
d.unmarshal(n.children[i+1], value) | |||
inlineMap.SetMapIndex(name, value) | |||
} | |||
} | |||
return true | |||
} | |||
func failWantMap() { | |||
failf("map merge requires map or sequence of maps as the value") | |||
} | |||
func (d *decoder) merge(n *node, out reflect.Value) { | |||
switch n.kind { | |||
case mappingNode: | |||
d.unmarshal(n, out) | |||
case aliasNode: | |||
an, ok := d.doc.anchors[n.value] | |||
if ok && an.kind != mappingNode { | |||
failWantMap() | |||
} | |||
d.unmarshal(n, out) | |||
case sequenceNode: | |||
// Step backwards as earlier nodes take precedence. | |||
for i := len(n.children) - 1; i >= 0; i-- { | |||
ni := n.children[i] | |||
if ni.kind == aliasNode { | |||
an, ok := d.doc.anchors[ni.value] | |||
if ok && an.kind != mappingNode { | |||
failWantMap() | |||
} | |||
} else if ni.kind != mappingNode { | |||
failWantMap() | |||
} | |||
d.unmarshal(ni, out) | |||
} | |||
default: | |||
failWantMap() | |||
} | |||
} | |||
func isMerge(n *node) bool { | |||
return n.kind == scalarNode && n.value == "<<" && (n.implicit == true || n.tag == yaml_MERGE_TAG) | |||
} |
@@ -0,0 +1,306 @@ | |||
package yaml | |||
import ( | |||
"encoding" | |||
"fmt" | |||
"reflect" | |||
"regexp" | |||
"sort" | |||
"strconv" | |||
"strings" | |||
"time" | |||
) | |||
type encoder struct { | |||
emitter yaml_emitter_t | |||
event yaml_event_t | |||
out []byte | |||
flow bool | |||
} | |||
func newEncoder() (e *encoder) { | |||
e = &encoder{} | |||
e.must(yaml_emitter_initialize(&e.emitter)) | |||
yaml_emitter_set_output_string(&e.emitter, &e.out) | |||
yaml_emitter_set_unicode(&e.emitter, true) | |||
e.must(yaml_stream_start_event_initialize(&e.event, yaml_UTF8_ENCODING)) | |||
e.emit() | |||
e.must(yaml_document_start_event_initialize(&e.event, nil, nil, true)) | |||
e.emit() | |||
return e | |||
} | |||
func (e *encoder) finish() { | |||
e.must(yaml_document_end_event_initialize(&e.event, true)) | |||
e.emit() | |||
e.emitter.open_ended = false | |||
e.must(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. | |||
if !yaml_emitter_emit(&e.emitter, &e.event) && e.event.typ != yaml_DOCUMENT_END_EVENT && e.event.typ != yaml_STREAM_END_EVENT { | |||
e.must(false) | |||
} | |||
} | |||
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) marshal(tag string, in reflect.Value) { | |||
if !in.IsValid() { | |||
e.nilv() | |||
return | |||
} | |||
iface := in.Interface() | |||
if m, ok := iface.(Marshaler); ok { | |||
v, err := m.MarshalYAML() | |||
if err != nil { | |||
fail(err) | |||
} | |||
if v == nil { | |||
e.nilv() | |||
return | |||
} | |||
in = reflect.ValueOf(v) | |||
} else if m, ok := iface.(encoding.TextMarshaler); ok { | |||
text, err := m.MarshalText() | |||
if err != nil { | |||
fail(err) | |||
} | |||
in = reflect.ValueOf(string(text)) | |||
} | |||
switch in.Kind() { | |||
case reflect.Interface: | |||
if in.IsNil() { | |||
e.nilv() | |||
} else { | |||
e.marshal(tag, in.Elem()) | |||
} | |||
case reflect.Map: | |||
e.mapv(tag, in) | |||
case reflect.Ptr: | |||
if in.IsNil() { | |||
e.nilv() | |||
} else { | |||
e.marshal(tag, in.Elem()) | |||
} | |||
case reflect.Struct: | |||
e.structv(tag, in) | |||
case reflect.Slice: | |||
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 | |||
} | |||
e.must(yaml_mapping_start_event_initialize(&e.event, nil, []byte(tag), implicit, style)) | |||
e.emit() | |||
f() | |||
e.must(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() | |||
rtag, rs := resolve("", s) | |||
if rtag == yaml_BINARY_TAG { | |||
if tag == "" || tag == yaml_STR_TAG { | |||
tag = rtag | |||
s = rs.(string) | |||
} else if tag == yaml_BINARY_TAG { | |||
failf("explicitly tagged !!binary data must be base64-encoded") | |||
} else { | |||
failf("cannot marshal invalid UTF-8 data as %s", shortTag(tag)) | |||
} | |||
} | |||
if tag == "" && (rtag != yaml_STR_TAG || isBase60Float(s)) { | |||
style = yaml_DOUBLE_QUOTED_SCALAR_STYLE | |||
} else if strings.Contains(s, "\n") { | |||
style = yaml_LITERAL_SCALAR_STYLE | |||
} else { | |||
style = yaml_PLAIN_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) floatv(tag string, in reflect.Value) { | |||
// FIXME: Handle 64 bits here. | |||
s := strconv.FormatFloat(float64(in.Float()), 'g', -1, 32) | |||
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() | |||
} |
@@ -0,0 +1,394 @@ | |||
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") | |||
} | |||
// 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) { | |||
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 | |||
} | |||
} | |||
parser.buffer = parser.buffer[:buffer_len] | |||
return true | |||
} |
@@ -0,0 +1,203 @@ | |||
package yaml | |||
import ( | |||
"encoding/base64" | |||
"math" | |||
"strconv" | |||
"strings" | |||
"unicode/utf8" | |||
) | |||
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: | |||
return true | |||
} | |||
return false | |||
} | |||
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 | |||
} | |||
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. | |||
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 | |||
} | |||
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 intv == int64(int(intv)) { | |||
return yaml_INT_TAG, -int(intv) | |||
} else { | |||
return yaml_INT_TAG, -intv | |||
} | |||
} | |||
} | |||
// XXX Handle timestamps here. | |||
default: | |||
panic("resolveTable item not yet handled: " + string(rune(hint)) + " (with " + in + ")") | |||
} | |||
} | |||
if tag == yaml_BINARY_TAG { | |||
return yaml_BINARY_TAG, in | |||
} | |||
if utf8.ValidString(in) { | |||
return yaml_STR_TAG, in | |||
} | |||
return yaml_BINARY_TAG, encodeBase64(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]) | |||
} |
@@ -0,0 +1,104 @@ | |||
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 | |||
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") | |||
} |
@@ -0,0 +1,89 @@ | |||
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 the output encoding is UTF-8, we don't need to recode the buffer. | |||
if emitter.encoding == yaml_UTF8_ENCODING { | |||
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 | |||
} | |||
// Recode the buffer into the raw buffer. | |||
var low, high int | |||
if emitter.encoding == yaml_UTF16LE_ENCODING { | |||
low, high = 0, 1 | |||
} else { | |||
high, low = 1, 0 | |||
} | |||
pos := 0 | |||
for pos < emitter.buffer_pos { | |||
// See the "reader.c" code for more details on UTF-8 encoding. Note | |||
// that we assume that the buffer contains a valid UTF-8 sequence. | |||
// Read the next UTF-8 character. | |||
octet := emitter.buffer[pos] | |||
var w int | |||
var value rune | |||
switch { | |||
case octet&0x80 == 0x00: | |||
w, value = 1, rune(octet&0x7F) | |||
case octet&0xE0 == 0xC0: | |||
w, value = 2, rune(octet&0x1F) | |||
case octet&0xF0 == 0xE0: | |||
w, value = 3, rune(octet&0x0F) | |||
case octet&0xF8 == 0xF0: | |||
w, value = 4, rune(octet&0x07) | |||
} | |||
for k := 1; k < w; k++ { | |||
octet = emitter.buffer[pos+k] | |||
value = (value << 6) + (rune(octet) & 0x3F) | |||
} | |||
pos += w | |||
// Write the character. | |||
if value < 0x10000 { | |||
var b [2]byte | |||
b[high] = byte(value >> 8) | |||
b[low] = byte(value & 0xFF) | |||
emitter.raw_buffer = append(emitter.raw_buffer, b[0], b[1]) | |||
} else { | |||
// Write the character using a surrogate pair (check "reader.c"). | |||
var b [4]byte | |||
value -= 0x10000 | |||
b[high] = byte(0xD8 + (value >> 18)) | |||
b[low] = byte((value >> 10) & 0xFF) | |||
b[high+2] = byte(0xDC + ((value >> 8) & 0xFF)) | |||
b[low+2] = byte(value & 0xFF) | |||
emitter.raw_buffer = append(emitter.raw_buffer, b[0], b[1], b[2], b[3]) | |||
} | |||
} | |||
// Write the raw buffer. | |||
if err := emitter.write_handler(emitter, emitter.raw_buffer); err != nil { | |||
return yaml_emitter_set_writer_error(emitter, "write error: "+err.Error()) | |||
} | |||
emitter.buffer_pos = 0 | |||
emitter.raw_buffer = emitter.raw_buffer[:0] | |||
return true | |||
} |
@@ -0,0 +1,346 @@ | |||
// 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" | |||
"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) { | |||
defer handleErr(&err) | |||
d := newDecoder() | |||
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 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. | |||
// 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. | |||
// Does not apply to zero valued structs. | |||
// | |||
// 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 "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.marshal("", reflect.ValueOf(in)) | |||
e.finish() | |||
out = e.out | |||
return | |||
} | |||
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 | |||
// 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...) | |||
} | |||
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) | |||
} | |||
fieldsList = append(fieldsList, info) | |||
fieldsMap[info.Key] = info | |||
} | |||
sinfo = &structInfo{fieldsMap, fieldsList, inlineMap} | |||
fieldMapMutex.Lock() | |||
structMap[st] = sinfo | |||
fieldMapMutex.Unlock() | |||
return sinfo, nil | |||
} | |||
func isZero(v reflect.Value) bool { | |||
switch v.Kind() { | |||
case reflect.String: | |||
return len(v.String()) == 0 | |||
case reflect.Interface, reflect.Ptr: | |||
return v.IsNil() | |||
case reflect.Slice: | |||
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 | |||
} |
@@ -0,0 +1,716 @@ | |||
package yaml | |||
import ( | |||
"io" | |||
) | |||
// The version directive data. | |||
type yaml_version_directive_t struct { | |||
major int8 // The major version number. | |||
minor int8 // The minor version number. | |||
} | |||
// The tag directive data. | |||
type yaml_tag_directive_t struct { | |||
handle []byte // The tag handle. | |||
prefix []byte // The tag prefix. | |||
} | |||
type yaml_encoding_t int | |||
// The stream encoding. | |||
const ( | |||
// Let the parser choose the encoding. | |||
yaml_ANY_ENCODING yaml_encoding_t = iota | |||
yaml_UTF8_ENCODING // The default UTF-8 encoding. | |||
yaml_UTF16LE_ENCODING // The UTF-16-LE encoding with BOM. | |||
yaml_UTF16BE_ENCODING // The UTF-16-BE encoding with BOM. | |||
) | |||
type yaml_break_t int | |||
// Line break types. | |||
const ( | |||
// Let the parser choose the break type. | |||
yaml_ANY_BREAK yaml_break_t = iota | |||
yaml_CR_BREAK // Use CR for line breaks (Mac style). | |||
yaml_LN_BREAK // Use LN for line breaks (Unix style). | |||
yaml_CRLN_BREAK // Use CR LN for line breaks (DOS style). | |||
) | |||
type yaml_error_type_t int | |||
// Many bad things could happen with the parser and emitter. | |||
const ( | |||
// No error is produced. | |||
yaml_NO_ERROR yaml_error_type_t = iota | |||
yaml_MEMORY_ERROR // Cannot allocate or reallocate a block of memory. | |||
yaml_READER_ERROR // Cannot read or decode the input stream. | |||
yaml_SCANNER_ERROR // Cannot scan the input stream. | |||
yaml_PARSER_ERROR // Cannot parse the input stream. | |||
yaml_COMPOSER_ERROR // Cannot compose a YAML document. | |||
yaml_WRITER_ERROR // Cannot write to the output stream. | |||
yaml_EMITTER_ERROR // Cannot emit a YAML stream. | |||
) | |||
// The pointer position. | |||
type yaml_mark_t struct { | |||
index int // The position index. | |||
line int // The position line. | |||
column int // The position column. | |||
} | |||
// Node Styles | |||
type yaml_style_t int8 | |||
type yaml_scalar_style_t yaml_style_t | |||
// Scalar styles. | |||
const ( | |||
// Let the emitter choose the style. | |||
yaml_ANY_SCALAR_STYLE yaml_scalar_style_t = iota | |||
yaml_PLAIN_SCALAR_STYLE // The plain scalar style. | |||
yaml_SINGLE_QUOTED_SCALAR_STYLE // The single-quoted scalar style. | |||
yaml_DOUBLE_QUOTED_SCALAR_STYLE // The double-quoted scalar style. | |||
yaml_LITERAL_SCALAR_STYLE // The literal scalar style. | |||
yaml_FOLDED_SCALAR_STYLE // The folded scalar style. | |||
) | |||
type yaml_sequence_style_t yaml_style_t | |||
// Sequence styles. | |||
const ( | |||
// Let the emitter choose the style. | |||
yaml_ANY_SEQUENCE_STYLE yaml_sequence_style_t = iota | |||
yaml_BLOCK_SEQUENCE_STYLE // The block sequence style. | |||
yaml_FLOW_SEQUENCE_STYLE // The flow sequence style. | |||
) | |||
type yaml_mapping_style_t yaml_style_t | |||
// Mapping styles. | |||
const ( | |||
// Let the emitter choose the style. | |||
yaml_ANY_MAPPING_STYLE yaml_mapping_style_t = iota | |||
yaml_BLOCK_MAPPING_STYLE // The block mapping style. | |||
yaml_FLOW_MAPPING_STYLE // The flow mapping style. | |||
) | |||
// Tokens | |||
type yaml_token_type_t int | |||
// Token types. | |||
const ( | |||
// An empty token. | |||
yaml_NO_TOKEN yaml_token_type_t = iota | |||
yaml_STREAM_START_TOKEN // A STREAM-START token. | |||
yaml_STREAM_END_TOKEN // A STREAM-END token. | |||
yaml_VERSION_DIRECTIVE_TOKEN // A VERSION-DIRECTIVE token. | |||
yaml_TAG_DIRECTIVE_TOKEN // A TAG-DIRECTIVE token. | |||
yaml_DOCUMENT_START_TOKEN // A DOCUMENT-START token. | |||
yaml_DOCUMENT_END_TOKEN // A DOCUMENT-END token. | |||
yaml_BLOCK_SEQUENCE_START_TOKEN // A BLOCK-SEQUENCE-START token. | |||
yaml_BLOCK_MAPPING_START_TOKEN // A BLOCK-SEQUENCE-END token. | |||
yaml_BLOCK_END_TOKEN // A BLOCK-END token. | |||
yaml_FLOW_SEQUENCE_START_TOKEN // A FLOW-SEQUENCE-START token. | |||
yaml_FLOW_SEQUENCE_END_TOKEN // A FLOW-SEQUENCE-END token. | |||
yaml_FLOW_MAPPING_START_TOKEN // A FLOW-MAPPING-START token. | |||
yaml_FLOW_MAPPING_END_TOKEN // A FLOW-MAPPING-END token. | |||
yaml_BLOCK_ENTRY_TOKEN // A BLOCK-ENTRY token. | |||
yaml_FLOW_ENTRY_TOKEN // A FLOW-ENTRY token. | |||
yaml_KEY_TOKEN // A KEY token. | |||
yaml_VALUE_TOKEN // A VALUE token. | |||
yaml_ALIAS_TOKEN // An ALIAS token. | |||
yaml_ANCHOR_TOKEN // An ANCHOR token. | |||
yaml_TAG_TOKEN // A TAG token. | |||
yaml_SCALAR_TOKEN // A SCALAR token. | |||
) | |||
func (tt yaml_token_type_t) String() string { | |||
switch tt { | |||
case yaml_NO_TOKEN: | |||
return "yaml_NO_TOKEN" | |||
case yaml_STREAM_START_TOKEN: | |||
return "yaml_STREAM_START_TOKEN" | |||
case yaml_STREAM_END_TOKEN: | |||
return "yaml_STREAM_END_TOKEN" | |||
case yaml_VERSION_DIRECTIVE_TOKEN: | |||
return "yaml_VERSION_DIRECTIVE_TOKEN" | |||
case yaml_TAG_DIRECTIVE_TOKEN: | |||
return "yaml_TAG_DIRECTIVE_TOKEN" | |||
case yaml_DOCUMENT_START_TOKEN: | |||
return "yaml_DOCUMENT_START_TOKEN" | |||
case yaml_DOCUMENT_END_TOKEN: | |||
return "yaml_DOCUMENT_END_TOKEN" | |||
case yaml_BLOCK_SEQUENCE_START_TOKEN: | |||
return "yaml_BLOCK_SEQUENCE_START_TOKEN" | |||
case yaml_BLOCK_MAPPING_START_TOKEN: | |||
return "yaml_BLOCK_MAPPING_START_TOKEN" | |||
case yaml_BLOCK_END_TOKEN: | |||
return "yaml_BLOCK_END_TOKEN" | |||
case yaml_FLOW_SEQUENCE_START_TOKEN: | |||
return "yaml_FLOW_SEQUENCE_START_TOKEN" | |||
case yaml_FLOW_SEQUENCE_END_TOKEN: | |||
return "yaml_FLOW_SEQUENCE_END_TOKEN" | |||
case yaml_FLOW_MAPPING_START_TOKEN: | |||
return "yaml_FLOW_MAPPING_START_TOKEN" | |||
case yaml_FLOW_MAPPING_END_TOKEN: | |||
return "yaml_FLOW_MAPPING_END_TOKEN" | |||
case yaml_BLOCK_ENTRY_TOKEN: | |||
return "yaml_BLOCK_ENTRY_TOKEN" | |||
case yaml_FLOW_ENTRY_TOKEN: | |||
return "yaml_FLOW_ENTRY_TOKEN" | |||
case yaml_KEY_TOKEN: | |||
return "yaml_KEY_TOKEN" | |||
case yaml_VALUE_TOKEN: | |||
return "yaml_VALUE_TOKEN" | |||
case yaml_ALIAS_TOKEN: | |||
return "yaml_ALIAS_TOKEN" | |||
case yaml_ANCHOR_TOKEN: | |||
return "yaml_ANCHOR_TOKEN" | |||
case yaml_TAG_TOKEN: | |||
return "yaml_TAG_TOKEN" | |||
case yaml_SCALAR_TOKEN: | |||
return "yaml_SCALAR_TOKEN" | |||
} | |||
return "<unknown token>" | |||
} | |||
// The token structure. | |||
type yaml_token_t struct { | |||
// The token type. | |||
typ yaml_token_type_t | |||
// The start/end of the token. | |||
start_mark, end_mark yaml_mark_t | |||
// The stream encoding (for yaml_STREAM_START_TOKEN). | |||
encoding yaml_encoding_t | |||
// The alias/anchor/scalar value or tag/tag directive handle | |||
// (for yaml_ALIAS_TOKEN, yaml_ANCHOR_TOKEN, yaml_SCALAR_TOKEN, yaml_TAG_TOKEN, yaml_TAG_DIRECTIVE_TOKEN). | |||
value []byte | |||
// The tag suffix (for yaml_TAG_TOKEN). | |||
suffix []byte | |||
// The tag directive prefix (for yaml_TAG_DIRECTIVE_TOKEN). | |||
prefix []byte | |||
// The scalar style (for yaml_SCALAR_TOKEN). | |||
style yaml_scalar_style_t | |||
// The version directive major/minor (for yaml_VERSION_DIRECTIVE_TOKEN). | |||
major, minor int8 | |||
} | |||
// Events | |||
type yaml_event_type_t int8 | |||
// Event types. | |||
const ( | |||
// An empty event. | |||
yaml_NO_EVENT yaml_event_type_t = iota | |||
yaml_STREAM_START_EVENT // A STREAM-START event. | |||
yaml_STREAM_END_EVENT // A STREAM-END event. | |||
yaml_DOCUMENT_START_EVENT // A DOCUMENT-START event. | |||
yaml_DOCUMENT_END_EVENT // A DOCUMENT-END event. | |||
yaml_ALIAS_EVENT // An ALIAS event. | |||
yaml_SCALAR_EVENT // A SCALAR event. | |||
yaml_SEQUENCE_START_EVENT // A SEQUENCE-START event. | |||
yaml_SEQUENCE_END_EVENT // A SEQUENCE-END event. | |||
yaml_MAPPING_START_EVENT // A MAPPING-START event. | |||
yaml_MAPPING_END_EVENT // A MAPPING-END event. | |||
) | |||
// The event structure. | |||
type yaml_event_t struct { | |||
// The event type. | |||
typ yaml_event_type_t | |||
// The start and end of the event. | |||
start_mark, end_mark yaml_mark_t | |||
// The document encoding (for yaml_STREAM_START_EVENT). | |||
encoding yaml_encoding_t | |||
// The version directive (for yaml_DOCUMENT_START_EVENT). | |||
version_directive *yaml_version_directive_t | |||
// The list of tag directives (for yaml_DOCUMENT_START_EVENT). | |||
tag_directives []yaml_tag_directive_t | |||
// The anchor (for yaml_SCALAR_EVENT, yaml_SEQUENCE_START_EVENT, yaml_MAPPING_START_EVENT, yaml_ALIAS_EVENT). | |||
anchor []byte | |||
// The tag (for yaml_SCALAR_EVENT, yaml_SEQUENCE_START_EVENT, yaml_MAPPING_START_EVENT). | |||
tag []byte | |||
// The scalar value (for yaml_SCALAR_EVENT). | |||
value []byte | |||
// Is the document start/end indicator implicit, or the tag optional? | |||
// (for yaml_DOCUMENT_START_EVENT, yaml_DOCUMENT_END_EVENT, yaml_SEQUENCE_START_EVENT, yaml_MAPPING_START_EVENT, yaml_SCALAR_EVENT). | |||
implicit bool | |||
// Is the tag optional for any non-plain style? (for yaml_SCALAR_EVENT). | |||
quoted_implicit bool | |||
// The style (for yaml_SCALAR_EVENT, yaml_SEQUENCE_START_EVENT, yaml_MAPPING_START_EVENT). | |||
style yaml_style_t | |||
} | |||
func (e *yaml_event_t) scalar_style() yaml_scalar_style_t { return yaml_scalar_style_t(e.style) } | |||
func (e *yaml_event_t) sequence_style() yaml_sequence_style_t { return yaml_sequence_style_t(e.style) } | |||
func (e *yaml_event_t) mapping_style() yaml_mapping_style_t { return yaml_mapping_style_t(e.style) } | |||
// Nodes | |||
const ( | |||
yaml_NULL_TAG = "tag:yaml.org,2002:null" // The tag !!null with the only possible value: null. | |||
yaml_BOOL_TAG = "tag:yaml.org,2002:bool" // The tag !!bool with the values: true and false. | |||
yaml_STR_TAG = "tag:yaml.org,2002:str" // The tag !!str for string values. | |||
yaml_INT_TAG = "tag:yaml.org,2002:int" // The tag !!int for integer values. | |||
yaml_FLOAT_TAG = "tag:yaml.org,2002:float" // The tag !!float for float values. | |||
yaml_TIMESTAMP_TAG = "tag:yaml.org,2002:timestamp" // The tag !!timestamp for date and time values. | |||
yaml_SEQ_TAG = "tag:yaml.org,2002:seq" // The tag !!seq is used to denote sequences. | |||
yaml_MAP_TAG = "tag:yaml.org,2002:map" // The tag !!map is used to denote mapping. | |||
// Not in original libyaml. | |||
yaml_BINARY_TAG = "tag:yaml.org,2002:binary" | |||
yaml_MERGE_TAG = "tag:yaml.org,2002:merge" | |||
yaml_DEFAULT_SCALAR_TAG = yaml_STR_TAG // The default scalar tag is !!str. | |||
yaml_DEFAULT_SEQUENCE_TAG = yaml_SEQ_TAG // The default sequence tag is !!seq. | |||
yaml_DEFAULT_MAPPING_TAG = yaml_MAP_TAG // The default mapping tag is !!map. | |||
) | |||
type yaml_node_type_t int | |||
// Node types. | |||
const ( | |||
// An empty node. | |||
yaml_NO_NODE yaml_node_type_t = iota | |||
yaml_SCALAR_NODE // A scalar node. | |||
yaml_SEQUENCE_NODE // A sequence node. | |||
yaml_MAPPING_NODE // A mapping node. | |||
) | |||
// An element of a sequence node. | |||
type yaml_node_item_t int | |||
// An element of a mapping node. | |||
type yaml_node_pair_t struct { | |||
key int // The key of the element. | |||
value int // The value of the element. | |||
} | |||
// The node structure. | |||
type yaml_node_t struct { | |||
typ yaml_node_type_t // The node type. | |||
tag []byte // The node tag. | |||
// The node data. | |||
// The scalar parameters (for yaml_SCALAR_NODE). | |||
scalar struct { | |||
value []byte // The scalar value. | |||
length int // The length of the scalar value. | |||
style yaml_scalar_style_t // The scalar style. | |||
} | |||
// The sequence parameters (for YAML_SEQUENCE_NODE). | |||
sequence struct { | |||
items_data []yaml_node_item_t // The stack of sequence items. | |||
style yaml_sequence_style_t // The sequence style. | |||
} | |||
// The mapping parameters (for yaml_MAPPING_NODE). | |||
mapping struct { | |||
pairs_data []yaml_node_pair_t // The stack of mapping pairs (key, value). | |||
pairs_start *yaml_node_pair_t // The beginning of the stack. | |||
pairs_end *yaml_node_pair_t // The end of the stack. | |||
pairs_top *yaml_node_pair_t // The top of the stack. | |||
style yaml_mapping_style_t // The mapping style. | |||
} | |||
start_mark yaml_mark_t // The beginning of the node. | |||
end_mark yaml_mark_t // The end of the node. | |||
} | |||
// The document structure. | |||
type yaml_document_t struct { | |||
// The document nodes. | |||
nodes []yaml_node_t | |||
// The version directive. | |||
version_directive *yaml_version_directive_t | |||
// The list of tag directives. | |||
tag_directives_data []yaml_tag_directive_t | |||
tag_directives_start int // The beginning of the tag directives list. | |||
tag_directives_end int // The end of the tag directives list. | |||
start_implicit int // Is the document start indicator implicit? | |||
end_implicit int // Is the document end indicator implicit? | |||
// The start/end of the document. | |||
start_mark, end_mark yaml_mark_t | |||
} | |||
// The prototype of a read handler. | |||
// | |||
// The read handler is called when the parser needs to read more bytes from the | |||
// source. The handler should write not more than size bytes to the buffer. | |||
// The number of written bytes should be set to the size_read variable. | |||
// | |||
// [in,out] data A pointer to an application data specified by | |||
// yaml_parser_set_input(). | |||
// [out] buffer The buffer to write the data from the source. | |||
// [in] size The size of the buffer. | |||
// [out] size_read The actual number of bytes read from the source. | |||
// | |||
// On success, the handler should return 1. If the handler failed, | |||
// the returned value should be 0. On EOF, the handler should set the | |||
// size_read to 0 and return 1. | |||
type yaml_read_handler_t func(parser *yaml_parser_t, buffer []byte) (n int, err error) | |||
// This structure holds information about a potential simple key. | |||
type yaml_simple_key_t struct { | |||
possible bool // Is a simple key possible? | |||
required bool // Is a simple key required? | |||
token_number int // The number of the token. | |||
mark yaml_mark_t // The position mark. | |||
} | |||
// The states of the parser. | |||
type yaml_parser_state_t int | |||
const ( | |||
yaml_PARSE_STREAM_START_STATE yaml_parser_state_t = iota | |||
yaml_PARSE_IMPLICIT_DOCUMENT_START_STATE // Expect the beginning of an implicit document. | |||
yaml_PARSE_DOCUMENT_START_STATE // Expect DOCUMENT-START. | |||
yaml_PARSE_DOCUMENT_CONTENT_STATE // Expect the content of a document. | |||
yaml_PARSE_DOCUMENT_END_STATE // Expect DOCUMENT-END. | |||
yaml_PARSE_BLOCK_NODE_STATE // Expect a block node. | |||
yaml_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE // Expect a block node or indentless sequence. | |||
yaml_PARSE_FLOW_NODE_STATE // Expect a flow node. | |||
yaml_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE // Expect the first entry of a block sequence. | |||
yaml_PARSE_BLOCK_SEQUENCE_ENTRY_STATE // Expect an entry of a block sequence. | |||
yaml_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE // Expect an entry of an indentless sequence. | |||
yaml_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE // Expect the first key of a block mapping. | |||
yaml_PARSE_BLOCK_MAPPING_KEY_STATE // Expect a block mapping key. | |||
yaml_PARSE_BLOCK_MAPPING_VALUE_STATE // Expect a block mapping value. | |||
yaml_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE // Expect the first entry of a flow sequence. | |||
yaml_PARSE_FLOW_SEQUENCE_ENTRY_STATE // Expect an entry of a flow sequence. | |||
yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE // Expect a key of an ordered mapping. | |||
yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE // Expect a value of an ordered mapping. | |||
yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE // Expect the and of an ordered mapping entry. | |||
yaml_PARSE_FLOW_MAPPING_FIRST_KEY_STATE // Expect the first key of a flow mapping. | |||
yaml_PARSE_FLOW_MAPPING_KEY_STATE // Expect a key of a flow mapping. | |||
yaml_PARSE_FLOW_MAPPING_VALUE_STATE // Expect a value of a flow mapping. | |||
yaml_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE // Expect an empty value of a flow mapping. | |||
yaml_PARSE_END_STATE // Expect nothing. | |||
) | |||
func (ps yaml_parser_state_t) String() string { | |||
switch ps { | |||
case yaml_PARSE_STREAM_START_STATE: | |||
return "yaml_PARSE_STREAM_START_STATE" | |||
case yaml_PARSE_IMPLICIT_DOCUMENT_START_STATE: | |||
return "yaml_PARSE_IMPLICIT_DOCUMENT_START_STATE" | |||
case yaml_PARSE_DOCUMENT_START_STATE: | |||
return "yaml_PARSE_DOCUMENT_START_STATE" | |||
case yaml_PARSE_DOCUMENT_CONTENT_STATE: | |||
return "yaml_PARSE_DOCUMENT_CONTENT_STATE" | |||
case yaml_PARSE_DOCUMENT_END_STATE: | |||
return "yaml_PARSE_DOCUMENT_END_STATE" | |||
case yaml_PARSE_BLOCK_NODE_STATE: | |||
return "yaml_PARSE_BLOCK_NODE_STATE" | |||
case yaml_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE: | |||
return "yaml_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE" | |||
case yaml_PARSE_FLOW_NODE_STATE: | |||
return "yaml_PARSE_FLOW_NODE_STATE" | |||
case yaml_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE: | |||
return "yaml_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE" | |||
case yaml_PARSE_BLOCK_SEQUENCE_ENTRY_STATE: | |||
return "yaml_PARSE_BLOCK_SEQUENCE_ENTRY_STATE" | |||
case yaml_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE: | |||
return "yaml_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE" | |||
case yaml_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE: | |||
return "yaml_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE" | |||
case yaml_PARSE_BLOCK_MAPPING_KEY_STATE: | |||
return "yaml_PARSE_BLOCK_MAPPING_KEY_STATE" | |||
case yaml_PARSE_BLOCK_MAPPING_VALUE_STATE: | |||
return "yaml_PARSE_BLOCK_MAPPING_VALUE_STATE" | |||
case yaml_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE: | |||
return "yaml_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE" | |||
case yaml_PARSE_FLOW_SEQUENCE_ENTRY_STATE: | |||
return "yaml_PARSE_FLOW_SEQUENCE_ENTRY_STATE" | |||
case yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE: | |||
return "yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE" | |||
case yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE: | |||
return "yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE" | |||
case yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE: | |||
return "yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE" | |||
case yaml_PARSE_FLOW_MAPPING_FIRST_KEY_STATE: | |||
return "yaml_PARSE_FLOW_MAPPING_FIRST_KEY_STATE" | |||
case yaml_PARSE_FLOW_MAPPING_KEY_STATE: | |||
return "yaml_PARSE_FLOW_MAPPING_KEY_STATE" | |||
case yaml_PARSE_FLOW_MAPPING_VALUE_STATE: | |||
return "yaml_PARSE_FLOW_MAPPING_VALUE_STATE" | |||
case yaml_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE: | |||
return "yaml_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE" | |||
case yaml_PARSE_END_STATE: | |||
return "yaml_PARSE_END_STATE" | |||
} | |||
return "<unknown parser state>" | |||
} | |||
// This structure holds aliases data. | |||
type yaml_alias_data_t struct { | |||
anchor []byte // The anchor. | |||
index int // The node id. | |||
mark yaml_mark_t // The anchor mark. | |||
} | |||
// The parser structure. | |||
// | |||
// All members are internal. Manage the structure using the | |||
// yaml_parser_ family of functions. | |||
type yaml_parser_t struct { | |||
// Error handling | |||
error yaml_error_type_t // Error type. | |||
problem string // Error description. | |||
// The byte about which the problem occured. | |||
problem_offset int | |||
problem_value int | |||
problem_mark yaml_mark_t | |||
// The error context. | |||
context string | |||
context_mark yaml_mark_t | |||
// Reader stuff | |||
read_handler yaml_read_handler_t // Read handler. | |||
input_file io.Reader // File input data. | |||
input []byte // String input data. | |||
input_pos int | |||
eof bool // EOF flag | |||
buffer []byte // The working buffer. | |||
buffer_pos int // The current position of the buffer. | |||
unread int // The number of unread characters in the buffer. | |||
raw_buffer []byte // The raw buffer. | |||
raw_buffer_pos int // The current position of the buffer. | |||
encoding yaml_encoding_t // The input encoding. | |||
offset int // The offset of the current position (in bytes). | |||
mark yaml_mark_t // The mark of the current position. | |||
// Scanner stuff | |||
stream_start_produced bool // Have we started to scan the input stream? | |||
stream_end_produced bool // Have we reached the end of the input stream? | |||
flow_level int // The number of unclosed '[' and '{' indicators. | |||
tokens []yaml_token_t // The tokens queue. | |||
tokens_head int // The head of the tokens queue. | |||
tokens_parsed int // The number of tokens fetched from the queue. | |||
token_available bool // Does the tokens queue contain a token ready for dequeueing. | |||
indent int // The current indentation level. | |||
indents []int // The indentation levels stack. | |||
simple_key_allowed bool // May a simple key occur at the current position? | |||
simple_keys []yaml_simple_key_t // The stack of simple keys. | |||
// Parser stuff | |||
state yaml_parser_state_t // The current parser state. | |||
states []yaml_parser_state_t // The parser states stack. | |||
marks []yaml_mark_t // The stack of marks. | |||
tag_directives []yaml_tag_directive_t // The list of TAG directives. | |||
// Dumper stuff | |||
aliases []yaml_alias_data_t // The alias data. | |||
document *yaml_document_t // The currently parsed document. | |||
} | |||
// Emitter Definitions | |||
// The prototype of a write handler. | |||
// | |||
// The write handler is called when the emitter needs to flush the accumulated | |||
// characters to the output. The handler should write @a size bytes of the | |||
// @a buffer to the output. | |||
// | |||
// @param[in,out] data A pointer to an application data specified by | |||
// yaml_emitter_set_output(). | |||
// @param[in] buffer The buffer with bytes to be written. | |||
// @param[in] size The size of the buffer. | |||
// | |||
// @returns On success, the handler should return @c 1. If the handler failed, | |||
// the returned value should be @c 0. | |||
// | |||
type yaml_write_handler_t func(emitter *yaml_emitter_t, buffer []byte) error | |||
type yaml_emitter_state_t int | |||
// The emitter states. | |||
const ( | |||
// Expect STREAM-START. | |||
yaml_EMIT_STREAM_START_STATE yaml_emitter_state_t = iota | |||
yaml_EMIT_FIRST_DOCUMENT_START_STATE // Expect the first DOCUMENT-START or STREAM-END. | |||
yaml_EMIT_DOCUMENT_START_STATE // Expect DOCUMENT-START or STREAM-END. | |||
yaml_EMIT_DOCUMENT_CONTENT_STATE // Expect the content of a document. | |||
yaml_EMIT_DOCUMENT_END_STATE // Expect DOCUMENT-END. | |||
yaml_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE // Expect the first item of a flow sequence. | |||
yaml_EMIT_FLOW_SEQUENCE_ITEM_STATE // Expect an item of a flow sequence. | |||
yaml_EMIT_FLOW_MAPPING_FIRST_KEY_STATE // Expect the first key of a flow mapping. | |||
yaml_EMIT_FLOW_MAPPING_KEY_STATE // Expect a key of a flow mapping. | |||
yaml_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE // Expect a value for a simple key of a flow mapping. | |||
yaml_EMIT_FLOW_MAPPING_VALUE_STATE // Expect a value of a flow mapping. | |||
yaml_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE // Expect the first item of a block sequence. | |||
yaml_EMIT_BLOCK_SEQUENCE_ITEM_STATE // Expect an item of a block sequence. | |||
yaml_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE // Expect the first key of a block mapping. | |||
yaml_EMIT_BLOCK_MAPPING_KEY_STATE // Expect the key of a block mapping. | |||
yaml_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE // Expect a value for a simple key of a block mapping. | |||
yaml_EMIT_BLOCK_MAPPING_VALUE_STATE // Expect a value of a block mapping. | |||
yaml_EMIT_END_STATE // Expect nothing. | |||
) | |||
// The emitter structure. | |||
// | |||
// All members are internal. Manage the structure using the @c yaml_emitter_ | |||
// family of functions. | |||
type yaml_emitter_t struct { | |||
// Error handling | |||
error yaml_error_type_t // Error type. | |||
problem string // Error description. | |||
// Writer stuff | |||
write_handler yaml_write_handler_t // Write handler. | |||
output_buffer *[]byte // String output data. | |||
output_file io.Writer // File output data. | |||
buffer []byte // The working buffer. | |||
buffer_pos int // The current position of the buffer. | |||
raw_buffer []byte // The raw buffer. | |||
raw_buffer_pos int // The current position of the buffer. | |||
encoding yaml_encoding_t // The stream encoding. | |||
// Emitter stuff | |||
canonical bool // If the output is in the canonical style? | |||
best_indent int // The number of indentation spaces. | |||
best_width int // The preferred width of the output lines. | |||
unicode bool // Allow unescaped non-ASCII characters? | |||
line_break yaml_break_t // The preferred line break. | |||
state yaml_emitter_state_t // The current emitter state. | |||
states []yaml_emitter_state_t // The stack of states. | |||
events []yaml_event_t // The event queue. | |||
events_head int // The head of the event queue. | |||
indents []int // The stack of indentation levels. | |||
tag_directives []yaml_tag_directive_t // The list of tag directives. | |||
indent int // The current indentation level. | |||
flow_level int // The current flow level. | |||
root_context bool // Is it the document root context? | |||
sequence_context bool // Is it a sequence context? | |||
mapping_context bool // Is it a mapping context? | |||
simple_key_context bool // Is it a simple mapping key context? | |||
line int // The current line. | |||
column int // The current column. | |||
whitespace bool // If the last character was a whitespace? | |||
indention bool // If the last character was an indentation character (' ', '-', '?', ':')? | |||
open_ended bool // If an explicit document end is required? | |||
// Anchor analysis. | |||
anchor_data struct { | |||
anchor []byte // The anchor value. | |||
alias bool // Is it an alias? | |||
} | |||
// Tag analysis. | |||
tag_data struct { | |||
handle []byte // The tag handle. | |||
suffix []byte // The tag suffix. | |||
} | |||
// Scalar analysis. | |||
scalar_data struct { | |||
value []byte // The scalar value. | |||
multiline bool // Does the scalar contain line breaks? | |||
flow_plain_allowed bool // Can the scalar be expessed in the flow plain style? | |||
block_plain_allowed bool // Can the scalar be expressed in the block plain style? | |||
single_quoted_allowed bool // Can the scalar be expressed in the single quoted style? | |||
block_allowed bool // Can the scalar be expressed in the literal or folded styles? | |||
style yaml_scalar_style_t // The output style. | |||
} | |||
// Dumper stuff | |||
opened bool // If the stream was already opened? | |||
closed bool // If the stream was already closed? | |||
// The information associated with the document nodes. | |||
anchors *struct { | |||
references int // The number of references. | |||
anchor int // The anchor id. | |||
serialized bool // If the node has been emitted? | |||
} | |||
last_anchor_id int // The last assigned anchor id. | |||
document *yaml_document_t // The currently emitted document. | |||
} |
@@ -0,0 +1,173 @@ | |||
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 | |||
} |
@@ -806,6 +806,12 @@ | |||
"revision": "976c720a22c8eb4eb6a0b4348ad85ad12491a506", | |||
"revisionTime": "2016-09-25T22:06:09Z" | |||
}, | |||
{ | |||
"checksumSHA1": "2PpOCNkWnshDrXeCVH2kp3VHhIM=", | |||
"path": "github.com/stretchr/testify/require", | |||
"revision": "2402e8e7a02fc811447d11f881aa9746cdc57983", | |||
"revisionTime": "2016-12-17T20:04:45Z" | |||
}, | |||
{ | |||
"checksumSHA1": "MAnxhGyQfhoyoATeT1zJDPyWq7A=", | |||
"path": "github.com/syndtr/goleveldb/leveldb", | |||
@@ -1112,6 +1118,18 @@ | |||
"revision": "e6179049628164864e6e84e973cfb56335748dea", | |||
"revisionTime": "2014-12-09T11:07:59Z" | |||
}, | |||
{ | |||
"checksumSHA1": "LUbT9kZUJcQkU/6GSbnsai+b5t4=", | |||
"path": "gopkg.in/testfixtures.v2", | |||
"revision": "b9ef14dc461bf934d8df2dfc6f1f456be5664cca", | |||
"revisionTime": "2016-10-15T20:31:37Z" | |||
}, | |||
{ | |||
"checksumSHA1": "12GqsW8PiRPnezDDy0v4brZrndM=", | |||
"path": "gopkg.in/yaml.v2", | |||
"revision": "a5b47d31c556af34a302ce5d659e6fea44d90de0", | |||
"revisionTime": "2016-09-28T15:37:09Z" | |||
}, | |||
{ | |||
"checksumSHA1": "JQBqnAXO83ic7bwer/MwurhQMtg=", | |||
"path": "strk.kbt.io/projects/go/libravatar", |