[Vendor] update macaron related (#13409)
* Vendor: update gitea.com/macaron/session to a177a270 * make vendor * Vendor: update gitea.com/macaron/macaron to 0db5d458 * make vendor * Vendor: update gitea.com/macaron/cache to 905232fb * make vendor * Vendor: update gitea.com/macaron/i18n to 4ca3dd0c * make vendor * Vendor: update gitea.com/macaron/gzip to efa5e847 * make vendor * Vendor: update gitea.com/macaron/captcha to e8597820 * make vendortokarchuk/v1.17
6543
4 years ago
committed by
GitHub
parent
b687707014
commit
70ea2300ca
@ -1,12 +1,14 @@ |
|||||||
## log |
## log |
||||||
[](https://godoc.org/github.com/lunny/log) |
|
||||||
|
|
||||||
[简体中文](https://github.com/lunny/log/blob/master/README_CN.md) |
[](https://goreportcard.com/report/gitea.com/lunny/log) |
||||||
|
[](https://godoc.org/gitea.com/lunny/log) |
||||||
|
|
||||||
|
[简体中文](https://gitea.com/lunny/log/blob/master/README_CN.md) |
||||||
|
|
||||||
# Installation |
# Installation |
||||||
|
|
||||||
``` |
``` |
||||||
go get github.com/lunny/log |
go get gitea.com/lunny/log |
||||||
``` |
``` |
||||||
|
|
||||||
# Features |
# Features |
||||||
8
vendor/github.com/lunny/log/README_CN.md → vendor/gitea.com/lunny/log/README_CN.md
generated
vendored
8
vendor/github.com/lunny/log/README_CN.md → vendor/gitea.com/lunny/log/README_CN.md
generated
vendored
@ -1,12 +1,14 @@ |
|||||||
## log |
## log |
||||||
[](https://godoc.org/github.com/lunny/log) |
|
||||||
|
|
||||||
[English](https://github.com/lunny/log/blob/master/README.md) |
[](https://goreportcard.com/report/gitea.com/lunny/log) |
||||||
|
[](https://godoc.org/gitea.com/lunny/log) |
||||||
|
|
||||||
|
[English](https://gitea.com/lunny/log/blob/master/README.md) |
||||||
|
|
||||||
# 安装 |
# 安装 |
||||||
|
|
||||||
``` |
``` |
||||||
go get github.com/lunny/log |
go get gitea.com/lunny/log |
||||||
``` |
``` |
||||||
|
|
||||||
# 特性 |
# 特性 |
||||||
0
vendor/github.com/lunny/log/dbwriter.go → vendor/gitea.com/lunny/log/dbwriter.go
generated
vendored
0
vendor/github.com/lunny/log/dbwriter.go → vendor/gitea.com/lunny/log/dbwriter.go
generated
vendored
0
vendor/github.com/lunny/log/filewriter.go → vendor/gitea.com/lunny/log/filewriter.go
generated
vendored
0
vendor/github.com/lunny/log/filewriter.go → vendor/gitea.com/lunny/log/filewriter.go
generated
vendored
@ -0,0 +1,5 @@ |
|||||||
|
module gitea.com/lunny/log |
||||||
|
|
||||||
|
go 1.12 |
||||||
|
|
||||||
|
require github.com/mattn/go-sqlite3 v1.10.0 |
||||||
@ -0,0 +1,2 @@ |
|||||||
|
github.com/mattn/go-sqlite3 v1.10.0 h1:jbhqpg7tQe4SupckyijYiy0mJJ/pRyHvXf7JdWK860o= |
||||||
|
github.com/mattn/go-sqlite3 v1.10.0/go.mod h1:FPy6KqzDD04eiIsT53CuJW3U88zkxoIYsOqkbpncsNc= |
||||||
0
vendor/github.com/lunny/nodb/.gitignore → vendor/gitea.com/lunny/nodb/.gitignore
generated
vendored
0
vendor/github.com/lunny/nodb/.gitignore → vendor/gitea.com/lunny/nodb/.gitignore
generated
vendored
11
vendor/github.com/lunny/nodb/README.md → vendor/gitea.com/lunny/nodb/README.md
generated
vendored
11
vendor/github.com/lunny/nodb/README.md → vendor/gitea.com/lunny/nodb/README.md
generated
vendored
11
vendor/github.com/lunny/nodb/README_CN.md → vendor/gitea.com/lunny/nodb/README_CN.md
generated
vendored
11
vendor/github.com/lunny/nodb/README_CN.md → vendor/gitea.com/lunny/nodb/README_CN.md
generated
vendored
18
vendor/github.com/lunny/nodb/binlog.go → vendor/gitea.com/lunny/nodb/binlog.go
generated
vendored
18
vendor/github.com/lunny/nodb/binlog.go → vendor/gitea.com/lunny/nodb/binlog.go
generated
vendored
@ -0,0 +1,11 @@ |
|||||||
|
module gitea.com/lunny/nodb |
||||||
|
|
||||||
|
go 1.12 |
||||||
|
|
||||||
|
require ( |
||||||
|
gitea.com/lunny/log v0.0.0-20190322053110-01b5df579c4e |
||||||
|
github.com/mattn/go-sqlite3 v1.11.0 // indirect |
||||||
|
github.com/pelletier/go-toml v1.8.1 |
||||||
|
github.com/siddontang/go-snappy v0.0.0-20140704025258-d8f7bb82a96d |
||||||
|
github.com/syndtr/goleveldb v1.0.0 |
||||||
|
) |
||||||
@ -0,0 +1,42 @@ |
|||||||
|
gitea.com/lunny/log v0.0.0-20190322053110-01b5df579c4e h1:r1en/D7xJmcY24VkHkjkcJFa+7ZWubVWPBrvsHkmHxk= |
||||||
|
gitea.com/lunny/log v0.0.0-20190322053110-01b5df579c4e/go.mod h1:uJEsN4LQpeGYRCjuPXPZBClU7N5pWzGuyF4uqLpE/e0= |
||||||
|
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= |
||||||
|
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= |
||||||
|
github.com/fsnotify/fsnotify v1.4.7 h1:IXs+QLmnXW2CcXuY+8Mzv/fWEsPGWxqefPtCP5CnV9I= |
||||||
|
github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo= |
||||||
|
github.com/golang/protobuf v1.2.0 h1:P3YflyNX/ehuJFLhxviNdFxQPkGK5cDcApsge1SqnvM= |
||||||
|
github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= |
||||||
|
github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db h1:woRePGFeVFfLKN/pOkfl+p/TAqKOfFu+7KPlMVpok/w= |
||||||
|
github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= |
||||||
|
github.com/hpcloud/tail v1.0.0 h1:nfCOvKYfkgYP8hkirhJocXT2+zOD8yUNjXaWfTlyFKI= |
||||||
|
github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU= |
||||||
|
github.com/mattn/go-sqlite3 v1.10.0/go.mod h1:FPy6KqzDD04eiIsT53CuJW3U88zkxoIYsOqkbpncsNc= |
||||||
|
github.com/mattn/go-sqlite3 v1.11.0 h1:LDdKkqtYlom37fkvqs8rMPFKAMe8+SgjbwZ6ex1/A/Q= |
||||||
|
github.com/mattn/go-sqlite3 v1.11.0/go.mod h1:FPy6KqzDD04eiIsT53CuJW3U88zkxoIYsOqkbpncsNc= |
||||||
|
github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= |
||||||
|
github.com/onsi/ginkgo v1.7.0 h1:WSHQ+IS43OoUrWtD1/bbclrwK8TTH5hzp+umCiuxHgs= |
||||||
|
github.com/onsi/ginkgo v1.7.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= |
||||||
|
github.com/onsi/gomega v1.4.3 h1:RE1xgDvH7imwFD45h+u2SgIfERHlS2yNG4DObb5BSKU= |
||||||
|
github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY= |
||||||
|
github.com/pelletier/go-toml v1.8.1 h1:1Nf83orprkJyknT6h7zbuEGUEjcyVlCxSUGTENmNCRM= |
||||||
|
github.com/pelletier/go-toml v1.8.1/go.mod h1:T2/BmBdy8dvIRq1a/8aqjN41wvWlN4lrapLU/GW4pbc= |
||||||
|
github.com/siddontang/go-snappy v0.0.0-20140704025258-d8f7bb82a96d h1:qQWKKOvHN7Q9c6GdmUteCef2F9ubxMpxY1IKwpIKz68= |
||||||
|
github.com/siddontang/go-snappy v0.0.0-20140704025258-d8f7bb82a96d/go.mod h1:vq0tzqLRu6TS7Id0wMo2N5QzJoKedVeovOpHjnykSzY= |
||||||
|
github.com/syndtr/goleveldb v1.0.0 h1:fBdIW9lB4Iz0n9khmH8w27SJ3QEJ7+IgjPEwGSZiFdE= |
||||||
|
github.com/syndtr/goleveldb v1.0.0/go.mod h1:ZVVdQEZoIme9iO1Ch2Jdy24qqXrMMOU6lpPAyBWyWuQ= |
||||||
|
golang.org/x/net v0.0.0-20180906233101-161cd47e91fd h1:nTDtHvHSdCn1m6ITfMRqtOd/9+7a3s8RBNOZ3eYZzJA= |
||||||
|
golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= |
||||||
|
golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f h1:wMNYb4v58l5UBM7MYRLPG6ZhfOqbKu7X5eyFl8ZhKvA= |
||||||
|
golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= |
||||||
|
golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e h1:o3PsSEY8E4eXWkXrIP9YJALUkVZqzHJT5DOasTyn8Vs= |
||||||
|
golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= |
||||||
|
golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg= |
||||||
|
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= |
||||||
|
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM= |
||||||
|
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= |
||||||
|
gopkg.in/fsnotify.v1 v1.4.7 h1:xOHLXZwVvI9hhs+cLKq5+I5onOuwQLhQwiu63xxlHs4= |
||||||
|
gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys= |
||||||
|
gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ= |
||||||
|
gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw= |
||||||
|
gopkg.in/yaml.v2 v2.2.1 h1:mUhvW9EsL+naU5Q3cakzfE91YhliOondGd6ZrsDBHQE= |
||||||
|
gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= |
||||||
2
vendor/github.com/lunny/nodb/nodb_db.go → vendor/gitea.com/lunny/nodb/nodb_db.go
generated
vendored
2
vendor/github.com/lunny/nodb/nodb_db.go → vendor/gitea.com/lunny/nodb/nodb_db.go
generated
vendored
2
vendor/github.com/lunny/nodb/store/db.go → vendor/gitea.com/lunny/nodb/store/db.go
generated
vendored
2
vendor/github.com/lunny/nodb/store/db.go → vendor/gitea.com/lunny/nodb/store/db.go
generated
vendored
@ -1,7 +1,7 @@ |
|||||||
package store |
package store |
||||||
|
|
||||||
import ( |
import ( |
||||||
"github.com/lunny/nodb/store/driver" |
"gitea.com/lunny/nodb/store/driver" |
||||||
) |
) |
||||||
|
|
||||||
type DB struct { |
type DB struct { |
||||||
@ -1,7 +1,7 @@ |
|||||||
package goleveldb |
package goleveldb |
||||||
|
|
||||||
import ( |
import ( |
||||||
"github.com/lunny/nodb/store/driver" |
"gitea.com/lunny/nodb/store/driver" |
||||||
"github.com/syndtr/goleveldb/leveldb" |
"github.com/syndtr/goleveldb/leveldb" |
||||||
) |
) |
||||||
|
|
||||||
@ -1,7 +1,7 @@ |
|||||||
package store |
package store |
||||||
|
|
||||||
import ( |
import ( |
||||||
"github.com/lunny/nodb/store/driver" |
"gitea.com/lunny/nodb/store/driver" |
||||||
) |
) |
||||||
|
|
||||||
type Snapshot struct { |
type Snapshot struct { |
||||||
2
vendor/github.com/lunny/nodb/store/tx.go → vendor/gitea.com/lunny/nodb/store/tx.go
generated
vendored
2
vendor/github.com/lunny/nodb/store/tx.go → vendor/gitea.com/lunny/nodb/store/tx.go
generated
vendored
@ -1,7 +1,7 @@ |
|||||||
package store |
package store |
||||||
|
|
||||||
import ( |
import ( |
||||||
"github.com/lunny/nodb/store/driver" |
"gitea.com/lunny/nodb/store/driver" |
||||||
) |
) |
||||||
|
|
||||||
type Tx struct { |
type Tx struct { |
||||||
@ -1,7 +1,7 @@ |
|||||||
package store |
package store |
||||||
|
|
||||||
import ( |
import ( |
||||||
"github.com/lunny/nodb/store/driver" |
"gitea.com/lunny/nodb/store/driver" |
||||||
) |
) |
||||||
|
|
||||||
type WriteBatch interface { |
type WriteBatch interface { |
||||||
@ -1,5 +0,0 @@ |
|||||||
TAGS |
|
||||||
tags |
|
||||||
.*.swp |
|
||||||
tomlcheck/tomlcheck |
|
||||||
toml.test |
|
||||||
@ -1,15 +0,0 @@ |
|||||||
language: go |
|
||||||
go: |
|
||||||
- 1.1 |
|
||||||
- 1.2 |
|
||||||
- 1.3 |
|
||||||
- 1.4 |
|
||||||
- 1.5 |
|
||||||
- 1.6 |
|
||||||
- tip |
|
||||||
install: |
|
||||||
- go install ./... |
|
||||||
- go get github.com/BurntSushi/toml-test |
|
||||||
script: |
|
||||||
- export PATH="$PATH:$HOME/gopath/bin" |
|
||||||
- make test |
|
||||||
@ -1,3 +0,0 @@ |
|||||||
Compatible with TOML version |
|
||||||
[v0.4.0](https://github.com/toml-lang/toml/blob/v0.4.0/versions/en/toml-v0.4.0.md) |
|
||||||
|
|
||||||
@ -1,21 +0,0 @@ |
|||||||
The MIT License (MIT) |
|
||||||
|
|
||||||
Copyright (c) 2013 TOML authors |
|
||||||
|
|
||||||
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. |
|
||||||
@ -1,19 +0,0 @@ |
|||||||
install: |
|
||||||
go install ./...
|
|
||||||
|
|
||||||
test: install |
|
||||||
go test -v
|
|
||||||
toml-test toml-test-decoder
|
|
||||||
toml-test -encoder toml-test-encoder
|
|
||||||
|
|
||||||
fmt: |
|
||||||
gofmt -w *.go */*.go
|
|
||||||
colcheck *.go */*.go
|
|
||||||
|
|
||||||
tags: |
|
||||||
find ./ -name '*.go' -print0 | xargs -0 gotags > TAGS
|
|
||||||
|
|
||||||
push: |
|
||||||
git push origin master
|
|
||||||
git push github master
|
|
||||||
|
|
||||||
@ -1,218 +0,0 @@ |
|||||||
## TOML parser and encoder for Go with reflection |
|
||||||
|
|
||||||
TOML stands for Tom's Obvious, Minimal Language. This Go package provides a |
|
||||||
reflection interface similar to Go's standard library `json` and `xml` |
|
||||||
packages. This package also supports the `encoding.TextUnmarshaler` and |
|
||||||
`encoding.TextMarshaler` interfaces so that you can define custom data |
|
||||||
representations. (There is an example of this below.) |
|
||||||
|
|
||||||
Spec: https://github.com/toml-lang/toml |
|
||||||
|
|
||||||
Compatible with TOML version |
|
||||||
[v0.4.0](https://github.com/toml-lang/toml/blob/master/versions/en/toml-v0.4.0.md) |
|
||||||
|
|
||||||
Documentation: https://godoc.org/github.com/BurntSushi/toml |
|
||||||
|
|
||||||
Installation: |
|
||||||
|
|
||||||
```bash |
|
||||||
go get github.com/BurntSushi/toml |
|
||||||
``` |
|
||||||
|
|
||||||
Try the toml validator: |
|
||||||
|
|
||||||
```bash |
|
||||||
go get github.com/BurntSushi/toml/cmd/tomlv |
|
||||||
tomlv some-toml-file.toml |
|
||||||
``` |
|
||||||
|
|
||||||
[](https://travis-ci.org/BurntSushi/toml) [](https://godoc.org/github.com/BurntSushi/toml) |
|
||||||
|
|
||||||
### Testing |
|
||||||
|
|
||||||
This package passes all tests in |
|
||||||
[toml-test](https://github.com/BurntSushi/toml-test) for both the decoder |
|
||||||
and the encoder. |
|
||||||
|
|
||||||
### Examples |
|
||||||
|
|
||||||
This package works similarly to how the Go standard library handles `XML` |
|
||||||
and `JSON`. Namely, data is loaded into Go values via reflection. |
|
||||||
|
|
||||||
For the simplest example, consider some TOML file as just a list of keys |
|
||||||
and values: |
|
||||||
|
|
||||||
```toml |
|
||||||
Age = 25 |
|
||||||
Cats = [ "Cauchy", "Plato" ] |
|
||||||
Pi = 3.14 |
|
||||||
Perfection = [ 6, 28, 496, 8128 ] |
|
||||||
DOB = 1987-07-05T05:45:00Z |
|
||||||
``` |
|
||||||
|
|
||||||
Which could be defined in Go as: |
|
||||||
|
|
||||||
```go |
|
||||||
type Config struct { |
|
||||||
Age int |
|
||||||
Cats []string |
|
||||||
Pi float64 |
|
||||||
Perfection []int |
|
||||||
DOB time.Time // requires `import time` |
|
||||||
} |
|
||||||
``` |
|
||||||
|
|
||||||
And then decoded with: |
|
||||||
|
|
||||||
```go |
|
||||||
var conf Config |
|
||||||
if _, err := toml.Decode(tomlData, &conf); err != nil { |
|
||||||
// handle error |
|
||||||
} |
|
||||||
``` |
|
||||||
|
|
||||||
You can also use struct tags if your struct field name doesn't map to a TOML |
|
||||||
key value directly: |
|
||||||
|
|
||||||
```toml |
|
||||||
some_key_NAME = "wat" |
|
||||||
``` |
|
||||||
|
|
||||||
```go |
|
||||||
type TOML struct { |
|
||||||
ObscureKey string `toml:"some_key_NAME"` |
|
||||||
} |
|
||||||
``` |
|
||||||
|
|
||||||
### Using the `encoding.TextUnmarshaler` interface |
|
||||||
|
|
||||||
Here's an example that automatically parses duration strings into |
|
||||||
`time.Duration` values: |
|
||||||
|
|
||||||
```toml |
|
||||||
[[song]] |
|
||||||
name = "Thunder Road" |
|
||||||
duration = "4m49s" |
|
||||||
|
|
||||||
[[song]] |
|
||||||
name = "Stairway to Heaven" |
|
||||||
duration = "8m03s" |
|
||||||
``` |
|
||||||
|
|
||||||
Which can be decoded with: |
|
||||||
|
|
||||||
```go |
|
||||||
type song struct { |
|
||||||
Name string |
|
||||||
Duration duration |
|
||||||
} |
|
||||||
type songs struct { |
|
||||||
Song []song |
|
||||||
} |
|
||||||
var favorites songs |
|
||||||
if _, err := toml.Decode(blob, &favorites); err != nil { |
|
||||||
log.Fatal(err) |
|
||||||
} |
|
||||||
|
|
||||||
for _, s := range favorites.Song { |
|
||||||
fmt.Printf("%s (%s)\n", s.Name, s.Duration) |
|
||||||
} |
|
||||||
``` |
|
||||||
|
|
||||||
And you'll also need a `duration` type that satisfies the |
|
||||||
`encoding.TextUnmarshaler` interface: |
|
||||||
|
|
||||||
```go |
|
||||||
type duration struct { |
|
||||||
time.Duration |
|
||||||
} |
|
||||||
|
|
||||||
func (d *duration) UnmarshalText(text []byte) error { |
|
||||||
var err error |
|
||||||
d.Duration, err = time.ParseDuration(string(text)) |
|
||||||
return err |
|
||||||
} |
|
||||||
``` |
|
||||||
|
|
||||||
### More complex usage |
|
||||||
|
|
||||||
Here's an example of how to load the example from the official spec page: |
|
||||||
|
|
||||||
```toml |
|
||||||
# This is a TOML document. Boom. |
|
||||||
|
|
||||||
title = "TOML Example" |
|
||||||
|
|
||||||
[owner] |
|
||||||
name = "Tom Preston-Werner" |
|
||||||
organization = "GitHub" |
|
||||||
bio = "GitHub Cofounder & CEO\nLikes tater tots and beer." |
|
||||||
dob = 1979-05-27T07:32:00Z # First class dates? Why not? |
|
||||||
|
|
||||||
[database] |
|
||||||
server = "192.168.1.1" |
|
||||||
ports = [ 8001, 8001, 8002 ] |
|
||||||
connection_max = 5000 |
|
||||||
enabled = true |
|
||||||
|
|
||||||
[servers] |
|
||||||
|
|
||||||
# You can indent as you please. Tabs or spaces. TOML don't care. |
|
||||||
[servers.alpha] |
|
||||||
ip = "10.0.0.1" |
|
||||||
dc = "eqdc10" |
|
||||||
|
|
||||||
[servers.beta] |
|
||||||
ip = "10.0.0.2" |
|
||||||
dc = "eqdc10" |
|
||||||
|
|
||||||
[clients] |
|
||||||
data = [ ["gamma", "delta"], [1, 2] ] # just an update to make sure parsers support it |
|
||||||
|
|
||||||
# Line breaks are OK when inside arrays |
|
||||||
hosts = [ |
|
||||||
"alpha", |
|
||||||
"omega" |
|
||||||
] |
|
||||||
``` |
|
||||||
|
|
||||||
And the corresponding Go types are: |
|
||||||
|
|
||||||
```go |
|
||||||
type tomlConfig struct { |
|
||||||
Title string |
|
||||||
Owner ownerInfo |
|
||||||
DB database `toml:"database"` |
|
||||||
Servers map[string]server |
|
||||||
Clients clients |
|
||||||
} |
|
||||||
|
|
||||||
type ownerInfo struct { |
|
||||||
Name string |
|
||||||
Org string `toml:"organization"` |
|
||||||
Bio string |
|
||||||
DOB time.Time |
|
||||||
} |
|
||||||
|
|
||||||
type database struct { |
|
||||||
Server string |
|
||||||
Ports []int |
|
||||||
ConnMax int `toml:"connection_max"` |
|
||||||
Enabled bool |
|
||||||
} |
|
||||||
|
|
||||||
type server struct { |
|
||||||
IP string |
|
||||||
DC string |
|
||||||
} |
|
||||||
|
|
||||||
type clients struct { |
|
||||||
Data [][]interface{} |
|
||||||
Hosts []string |
|
||||||
} |
|
||||||
``` |
|
||||||
|
|
||||||
Note that a case insensitive match will be tried if an exact match can't be |
|
||||||
found. |
|
||||||
|
|
||||||
A working example of the above can be found in `_examples/example.{go,toml}`. |
|
||||||
@ -1,509 +0,0 @@ |
|||||||
package toml |
|
||||||
|
|
||||||
import ( |
|
||||||
"fmt" |
|
||||||
"io" |
|
||||||
"io/ioutil" |
|
||||||
"math" |
|
||||||
"reflect" |
|
||||||
"strings" |
|
||||||
"time" |
|
||||||
) |
|
||||||
|
|
||||||
func e(format string, args ...interface{}) error { |
|
||||||
return fmt.Errorf("toml: "+format, args...) |
|
||||||
} |
|
||||||
|
|
||||||
// Unmarshaler is the interface implemented by objects that can unmarshal a
|
|
||||||
// TOML description of themselves.
|
|
||||||
type Unmarshaler interface { |
|
||||||
UnmarshalTOML(interface{}) error |
|
||||||
} |
|
||||||
|
|
||||||
// Unmarshal decodes the contents of `p` in TOML format into a pointer `v`.
|
|
||||||
func Unmarshal(p []byte, v interface{}) error { |
|
||||||
_, err := Decode(string(p), v) |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
// Primitive is a TOML value that hasn't been decoded into a Go value.
|
|
||||||
// When using the various `Decode*` functions, the type `Primitive` may
|
|
||||||
// be given to any value, and its decoding will be delayed.
|
|
||||||
//
|
|
||||||
// A `Primitive` value can be decoded using the `PrimitiveDecode` function.
|
|
||||||
//
|
|
||||||
// The underlying representation of a `Primitive` value is subject to change.
|
|
||||||
// Do not rely on it.
|
|
||||||
//
|
|
||||||
// N.B. Primitive values are still parsed, so using them will only avoid
|
|
||||||
// the overhead of reflection. They can be useful when you don't know the
|
|
||||||
// exact type of TOML data until run time.
|
|
||||||
type Primitive struct { |
|
||||||
undecoded interface{} |
|
||||||
context Key |
|
||||||
} |
|
||||||
|
|
||||||
// DEPRECATED!
|
|
||||||
//
|
|
||||||
// Use MetaData.PrimitiveDecode instead.
|
|
||||||
func PrimitiveDecode(primValue Primitive, v interface{}) error { |
|
||||||
md := MetaData{decoded: make(map[string]bool)} |
|
||||||
return md.unify(primValue.undecoded, rvalue(v)) |
|
||||||
} |
|
||||||
|
|
||||||
// PrimitiveDecode is just like the other `Decode*` functions, except it
|
|
||||||
// decodes a TOML value that has already been parsed. Valid primitive values
|
|
||||||
// can *only* be obtained from values filled by the decoder functions,
|
|
||||||
// including this method. (i.e., `v` may contain more `Primitive`
|
|
||||||
// values.)
|
|
||||||
//
|
|
||||||
// Meta data for primitive values is included in the meta data returned by
|
|
||||||
// the `Decode*` functions with one exception: keys returned by the Undecoded
|
|
||||||
// method will only reflect keys that were decoded. Namely, any keys hidden
|
|
||||||
// behind a Primitive will be considered undecoded. Executing this method will
|
|
||||||
// update the undecoded keys in the meta data. (See the example.)
|
|
||||||
func (md *MetaData) PrimitiveDecode(primValue Primitive, v interface{}) error { |
|
||||||
md.context = primValue.context |
|
||||||
defer func() { md.context = nil }() |
|
||||||
return md.unify(primValue.undecoded, rvalue(v)) |
|
||||||
} |
|
||||||
|
|
||||||
// Decode will decode the contents of `data` in TOML format into a pointer
|
|
||||||
// `v`.
|
|
||||||
//
|
|
||||||
// TOML hashes correspond to Go structs or maps. (Dealer's choice. They can be
|
|
||||||
// used interchangeably.)
|
|
||||||
//
|
|
||||||
// TOML arrays of tables correspond to either a slice of structs or a slice
|
|
||||||
// of maps.
|
|
||||||
//
|
|
||||||
// TOML datetimes correspond to Go `time.Time` values.
|
|
||||||
//
|
|
||||||
// All other TOML types (float, string, int, bool and array) correspond
|
|
||||||
// to the obvious Go types.
|
|
||||||
//
|
|
||||||
// An exception to the above rules is if a type implements the
|
|
||||||
// encoding.TextUnmarshaler interface. In this case, any primitive TOML value
|
|
||||||
// (floats, strings, integers, booleans and datetimes) will be converted to
|
|
||||||
// a byte string and given to the value's UnmarshalText method. See the
|
|
||||||
// Unmarshaler example for a demonstration with time duration strings.
|
|
||||||
//
|
|
||||||
// Key mapping
|
|
||||||
//
|
|
||||||
// TOML keys can map to either keys in a Go map or field names in a Go
|
|
||||||
// struct. The special `toml` struct tag may be used to map TOML keys to
|
|
||||||
// struct fields that don't match the key name exactly. (See the example.)
|
|
||||||
// A case insensitive match to struct names will be tried if an exact match
|
|
||||||
// can't be found.
|
|
||||||
//
|
|
||||||
// The mapping between TOML values and Go values is loose. That is, there
|
|
||||||
// may exist TOML values that cannot be placed into your representation, and
|
|
||||||
// there may be parts of your representation that do not correspond to
|
|
||||||
// TOML values. This loose mapping can be made stricter by using the IsDefined
|
|
||||||
// and/or Undecoded methods on the MetaData returned.
|
|
||||||
//
|
|
||||||
// This decoder will not handle cyclic types. If a cyclic type is passed,
|
|
||||||
// `Decode` will not terminate.
|
|
||||||
func Decode(data string, v interface{}) (MetaData, error) { |
|
||||||
rv := reflect.ValueOf(v) |
|
||||||
if rv.Kind() != reflect.Ptr { |
|
||||||
return MetaData{}, e("Decode of non-pointer %s", reflect.TypeOf(v)) |
|
||||||
} |
|
||||||
if rv.IsNil() { |
|
||||||
return MetaData{}, e("Decode of nil %s", reflect.TypeOf(v)) |
|
||||||
} |
|
||||||
p, err := parse(data) |
|
||||||
if err != nil { |
|
||||||
return MetaData{}, err |
|
||||||
} |
|
||||||
md := MetaData{ |
|
||||||
p.mapping, p.types, p.ordered, |
|
||||||
make(map[string]bool, len(p.ordered)), nil, |
|
||||||
} |
|
||||||
return md, md.unify(p.mapping, indirect(rv)) |
|
||||||
} |
|
||||||
|
|
||||||
// DecodeFile is just like Decode, except it will automatically read the
|
|
||||||
// contents of the file at `fpath` and decode it for you.
|
|
||||||
func DecodeFile(fpath string, v interface{}) (MetaData, error) { |
|
||||||
bs, err := ioutil.ReadFile(fpath) |
|
||||||
if err != nil { |
|
||||||
return MetaData{}, err |
|
||||||
} |
|
||||||
return Decode(string(bs), v) |
|
||||||
} |
|
||||||
|
|
||||||
// DecodeReader is just like Decode, except it will consume all bytes
|
|
||||||
// from the reader and decode it for you.
|
|
||||||
func DecodeReader(r io.Reader, v interface{}) (MetaData, error) { |
|
||||||
bs, err := ioutil.ReadAll(r) |
|
||||||
if err != nil { |
|
||||||
return MetaData{}, err |
|
||||||
} |
|
||||||
return Decode(string(bs), v) |
|
||||||
} |
|
||||||
|
|
||||||
// unify performs a sort of type unification based on the structure of `rv`,
|
|
||||||
// which is the client representation.
|
|
||||||
//
|
|
||||||
// Any type mismatch produces an error. Finding a type that we don't know
|
|
||||||
// how to handle produces an unsupported type error.
|
|
||||||
func (md *MetaData) unify(data interface{}, rv reflect.Value) error { |
|
||||||
|
|
||||||
// Special case. Look for a `Primitive` value.
|
|
||||||
if rv.Type() == reflect.TypeOf((*Primitive)(nil)).Elem() { |
|
||||||
// Save the undecoded data and the key context into the primitive
|
|
||||||
// value.
|
|
||||||
context := make(Key, len(md.context)) |
|
||||||
copy(context, md.context) |
|
||||||
rv.Set(reflect.ValueOf(Primitive{ |
|
||||||
undecoded: data, |
|
||||||
context: context, |
|
||||||
})) |
|
||||||
return nil |
|
||||||
} |
|
||||||
|
|
||||||
// Special case. Unmarshaler Interface support.
|
|
||||||
if rv.CanAddr() { |
|
||||||
if v, ok := rv.Addr().Interface().(Unmarshaler); ok { |
|
||||||
return v.UnmarshalTOML(data) |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
// Special case. Handle time.Time values specifically.
|
|
||||||
// TODO: Remove this code when we decide to drop support for Go 1.1.
|
|
||||||
// This isn't necessary in Go 1.2 because time.Time satisfies the encoding
|
|
||||||
// interfaces.
|
|
||||||
if rv.Type().AssignableTo(rvalue(time.Time{}).Type()) { |
|
||||||
return md.unifyDatetime(data, rv) |
|
||||||
} |
|
||||||
|
|
||||||
// Special case. Look for a value satisfying the TextUnmarshaler interface.
|
|
||||||
if v, ok := rv.Interface().(TextUnmarshaler); ok { |
|
||||||
return md.unifyText(data, v) |
|
||||||
} |
|
||||||
// BUG(burntsushi)
|
|
||||||
// The behavior here is incorrect whenever a Go type satisfies the
|
|
||||||
// encoding.TextUnmarshaler interface but also corresponds to a TOML
|
|
||||||
// hash or array. In particular, the unmarshaler should only be applied
|
|
||||||
// to primitive TOML values. But at this point, it will be applied to
|
|
||||||
// all kinds of values and produce an incorrect error whenever those values
|
|
||||||
// are hashes or arrays (including arrays of tables).
|
|
||||||
|
|
||||||
k := rv.Kind() |
|
||||||
|
|
||||||
// laziness
|
|
||||||
if k >= reflect.Int && k <= reflect.Uint64 { |
|
||||||
return md.unifyInt(data, rv) |
|
||||||
} |
|
||||||
switch k { |
|
||||||
case reflect.Ptr: |
|
||||||
elem := reflect.New(rv.Type().Elem()) |
|
||||||
err := md.unify(data, reflect.Indirect(elem)) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
rv.Set(elem) |
|
||||||
return nil |
|
||||||
case reflect.Struct: |
|
||||||
return md.unifyStruct(data, rv) |
|
||||||
case reflect.Map: |
|
||||||
return md.unifyMap(data, rv) |
|
||||||
case reflect.Array: |
|
||||||
return md.unifyArray(data, rv) |
|
||||||
case reflect.Slice: |
|
||||||
return md.unifySlice(data, rv) |
|
||||||
case reflect.String: |
|
||||||
return md.unifyString(data, rv) |
|
||||||
case reflect.Bool: |
|
||||||
return md.unifyBool(data, rv) |
|
||||||
case reflect.Interface: |
|
||||||
// we only support empty interfaces.
|
|
||||||
if rv.NumMethod() > 0 { |
|
||||||
return e("unsupported type %s", rv.Type()) |
|
||||||
} |
|
||||||
return md.unifyAnything(data, rv) |
|
||||||
case reflect.Float32: |
|
||||||
fallthrough |
|
||||||
case reflect.Float64: |
|
||||||
return md.unifyFloat64(data, rv) |
|
||||||
} |
|
||||||
return e("unsupported type %s", rv.Kind()) |
|
||||||
} |
|
||||||
|
|
||||||
func (md *MetaData) unifyStruct(mapping interface{}, rv reflect.Value) error { |
|
||||||
tmap, ok := mapping.(map[string]interface{}) |
|
||||||
if !ok { |
|
||||||
if mapping == nil { |
|
||||||
return nil |
|
||||||
} |
|
||||||
return e("type mismatch for %s: expected table but found %T", |
|
||||||
rv.Type().String(), mapping) |
|
||||||
} |
|
||||||
|
|
||||||
for key, datum := range tmap { |
|
||||||
var f *field |
|
||||||
fields := cachedTypeFields(rv.Type()) |
|
||||||
for i := range fields { |
|
||||||
ff := &fields[i] |
|
||||||
if ff.name == key { |
|
||||||
f = ff |
|
||||||
break |
|
||||||
} |
|
||||||
if f == nil && strings.EqualFold(ff.name, key) { |
|
||||||
f = ff |
|
||||||
} |
|
||||||
} |
|
||||||
if f != nil { |
|
||||||
subv := rv |
|
||||||
for _, i := range f.index { |
|
||||||
subv = indirect(subv.Field(i)) |
|
||||||
} |
|
||||||
if isUnifiable(subv) { |
|
||||||
md.decoded[md.context.add(key).String()] = true |
|
||||||
md.context = append(md.context, key) |
|
||||||
if err := md.unify(datum, subv); err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
md.context = md.context[0 : len(md.context)-1] |
|
||||||
} else if f.name != "" { |
|
||||||
// Bad user! No soup for you!
|
|
||||||
return e("cannot write unexported field %s.%s", |
|
||||||
rv.Type().String(), f.name) |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
return nil |
|
||||||
} |
|
||||||
|
|
||||||
func (md *MetaData) unifyMap(mapping interface{}, rv reflect.Value) error { |
|
||||||
tmap, ok := mapping.(map[string]interface{}) |
|
||||||
if !ok { |
|
||||||
if tmap == nil { |
|
||||||
return nil |
|
||||||
} |
|
||||||
return badtype("map", mapping) |
|
||||||
} |
|
||||||
if rv.IsNil() { |
|
||||||
rv.Set(reflect.MakeMap(rv.Type())) |
|
||||||
} |
|
||||||
for k, v := range tmap { |
|
||||||
md.decoded[md.context.add(k).String()] = true |
|
||||||
md.context = append(md.context, k) |
|
||||||
|
|
||||||
rvkey := indirect(reflect.New(rv.Type().Key())) |
|
||||||
rvval := reflect.Indirect(reflect.New(rv.Type().Elem())) |
|
||||||
if err := md.unify(v, rvval); err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
md.context = md.context[0 : len(md.context)-1] |
|
||||||
|
|
||||||
rvkey.SetString(k) |
|
||||||
rv.SetMapIndex(rvkey, rvval) |
|
||||||
} |
|
||||||
return nil |
|
||||||
} |
|
||||||
|
|
||||||
func (md *MetaData) unifyArray(data interface{}, rv reflect.Value) error { |
|
||||||
datav := reflect.ValueOf(data) |
|
||||||
if datav.Kind() != reflect.Slice { |
|
||||||
if !datav.IsValid() { |
|
||||||
return nil |
|
||||||
} |
|
||||||
return badtype("slice", data) |
|
||||||
} |
|
||||||
sliceLen := datav.Len() |
|
||||||
if sliceLen != rv.Len() { |
|
||||||
return e("expected array length %d; got TOML array of length %d", |
|
||||||
rv.Len(), sliceLen) |
|
||||||
} |
|
||||||
return md.unifySliceArray(datav, rv) |
|
||||||
} |
|
||||||
|
|
||||||
func (md *MetaData) unifySlice(data interface{}, rv reflect.Value) error { |
|
||||||
datav := reflect.ValueOf(data) |
|
||||||
if datav.Kind() != reflect.Slice { |
|
||||||
if !datav.IsValid() { |
|
||||||
return nil |
|
||||||
} |
|
||||||
return badtype("slice", data) |
|
||||||
} |
|
||||||
n := datav.Len() |
|
||||||
if rv.IsNil() || rv.Cap() < n { |
|
||||||
rv.Set(reflect.MakeSlice(rv.Type(), n, n)) |
|
||||||
} |
|
||||||
rv.SetLen(n) |
|
||||||
return md.unifySliceArray(datav, rv) |
|
||||||
} |
|
||||||
|
|
||||||
func (md *MetaData) unifySliceArray(data, rv reflect.Value) error { |
|
||||||
sliceLen := data.Len() |
|
||||||
for i := 0; i < sliceLen; i++ { |
|
||||||
v := data.Index(i).Interface() |
|
||||||
sliceval := indirect(rv.Index(i)) |
|
||||||
if err := md.unify(v, sliceval); err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
} |
|
||||||
return nil |
|
||||||
} |
|
||||||
|
|
||||||
func (md *MetaData) unifyDatetime(data interface{}, rv reflect.Value) error { |
|
||||||
if _, ok := data.(time.Time); ok { |
|
||||||
rv.Set(reflect.ValueOf(data)) |
|
||||||
return nil |
|
||||||
} |
|
||||||
return badtype("time.Time", data) |
|
||||||
} |
|
||||||
|
|
||||||
func (md *MetaData) unifyString(data interface{}, rv reflect.Value) error { |
|
||||||
if s, ok := data.(string); ok { |
|
||||||
rv.SetString(s) |
|
||||||
return nil |
|
||||||
} |
|
||||||
return badtype("string", data) |
|
||||||
} |
|
||||||
|
|
||||||
func (md *MetaData) unifyFloat64(data interface{}, rv reflect.Value) error { |
|
||||||
if num, ok := data.(float64); ok { |
|
||||||
switch rv.Kind() { |
|
||||||
case reflect.Float32: |
|
||||||
fallthrough |
|
||||||
case reflect.Float64: |
|
||||||
rv.SetFloat(num) |
|
||||||
default: |
|
||||||
panic("bug") |
|
||||||
} |
|
||||||
return nil |
|
||||||
} |
|
||||||
return badtype("float", data) |
|
||||||
} |
|
||||||
|
|
||||||
func (md *MetaData) unifyInt(data interface{}, rv reflect.Value) error { |
|
||||||
if num, ok := data.(int64); ok { |
|
||||||
if rv.Kind() >= reflect.Int && rv.Kind() <= reflect.Int64 { |
|
||||||
switch rv.Kind() { |
|
||||||
case reflect.Int, reflect.Int64: |
|
||||||
// No bounds checking necessary.
|
|
||||||
case reflect.Int8: |
|
||||||
if num < math.MinInt8 || num > math.MaxInt8 { |
|
||||||
return e("value %d is out of range for int8", num) |
|
||||||
} |
|
||||||
case reflect.Int16: |
|
||||||
if num < math.MinInt16 || num > math.MaxInt16 { |
|
||||||
return e("value %d is out of range for int16", num) |
|
||||||
} |
|
||||||
case reflect.Int32: |
|
||||||
if num < math.MinInt32 || num > math.MaxInt32 { |
|
||||||
return e("value %d is out of range for int32", num) |
|
||||||
} |
|
||||||
} |
|
||||||
rv.SetInt(num) |
|
||||||
} else if rv.Kind() >= reflect.Uint && rv.Kind() <= reflect.Uint64 { |
|
||||||
unum := uint64(num) |
|
||||||
switch rv.Kind() { |
|
||||||
case reflect.Uint, reflect.Uint64: |
|
||||||
// No bounds checking necessary.
|
|
||||||
case reflect.Uint8: |
|
||||||
if num < 0 || unum > math.MaxUint8 { |
|
||||||
return e("value %d is out of range for uint8", num) |
|
||||||
} |
|
||||||
case reflect.Uint16: |
|
||||||
if num < 0 || unum > math.MaxUint16 { |
|
||||||
return e("value %d is out of range for uint16", num) |
|
||||||
} |
|
||||||
case reflect.Uint32: |
|
||||||
if num < 0 || unum > math.MaxUint32 { |
|
||||||
return e("value %d is out of range for uint32", num) |
|
||||||
} |
|
||||||
} |
|
||||||
rv.SetUint(unum) |
|
||||||
} else { |
|
||||||
panic("unreachable") |
|
||||||
} |
|
||||||
return nil |
|
||||||
} |
|
||||||
return badtype("integer", data) |
|
||||||
} |
|
||||||
|
|
||||||
func (md *MetaData) unifyBool(data interface{}, rv reflect.Value) error { |
|
||||||
if b, ok := data.(bool); ok { |
|
||||||
rv.SetBool(b) |
|
||||||
return nil |
|
||||||
} |
|
||||||
return badtype("boolean", data) |
|
||||||
} |
|
||||||
|
|
||||||
func (md *MetaData) unifyAnything(data interface{}, rv reflect.Value) error { |
|
||||||
rv.Set(reflect.ValueOf(data)) |
|
||||||
return nil |
|
||||||
} |
|
||||||
|
|
||||||
func (md *MetaData) unifyText(data interface{}, v TextUnmarshaler) error { |
|
||||||
var s string |
|
||||||
switch sdata := data.(type) { |
|
||||||
case TextMarshaler: |
|
||||||
text, err := sdata.MarshalText() |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
s = string(text) |
|
||||||
case fmt.Stringer: |
|
||||||
s = sdata.String() |
|
||||||
case string: |
|
||||||
s = sdata |
|
||||||
case bool: |
|
||||||
s = fmt.Sprintf("%v", sdata) |
|
||||||
case int64: |
|
||||||
s = fmt.Sprintf("%d", sdata) |
|
||||||
case float64: |
|
||||||
s = fmt.Sprintf("%f", sdata) |
|
||||||
default: |
|
||||||
return badtype("primitive (string-like)", data) |
|
||||||
} |
|
||||||
if err := v.UnmarshalText([]byte(s)); err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
return nil |
|
||||||
} |
|
||||||
|
|
||||||
// rvalue returns a reflect.Value of `v`. All pointers are resolved.
|
|
||||||
func rvalue(v interface{}) reflect.Value { |
|
||||||
return indirect(reflect.ValueOf(v)) |
|
||||||
} |
|
||||||
|
|
||||||
// indirect returns the value pointed to by a pointer.
|
|
||||||
// Pointers are followed until the value is not a pointer.
|
|
||||||
// New values are allocated for each nil pointer.
|
|
||||||
//
|
|
||||||
// An exception to this rule is if the value satisfies an interface of
|
|
||||||
// interest to us (like encoding.TextUnmarshaler).
|
|
||||||
func indirect(v reflect.Value) reflect.Value { |
|
||||||
if v.Kind() != reflect.Ptr { |
|
||||||
if v.CanSet() { |
|
||||||
pv := v.Addr() |
|
||||||
if _, ok := pv.Interface().(TextUnmarshaler); ok { |
|
||||||
return pv |
|
||||||
} |
|
||||||
} |
|
||||||
return v |
|
||||||
} |
|
||||||
if v.IsNil() { |
|
||||||
v.Set(reflect.New(v.Type().Elem())) |
|
||||||
} |
|
||||||
return indirect(reflect.Indirect(v)) |
|
||||||
} |
|
||||||
|
|
||||||
func isUnifiable(rv reflect.Value) bool { |
|
||||||
if rv.CanSet() { |
|
||||||
return true |
|
||||||
} |
|
||||||
if _, ok := rv.Interface().(TextUnmarshaler); ok { |
|
||||||
return true |
|
||||||
} |
|
||||||
return false |
|
||||||
} |
|
||||||
|
|
||||||
func badtype(expected string, data interface{}) error { |
|
||||||
return e("cannot load TOML value of type %T into a Go %s", data, expected) |
|
||||||
} |
|
||||||
@ -1,121 +0,0 @@ |
|||||||
package toml |
|
||||||
|
|
||||||
import "strings" |
|
||||||
|
|
||||||
// MetaData allows access to meta information about TOML data that may not
|
|
||||||
// be inferrable via reflection. In particular, whether a key has been defined
|
|
||||||
// and the TOML type of a key.
|
|
||||||
type MetaData struct { |
|
||||||
mapping map[string]interface{} |
|
||||||
types map[string]tomlType |
|
||||||
keys []Key |
|
||||||
decoded map[string]bool |
|
||||||
context Key // Used only during decoding.
|
|
||||||
} |
|
||||||
|
|
||||||
// IsDefined returns true if the key given exists in the TOML data. The key
|
|
||||||
// should be specified hierarchially. e.g.,
|
|
||||||
//
|
|
||||||
// // access the TOML key 'a.b.c'
|
|
||||||
// IsDefined("a", "b", "c")
|
|
||||||
//
|
|
||||||
// IsDefined will return false if an empty key given. Keys are case sensitive.
|
|
||||||
func (md *MetaData) IsDefined(key ...string) bool { |
|
||||||
if len(key) == 0 { |
|
||||||
return false |
|
||||||
} |
|
||||||
|
|
||||||
var hash map[string]interface{} |
|
||||||
var ok bool |
|
||||||
var hashOrVal interface{} = md.mapping |
|
||||||
for _, k := range key { |
|
||||||
if hash, ok = hashOrVal.(map[string]interface{}); !ok { |
|
||||||
return false |
|
||||||
} |
|
||||||
if hashOrVal, ok = hash[k]; !ok { |
|
||||||
return false |
|
||||||
} |
|
||||||
} |
|
||||||
return true |
|
||||||
} |
|
||||||
|
|
||||||
// Type returns a string representation of the type of the key specified.
|
|
||||||
//
|
|
||||||
// Type will return the empty string if given an empty key or a key that
|
|
||||||
// does not exist. Keys are case sensitive.
|
|
||||||
func (md *MetaData) Type(key ...string) string { |
|
||||||
fullkey := strings.Join(key, ".") |
|
||||||
if typ, ok := md.types[fullkey]; ok { |
|
||||||
return typ.typeString() |
|
||||||
} |
|
||||||
return "" |
|
||||||
} |
|
||||||
|
|
||||||
// Key is the type of any TOML key, including key groups. Use (MetaData).Keys
|
|
||||||
// to get values of this type.
|
|
||||||
type Key []string |
|
||||||
|
|
||||||
func (k Key) String() string { |
|
||||||
return strings.Join(k, ".") |
|
||||||
} |
|
||||||
|
|
||||||
func (k Key) maybeQuotedAll() string { |
|
||||||
var ss []string |
|
||||||
for i := range k { |
|
||||||
ss = append(ss, k.maybeQuoted(i)) |
|
||||||
} |
|
||||||
return strings.Join(ss, ".") |
|
||||||
} |
|
||||||
|
|
||||||
func (k Key) maybeQuoted(i int) string { |
|
||||||
quote := false |
|
||||||
for _, c := range k[i] { |
|
||||||
if !isBareKeyChar(c) { |
|
||||||
quote = true |
|
||||||
break |
|
||||||
} |
|
||||||
} |
|
||||||
if quote { |
|
||||||
return "\"" + strings.Replace(k[i], "\"", "\\\"", -1) + "\"" |
|
||||||
} |
|
||||||
return k[i] |
|
||||||
} |
|
||||||
|
|
||||||
func (k Key) add(piece string) Key { |
|
||||||
newKey := make(Key, len(k)+1) |
|
||||||
copy(newKey, k) |
|
||||||
newKey[len(k)] = piece |
|
||||||
return newKey |
|
||||||
} |
|
||||||
|
|
||||||
// Keys returns a slice of every key in the TOML data, including key groups.
|
|
||||||
// Each key is itself a slice, where the first element is the top of the
|
|
||||||
// hierarchy and the last is the most specific.
|
|
||||||
//
|
|
||||||
// The list will have the same order as the keys appeared in the TOML data.
|
|
||||||
//
|
|
||||||
// All keys returned are non-empty.
|
|
||||||
func (md *MetaData) Keys() []Key { |
|
||||||
return md.keys |
|
||||||
} |
|
||||||
|
|
||||||
// Undecoded returns all keys that have not been decoded in the order in which
|
|
||||||
// they appear in the original TOML document.
|
|
||||||
//
|
|
||||||
// This includes keys that haven't been decoded because of a Primitive value.
|
|
||||||
// Once the Primitive value is decoded, the keys will be considered decoded.
|
|
||||||
//
|
|
||||||
// Also note that decoding into an empty interface will result in no decoding,
|
|
||||||
// and so no keys will be considered decoded.
|
|
||||||
//
|
|
||||||
// In this sense, the Undecoded keys correspond to keys in the TOML document
|
|
||||||
// that do not have a concrete type in your representation.
|
|
||||||
func (md *MetaData) Undecoded() []Key { |
|
||||||
undecoded := make([]Key, 0, len(md.keys)) |
|
||||||
for _, key := range md.keys { |
|
||||||
if !md.decoded[key.String()] { |
|
||||||
undecoded = append(undecoded, key) |
|
||||||
} |
|
||||||
} |
|
||||||
return undecoded |
|
||||||
} |
|
||||||
@ -1,27 +0,0 @@ |
|||||||
/* |
|
||||||
Package toml provides facilities for decoding and encoding TOML configuration |
|
||||||
files via reflection. There is also support for delaying decoding with |
|
||||||
the Primitive type, and querying the set of keys in a TOML document with the |
|
||||||
MetaData type. |
|
||||||
|
|
||||||
The specification implemented: https://github.com/toml-lang/toml
|
|
||||||
|
|
||||||
The sub-command github.com/BurntSushi/toml/cmd/tomlv can be used to verify |
|
||||||
whether a file is a valid TOML document. It can also be used to print the |
|
||||||
type of each key in a TOML document. |
|
||||||
|
|
||||||
Testing |
|
||||||
|
|
||||||
There are two important types of tests used for this package. The first is |
|
||||||
contained inside '*_test.go' files and uses the standard Go unit testing |
|
||||||
framework. These tests are primarily devoted to holistically testing the |
|
||||||
decoder and encoder. |
|
||||||
|
|
||||||
The second type of testing is used to verify the implementation's adherence |
|
||||||
to the TOML specification. These tests have been factored into their own |
|
||||||
project: https://github.com/BurntSushi/toml-test
|
|
||||||
|
|
||||||
The reason the tests are in a separate project is so that they can be used by |
|
||||||
any implementation of TOML. Namely, it is language agnostic. |
|
||||||
*/ |
|
||||||
package toml |
|
||||||
@ -1,568 +0,0 @@ |
|||||||
package toml |
|
||||||
|
|
||||||
import ( |
|
||||||
"bufio" |
|
||||||
"errors" |
|
||||||
"fmt" |
|
||||||
"io" |
|
||||||
"reflect" |
|
||||||
"sort" |
|
||||||
"strconv" |
|
||||||
"strings" |
|
||||||
"time" |
|
||||||
) |
|
||||||
|
|
||||||
type tomlEncodeError struct{ error } |
|
||||||
|
|
||||||
var ( |
|
||||||
errArrayMixedElementTypes = errors.New( |
|
||||||
"toml: cannot encode array with mixed element types") |
|
||||||
errArrayNilElement = errors.New( |
|
||||||
"toml: cannot encode array with nil element") |
|
||||||
errNonString = errors.New( |
|
||||||
"toml: cannot encode a map with non-string key type") |
|
||||||
errAnonNonStruct = errors.New( |
|
||||||
"toml: cannot encode an anonymous field that is not a struct") |
|
||||||
errArrayNoTable = errors.New( |
|
||||||
"toml: TOML array element cannot contain a table") |
|
||||||
errNoKey = errors.New( |
|
||||||
"toml: top-level values must be Go maps or structs") |
|
||||||
errAnything = errors.New("") // used in testing
|
|
||||||
) |
|
||||||
|
|
||||||
var quotedReplacer = strings.NewReplacer( |
|
||||||
"\t", "\\t", |
|
||||||
"\n", "\\n", |
|
||||||
"\r", "\\r", |
|
||||||
"\"", "\\\"", |
|
||||||
"\\", "\\\\", |
|
||||||
) |
|
||||||
|
|
||||||
// Encoder controls the encoding of Go values to a TOML document to some
|
|
||||||
// io.Writer.
|
|
||||||
//
|
|
||||||
// The indentation level can be controlled with the Indent field.
|
|
||||||
type Encoder struct { |
|
||||||
// A single indentation level. By default it is two spaces.
|
|
||||||
Indent string |
|
||||||
|
|
||||||
// hasWritten is whether we have written any output to w yet.
|
|
||||||
hasWritten bool |
|
||||||
w *bufio.Writer |
|
||||||
} |
|
||||||
|
|
||||||
// NewEncoder returns a TOML encoder that encodes Go values to the io.Writer
|
|
||||||
// given. By default, a single indentation level is 2 spaces.
|
|
||||||
func NewEncoder(w io.Writer) *Encoder { |
|
||||||
return &Encoder{ |
|
||||||
w: bufio.NewWriter(w), |
|
||||||
Indent: " ", |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
// Encode writes a TOML representation of the Go value to the underlying
|
|
||||||
// io.Writer. If the value given cannot be encoded to a valid TOML document,
|
|
||||||
// then an error is returned.
|
|
||||||
//
|
|
||||||
// The mapping between Go values and TOML values should be precisely the same
|
|
||||||
// as for the Decode* functions. Similarly, the TextMarshaler interface is
|
|
||||||
// supported by encoding the resulting bytes as strings. (If you want to write
|
|
||||||
// arbitrary binary data then you will need to use something like base64 since
|
|
||||||
// TOML does not have any binary types.)
|
|
||||||
//
|
|
||||||
// When encoding TOML hashes (i.e., Go maps or structs), keys without any
|
|
||||||
// sub-hashes are encoded first.
|
|
||||||
//
|
|
||||||
// If a Go map is encoded, then its keys are sorted alphabetically for
|
|
||||||
// deterministic output. More control over this behavior may be provided if
|
|
||||||
// there is demand for it.
|
|
||||||
//
|
|
||||||
// Encoding Go values without a corresponding TOML representation---like map
|
|
||||||
// types with non-string keys---will cause an error to be returned. Similarly
|
|
||||||
// for mixed arrays/slices, arrays/slices with nil elements, embedded
|
|
||||||
// non-struct types and nested slices containing maps or structs.
|
|
||||||
// (e.g., [][]map[string]string is not allowed but []map[string]string is OK
|
|
||||||
// and so is []map[string][]string.)
|
|
||||||
func (enc *Encoder) Encode(v interface{}) error { |
|
||||||
rv := eindirect(reflect.ValueOf(v)) |
|
||||||
if err := enc.safeEncode(Key([]string{}), rv); err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
return enc.w.Flush() |
|
||||||
} |
|
||||||
|
|
||||||
func (enc *Encoder) safeEncode(key Key, rv reflect.Value) (err error) { |
|
||||||
defer func() { |
|
||||||
if r := recover(); r != nil { |
|
||||||
if terr, ok := r.(tomlEncodeError); ok { |
|
||||||
err = terr.error |
|
||||||
return |
|
||||||
} |
|
||||||
panic(r) |
|
||||||
} |
|
||||||
}() |
|
||||||
enc.encode(key, rv) |
|
||||||
return nil |
|
||||||
} |
|
||||||
|
|
||||||
func (enc *Encoder) encode(key Key, rv reflect.Value) { |
|
||||||
// Special case. Time needs to be in ISO8601 format.
|
|
||||||
// Special case. If we can marshal the type to text, then we used that.
|
|
||||||
// Basically, this prevents the encoder for handling these types as
|
|
||||||
// generic structs (or whatever the underlying type of a TextMarshaler is).
|
|
||||||
switch rv.Interface().(type) { |
|
||||||
case time.Time, TextMarshaler: |
|
||||||
enc.keyEqElement(key, rv) |
|
||||||
return |
|
||||||
} |
|
||||||
|
|
||||||
k := rv.Kind() |
|
||||||
switch k { |
|
||||||
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, |
|
||||||
reflect.Int64, |
|
||||||
reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, |
|
||||||
reflect.Uint64, |
|
||||||
reflect.Float32, reflect.Float64, reflect.String, reflect.Bool: |
|
||||||
enc.keyEqElement(key, rv) |
|
||||||
case reflect.Array, reflect.Slice: |
|
||||||
if typeEqual(tomlArrayHash, tomlTypeOfGo(rv)) { |
|
||||||
enc.eArrayOfTables(key, rv) |
|
||||||
} else { |
|
||||||
enc.keyEqElement(key, rv) |
|
||||||
} |
|
||||||
case reflect.Interface: |
|
||||||
if rv.IsNil() { |
|
||||||
return |
|
||||||
} |
|
||||||
enc.encode(key, rv.Elem()) |
|
||||||
case reflect.Map: |
|
||||||
if rv.IsNil() { |
|
||||||
return |
|
||||||
} |
|
||||||
enc.eTable(key, rv) |
|
||||||
case reflect.Ptr: |
|
||||||
if rv.IsNil() { |
|
||||||
return |
|
||||||
} |
|
||||||
enc.encode(key, rv.Elem()) |
|
||||||
case reflect.Struct: |
|
||||||
enc.eTable(key, rv) |
|
||||||
default: |
|
||||||
panic(e("unsupported type for key '%s': %s", key, k)) |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
// eElement encodes any value that can be an array element (primitives and
|
|
||||||
// arrays).
|
|
||||||
func (enc *Encoder) eElement(rv reflect.Value) { |
|
||||||
switch v := rv.Interface().(type) { |
|
||||||
case time.Time: |
|
||||||
// Special case time.Time as a primitive. Has to come before
|
|
||||||
// TextMarshaler below because time.Time implements
|
|
||||||
// encoding.TextMarshaler, but we need to always use UTC.
|
|
||||||
enc.wf(v.UTC().Format("2006-01-02T15:04:05Z")) |
|
||||||
return |
|
||||||
case TextMarshaler: |
|
||||||
// Special case. Use text marshaler if it's available for this value.
|
|
||||||
if s, err := v.MarshalText(); err != nil { |
|
||||||
encPanic(err) |
|
||||||
} else { |
|
||||||
enc.writeQuoted(string(s)) |
|
||||||
} |
|
||||||
return |
|
||||||
} |
|
||||||
switch rv.Kind() { |
|
||||||
case reflect.Bool: |
|
||||||
enc.wf(strconv.FormatBool(rv.Bool())) |
|
||||||
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, |
|
||||||
reflect.Int64: |
|
||||||
enc.wf(strconv.FormatInt(rv.Int(), 10)) |
|
||||||
case reflect.Uint, reflect.Uint8, reflect.Uint16, |
|
||||||
reflect.Uint32, reflect.Uint64: |
|
||||||
enc.wf(strconv.FormatUint(rv.Uint(), 10)) |
|
||||||
case reflect.Float32: |
|
||||||
enc.wf(floatAddDecimal(strconv.FormatFloat(rv.Float(), 'f', -1, 32))) |
|
||||||
case reflect.Float64: |
|
||||||
enc.wf(floatAddDecimal(strconv.FormatFloat(rv.Float(), 'f', -1, 64))) |
|
||||||
case reflect.Array, reflect.Slice: |
|
||||||
enc.eArrayOrSliceElement(rv) |
|
||||||
case reflect.Interface: |
|
||||||
enc.eElement(rv.Elem()) |
|
||||||
case reflect.String: |
|
||||||
enc.writeQuoted(rv.String()) |
|
||||||
default: |
|
||||||
panic(e("unexpected primitive type: %s", rv.Kind())) |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
// By the TOML spec, all floats must have a decimal with at least one
|
|
||||||
// number on either side.
|
|
||||||
func floatAddDecimal(fstr string) string { |
|
||||||
if !strings.Contains(fstr, ".") { |
|
||||||
return fstr + ".0" |
|
||||||
} |
|
||||||
return fstr |
|
||||||
} |
|
||||||
|
|
||||||
func (enc *Encoder) writeQuoted(s string) { |
|
||||||
enc.wf("\"%s\"", quotedReplacer.Replace(s)) |
|
||||||
} |
|
||||||
|
|
||||||
func (enc *Encoder) eArrayOrSliceElement(rv reflect.Value) { |
|
||||||
length := rv.Len() |
|
||||||
enc.wf("[") |
|
||||||
for i := 0; i < length; i++ { |
|
||||||
elem := rv.Index(i) |
|
||||||
enc.eElement(elem) |
|
||||||
if i != length-1 { |
|
||||||
enc.wf(", ") |
|
||||||
} |
|
||||||
} |
|
||||||
enc.wf("]") |
|
||||||
} |
|
||||||
|
|
||||||
func (enc *Encoder) eArrayOfTables(key Key, rv reflect.Value) { |
|
||||||
if len(key) == 0 { |
|
||||||
encPanic(errNoKey) |
|
||||||
} |
|
||||||
for i := 0; i < rv.Len(); i++ { |
|
||||||
trv := rv.Index(i) |
|
||||||
if isNil(trv) { |
|
||||||
continue |
|
||||||
} |
|
||||||
panicIfInvalidKey(key) |
|
||||||
enc.newline() |
|
||||||
enc.wf("%s[[%s]]", enc.indentStr(key), key.maybeQuotedAll()) |
|
||||||
enc.newline() |
|
||||||
enc.eMapOrStruct(key, trv) |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
func (enc *Encoder) eTable(key Key, rv reflect.Value) { |
|
||||||
panicIfInvalidKey(key) |
|
||||||
if len(key) == 1 { |
|
||||||
// Output an extra newline between top-level tables.
|
|
||||||
// (The newline isn't written if nothing else has been written though.)
|
|
||||||
enc.newline() |
|
||||||
} |
|
||||||
if len(key) > 0 { |
|
||||||
enc.wf("%s[%s]", enc.indentStr(key), key.maybeQuotedAll()) |
|
||||||
enc.newline() |
|
||||||
} |
|
||||||
enc.eMapOrStruct(key, rv) |
|
||||||
} |
|
||||||
|
|
||||||
func (enc *Encoder) eMapOrStruct(key Key, rv reflect.Value) { |
|
||||||
switch rv := eindirect(rv); rv.Kind() { |
|
||||||
case reflect.Map: |
|
||||||
enc.eMap(key, rv) |
|
||||||
case reflect.Struct: |
|
||||||
enc.eStruct(key, rv) |
|
||||||
default: |
|
||||||
panic("eTable: unhandled reflect.Value Kind: " + rv.Kind().String()) |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
func (enc *Encoder) eMap(key Key, rv reflect.Value) { |
|
||||||
rt := rv.Type() |
|
||||||
if rt.Key().Kind() != reflect.String { |
|
||||||
encPanic(errNonString) |
|
||||||
} |
|
||||||
|
|
||||||
// Sort keys so that we have deterministic output. And write keys directly
|
|
||||||
// underneath this key first, before writing sub-structs or sub-maps.
|
|
||||||
var mapKeysDirect, mapKeysSub []string |
|
||||||
for _, mapKey := range rv.MapKeys() { |
|
||||||
k := mapKey.String() |
|
||||||
if typeIsHash(tomlTypeOfGo(rv.MapIndex(mapKey))) { |
|
||||||
mapKeysSub = append(mapKeysSub, k) |
|
||||||
} else { |
|
||||||
mapKeysDirect = append(mapKeysDirect, k) |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
var writeMapKeys = func(mapKeys []string) { |
|
||||||
sort.Strings(mapKeys) |
|
||||||
for _, mapKey := range mapKeys { |
|
||||||
mrv := rv.MapIndex(reflect.ValueOf(mapKey)) |
|
||||||
if isNil(mrv) { |
|
||||||
// Don't write anything for nil fields.
|
|
||||||
continue |
|
||||||
} |
|
||||||
enc.encode(key.add(mapKey), mrv) |
|
||||||
} |
|
||||||
} |
|
||||||
writeMapKeys(mapKeysDirect) |
|
||||||
writeMapKeys(mapKeysSub) |
|
||||||
} |
|
||||||
|
|
||||||
func (enc *Encoder) eStruct(key Key, rv reflect.Value) { |
|
||||||
// Write keys for fields directly under this key first, because if we write
|
|
||||||
// a field that creates a new table, then all keys under it will be in that
|
|
||||||
// table (not the one we're writing here).
|
|
||||||
rt := rv.Type() |
|
||||||
var fieldsDirect, fieldsSub [][]int |
|
||||||
var addFields func(rt reflect.Type, rv reflect.Value, start []int) |
|
||||||
addFields = func(rt reflect.Type, rv reflect.Value, start []int) { |
|
||||||
for i := 0; i < rt.NumField(); i++ { |
|
||||||
f := rt.Field(i) |
|
||||||
// skip unexported fields
|
|
||||||
if f.PkgPath != "" && !f.Anonymous { |
|
||||||
continue |
|
||||||
} |
|
||||||
frv := rv.Field(i) |
|
||||||
if f.Anonymous { |
|
||||||
t := f.Type |
|
||||||
switch t.Kind() { |
|
||||||
case reflect.Struct: |
|
||||||
// Treat anonymous struct fields with
|
|
||||||
// tag names as though they are not
|
|
||||||
// anonymous, like encoding/json does.
|
|
||||||
if getOptions(f.Tag).name == "" { |
|
||||||
addFields(t, frv, f.Index) |
|
||||||
continue |
|
||||||
} |
|
||||||
case reflect.Ptr: |
|
||||||
if t.Elem().Kind() == reflect.Struct && |
|
||||||
getOptions(f.Tag).name == "" { |
|
||||||
if !frv.IsNil() { |
|
||||||
addFields(t.Elem(), frv.Elem(), f.Index) |
|
||||||
} |
|
||||||
continue |
|
||||||
} |
|
||||||
// Fall through to the normal field encoding logic below
|
|
||||||
// for non-struct anonymous fields.
|
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
if typeIsHash(tomlTypeOfGo(frv)) { |
|
||||||
fieldsSub = append(fieldsSub, append(start, f.Index...)) |
|
||||||
} else { |
|
||||||
fieldsDirect = append(fieldsDirect, append(start, f.Index...)) |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
addFields(rt, rv, nil) |
|
||||||
|
|
||||||
var writeFields = func(fields [][]int) { |
|
||||||
for _, fieldIndex := range fields { |
|
||||||
sft := rt.FieldByIndex(fieldIndex) |
|
||||||
sf := rv.FieldByIndex(fieldIndex) |
|
||||||
if isNil(sf) { |
|
||||||
// Don't write anything for nil fields.
|
|
||||||
continue |
|
||||||
} |
|
||||||
|
|
||||||
opts := getOptions(sft.Tag) |
|
||||||
if opts.skip { |
|
||||||
continue |
|
||||||
} |
|
||||||
keyName := sft.Name |
|
||||||
if opts.name != "" { |
|
||||||
keyName = opts.name |
|
||||||
} |
|
||||||
if opts.omitempty && isEmpty(sf) { |
|
||||||
continue |
|
||||||
} |
|
||||||
if opts.omitzero && isZero(sf) { |
|
||||||
continue |
|
||||||
} |
|
||||||
|
|
||||||
enc.encode(key.add(keyName), sf) |
|
||||||
} |
|
||||||
} |
|
||||||
writeFields(fieldsDirect) |
|
||||||
writeFields(fieldsSub) |
|
||||||
} |
|
||||||
|
|
||||||
// tomlTypeName returns the TOML type name of the Go value's type. It is
|
|
||||||
// used to determine whether the types of array elements are mixed (which is
|
|
||||||
// forbidden). If the Go value is nil, then it is illegal for it to be an array
|
|
||||||
// element, and valueIsNil is returned as true.
|
|
||||||
|
|
||||||
// Returns the TOML type of a Go value. The type may be `nil`, which means
|
|
||||||
// no concrete TOML type could be found.
|
|
||||||
func tomlTypeOfGo(rv reflect.Value) tomlType { |
|
||||||
if isNil(rv) || !rv.IsValid() { |
|
||||||
return nil |
|
||||||
} |
|
||||||
switch rv.Kind() { |
|
||||||
case reflect.Bool: |
|
||||||
return tomlBool |
|
||||||
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, |
|
||||||
reflect.Int64, |
|
||||||
reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, |
|
||||||
reflect.Uint64: |
|
||||||
return tomlInteger |
|
||||||
case reflect.Float32, reflect.Float64: |
|
||||||
return tomlFloat |
|
||||||
case reflect.Array, reflect.Slice: |
|
||||||
if typeEqual(tomlHash, tomlArrayType(rv)) { |
|
||||||
return tomlArrayHash |
|
||||||
} |
|
||||||
return tomlArray |
|
||||||
case reflect.Ptr, reflect.Interface: |
|
||||||
return tomlTypeOfGo(rv.Elem()) |
|
||||||
case reflect.String: |
|
||||||
return tomlString |
|
||||||
case reflect.Map: |
|
||||||
return tomlHash |
|
||||||
case reflect.Struct: |
|
||||||
switch rv.Interface().(type) { |
|
||||||
case time.Time: |
|
||||||
return tomlDatetime |
|
||||||
case TextMarshaler: |
|
||||||
return tomlString |
|
||||||
default: |
|
||||||
return tomlHash |
|
||||||
} |
|
||||||
default: |
|
||||||
panic("unexpected reflect.Kind: " + rv.Kind().String()) |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
// tomlArrayType returns the element type of a TOML array. The type returned
|
|
||||||
// may be nil if it cannot be determined (e.g., a nil slice or a zero length
|
|
||||||
// slize). This function may also panic if it finds a type that cannot be
|
|
||||||
// expressed in TOML (such as nil elements, heterogeneous arrays or directly
|
|
||||||
// nested arrays of tables).
|
|
||||||
func tomlArrayType(rv reflect.Value) tomlType { |
|
||||||
if isNil(rv) || !rv.IsValid() || rv.Len() == 0 { |
|
||||||
return nil |
|
||||||
} |
|
||||||
firstType := tomlTypeOfGo(rv.Index(0)) |
|
||||||
if firstType == nil { |
|
||||||
encPanic(errArrayNilElement) |
|
||||||
} |
|
||||||
|
|
||||||
rvlen := rv.Len() |
|
||||||
for i := 1; i < rvlen; i++ { |
|
||||||
elem := rv.Index(i) |
|
||||||
switch elemType := tomlTypeOfGo(elem); { |
|
||||||
case elemType == nil: |
|
||||||
encPanic(errArrayNilElement) |
|
||||||
case !typeEqual(firstType, elemType): |
|
||||||
encPanic(errArrayMixedElementTypes) |
|
||||||
} |
|
||||||
} |
|
||||||
// If we have a nested array, then we must make sure that the nested
|
|
||||||
// array contains ONLY primitives.
|
|
||||||
// This checks arbitrarily nested arrays.
|
|
||||||
if typeEqual(firstType, tomlArray) || typeEqual(firstType, tomlArrayHash) { |
|
||||||
nest := tomlArrayType(eindirect(rv.Index(0))) |
|
||||||
if typeEqual(nest, tomlHash) || typeEqual(nest, tomlArrayHash) { |
|
||||||
encPanic(errArrayNoTable) |
|
||||||
} |
|
||||||
} |
|
||||||
return firstType |
|
||||||
} |
|
||||||
|
|
||||||
type tagOptions struct { |
|
||||||
skip bool // "-"
|
|
||||||
name string |
|
||||||
omitempty bool |
|
||||||
omitzero bool |
|
||||||
} |
|
||||||
|
|
||||||
func getOptions(tag reflect.StructTag) tagOptions { |
|
||||||
t := tag.Get("toml") |
|
||||||
if t == "-" { |
|
||||||
return tagOptions{skip: true} |
|
||||||
} |
|
||||||
var opts tagOptions |
|
||||||
parts := strings.Split(t, ",") |
|
||||||
opts.name = parts[0] |
|
||||||
for _, s := range parts[1:] { |
|
||||||
switch s { |
|
||||||
case "omitempty": |
|
||||||
opts.omitempty = true |
|
||||||
case "omitzero": |
|
||||||
opts.omitzero = true |
|
||||||
} |
|
||||||
} |
|
||||||
return opts |
|
||||||
} |
|
||||||
|
|
||||||
func isZero(rv reflect.Value) bool { |
|
||||||
switch rv.Kind() { |
|
||||||
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: |
|
||||||
return rv.Int() == 0 |
|
||||||
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: |
|
||||||
return rv.Uint() == 0 |
|
||||||
case reflect.Float32, reflect.Float64: |
|
||||||
return rv.Float() == 0.0 |
|
||||||
} |
|
||||||
return false |
|
||||||
} |
|
||||||
|
|
||||||
func isEmpty(rv reflect.Value) bool { |
|
||||||
switch rv.Kind() { |
|
||||||
case reflect.Array, reflect.Slice, reflect.Map, reflect.String: |
|
||||||
return rv.Len() == 0 |
|
||||||
case reflect.Bool: |
|
||||||
return !rv.Bool() |
|
||||||
} |
|
||||||
return false |
|
||||||
} |
|
||||||
|
|
||||||
func (enc *Encoder) newline() { |
|
||||||
if enc.hasWritten { |
|
||||||
enc.wf("\n") |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
func (enc *Encoder) keyEqElement(key Key, val reflect.Value) { |
|
||||||
if len(key) == 0 { |
|
||||||
encPanic(errNoKey) |
|
||||||
} |
|
||||||
panicIfInvalidKey(key) |
|
||||||
enc.wf("%s%s = ", enc.indentStr(key), key.maybeQuoted(len(key)-1)) |
|
||||||
enc.eElement(val) |
|
||||||
enc.newline() |
|
||||||
} |
|
||||||
|
|
||||||
func (enc *Encoder) wf(format string, v ...interface{}) { |
|
||||||
if _, err := fmt.Fprintf(enc.w, format, v...); err != nil { |
|
||||||
encPanic(err) |
|
||||||
} |
|
||||||
enc.hasWritten = true |
|
||||||
} |
|
||||||
|
|
||||||
func (enc *Encoder) indentStr(key Key) string { |
|
||||||
return strings.Repeat(enc.Indent, len(key)-1) |
|
||||||
} |
|
||||||
|
|
||||||
func encPanic(err error) { |
|
||||||
panic(tomlEncodeError{err}) |
|
||||||
} |
|
||||||
|
|
||||||
func eindirect(v reflect.Value) reflect.Value { |
|
||||||
switch v.Kind() { |
|
||||||
case reflect.Ptr, reflect.Interface: |
|
||||||
return eindirect(v.Elem()) |
|
||||||
default: |
|
||||||
return v |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
func isNil(rv reflect.Value) bool { |
|
||||||
switch rv.Kind() { |
|
||||||
case reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice: |
|
||||||
return rv.IsNil() |
|
||||||
default: |
|
||||||
return false |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
func panicIfInvalidKey(key Key) { |
|
||||||
for _, k := range key { |
|
||||||
if len(k) == 0 { |
|
||||||
encPanic(e("Key '%s' is not a valid table name. Key names "+ |
|
||||||
"cannot be empty.", key.maybeQuotedAll())) |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
func isValidKeyName(s string) bool { |
|
||||||
return len(s) != 0 |
|
||||||
} |
|
||||||
@ -1,19 +0,0 @@ |
|||||||
// +build go1.2
|
|
||||||
|
|
||||||
package toml |
|
||||||
|
|
||||||
// In order to support Go 1.1, we define our own TextMarshaler and
|
|
||||||
// TextUnmarshaler types. For Go 1.2+, we just alias them with the
|
|
||||||
// standard library interfaces.
|
|
||||||
|
|
||||||
import ( |
|
||||||
"encoding" |
|
||||||
) |
|
||||||
|
|
||||||
// TextMarshaler is a synonym for encoding.TextMarshaler. It is defined here
|
|
||||||
// so that Go 1.1 can be supported.
|
|
||||||
type TextMarshaler encoding.TextMarshaler |
|
||||||
|
|
||||||
// TextUnmarshaler is a synonym for encoding.TextUnmarshaler. It is defined
|
|
||||||
// here so that Go 1.1 can be supported.
|
|
||||||
type TextUnmarshaler encoding.TextUnmarshaler |
|
||||||
@ -1,18 +0,0 @@ |
|||||||
// +build !go1.2
|
|
||||||
|
|
||||||
package toml |
|
||||||
|
|
||||||
// These interfaces were introduced in Go 1.2, so we add them manually when
|
|
||||||
// compiling for Go 1.1.
|
|
||||||
|
|
||||||
// TextMarshaler is a synonym for encoding.TextMarshaler. It is defined here
|
|
||||||
// so that Go 1.1 can be supported.
|
|
||||||
type TextMarshaler interface { |
|
||||||
MarshalText() (text []byte, err error) |
|
||||||
} |
|
||||||
|
|
||||||
// TextUnmarshaler is a synonym for encoding.TextUnmarshaler. It is defined
|
|
||||||
// here so that Go 1.1 can be supported.
|
|
||||||
type TextUnmarshaler interface { |
|
||||||
UnmarshalText(text []byte) error |
|
||||||
} |
|
||||||
@ -1,953 +0,0 @@ |
|||||||
package toml |
|
||||||
|
|
||||||
import ( |
|
||||||
"fmt" |
|
||||||
"strings" |
|
||||||
"unicode" |
|
||||||
"unicode/utf8" |
|
||||||
) |
|
||||||
|
|
||||||
type itemType int |
|
||||||
|
|
||||||
const ( |
|
||||||
itemError itemType = iota |
|
||||||
itemNIL // used in the parser to indicate no type
|
|
||||||
itemEOF |
|
||||||
itemText |
|
||||||
itemString |
|
||||||
itemRawString |
|
||||||
itemMultilineString |
|
||||||
itemRawMultilineString |
|
||||||
itemBool |
|
||||||
itemInteger |
|
||||||
itemFloat |
|
||||||
itemDatetime |
|
||||||
itemArray // the start of an array
|
|
||||||
itemArrayEnd |
|
||||||
itemTableStart |
|
||||||
itemTableEnd |
|
||||||
itemArrayTableStart |
|
||||||
itemArrayTableEnd |
|
||||||
itemKeyStart |
|
||||||
itemCommentStart |
|
||||||
itemInlineTableStart |
|
||||||
itemInlineTableEnd |
|
||||||
) |
|
||||||
|
|
||||||
const ( |
|
||||||
eof = 0 |
|
||||||
comma = ',' |
|
||||||
tableStart = '[' |
|
||||||
tableEnd = ']' |
|
||||||
arrayTableStart = '[' |
|
||||||
arrayTableEnd = ']' |
|
||||||
tableSep = '.' |
|
||||||
keySep = '=' |
|
||||||
arrayStart = '[' |
|
||||||
arrayEnd = ']' |
|
||||||
commentStart = '#' |
|
||||||
stringStart = '"' |
|
||||||
stringEnd = '"' |
|
||||||
rawStringStart = '\'' |
|
||||||
rawStringEnd = '\'' |
|
||||||
inlineTableStart = '{' |
|
||||||
inlineTableEnd = '}' |
|
||||||
) |
|
||||||
|
|
||||||
type stateFn func(lx *lexer) stateFn |
|
||||||
|
|
||||||
type lexer struct { |
|
||||||
input string |
|
||||||
start int |
|
||||||
pos int |
|
||||||
line int |
|
||||||
state stateFn |
|
||||||
items chan item |
|
||||||
|
|
||||||
// Allow for backing up up to three runes.
|
|
||||||
// This is necessary because TOML contains 3-rune tokens (""" and ''').
|
|
||||||
prevWidths [3]int |
|
||||||
nprev int // how many of prevWidths are in use
|
|
||||||
// If we emit an eof, we can still back up, but it is not OK to call
|
|
||||||
// next again.
|
|
||||||
atEOF bool |
|
||||||
|
|
||||||
// A stack of state functions used to maintain context.
|
|
||||||
// The idea is to reuse parts of the state machine in various places.
|
|
||||||
// For example, values can appear at the top level or within arbitrarily
|
|
||||||
// nested arrays. The last state on the stack is used after a value has
|
|
||||||
// been lexed. Similarly for comments.
|
|
||||||
stack []stateFn |
|
||||||
} |
|
||||||
|
|
||||||
type item struct { |
|
||||||
typ itemType |
|
||||||
val string |
|
||||||
line int |
|
||||||
} |
|
||||||
|
|
||||||
func (lx *lexer) nextItem() item { |
|
||||||
for { |
|
||||||
select { |
|
||||||
case item := <-lx.items: |
|
||||||
return item |
|
||||||
default: |
|
||||||
lx.state = lx.state(lx) |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
func lex(input string) *lexer { |
|
||||||
lx := &lexer{ |
|
||||||
input: input, |
|
||||||
state: lexTop, |
|
||||||
line: 1, |
|
||||||
items: make(chan item, 10), |
|
||||||
stack: make([]stateFn, 0, 10), |
|
||||||
} |
|
||||||
return lx |
|
||||||
} |
|
||||||
|
|
||||||
func (lx *lexer) push(state stateFn) { |
|
||||||
lx.stack = append(lx.stack, state) |
|
||||||
} |
|
||||||
|
|
||||||
func (lx *lexer) pop() stateFn { |
|
||||||
if len(lx.stack) == 0 { |
|
||||||
return lx.errorf("BUG in lexer: no states to pop") |
|
||||||
} |
|
||||||
last := lx.stack[len(lx.stack)-1] |
|
||||||
lx.stack = lx.stack[0 : len(lx.stack)-1] |
|
||||||
return last |
|
||||||
} |
|
||||||
|
|
||||||
func (lx *lexer) current() string { |
|
||||||
return lx.input[lx.start:lx.pos] |
|
||||||
} |
|
||||||
|
|
||||||
func (lx *lexer) emit(typ itemType) { |
|
||||||
lx.items <- item{typ, lx.current(), lx.line} |
|
||||||
lx.start = lx.pos |
|
||||||
} |
|
||||||
|
|
||||||
func (lx *lexer) emitTrim(typ itemType) { |
|
||||||
lx.items <- item{typ, strings.TrimSpace(lx.current()), lx.line} |
|
||||||
lx.start = lx.pos |
|
||||||
} |
|
||||||
|
|
||||||
func (lx *lexer) next() (r rune) { |
|
||||||
if lx.atEOF { |
|
||||||
panic("next called after EOF") |
|
||||||
} |
|
||||||
if lx.pos >= len(lx.input) { |
|
||||||
lx.atEOF = true |
|
||||||
return eof |
|
||||||
} |
|
||||||
|
|
||||||
if lx.input[lx.pos] == '\n' { |
|
||||||
lx.line++ |
|
||||||
} |
|
||||||
lx.prevWidths[2] = lx.prevWidths[1] |
|
||||||
lx.prevWidths[1] = lx.prevWidths[0] |
|
||||||
if lx.nprev < 3 { |
|
||||||
lx.nprev++ |
|
||||||
} |
|
||||||
r, w := utf8.DecodeRuneInString(lx.input[lx.pos:]) |
|
||||||
lx.prevWidths[0] = w |
|
||||||
lx.pos += w |
|
||||||
return r |
|
||||||
} |
|
||||||
|
|
||||||
// ignore skips over the pending input before this point.
|
|
||||||
func (lx *lexer) ignore() { |
|
||||||
lx.start = lx.pos |
|
||||||
} |
|
||||||
|
|
||||||
// backup steps back one rune. Can be called only twice between calls to next.
|
|
||||||
func (lx *lexer) backup() { |
|
||||||
if lx.atEOF { |
|
||||||
lx.atEOF = false |
|
||||||
return |
|
||||||
} |
|
||||||
if lx.nprev < 1 { |
|
||||||
panic("backed up too far") |
|
||||||
} |
|
||||||
w := lx.prevWidths[0] |
|
||||||
lx.prevWidths[0] = lx.prevWidths[1] |
|
||||||
lx.prevWidths[1] = lx.prevWidths[2] |
|
||||||
lx.nprev-- |
|
||||||
lx.pos -= w |
|
||||||
if lx.pos < len(lx.input) && lx.input[lx.pos] == '\n' { |
|
||||||
lx.line-- |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
// accept consumes the next rune if it's equal to `valid`.
|
|
||||||
func (lx *lexer) accept(valid rune) bool { |
|
||||||
if lx.next() == valid { |
|
||||||
return true |
|
||||||
} |
|
||||||
lx.backup() |
|
||||||
return false |
|
||||||
} |
|
||||||
|
|
||||||
// peek returns but does not consume the next rune in the input.
|
|
||||||
func (lx *lexer) peek() rune { |
|
||||||
r := lx.next() |
|
||||||
lx.backup() |
|
||||||
return r |
|
||||||
} |
|
||||||
|
|
||||||
// skip ignores all input that matches the given predicate.
|
|
||||||
func (lx *lexer) skip(pred func(rune) bool) { |
|
||||||
for { |
|
||||||
r := lx.next() |
|
||||||
if pred(r) { |
|
||||||
continue |
|
||||||
} |
|
||||||
lx.backup() |
|
||||||
lx.ignore() |
|
||||||
return |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
// errorf stops all lexing by emitting an error and returning `nil`.
|
|
||||||
// Note that any value that is a character is escaped if it's a special
|
|
||||||
// character (newlines, tabs, etc.).
|
|
||||||
func (lx *lexer) errorf(format string, values ...interface{}) stateFn { |
|
||||||
lx.items <- item{ |
|
||||||
itemError, |
|
||||||
fmt.Sprintf(format, values...), |
|
||||||
lx.line, |
|
||||||
} |
|
||||||
return nil |
|
||||||
} |
|
||||||
|
|
||||||
// lexTop consumes elements at the top level of TOML data.
|
|
||||||
func lexTop(lx *lexer) stateFn { |
|
||||||
r := lx.next() |
|
||||||
if isWhitespace(r) || isNL(r) { |
|
||||||
return lexSkip(lx, lexTop) |
|
||||||
} |
|
||||||
switch r { |
|
||||||
case commentStart: |
|
||||||
lx.push(lexTop) |
|
||||||
return lexCommentStart |
|
||||||
case tableStart: |
|
||||||
return lexTableStart |
|
||||||
case eof: |
|
||||||
if lx.pos > lx.start { |
|
||||||
return lx.errorf("unexpected EOF") |
|
||||||
} |
|
||||||
lx.emit(itemEOF) |
|
||||||
return nil |
|
||||||
} |
|
||||||
|
|
||||||
// At this point, the only valid item can be a key, so we back up
|
|
||||||
// and let the key lexer do the rest.
|
|
||||||
lx.backup() |
|
||||||
lx.push(lexTopEnd) |
|
||||||
return lexKeyStart |
|
||||||
} |
|
||||||
|
|
||||||
// lexTopEnd is entered whenever a top-level item has been consumed. (A value
|
|
||||||
// or a table.) It must see only whitespace, and will turn back to lexTop
|
|
||||||
// upon a newline. If it sees EOF, it will quit the lexer successfully.
|
|
||||||
func lexTopEnd(lx *lexer) stateFn { |
|
||||||
r := lx.next() |
|
||||||
switch { |
|
||||||
case r == commentStart: |
|
||||||
// a comment will read to a newline for us.
|
|
||||||
lx.push(lexTop) |
|
||||||
return lexCommentStart |
|
||||||
case isWhitespace(r): |
|
||||||
return lexTopEnd |
|
||||||
case isNL(r): |
|
||||||
lx.ignore() |
|
||||||
return lexTop |
|
||||||
case r == eof: |
|
||||||
lx.emit(itemEOF) |
|
||||||
return nil |
|
||||||
} |
|
||||||
return lx.errorf("expected a top-level item to end with a newline, "+ |
|
||||||
"comment, or EOF, but got %q instead", r) |
|
||||||
} |
|
||||||
|
|
||||||
// lexTable lexes the beginning of a table. Namely, it makes sure that
|
|
||||||
// it starts with a character other than '.' and ']'.
|
|
||||||
// It assumes that '[' has already been consumed.
|
|
||||||
// It also handles the case that this is an item in an array of tables.
|
|
||||||
// e.g., '[[name]]'.
|
|
||||||
func lexTableStart(lx *lexer) stateFn { |
|
||||||
if lx.peek() == arrayTableStart { |
|
||||||
lx.next() |
|
||||||
lx.emit(itemArrayTableStart) |
|
||||||
lx.push(lexArrayTableEnd) |
|
||||||
} else { |
|
||||||
lx.emit(itemTableStart) |
|
||||||
lx.push(lexTableEnd) |
|
||||||
} |
|
||||||
return lexTableNameStart |
|
||||||
} |
|
||||||
|
|
||||||
func lexTableEnd(lx *lexer) stateFn { |
|
||||||
lx.emit(itemTableEnd) |
|
||||||
return lexTopEnd |
|
||||||
} |
|
||||||
|
|
||||||
func lexArrayTableEnd(lx *lexer) stateFn { |
|
||||||
if r := lx.next(); r != arrayTableEnd { |
|
||||||
return lx.errorf("expected end of table array name delimiter %q, "+ |
|
||||||
"but got %q instead", arrayTableEnd, r) |
|
||||||
} |
|
||||||
lx.emit(itemArrayTableEnd) |
|
||||||
return lexTopEnd |
|
||||||
} |
|
||||||
|
|
||||||
func lexTableNameStart(lx *lexer) stateFn { |
|
||||||
lx.skip(isWhitespace) |
|
||||||
switch r := lx.peek(); { |
|
||||||
case r == tableEnd || r == eof: |
|
||||||
return lx.errorf("unexpected end of table name " + |
|
||||||
"(table names cannot be empty)") |
|
||||||
case r == tableSep: |
|
||||||
return lx.errorf("unexpected table separator " + |
|
||||||
"(table names cannot be empty)") |
|
||||||
case r == stringStart || r == rawStringStart: |
|
||||||
lx.ignore() |
|
||||||
lx.push(lexTableNameEnd) |
|
||||||
return lexValue // reuse string lexing
|
|
||||||
default: |
|
||||||
return lexBareTableName |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
// lexBareTableName lexes the name of a table. It assumes that at least one
|
|
||||||
// valid character for the table has already been read.
|
|
||||||
func lexBareTableName(lx *lexer) stateFn { |
|
||||||
r := lx.next() |
|
||||||
if isBareKeyChar(r) { |
|
||||||
return lexBareTableName |
|
||||||
} |
|
||||||
lx.backup() |
|
||||||
lx.emit(itemText) |
|
||||||
return lexTableNameEnd |
|
||||||
} |
|
||||||
|
|
||||||
// lexTableNameEnd reads the end of a piece of a table name, optionally
|
|
||||||
// consuming whitespace.
|
|
||||||
func lexTableNameEnd(lx *lexer) stateFn { |
|
||||||
lx.skip(isWhitespace) |
|
||||||
switch r := lx.next(); { |
|
||||||
case isWhitespace(r): |
|
||||||
return lexTableNameEnd |
|
||||||
case r == tableSep: |
|
||||||
lx.ignore() |
|
||||||
return lexTableNameStart |
|
||||||
case r == tableEnd: |
|
||||||
return lx.pop() |
|
||||||
default: |
|
||||||
return lx.errorf("expected '.' or ']' to end table name, "+ |
|
||||||
"but got %q instead", r) |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
// lexKeyStart consumes a key name up until the first non-whitespace character.
|
|
||||||
// lexKeyStart will ignore whitespace.
|
|
||||||
func lexKeyStart(lx *lexer) stateFn { |
|
||||||
r := lx.peek() |
|
||||||
switch { |
|
||||||
case r == keySep: |
|
||||||
return lx.errorf("unexpected key separator %q", keySep) |
|
||||||
case isWhitespace(r) || isNL(r): |
|
||||||
lx.next() |
|
||||||
return lexSkip(lx, lexKeyStart) |
|
||||||
case r == stringStart || r == rawStringStart: |
|
||||||
lx.ignore() |
|
||||||
lx.emit(itemKeyStart) |
|
||||||
lx.push(lexKeyEnd) |
|
||||||
return lexValue // reuse string lexing
|
|
||||||
default: |
|
||||||
lx.ignore() |
|
||||||
lx.emit(itemKeyStart) |
|
||||||
return lexBareKey |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
// lexBareKey consumes the text of a bare key. Assumes that the first character
|
|
||||||
// (which is not whitespace) has not yet been consumed.
|
|
||||||
func lexBareKey(lx *lexer) stateFn { |
|
||||||
switch r := lx.next(); { |
|
||||||
case isBareKeyChar(r): |
|
||||||
return lexBareKey |
|
||||||
case isWhitespace(r): |
|
||||||
lx.backup() |
|
||||||
lx.emit(itemText) |
|
||||||
return lexKeyEnd |
|
||||||
case r == keySep: |
|
||||||
lx.backup() |
|
||||||
lx.emit(itemText) |
|
||||||
return lexKeyEnd |
|
||||||
default: |
|
||||||
return lx.errorf("bare keys cannot contain %q", r) |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
// lexKeyEnd consumes the end of a key and trims whitespace (up to the key
|
|
||||||
// separator).
|
|
||||||
func lexKeyEnd(lx *lexer) stateFn { |
|
||||||
switch r := lx.next(); { |
|
||||||
case r == keySep: |
|
||||||
return lexSkip(lx, lexValue) |
|
||||||
case isWhitespace(r): |
|
||||||
return lexSkip(lx, lexKeyEnd) |
|
||||||
default: |
|
||||||
return lx.errorf("expected key separator %q, but got %q instead", |
|
||||||
keySep, r) |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
// lexValue starts the consumption of a value anywhere a value is expected.
|
|
||||||
// lexValue will ignore whitespace.
|
|
||||||
// After a value is lexed, the last state on the next is popped and returned.
|
|
||||||
func lexValue(lx *lexer) stateFn { |
|
||||||
// We allow whitespace to precede a value, but NOT newlines.
|
|
||||||
// In array syntax, the array states are responsible for ignoring newlines.
|
|
||||||
r := lx.next() |
|
||||||
switch { |
|
||||||
case isWhitespace(r): |
|
||||||
return lexSkip(lx, lexValue) |
|
||||||
case isDigit(r): |
|
||||||
lx.backup() // avoid an extra state and use the same as above
|
|
||||||
return lexNumberOrDateStart |
|
||||||
} |
|
||||||
switch r { |
|
||||||
case arrayStart: |
|
||||||
lx.ignore() |
|
||||||
lx.emit(itemArray) |
|
||||||
return lexArrayValue |
|
||||||
case inlineTableStart: |
|
||||||
lx.ignore() |
|
||||||
lx.emit(itemInlineTableStart) |
|
||||||
return lexInlineTableValue |
|
||||||
case stringStart: |
|
||||||
if lx.accept(stringStart) { |
|
||||||
if lx.accept(stringStart) { |
|
||||||
lx.ignore() // Ignore """
|
|
||||||
return lexMultilineString |
|
||||||
} |
|
||||||
lx.backup() |
|
||||||
} |
|
||||||
lx.ignore() // ignore the '"'
|
|
||||||
return lexString |
|
||||||
case rawStringStart: |
|
||||||
if lx.accept(rawStringStart) { |
|
||||||
if lx.accept(rawStringStart) { |
|
||||||
lx.ignore() // Ignore """
|
|
||||||
return lexMultilineRawString |
|
||||||
} |
|
||||||
lx.backup() |
|
||||||
} |
|
||||||
lx.ignore() // ignore the "'"
|
|
||||||
return lexRawString |
|
||||||
case '+', '-': |
|
||||||
return lexNumberStart |
|
||||||
case '.': // special error case, be kind to users
|
|
||||||
return lx.errorf("floats must start with a digit, not '.'") |
|
||||||
} |
|
||||||
if unicode.IsLetter(r) { |
|
||||||
// Be permissive here; lexBool will give a nice error if the
|
|
||||||
// user wrote something like
|
|
||||||
// x = foo
|
|
||||||
// (i.e. not 'true' or 'false' but is something else word-like.)
|
|
||||||
lx.backup() |
|
||||||
return lexBool |
|
||||||
} |
|
||||||
return lx.errorf("expected value but found %q instead", r) |
|
||||||
} |
|
||||||
|
|
||||||
// lexArrayValue consumes one value in an array. It assumes that '[' or ','
|
|
||||||
// have already been consumed. All whitespace and newlines are ignored.
|
|
||||||
func lexArrayValue(lx *lexer) stateFn { |
|
||||||
r := lx.next() |
|
||||||
switch { |
|
||||||
case isWhitespace(r) || isNL(r): |
|
||||||
return lexSkip(lx, lexArrayValue) |
|
||||||
case r == commentStart: |
|
||||||
lx.push(lexArrayValue) |
|
||||||
return lexCommentStart |
|
||||||
case r == comma: |
|
||||||
return lx.errorf("unexpected comma") |
|
||||||
case r == arrayEnd: |
|
||||||
// NOTE(caleb): The spec isn't clear about whether you can have
|
|
||||||
// a trailing comma or not, so we'll allow it.
|
|
||||||
return lexArrayEnd |
|
||||||
} |
|
||||||
|
|
||||||
lx.backup() |
|
||||||
lx.push(lexArrayValueEnd) |
|
||||||
return lexValue |
|
||||||
} |
|
||||||
|
|
||||||
// lexArrayValueEnd consumes everything between the end of an array value and
|
|
||||||
// the next value (or the end of the array): it ignores whitespace and newlines
|
|
||||||
// and expects either a ',' or a ']'.
|
|
||||||
func lexArrayValueEnd(lx *lexer) stateFn { |
|
||||||
r := lx.next() |
|
||||||
switch { |
|
||||||
case isWhitespace(r) || isNL(r): |
|
||||||
return lexSkip(lx, lexArrayValueEnd) |
|
||||||
case r == commentStart: |
|
||||||
lx.push(lexArrayValueEnd) |
|
||||||
return lexCommentStart |
|
||||||
case r == comma: |
|
||||||
lx.ignore() |
|
||||||
return lexArrayValue // move on to the next value
|
|
||||||
case r == arrayEnd: |
|
||||||
return lexArrayEnd |
|
||||||
} |
|
||||||
return lx.errorf( |
|
||||||
"expected a comma or array terminator %q, but got %q instead", |
|
||||||
arrayEnd, r, |
|
||||||
) |
|
||||||
} |
|
||||||
|
|
||||||
// lexArrayEnd finishes the lexing of an array.
|
|
||||||
// It assumes that a ']' has just been consumed.
|
|
||||||
func lexArrayEnd(lx *lexer) stateFn { |
|
||||||
lx.ignore() |
|
||||||
lx.emit(itemArrayEnd) |
|
||||||
return lx.pop() |
|
||||||
} |
|
||||||
|
|
||||||
// lexInlineTableValue consumes one key/value pair in an inline table.
|
|
||||||
// It assumes that '{' or ',' have already been consumed. Whitespace is ignored.
|
|
||||||
func lexInlineTableValue(lx *lexer) stateFn { |
|
||||||
r := lx.next() |
|
||||||
switch { |
|
||||||
case isWhitespace(r): |
|
||||||
return lexSkip(lx, lexInlineTableValue) |
|
||||||
case isNL(r): |
|
||||||
return lx.errorf("newlines not allowed within inline tables") |
|
||||||
case r == commentStart: |
|
||||||
lx.push(lexInlineTableValue) |
|
||||||
return lexCommentStart |
|
||||||
case r == comma: |
|
||||||
return lx.errorf("unexpected comma") |
|
||||||
case r == inlineTableEnd: |
|
||||||
return lexInlineTableEnd |
|
||||||
} |
|
||||||
lx.backup() |
|
||||||
lx.push(lexInlineTableValueEnd) |
|
||||||
return lexKeyStart |
|
||||||
} |
|
||||||
|
|
||||||
// lexInlineTableValueEnd consumes everything between the end of an inline table
|
|
||||||
// key/value pair and the next pair (or the end of the table):
|
|
||||||
// it ignores whitespace and expects either a ',' or a '}'.
|
|
||||||
func lexInlineTableValueEnd(lx *lexer) stateFn { |
|
||||||
r := lx.next() |
|
||||||
switch { |
|
||||||
case isWhitespace(r): |
|
||||||
return lexSkip(lx, lexInlineTableValueEnd) |
|
||||||
case isNL(r): |
|
||||||
return lx.errorf("newlines not allowed within inline tables") |
|
||||||
case r == commentStart: |
|
||||||
lx.push(lexInlineTableValueEnd) |
|
||||||
return lexCommentStart |
|
||||||
case r == comma: |
|
||||||
lx.ignore() |
|
||||||
return lexInlineTableValue |
|
||||||
case r == inlineTableEnd: |
|
||||||
return lexInlineTableEnd |
|
||||||
} |
|
||||||
return lx.errorf("expected a comma or an inline table terminator %q, "+ |
|
||||||
"but got %q instead", inlineTableEnd, r) |
|
||||||
} |
|
||||||
|
|
||||||
// lexInlineTableEnd finishes the lexing of an inline table.
|
|
||||||
// It assumes that a '}' has just been consumed.
|
|
||||||
func lexInlineTableEnd(lx *lexer) stateFn { |
|
||||||
lx.ignore() |
|
||||||
lx.emit(itemInlineTableEnd) |
|
||||||
return lx.pop() |
|
||||||
} |
|
||||||
|
|
||||||
// lexString consumes the inner contents of a string. It assumes that the
|
|
||||||
// beginning '"' has already been consumed and ignored.
|
|
||||||
func lexString(lx *lexer) stateFn { |
|
||||||
r := lx.next() |
|
||||||
switch { |
|
||||||
case r == eof: |
|
||||||
return lx.errorf("unexpected EOF") |
|
||||||
case isNL(r): |
|
||||||
return lx.errorf("strings cannot contain newlines") |
|
||||||
case r == '\\': |
|
||||||
lx.push(lexString) |
|
||||||
return lexStringEscape |
|
||||||
case r == stringEnd: |
|
||||||
lx.backup() |
|
||||||
lx.emit(itemString) |
|
||||||
lx.next() |
|
||||||
lx.ignore() |
|
||||||
return lx.pop() |
|
||||||
} |
|
||||||
return lexString |
|
||||||
} |
|
||||||
|
|
||||||
// lexMultilineString consumes the inner contents of a string. It assumes that
|
|
||||||
// the beginning '"""' has already been consumed and ignored.
|
|
||||||
func lexMultilineString(lx *lexer) stateFn { |
|
||||||
switch lx.next() { |
|
||||||
case eof: |
|
||||||
return lx.errorf("unexpected EOF") |
|
||||||
case '\\': |
|
||||||
return lexMultilineStringEscape |
|
||||||
case stringEnd: |
|
||||||
if lx.accept(stringEnd) { |
|
||||||
if lx.accept(stringEnd) { |
|
||||||
lx.backup() |
|
||||||
lx.backup() |
|
||||||
lx.backup() |
|
||||||
lx.emit(itemMultilineString) |
|
||||||
lx.next() |
|
||||||
lx.next() |
|
||||||
lx.next() |
|
||||||
lx.ignore() |
|
||||||
return lx.pop() |
|
||||||
} |
|
||||||
lx.backup() |
|
||||||
} |
|
||||||
} |
|
||||||
return lexMultilineString |
|
||||||
} |
|
||||||
|
|
||||||
// lexRawString consumes a raw string. Nothing can be escaped in such a string.
|
|
||||||
// It assumes that the beginning "'" has already been consumed and ignored.
|
|
||||||
func lexRawString(lx *lexer) stateFn { |
|
||||||
r := lx.next() |
|
||||||
switch { |
|
||||||
case r == eof: |
|
||||||
return lx.errorf("unexpected EOF") |
|
||||||
case isNL(r): |
|
||||||
return lx.errorf("strings cannot contain newlines") |
|
||||||
case r == rawStringEnd: |
|
||||||
lx.backup() |
|
||||||
lx.emit(itemRawString) |
|
||||||
lx.next() |
|
||||||
lx.ignore() |
|
||||||
return lx.pop() |
|
||||||
} |
|
||||||
return lexRawString |
|
||||||
} |
|
||||||
|
|
||||||
// lexMultilineRawString consumes a raw string. Nothing can be escaped in such
|
|
||||||
// a string. It assumes that the beginning "'''" has already been consumed and
|
|
||||||
// ignored.
|
|
||||||
func lexMultilineRawString(lx *lexer) stateFn { |
|
||||||
switch lx.next() { |
|
||||||
case eof: |
|
||||||
return lx.errorf("unexpected EOF") |
|
||||||
case rawStringEnd: |
|
||||||
if lx.accept(rawStringEnd) { |
|
||||||
if lx.accept(rawStringEnd) { |
|
||||||
lx.backup() |
|
||||||
lx.backup() |
|
||||||
lx.backup() |
|
||||||
lx.emit(itemRawMultilineString) |
|
||||||
lx.next() |
|
||||||
lx.next() |
|
||||||
lx.next() |
|
||||||
lx.ignore() |
|
||||||
return lx.pop() |
|
||||||
} |
|
||||||
lx.backup() |
|
||||||
} |
|
||||||
} |
|
||||||
return lexMultilineRawString |
|
||||||
} |
|
||||||
|
|
||||||
// lexMultilineStringEscape consumes an escaped character. It assumes that the
|
|
||||||
// preceding '\\' has already been consumed.
|
|
||||||
func lexMultilineStringEscape(lx *lexer) stateFn { |
|
||||||
// Handle the special case first:
|
|
||||||
if isNL(lx.next()) { |
|
||||||
return lexMultilineString |
|
||||||
} |
|
||||||
lx.backup() |
|
||||||
lx.push(lexMultilineString) |
|
||||||
return lexStringEscape(lx) |
|
||||||
} |
|
||||||
|
|
||||||
func lexStringEscape(lx *lexer) stateFn { |
|
||||||
r := lx.next() |
|
||||||
switch r { |
|
||||||
case 'b': |
|
||||||
fallthrough |
|
||||||
case 't': |
|
||||||
fallthrough |
|
||||||
case 'n': |
|
||||||
fallthrough |
|
||||||
case 'f': |
|
||||||
fallthrough |
|
||||||
case 'r': |
|
||||||
fallthrough |
|
||||||
case '"': |
|
||||||
fallthrough |
|
||||||
case '\\': |
|
||||||
return lx.pop() |
|
||||||
case 'u': |
|
||||||
return lexShortUnicodeEscape |
|
||||||
case 'U': |
|
||||||
return lexLongUnicodeEscape |
|
||||||
} |
|
||||||
return lx.errorf("invalid escape character %q; only the following "+ |
|
||||||
"escape characters are allowed: "+ |
|
||||||
`\b, \t, \n, \f, \r, \", \\, \uXXXX, and \UXXXXXXXX`, r) |
|
||||||
} |
|
||||||
|
|
||||||
func lexShortUnicodeEscape(lx *lexer) stateFn { |
|
||||||
var r rune |
|
||||||
for i := 0; i < 4; i++ { |
|
||||||
r = lx.next() |
|
||||||
if !isHexadecimal(r) { |
|
||||||
return lx.errorf(`expected four hexadecimal digits after '\u', `+ |
|
||||||
"but got %q instead", lx.current()) |
|
||||||
} |
|
||||||
} |
|
||||||
return lx.pop() |
|
||||||
} |
|
||||||
|
|
||||||
func lexLongUnicodeEscape(lx *lexer) stateFn { |
|
||||||
var r rune |
|
||||||
for i := 0; i < 8; i++ { |
|
||||||
r = lx.next() |
|
||||||
if !isHexadecimal(r) { |
|
||||||
return lx.errorf(`expected eight hexadecimal digits after '\U', `+ |
|
||||||
"but got %q instead", lx.current()) |
|
||||||
} |
|
||||||
} |
|
||||||
return lx.pop() |
|
||||||
} |
|
||||||
|
|
||||||
// lexNumberOrDateStart consumes either an integer, a float, or datetime.
|
|
||||||
func lexNumberOrDateStart(lx *lexer) stateFn { |
|
||||||
r := lx.next() |
|
||||||
if isDigit(r) { |
|
||||||
return lexNumberOrDate |
|
||||||
} |
|
||||||
switch r { |
|
||||||
case '_': |
|
||||||
return lexNumber |
|
||||||
case 'e', 'E': |
|
||||||
return lexFloat |
|
||||||
case '.': |
|
||||||
return lx.errorf("floats must start with a digit, not '.'") |
|
||||||
} |
|
||||||
return lx.errorf("expected a digit but got %q", r) |
|
||||||
} |
|
||||||
|
|
||||||
// lexNumberOrDate consumes either an integer, float or datetime.
|
|
||||||
func lexNumberOrDate(lx *lexer) stateFn { |
|
||||||
r := lx.next() |
|
||||||
if isDigit(r) { |
|
||||||
return lexNumberOrDate |
|
||||||
} |
|
||||||
switch r { |
|
||||||
case '-': |
|
||||||
return lexDatetime |
|
||||||
case '_': |
|
||||||
return lexNumber |
|
||||||
case '.', 'e', 'E': |
|
||||||
return lexFloat |
|
||||||
} |
|
||||||
|
|
||||||
lx.backup() |
|
||||||
lx.emit(itemInteger) |
|
||||||
return lx.pop() |
|
||||||
} |
|
||||||
|
|
||||||
// lexDatetime consumes a Datetime, to a first approximation.
|
|
||||||
// The parser validates that it matches one of the accepted formats.
|
|
||||||
func lexDatetime(lx *lexer) stateFn { |
|
||||||
r := lx.next() |
|
||||||
if isDigit(r) { |
|
||||||
return lexDatetime |
|
||||||
} |
|
||||||
switch r { |
|
||||||
case '-', 'T', ':', '.', 'Z', '+': |
|
||||||
return lexDatetime |
|
||||||
} |
|
||||||
|
|
||||||
lx.backup() |
|
||||||
lx.emit(itemDatetime) |
|
||||||
return lx.pop() |
|
||||||
} |
|
||||||
|
|
||||||
// lexNumberStart consumes either an integer or a float. It assumes that a sign
|
|
||||||
// has already been read, but that *no* digits have been consumed.
|
|
||||||
// lexNumberStart will move to the appropriate integer or float states.
|
|
||||||
func lexNumberStart(lx *lexer) stateFn { |
|
||||||
// We MUST see a digit. Even floats have to start with a digit.
|
|
||||||
r := lx.next() |
|
||||||
if !isDigit(r) { |
|
||||||
if r == '.' { |
|
||||||
return lx.errorf("floats must start with a digit, not '.'") |
|
||||||
} |
|
||||||
return lx.errorf("expected a digit but got %q", r) |
|
||||||
} |
|
||||||
return lexNumber |
|
||||||
} |
|
||||||
|
|
||||||
// lexNumber consumes an integer or a float after seeing the first digit.
|
|
||||||
func lexNumber(lx *lexer) stateFn { |
|
||||||
r := lx.next() |
|
||||||
if isDigit(r) { |
|
||||||
return lexNumber |
|
||||||
} |
|
||||||
switch r { |
|
||||||
case '_': |
|
||||||
return lexNumber |
|
||||||
case '.', 'e', 'E': |
|
||||||
return lexFloat |
|
||||||
} |
|
||||||
|
|
||||||
lx.backup() |
|
||||||
lx.emit(itemInteger) |
|
||||||
return lx.pop() |
|
||||||
} |
|
||||||
|
|
||||||
// lexFloat consumes the elements of a float. It allows any sequence of
|
|
||||||
// float-like characters, so floats emitted by the lexer are only a first
|
|
||||||
// approximation and must be validated by the parser.
|
|
||||||
func lexFloat(lx *lexer) stateFn { |
|
||||||
r := lx.next() |
|
||||||
if isDigit(r) { |
|
||||||
return lexFloat |
|
||||||
} |
|
||||||
switch r { |
|
||||||
case '_', '.', '-', '+', 'e', 'E': |
|
||||||
return lexFloat |
|
||||||
} |
|
||||||
|
|
||||||
lx.backup() |
|
||||||
lx.emit(itemFloat) |
|
||||||
return lx.pop() |
|
||||||
} |
|
||||||
|
|
||||||
// lexBool consumes a bool string: 'true' or 'false.
|
|
||||||
func lexBool(lx *lexer) stateFn { |
|
||||||
var rs []rune |
|
||||||
for { |
|
||||||
r := lx.next() |
|
||||||
if !unicode.IsLetter(r) { |
|
||||||
lx.backup() |
|
||||||
break |
|
||||||
} |
|
||||||
rs = append(rs, r) |
|
||||||
} |
|
||||||
s := string(rs) |
|
||||||
switch s { |
|
||||||
case "true", "false": |
|
||||||
lx.emit(itemBool) |
|
||||||
return lx.pop() |
|
||||||
} |
|
||||||
return lx.errorf("expected value but found %q instead", s) |
|
||||||
} |
|
||||||
|
|
||||||
// lexCommentStart begins the lexing of a comment. It will emit
|
|
||||||
// itemCommentStart and consume no characters, passing control to lexComment.
|
|
||||||
func lexCommentStart(lx *lexer) stateFn { |
|
||||||
lx.ignore() |
|
||||||
lx.emit(itemCommentStart) |
|
||||||
return lexComment |
|
||||||
} |
|
||||||
|
|
||||||
// lexComment lexes an entire comment. It assumes that '#' has been consumed.
|
|
||||||
// It will consume *up to* the first newline character, and pass control
|
|
||||||
// back to the last state on the stack.
|
|
||||||
func lexComment(lx *lexer) stateFn { |
|
||||||
r := lx.peek() |
|
||||||
if isNL(r) || r == eof { |
|
||||||
lx.emit(itemText) |
|
||||||
return lx.pop() |
|
||||||
} |
|
||||||
lx.next() |
|
||||||
return lexComment |
|
||||||
} |
|
||||||
|
|
||||||
// lexSkip ignores all slurped input and moves on to the next state.
|
|
||||||
func lexSkip(lx *lexer, nextState stateFn) stateFn { |
|
||||||
return func(lx *lexer) stateFn { |
|
||||||
lx.ignore() |
|
||||||
return nextState |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
// isWhitespace returns true if `r` is a whitespace character according
|
|
||||||
// to the spec.
|
|
||||||
func isWhitespace(r rune) bool { |
|
||||||
return r == '\t' || r == ' ' |
|
||||||
} |
|
||||||
|
|
||||||
func isNL(r rune) bool { |
|
||||||
return r == '\n' || r == '\r' |
|
||||||
} |
|
||||||
|
|
||||||
func isDigit(r rune) bool { |
|
||||||
return r >= '0' && r <= '9' |
|
||||||
} |
|
||||||
|
|
||||||
func isHexadecimal(r rune) bool { |
|
||||||
return (r >= '0' && r <= '9') || |
|
||||||
(r >= 'a' && r <= 'f') || |
|
||||||
(r >= 'A' && r <= 'F') |
|
||||||
} |
|
||||||
|
|
||||||
func isBareKeyChar(r rune) bool { |
|
||||||
return (r >= 'A' && r <= 'Z') || |
|
||||||
(r >= 'a' && r <= 'z') || |
|
||||||
(r >= '0' && r <= '9') || |
|
||||||
r == '_' || |
|
||||||
r == '-' |
|
||||||
} |
|
||||||
|
|
||||||
func (itype itemType) String() string { |
|
||||||
switch itype { |
|
||||||
case itemError: |
|
||||||
return "Error" |
|
||||||
case itemNIL: |
|
||||||
return "NIL" |
|
||||||
case itemEOF: |
|
||||||
return "EOF" |
|
||||||
case itemText: |
|
||||||
return "Text" |
|
||||||
case itemString, itemRawString, itemMultilineString, itemRawMultilineString: |
|
||||||
return "String" |
|
||||||
case itemBool: |
|
||||||
return "Bool" |
|
||||||
case itemInteger: |
|
||||||
return "Integer" |
|
||||||
case itemFloat: |
|
||||||
return "Float" |
|
||||||
case itemDatetime: |
|
||||||
return "DateTime" |
|
||||||
case itemTableStart: |
|
||||||
return "TableStart" |
|
||||||
case itemTableEnd: |
|
||||||
return "TableEnd" |
|
||||||
case itemKeyStart: |
|
||||||
return "KeyStart" |
|
||||||
case itemArray: |
|
||||||
return "Array" |
|
||||||
case itemArrayEnd: |
|
||||||
return "ArrayEnd" |
|
||||||
case itemCommentStart: |
|
||||||
return "CommentStart" |
|
||||||
} |
|
||||||
panic(fmt.Sprintf("BUG: Unknown type '%d'.", int(itype))) |
|
||||||
} |
|
||||||
|
|
||||||
func (item item) String() string { |
|
||||||
return fmt.Sprintf("(%s, %s)", item.typ.String(), item.val) |
|
||||||
} |
|
||||||
@ -1,592 +0,0 @@ |
|||||||
package toml |
|
||||||
|
|
||||||
import ( |
|
||||||
"fmt" |
|
||||||
"strconv" |
|
||||||
"strings" |
|
||||||
"time" |
|
||||||
"unicode" |
|
||||||
"unicode/utf8" |
|
||||||
) |
|
||||||
|
|
||||||
type parser struct { |
|
||||||
mapping map[string]interface{} |
|
||||||
types map[string]tomlType |
|
||||||
lx *lexer |
|
||||||
|
|
||||||
// A list of keys in the order that they appear in the TOML data.
|
|
||||||
ordered []Key |
|
||||||
|
|
||||||
// the full key for the current hash in scope
|
|
||||||
context Key |
|
||||||
|
|
||||||
// the base key name for everything except hashes
|
|
||||||
currentKey string |
|
||||||
|
|
||||||
// rough approximation of line number
|
|
||||||
approxLine int |
|
||||||
|
|
||||||
// A map of 'key.group.names' to whether they were created implicitly.
|
|
||||||
implicits map[string]bool |
|
||||||
} |
|
||||||
|
|
||||||
type parseError string |
|
||||||
|
|
||||||
func (pe parseError) Error() string { |
|
||||||
return string(pe) |
|
||||||
} |
|
||||||
|
|
||||||
func parse(data string) (p *parser, err error) { |
|
||||||
defer func() { |
|
||||||
if r := recover(); r != nil { |
|
||||||
var ok bool |
|
||||||
if err, ok = r.(parseError); ok { |
|
||||||
return |
|
||||||
} |
|
||||||
panic(r) |
|
||||||
} |
|
||||||
}() |
|
||||||
|
|
||||||
p = &parser{ |
|
||||||
mapping: make(map[string]interface{}), |
|
||||||
types: make(map[string]tomlType), |
|
||||||
lx: lex(data), |
|
||||||
ordered: make([]Key, 0), |
|
||||||
implicits: make(map[string]bool), |
|
||||||
} |
|
||||||
for { |
|
||||||
item := p.next() |
|
||||||
if item.typ == itemEOF { |
|
||||||
break |
|
||||||
} |
|
||||||
p.topLevel(item) |
|
||||||
} |
|
||||||
|
|
||||||
return p, nil |
|
||||||
} |
|
||||||
|
|
||||||
func (p *parser) panicf(format string, v ...interface{}) { |
|
||||||
msg := fmt.Sprintf("Near line %d (last key parsed '%s'): %s", |
|
||||||
p.approxLine, p.current(), fmt.Sprintf(format, v...)) |
|
||||||
panic(parseError(msg)) |
|
||||||
} |
|
||||||
|
|
||||||
func (p *parser) next() item { |
|
||||||
it := p.lx.nextItem() |
|
||||||
if it.typ == itemError { |
|
||||||
p.panicf("%s", it.val) |
|
||||||
} |
|
||||||
return it |
|
||||||
} |
|
||||||
|
|
||||||
func (p *parser) bug(format string, v ...interface{}) { |
|
||||||
panic(fmt.Sprintf("BUG: "+format+"\n\n", v...)) |
|
||||||
} |
|
||||||
|
|
||||||
func (p *parser) expect(typ itemType) item { |
|
||||||
it := p.next() |
|
||||||
p.assertEqual(typ, it.typ) |
|
||||||
return it |
|
||||||
} |
|
||||||
|
|
||||||
func (p *parser) assertEqual(expected, got itemType) { |
|
||||||
if expected != got { |
|
||||||
p.bug("Expected '%s' but got '%s'.", expected, got) |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
func (p *parser) topLevel(item item) { |
|
||||||
switch item.typ { |
|
||||||
case itemCommentStart: |
|
||||||
p.approxLine = item.line |
|
||||||
p.expect(itemText) |
|
||||||
case itemTableStart: |
|
||||||
kg := p.next() |
|
||||||
p.approxLine = kg.line |
|
||||||
|
|
||||||
var key Key |
|
||||||
for ; kg.typ != itemTableEnd && kg.typ != itemEOF; kg = p.next() { |
|
||||||
key = append(key, p.keyString(kg)) |
|
||||||
} |
|
||||||
p.assertEqual(itemTableEnd, kg.typ) |
|
||||||
|
|
||||||
p.establishContext(key, false) |
|
||||||
p.setType("", tomlHash) |
|
||||||
p.ordered = append(p.ordered, key) |
|
||||||
case itemArrayTableStart: |
|
||||||
kg := p.next() |
|
||||||
p.approxLine = kg.line |
|
||||||
|
|
||||||
var key Key |
|
||||||
for ; kg.typ != itemArrayTableEnd && kg.typ != itemEOF; kg = p.next() { |
|
||||||
key = append(key, p.keyString(kg)) |
|
||||||
} |
|
||||||
p.assertEqual(itemArrayTableEnd, kg.typ) |
|
||||||
|
|
||||||
p.establishContext(key, true) |
|
||||||
p.setType("", tomlArrayHash) |
|
||||||
p.ordered = append(p.ordered, key) |
|
||||||
case itemKeyStart: |
|
||||||
kname := p.next() |
|
||||||
p.approxLine = kname.line |
|
||||||
p.currentKey = p.keyString(kname) |
|
||||||
|
|
||||||
val, typ := p.value(p.next()) |
|
||||||
p.setValue(p.currentKey, val) |
|
||||||
p.setType(p.currentKey, typ) |
|
||||||
p.ordered = append(p.ordered, p.context.add(p.currentKey)) |
|
||||||
p.currentKey = "" |
|
||||||
default: |
|
||||||
p.bug("Unexpected type at top level: %s", item.typ) |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
// Gets a string for a key (or part of a key in a table name).
|
|
||||||
func (p *parser) keyString(it item) string { |
|
||||||
switch it.typ { |
|
||||||
case itemText: |
|
||||||
return it.val |
|
||||||
case itemString, itemMultilineString, |
|
||||||
itemRawString, itemRawMultilineString: |
|
||||||
s, _ := p.value(it) |
|
||||||
return s.(string) |
|
||||||
default: |
|
||||||
p.bug("Unexpected key type: %s", it.typ) |
|
||||||
panic("unreachable") |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
// value translates an expected value from the lexer into a Go value wrapped
|
|
||||||
// as an empty interface.
|
|
||||||
func (p *parser) value(it item) (interface{}, tomlType) { |
|
||||||
switch it.typ { |
|
||||||
case itemString: |
|
||||||
return p.replaceEscapes(it.val), p.typeOfPrimitive(it) |
|
||||||
case itemMultilineString: |
|
||||||
trimmed := stripFirstNewline(stripEscapedWhitespace(it.val)) |
|
||||||
return p.replaceEscapes(trimmed), p.typeOfPrimitive(it) |
|
||||||
case itemRawString: |
|
||||||
return it.val, p.typeOfPrimitive(it) |
|
||||||
case itemRawMultilineString: |
|
||||||
return stripFirstNewline(it.val), p.typeOfPrimitive(it) |
|
||||||
case itemBool: |
|
||||||
switch it.val { |
|
||||||
case "true": |
|
||||||
return true, p.typeOfPrimitive(it) |
|
||||||
case "false": |
|
||||||
return false, p.typeOfPrimitive(it) |
|
||||||
} |
|
||||||
p.bug("Expected boolean value, but got '%s'.", it.val) |
|
||||||
case itemInteger: |
|
||||||
if !numUnderscoresOK(it.val) { |
|
||||||
p.panicf("Invalid integer %q: underscores must be surrounded by digits", |
|
||||||
it.val) |
|
||||||
} |
|
||||||
val := strings.Replace(it.val, "_", "", -1) |
|
||||||
num, err := strconv.ParseInt(val, 10, 64) |
|
||||||
if err != nil { |
|
||||||
// Distinguish integer values. Normally, it'd be a bug if the lexer
|
|
||||||
// provides an invalid integer, but it's possible that the number is
|
|
||||||
// out of range of valid values (which the lexer cannot determine).
|
|
||||||
// So mark the former as a bug but the latter as a legitimate user
|
|
||||||
// error.
|
|
||||||
if e, ok := err.(*strconv.NumError); ok && |
|
||||||
e.Err == strconv.ErrRange { |
|
||||||
|
|
||||||
p.panicf("Integer '%s' is out of the range of 64-bit "+ |
|
||||||
"signed integers.", it.val) |
|
||||||
} else { |
|
||||||
p.bug("Expected integer value, but got '%s'.", it.val) |
|
||||||
} |
|
||||||
} |
|
||||||
return num, p.typeOfPrimitive(it) |
|
||||||
case itemFloat: |
|
||||||
parts := strings.FieldsFunc(it.val, func(r rune) bool { |
|
||||||
switch r { |
|
||||||
case '.', 'e', 'E': |
|
||||||
return true |
|
||||||
} |
|
||||||
return false |
|
||||||
}) |
|
||||||
for _, part := range parts { |
|
||||||
if !numUnderscoresOK(part) { |
|
||||||
p.panicf("Invalid float %q: underscores must be "+ |
|
||||||
"surrounded by digits", it.val) |
|
||||||
} |
|
||||||
} |
|
||||||
if !numPeriodsOK(it.val) { |
|
||||||
// As a special case, numbers like '123.' or '1.e2',
|
|
||||||
// which are valid as far as Go/strconv are concerned,
|
|
||||||
// must be rejected because TOML says that a fractional
|
|
||||||
// part consists of '.' followed by 1+ digits.
|
|
||||||
p.panicf("Invalid float %q: '.' must be followed "+ |
|
||||||
"by one or more digits", it.val) |
|
||||||
} |
|
||||||
val := strings.Replace(it.val, "_", "", -1) |
|
||||||
num, err := strconv.ParseFloat(val, 64) |
|
||||||
if err != nil { |
|
||||||
if e, ok := err.(*strconv.NumError); ok && |
|
||||||
e.Err == strconv.ErrRange { |
|
||||||
|
|
||||||
p.panicf("Float '%s' is out of the range of 64-bit "+ |
|
||||||
"IEEE-754 floating-point numbers.", it.val) |
|
||||||
} else { |
|
||||||
p.panicf("Invalid float value: %q", it.val) |
|
||||||
} |
|
||||||
} |
|
||||||
return num, p.typeOfPrimitive(it) |
|
||||||
case itemDatetime: |
|
||||||
var t time.Time |
|
||||||
var ok bool |
|
||||||
var err error |
|
||||||
for _, format := range []string{ |
|
||||||
"2006-01-02T15:04:05Z07:00", |
|
||||||
"2006-01-02T15:04:05", |
|
||||||
"2006-01-02", |
|
||||||
} { |
|
||||||
t, err = time.ParseInLocation(format, it.val, time.Local) |
|
||||||
if err == nil { |
|
||||||
ok = true |
|
||||||
break |
|
||||||
} |
|
||||||
} |
|
||||||
if !ok { |
|
||||||
p.panicf("Invalid TOML Datetime: %q.", it.val) |
|
||||||
} |
|
||||||
return t, p.typeOfPrimitive(it) |
|
||||||
case itemArray: |
|
||||||
array := make([]interface{}, 0) |
|
||||||
types := make([]tomlType, 0) |
|
||||||
|
|
||||||
for it = p.next(); it.typ != itemArrayEnd; it = p.next() { |
|
||||||
if it.typ == itemCommentStart { |
|
||||||
p.expect(itemText) |
|
||||||
continue |
|
||||||
} |
|
||||||
|
|
||||||
val, typ := p.value(it) |
|
||||||
array = append(array, val) |
|
||||||
types = append(types, typ) |
|
||||||
} |
|
||||||
return array, p.typeOfArray(types) |
|
||||||
case itemInlineTableStart: |
|
||||||
var ( |
|
||||||
hash = make(map[string]interface{}) |
|
||||||
outerContext = p.context |
|
||||||
outerKey = p.currentKey |
|
||||||
) |
|
||||||
|
|
||||||
p.context = append(p.context, p.currentKey) |
|
||||||
p.currentKey = "" |
|
||||||
for it := p.next(); it.typ != itemInlineTableEnd; it = p.next() { |
|
||||||
if it.typ != itemKeyStart { |
|
||||||
p.bug("Expected key start but instead found %q, around line %d", |
|
||||||
it.val, p.approxLine) |
|
||||||
} |
|
||||||
if it.typ == itemCommentStart { |
|
||||||
p.expect(itemText) |
|
||||||
continue |
|
||||||
} |
|
||||||
|
|
||||||
// retrieve key
|
|
||||||
k := p.next() |
|
||||||
p.approxLine = k.line |
|
||||||
kname := p.keyString(k) |
|
||||||
|
|
||||||
// retrieve value
|
|
||||||
p.currentKey = kname |
|
||||||
val, typ := p.value(p.next()) |
|
||||||
// make sure we keep metadata up to date
|
|
||||||
p.setType(kname, typ) |
|
||||||
p.ordered = append(p.ordered, p.context.add(p.currentKey)) |
|
||||||
hash[kname] = val |
|
||||||
} |
|
||||||
p.context = outerContext |
|
||||||
p.currentKey = outerKey |
|
||||||
return hash, tomlHash |
|
||||||
} |
|
||||||
p.bug("Unexpected value type: %s", it.typ) |
|
||||||
panic("unreachable") |
|
||||||
} |
|
||||||
|
|
||||||
// numUnderscoresOK checks whether each underscore in s is surrounded by
|
|
||||||
// characters that are not underscores.
|
|
||||||
func numUnderscoresOK(s string) bool { |
|
||||||
accept := false |
|
||||||
for _, r := range s { |
|
||||||
if r == '_' { |
|
||||||
if !accept { |
|
||||||
return false |
|
||||||
} |
|
||||||
accept = false |
|
||||||
continue |
|
||||||
} |
|
||||||
accept = true |
|
||||||
} |
|
||||||
return accept |
|
||||||
} |
|
||||||
|
|
||||||
// numPeriodsOK checks whether every period in s is followed by a digit.
|
|
||||||
func numPeriodsOK(s string) bool { |
|
||||||
period := false |
|
||||||
for _, r := range s { |
|
||||||
if period && !isDigit(r) { |
|
||||||
return false |
|
||||||
} |
|
||||||
period = r == '.' |
|
||||||
} |
|
||||||
return !period |
|
||||||
} |
|
||||||
|
|
||||||
// establishContext sets the current context of the parser,
|
|
||||||
// where the context is either a hash or an array of hashes. Which one is
|
|
||||||
// set depends on the value of the `array` parameter.
|
|
||||||
//
|
|
||||||
// Establishing the context also makes sure that the key isn't a duplicate, and
|
|
||||||
// will create implicit hashes automatically.
|
|
||||||
func (p *parser) establishContext(key Key, array bool) { |
|
||||||
var ok bool |
|
||||||
|
|
||||||
// Always start at the top level and drill down for our context.
|
|
||||||
hashContext := p.mapping |
|
||||||
keyContext := make(Key, 0) |
|
||||||
|
|
||||||
// We only need implicit hashes for key[0:-1]
|
|
||||||
for _, k := range key[0 : len(key)-1] { |
|
||||||
_, ok = hashContext[k] |
|
||||||
keyContext = append(keyContext, k) |
|
||||||
|
|
||||||
// No key? Make an implicit hash and move on.
|
|
||||||
if !ok { |
|
||||||
p.addImplicit(keyContext) |
|
||||||
hashContext[k] = make(map[string]interface{}) |
|
||||||
} |
|
||||||
|
|
||||||
// If the hash context is actually an array of tables, then set
|
|
||||||
// the hash context to the last element in that array.
|
|
||||||
//
|
|
||||||
// Otherwise, it better be a table, since this MUST be a key group (by
|
|
||||||
// virtue of it not being the last element in a key).
|
|
||||||
switch t := hashContext[k].(type) { |
|
||||||
case []map[string]interface{}: |
|
||||||
hashContext = t[len(t)-1] |
|
||||||
case map[string]interface{}: |
|
||||||
hashContext = t |
|
||||||
default: |
|
||||||
p.panicf("Key '%s' was already created as a hash.", keyContext) |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
p.context = keyContext |
|
||||||
if array { |
|
||||||
// If this is the first element for this array, then allocate a new
|
|
||||||
// list of tables for it.
|
|
||||||
k := key[len(key)-1] |
|
||||||
if _, ok := hashContext[k]; !ok { |
|
||||||
hashContext[k] = make([]map[string]interface{}, 0, 5) |
|
||||||
} |
|
||||||
|
|
||||||
// Add a new table. But make sure the key hasn't already been used
|
|
||||||
// for something else.
|
|
||||||
if hash, ok := hashContext[k].([]map[string]interface{}); ok { |
|
||||||
hashContext[k] = append(hash, make(map[string]interface{})) |
|
||||||
} else { |
|
||||||
p.panicf("Key '%s' was already created and cannot be used as "+ |
|
||||||
"an array.", keyContext) |
|
||||||
} |
|
||||||
} else { |
|
||||||
p.setValue(key[len(key)-1], make(map[string]interface{})) |
|
||||||
} |
|
||||||
p.context = append(p.context, key[len(key)-1]) |
|
||||||
} |
|
||||||
|
|
||||||
// setValue sets the given key to the given value in the current context.
|
|
||||||
// It will make sure that the key hasn't already been defined, account for
|
|
||||||
// implicit key groups.
|
|
||||||
func (p *parser) setValue(key string, value interface{}) { |
|
||||||
var tmpHash interface{} |
|
||||||
var ok bool |
|
||||||
|
|
||||||
hash := p.mapping |
|
||||||
keyContext := make(Key, 0) |
|
||||||
for _, k := range p.context { |
|
||||||
keyContext = append(keyContext, k) |
|
||||||
if tmpHash, ok = hash[k]; !ok { |
|
||||||
p.bug("Context for key '%s' has not been established.", keyContext) |
|
||||||
} |
|
||||||
switch t := tmpHash.(type) { |
|
||||||
case []map[string]interface{}: |
|
||||||
// The context is a table of hashes. Pick the most recent table
|
|
||||||
// defined as the current hash.
|
|
||||||
hash = t[len(t)-1] |
|
||||||
case map[string]interface{}: |
|
||||||
hash = t |
|
||||||
default: |
|
||||||
p.bug("Expected hash to have type 'map[string]interface{}', but "+ |
|
||||||
"it has '%T' instead.", tmpHash) |
|
||||||
} |
|
||||||
} |
|
||||||
keyContext = append(keyContext, key) |
|
||||||
|
|
||||||
if _, ok := hash[key]; ok { |
|
||||||
// Typically, if the given key has already been set, then we have
|
|
||||||
// to raise an error since duplicate keys are disallowed. However,
|
|
||||||
// it's possible that a key was previously defined implicitly. In this
|
|
||||||
// case, it is allowed to be redefined concretely. (See the
|
|
||||||
// `tests/valid/implicit-and-explicit-after.toml` test in `toml-test`.)
|
|
||||||
//
|
|
||||||
// But we have to make sure to stop marking it as an implicit. (So that
|
|
||||||
// another redefinition provokes an error.)
|
|
||||||
//
|
|
||||||
// Note that since it has already been defined (as a hash), we don't
|
|
||||||
// want to overwrite it. So our business is done.
|
|
||||||
if p.isImplicit(keyContext) { |
|
||||||
p.removeImplicit(keyContext) |
|
||||||
return |
|
||||||
} |
|
||||||
|
|
||||||
// Otherwise, we have a concrete key trying to override a previous
|
|
||||||
// key, which is *always* wrong.
|
|
||||||
p.panicf("Key '%s' has already been defined.", keyContext) |
|
||||||
} |
|
||||||
hash[key] = value |
|
||||||
} |
|
||||||
|
|
||||||
// setType sets the type of a particular value at a given key.
|
|
||||||
// It should be called immediately AFTER setValue.
|
|
||||||
//
|
|
||||||
// Note that if `key` is empty, then the type given will be applied to the
|
|
||||||
// current context (which is either a table or an array of tables).
|
|
||||||
func (p *parser) setType(key string, typ tomlType) { |
|
||||||
keyContext := make(Key, 0, len(p.context)+1) |
|
||||||
for _, k := range p.context { |
|
||||||
keyContext = append(keyContext, k) |
|
||||||
} |
|
||||||
if len(key) > 0 { // allow type setting for hashes
|
|
||||||
keyContext = append(keyContext, key) |
|
||||||
} |
|
||||||
p.types[keyContext.String()] = typ |
|
||||||
} |
|
||||||
|
|
||||||
// addImplicit sets the given Key as having been created implicitly.
|
|
||||||
func (p *parser) addImplicit(key Key) { |
|
||||||
p.implicits[key.String()] = true |
|
||||||
} |
|
||||||
|
|
||||||
// removeImplicit stops tagging the given key as having been implicitly
|
|
||||||
// created.
|
|
||||||
func (p *parser) removeImplicit(key Key) { |
|
||||||
p.implicits[key.String()] = false |
|
||||||
} |
|
||||||
|
|
||||||
// isImplicit returns true if the key group pointed to by the key was created
|
|
||||||
// implicitly.
|
|
||||||
func (p *parser) isImplicit(key Key) bool { |
|
||||||
return p.implicits[key.String()] |
|
||||||
} |
|
||||||
|
|
||||||
// current returns the full key name of the current context.
|
|
||||||
func (p *parser) current() string { |
|
||||||
if len(p.currentKey) == 0 { |
|
||||||
return p.context.String() |
|
||||||
} |
|
||||||
if len(p.context) == 0 { |
|
||||||
return p.currentKey |
|
||||||
} |
|
||||||
return fmt.Sprintf("%s.%s", p.context, p.currentKey) |
|
||||||
} |
|
||||||
|
|
||||||
func stripFirstNewline(s string) string { |
|
||||||
if len(s) == 0 || s[0] != '\n' { |
|
||||||
return s |
|
||||||
} |
|
||||||
return s[1:] |
|
||||||
} |
|
||||||
|
|
||||||
func stripEscapedWhitespace(s string) string { |
|
||||||
esc := strings.Split(s, "\\\n") |
|
||||||
if len(esc) > 1 { |
|
||||||
for i := 1; i < len(esc); i++ { |
|
||||||
esc[i] = strings.TrimLeftFunc(esc[i], unicode.IsSpace) |
|
||||||
} |
|
||||||
} |
|
||||||
return strings.Join(esc, "") |
|
||||||
} |
|
||||||
|
|
||||||
func (p *parser) replaceEscapes(str string) string { |
|
||||||
var replaced []rune |
|
||||||
s := []byte(str) |
|
||||||
r := 0 |
|
||||||
for r < len(s) { |
|
||||||
if s[r] != '\\' { |
|
||||||
c, size := utf8.DecodeRune(s[r:]) |
|
||||||
r += size |
|
||||||
replaced = append(replaced, c) |
|
||||||
continue |
|
||||||
} |
|
||||||
r += 1 |
|
||||||
if r >= len(s) { |
|
||||||
p.bug("Escape sequence at end of string.") |
|
||||||
return "" |
|
||||||
} |
|
||||||
switch s[r] { |
|
||||||
default: |
|
||||||
p.bug("Expected valid escape code after \\, but got %q.", s[r]) |
|
||||||
return "" |
|
||||||
case 'b': |
|
||||||
replaced = append(replaced, rune(0x0008)) |
|
||||||
r += 1 |
|
||||||
case 't': |
|
||||||
replaced = append(replaced, rune(0x0009)) |
|
||||||
r += 1 |
|
||||||
case 'n': |
|
||||||
replaced = append(replaced, rune(0x000A)) |
|
||||||
r += 1 |
|
||||||
case 'f': |
|
||||||
replaced = append(replaced, rune(0x000C)) |
|
||||||
r += 1 |
|
||||||
case 'r': |
|
||||||
replaced = append(replaced, rune(0x000D)) |
|
||||||
r += 1 |
|
||||||
case '"': |
|
||||||
replaced = append(replaced, rune(0x0022)) |
|
||||||
r += 1 |
|
||||||
case '\\': |
|
||||||
replaced = append(replaced, rune(0x005C)) |
|
||||||
r += 1 |
|
||||||
case 'u': |
|
||||||
// At this point, we know we have a Unicode escape of the form
|
|
||||||
// `uXXXX` at [r, r+5). (Because the lexer guarantees this
|
|
||||||
// for us.)
|
|
||||||
escaped := p.asciiEscapeToUnicode(s[r+1 : r+5]) |
|
||||||
replaced = append(replaced, escaped) |
|
||||||
r += 5 |
|
||||||
case 'U': |
|
||||||
// At this point, we know we have a Unicode escape of the form
|
|
||||||
// `uXXXX` at [r, r+9). (Because the lexer guarantees this
|
|
||||||
// for us.)
|
|
||||||
escaped := p.asciiEscapeToUnicode(s[r+1 : r+9]) |
|
||||||
replaced = append(replaced, escaped) |
|
||||||
r += 9 |
|
||||||
} |
|
||||||
} |
|
||||||
return string(replaced) |
|
||||||
} |
|
||||||
|
|
||||||
func (p *parser) asciiEscapeToUnicode(bs []byte) rune { |
|
||||||
s := string(bs) |
|
||||||
hex, err := strconv.ParseUint(strings.ToLower(s), 16, 32) |
|
||||||
if err != nil { |
|
||||||
p.bug("Could not parse '%s' as a hexadecimal number, but the "+ |
|
||||||
"lexer claims it's OK: %s", s, err) |
|
||||||
} |
|
||||||
if !utf8.ValidRune(rune(hex)) { |
|
||||||
p.panicf("Escaped character '\\u%s' is not valid UTF-8.", s) |
|
||||||
} |
|
||||||
return rune(hex) |
|
||||||
} |
|
||||||
|
|
||||||
func isStringType(ty itemType) bool { |
|
||||||
return ty == itemString || ty == itemMultilineString || |
|
||||||
ty == itemRawString || ty == itemRawMultilineString |
|
||||||
} |
|
||||||
@ -1 +0,0 @@ |
|||||||
au BufWritePost *.go silent!make tags > /dev/null 2>&1 |
|
||||||
@ -1,91 +0,0 @@ |
|||||||
package toml |
|
||||||
|
|
||||||
// tomlType represents any Go type that corresponds to a TOML type.
|
|
||||||
// While the first draft of the TOML spec has a simplistic type system that
|
|
||||||
// probably doesn't need this level of sophistication, we seem to be militating
|
|
||||||
// toward adding real composite types.
|
|
||||||
type tomlType interface { |
|
||||||
typeString() string |
|
||||||
} |
|
||||||
|
|
||||||
// typeEqual accepts any two types and returns true if they are equal.
|
|
||||||
func typeEqual(t1, t2 tomlType) bool { |
|
||||||
if t1 == nil || t2 == nil { |
|
||||||
return false |
|
||||||
} |
|
||||||
return t1.typeString() == t2.typeString() |
|
||||||
} |
|
||||||
|
|
||||||
func typeIsHash(t tomlType) bool { |
|
||||||
return typeEqual(t, tomlHash) || typeEqual(t, tomlArrayHash) |
|
||||||
} |
|
||||||
|
|
||||||
type tomlBaseType string |
|
||||||
|
|
||||||
func (btype tomlBaseType) typeString() string { |
|
||||||
return string(btype) |
|
||||||
} |
|
||||||
|
|
||||||
func (btype tomlBaseType) String() string { |
|
||||||
return btype.typeString() |
|
||||||
} |
|
||||||
|
|
||||||
var ( |
|
||||||
tomlInteger tomlBaseType = "Integer" |
|
||||||
tomlFloat tomlBaseType = "Float" |
|
||||||
tomlDatetime tomlBaseType = "Datetime" |
|
||||||
tomlString tomlBaseType = "String" |
|
||||||
tomlBool tomlBaseType = "Bool" |
|
||||||
tomlArray tomlBaseType = "Array" |
|
||||||
tomlHash tomlBaseType = "Hash" |
|
||||||
tomlArrayHash tomlBaseType = "ArrayHash" |
|
||||||
) |
|
||||||
|
|
||||||
// typeOfPrimitive returns a tomlType of any primitive value in TOML.
|
|
||||||
// Primitive values are: Integer, Float, Datetime, String and Bool.
|
|
||||||
//
|
|
||||||
// Passing a lexer item other than the following will cause a BUG message
|
|
||||||
// to occur: itemString, itemBool, itemInteger, itemFloat, itemDatetime.
|
|
||||||
func (p *parser) typeOfPrimitive(lexItem item) tomlType { |
|
||||||
switch lexItem.typ { |
|
||||||
case itemInteger: |
|
||||||
return tomlInteger |
|
||||||
case itemFloat: |
|
||||||
return tomlFloat |
|
||||||
case itemDatetime: |
|
||||||
return tomlDatetime |
|
||||||
case itemString: |
|
||||||
return tomlString |
|
||||||
case itemMultilineString: |
|
||||||
return tomlString |
|
||||||
case itemRawString: |
|
||||||
return tomlString |
|
||||||
case itemRawMultilineString: |
|
||||||
return tomlString |
|
||||||
case itemBool: |
|
||||||
return tomlBool |
|
||||||
} |
|
||||||
p.bug("Cannot infer primitive type of lex item '%s'.", lexItem) |
|
||||||
panic("unreachable") |
|
||||||
} |
|
||||||
|
|
||||||
// typeOfArray returns a tomlType for an array given a list of types of its
|
|
||||||
// values.
|
|
||||||
//
|
|
||||||
// In the current spec, if an array is homogeneous, then its type is always
|
|
||||||
// "Array". If the array is not homogeneous, an error is generated.
|
|
||||||
func (p *parser) typeOfArray(types []tomlType) tomlType { |
|
||||||
// Empty arrays are cool.
|
|
||||||
if len(types) == 0 { |
|
||||||
return tomlArray |
|
||||||
} |
|
||||||
|
|
||||||
theType := types[0] |
|
||||||
for _, t := range types[1:] { |
|
||||||
if !typeEqual(theType, t) { |
|
||||||
p.panicf("Array contains values of type '%s' and '%s', but "+ |
|
||||||
"arrays must be homogeneous.", theType, t) |
|
||||||
} |
|
||||||
} |
|
||||||
return tomlArray |
|
||||||
} |
|
||||||
@ -1,242 +0,0 @@ |
|||||||
package toml |
|
||||||
|
|
||||||
// Struct field handling is adapted from code in encoding/json:
|
|
||||||
//
|
|
||||||
// Copyright 2010 The Go Authors. All rights reserved.
|
|
||||||
// Use of this source code is governed by a BSD-style
|
|
||||||
// license that can be found in the Go distribution.
|
|
||||||
|
|
||||||
import ( |
|
||||||
"reflect" |
|
||||||
"sort" |
|
||||||
"sync" |
|
||||||
) |
|
||||||
|
|
||||||
// A field represents a single field found in a struct.
|
|
||||||
type field struct { |
|
||||||
name string // the name of the field (`toml` tag included)
|
|
||||||
tag bool // whether field has a `toml` tag
|
|
||||||
index []int // represents the depth of an anonymous field
|
|
||||||
typ reflect.Type // the type of the field
|
|
||||||
} |
|
||||||
|
|
||||||
// byName sorts field by name, breaking ties with depth,
|
|
||||||
// then breaking ties with "name came from toml tag", then
|
|
||||||
// breaking ties with index sequence.
|
|
||||||
type byName []field |
|
||||||
|
|
||||||
func (x byName) Len() int { return len(x) } |
|
||||||
|
|
||||||
func (x byName) Swap(i, j int) { x[i], x[j] = x[j], x[i] } |
|
||||||
|
|
||||||
func (x byName) Less(i, j int) bool { |
|
||||||
if x[i].name != x[j].name { |
|
||||||
return x[i].name < x[j].name |
|
||||||
} |
|
||||||
if len(x[i].index) != len(x[j].index) { |
|
||||||
return len(x[i].index) < len(x[j].index) |
|
||||||
} |
|
||||||
if x[i].tag != x[j].tag { |
|
||||||
return x[i].tag |
|
||||||
} |
|
||||||
return byIndex(x).Less(i, j) |
|
||||||
} |
|
||||||
|
|
||||||
// byIndex sorts field by index sequence.
|
|
||||||
type byIndex []field |
|
||||||
|
|
||||||
func (x byIndex) Len() int { return len(x) } |
|
||||||
|
|
||||||
func (x byIndex) Swap(i, j int) { x[i], x[j] = x[j], x[i] } |
|
||||||
|
|
||||||
func (x byIndex) Less(i, j int) bool { |
|
||||||
for k, xik := range x[i].index { |
|
||||||
if k >= len(x[j].index) { |
|
||||||
return false |
|
||||||
} |
|
||||||
if xik != x[j].index[k] { |
|
||||||
return xik < x[j].index[k] |
|
||||||
} |
|
||||||
} |
|
||||||
return len(x[i].index) < len(x[j].index) |
|
||||||
} |
|
||||||
|
|
||||||
// typeFields returns a list of fields that TOML should recognize for the given
|
|
||||||
// type. The algorithm is breadth-first search over the set of structs to
|
|
||||||
// include - the top struct and then any reachable anonymous structs.
|
|
||||||
func typeFields(t reflect.Type) []field { |
|
||||||
// Anonymous fields to explore at the current level and the next.
|
|
||||||
current := []field{} |
|
||||||
next := []field{{typ: t}} |
|
||||||
|
|
||||||
// Count of queued names for current level and the next.
|
|
||||||
count := map[reflect.Type]int{} |
|
||||||
nextCount := map[reflect.Type]int{} |
|
||||||
|
|
||||||
// Types already visited at an earlier level.
|
|
||||||
visited := map[reflect.Type]bool{} |
|
||||||
|
|
||||||
// Fields found.
|
|
||||||
var fields []field |
|
||||||
|
|
||||||
for len(next) > 0 { |
|
||||||
current, next = next, current[:0] |
|
||||||
count, nextCount = nextCount, map[reflect.Type]int{} |
|
||||||
|
|
||||||
for _, f := range current { |
|
||||||
if visited[f.typ] { |
|
||||||
continue |
|
||||||
} |
|
||||||
visited[f.typ] = true |
|
||||||
|
|
||||||
// Scan f.typ for fields to include.
|
|
||||||
for i := 0; i < f.typ.NumField(); i++ { |
|
||||||
sf := f.typ.Field(i) |
|
||||||
if sf.PkgPath != "" && !sf.Anonymous { // unexported
|
|
||||||
continue |
|
||||||
} |
|
||||||
opts := getOptions(sf.Tag) |
|
||||||
if opts.skip { |
|
||||||
continue |
|
||||||
} |
|
||||||
index := make([]int, len(f.index)+1) |
|
||||||
copy(index, f.index) |
|
||||||
index[len(f.index)] = i |
|
||||||
|
|
||||||
ft := sf.Type |
|
||||||
if ft.Name() == "" && ft.Kind() == reflect.Ptr { |
|
||||||
// Follow pointer.
|
|
||||||
ft = ft.Elem() |
|
||||||
} |
|
||||||
|
|
||||||
// Record found field and index sequence.
|
|
||||||
if opts.name != "" || !sf.Anonymous || ft.Kind() != reflect.Struct { |
|
||||||
tagged := opts.name != "" |
|
||||||
name := opts.name |
|
||||||
if name == "" { |
|
||||||
name = sf.Name |
|
||||||
} |
|
||||||
fields = append(fields, field{name, tagged, index, ft}) |
|
||||||
if count[f.typ] > 1 { |
|
||||||
// If there were multiple instances, add a second,
|
|
||||||
// so that the annihilation code will see a duplicate.
|
|
||||||
// It only cares about the distinction between 1 or 2,
|
|
||||||
// so don't bother generating any more copies.
|
|
||||||
fields = append(fields, fields[len(fields)-1]) |
|
||||||
} |
|
||||||
continue |
|
||||||
} |
|
||||||
|
|
||||||
// Record new anonymous struct to explore in next round.
|
|
||||||
nextCount[ft]++ |
|
||||||
if nextCount[ft] == 1 { |
|
||||||
f := field{name: ft.Name(), index: index, typ: ft} |
|
||||||
next = append(next, f) |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
sort.Sort(byName(fields)) |
|
||||||
|
|
||||||
// Delete all fields that are hidden by the Go rules for embedded fields,
|
|
||||||
// except that fields with TOML tags are promoted.
|
|
||||||
|
|
||||||
// The fields are sorted in primary order of name, secondary order
|
|
||||||
// of field index length. Loop over names; for each name, delete
|
|
||||||
// hidden fields by choosing the one dominant field that survives.
|
|
||||||
out := fields[:0] |
|
||||||
for advance, i := 0, 0; i < len(fields); i += advance { |
|
||||||
// One iteration per name.
|
|
||||||
// Find the sequence of fields with the name of this first field.
|
|
||||||
fi := fields[i] |
|
||||||
name := fi.name |
|
||||||
for advance = 1; i+advance < len(fields); advance++ { |
|
||||||
fj := fields[i+advance] |
|
||||||
if fj.name != name { |
|
||||||
break |
|
||||||
} |
|
||||||
} |
|
||||||
if advance == 1 { // Only one field with this name
|
|
||||||
out = append(out, fi) |
|
||||||
continue |
|
||||||
} |
|
||||||
dominant, ok := dominantField(fields[i : i+advance]) |
|
||||||
if ok { |
|
||||||
out = append(out, dominant) |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
fields = out |
|
||||||
sort.Sort(byIndex(fields)) |
|
||||||
|
|
||||||
return fields |
|
||||||
} |
|
||||||
|
|
||||||
// dominantField looks through the fields, all of which are known to
|
|
||||||
// have the same name, to find the single field that dominates the
|
|
||||||
// others using Go's embedding rules, modified by the presence of
|
|
||||||
// TOML tags. If there are multiple top-level fields, the boolean
|
|
||||||
// will be false: This condition is an error in Go and we skip all
|
|
||||||
// the fields.
|
|
||||||
func dominantField(fields []field) (field, bool) { |
|
||||||
// The fields are sorted in increasing index-length order. The winner
|
|
||||||
// must therefore be one with the shortest index length. Drop all
|
|
||||||
// longer entries, which is easy: just truncate the slice.
|
|
||||||
length := len(fields[0].index) |
|
||||||
tagged := -1 // Index of first tagged field.
|
|
||||||
for i, f := range fields { |
|
||||||
if len(f.index) > length { |
|
||||||
fields = fields[:i] |
|
||||||
break |
|
||||||
} |
|
||||||
if f.tag { |
|
||||||
if tagged >= 0 { |
|
||||||
// Multiple tagged fields at the same level: conflict.
|
|
||||||
// Return no field.
|
|
||||||
return field{}, false |
|
||||||
} |
|
||||||
tagged = i |
|
||||||
} |
|
||||||
} |
|
||||||
if tagged >= 0 { |
|
||||||
return fields[tagged], true |
|
||||||
} |
|
||||||
// All remaining fields have the same length. If there's more than one,
|
|
||||||
// we have a conflict (two fields named "X" at the same level) and we
|
|
||||||
// return no field.
|
|
||||||
if len(fields) > 1 { |
|
||||||
return field{}, false |
|
||||||
} |
|
||||||
return fields[0], true |
|
||||||
} |
|
||||||
|
|
||||||
var fieldCache struct { |
|
||||||
sync.RWMutex |
|
||||||
m map[reflect.Type][]field |
|
||||||
} |
|
||||||
|
|
||||||
// cachedTypeFields is like typeFields but uses a cache to avoid repeated work.
|
|
||||||
func cachedTypeFields(t reflect.Type) []field { |
|
||||||
fieldCache.RLock() |
|
||||||
f := fieldCache.m[t] |
|
||||||
fieldCache.RUnlock() |
|
||||||
if f != nil { |
|
||||||
return f |
|
||||||
} |
|
||||||
|
|
||||||
// Compute fields without lock.
|
|
||||||
// Might duplicate effort but won't hold other computations back.
|
|
||||||
f = typeFields(t) |
|
||||||
if f == nil { |
|
||||||
f = []field{} |
|
||||||
} |
|
||||||
|
|
||||||
fieldCache.Lock() |
|
||||||
if fieldCache.m == nil { |
|
||||||
fieldCache.m = map[reflect.Type][]field{} |
|
||||||
} |
|
||||||
fieldCache.m[t] = f |
|
||||||
fieldCache.Unlock() |
|
||||||
return f |
|
||||||
} |
|
||||||
@ -0,0 +1,3 @@ |
|||||||
|
module github.com/couchbase/go-couchbase |
||||||
|
|
||||||
|
go 1.13 |
||||||
@ -0,0 +1,106 @@ |
|||||||
|
package couchbase |
||||||
|
|
||||||
|
/* |
||||||
|
|
||||||
|
The goal here is to map a hostname:port combination to another hostname:port |
||||||
|
combination. The original hostname:port gives the name and regular KV port |
||||||
|
of a couchbase server. We want to determine the corresponding SSL KV port. |
||||||
|
|
||||||
|
To do this, we have a pool services structure, as obtained from |
||||||
|
the /pools/default/nodeServices API. |
||||||
|
|
||||||
|
For a fully configured two-node system, the structure may look like this: |
||||||
|
{"rev":32,"nodesExt":[ |
||||||
|
{"services":{"mgmt":8091,"mgmtSSL":18091,"fts":8094,"ftsSSL":18094,"indexAdmin":9100,"indexScan":9101,"indexHttp":9102,"indexStreamInit":9103,"indexStreamCatchup":9104,"indexStreamMaint":9105,"indexHttps":19102,"capiSSL":18092,"capi":8092,"kvSSL":11207,"projector":9999,"kv":11210,"moxi":11211},"hostname":"172.23.123.101"}, |
||||||
|
{"services":{"mgmt":8091,"mgmtSSL":18091,"indexAdmin":9100,"indexScan":9101,"indexHttp":9102,"indexStreamInit":9103,"indexStreamCatchup":9104,"indexStreamMaint":9105,"indexHttps":19102,"capiSSL":18092,"capi":8092,"kvSSL":11207,"projector":9999,"kv":11210,"moxi":11211,"n1ql":8093,"n1qlSSL":18093},"thisNode":true,"hostname":"172.23.123.102"}]} |
||||||
|
|
||||||
|
In this case, note the "hostname" fields, and the "kv" and "kvSSL" fields. |
||||||
|
|
||||||
|
For a single-node system, perhaps brought up for testing, the structure may look like this: |
||||||
|
{"rev":66,"nodesExt":[ |
||||||
|
{"services":{"mgmt":8091,"mgmtSSL":18091,"indexAdmin":9100,"indexScan":9101,"indexHttp":9102,"indexStreamInit":9103,"indexStreamCatchup":9104,"indexStreamMaint":9105,"indexHttps":19102,"kv":11210,"kvSSL":11207,"capi":8092,"capiSSL":18092,"projector":9999,"n1ql":8093,"n1qlSSL":18093},"thisNode":true}],"clusterCapabilitiesVer":[1,0],"clusterCapabilities":{"n1ql":["enhancedPreparedStatements"]}} |
||||||
|
|
||||||
|
Here, note that there is only a single entry in the "nodeExt" array and that it does not have a "hostname" field. |
||||||
|
We will assume that either hostname fields are present, or there is only a single node. |
||||||
|
*/ |
||||||
|
|
||||||
|
import ( |
||||||
|
"encoding/json" |
||||||
|
"fmt" |
||||||
|
"net" |
||||||
|
"strconv" |
||||||
|
) |
||||||
|
|
||||||
|
func ParsePoolServices(jsonInput string) (*PoolServices, error) { |
||||||
|
ps := &PoolServices{} |
||||||
|
err := json.Unmarshal([]byte(jsonInput), ps) |
||||||
|
return ps, err |
||||||
|
} |
||||||
|
|
||||||
|
// Accepts a "host:port" string representing the KV TCP port and the pools
|
||||||
|
// nodeServices payload and returns a host:port string representing the KV
|
||||||
|
// TLS port on the same node as the KV TCP port.
|
||||||
|
// Returns the original host:port if in case of local communication (services
|
||||||
|
// on the same node as source)
|
||||||
|
func MapKVtoSSL(hostport string, ps *PoolServices) (string, bool, error) { |
||||||
|
return MapKVtoSSLExt(hostport, ps, false) |
||||||
|
} |
||||||
|
|
||||||
|
func MapKVtoSSLExt(hostport string, ps *PoolServices, force bool) (string, bool, error) { |
||||||
|
host, port, err := net.SplitHostPort(hostport) |
||||||
|
if err != nil { |
||||||
|
return "", false, fmt.Errorf("Unable to split hostport %s: %v", hostport, err) |
||||||
|
} |
||||||
|
|
||||||
|
portInt, err := strconv.Atoi(port) |
||||||
|
if err != nil { |
||||||
|
return "", false, fmt.Errorf("Unable to parse host/port combination %s: %v", hostport, err) |
||||||
|
} |
||||||
|
|
||||||
|
var ns *NodeServices |
||||||
|
for i := range ps.NodesExt { |
||||||
|
hostname := ps.NodesExt[i].Hostname |
||||||
|
if len(hostname) != 0 && hostname != host { |
||||||
|
/* If the hostname is the empty string, it means the node (and by extension |
||||||
|
the cluster) is configured on the loopback. Further, it means that the client |
||||||
|
should use whatever hostname it used to get the nodeServices information in |
||||||
|
the first place to access the cluster. Thus, when the hostname is empty in |
||||||
|
the nodeService entry we can assume that client will use the hostname it used |
||||||
|
to access the KV TCP endpoint - and thus that it automatically "matches". |
||||||
|
If hostname is not empty and doesn't match then we move to the next entry. |
||||||
|
*/ |
||||||
|
continue |
||||||
|
} |
||||||
|
kvPort, found := ps.NodesExt[i].Services["kv"] |
||||||
|
if !found { |
||||||
|
/* not a node with a KV service */ |
||||||
|
continue |
||||||
|
} |
||||||
|
if kvPort == portInt { |
||||||
|
ns = &(ps.NodesExt[i]) |
||||||
|
break |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
if ns == nil { |
||||||
|
return "", false, fmt.Errorf("Unable to parse host/port combination %s: no matching node found among %d", hostport, len(ps.NodesExt)) |
||||||
|
} |
||||||
|
kvSSL, found := ns.Services["kvSSL"] |
||||||
|
if !found { |
||||||
|
return "", false, fmt.Errorf("Unable to map host/port combination %s: target host has no kvSSL port listed", hostport) |
||||||
|
} |
||||||
|
|
||||||
|
//Don't encrypt for communication between local nodes
|
||||||
|
if !force && (len(ns.Hostname) == 0 || ns.ThisNode) { |
||||||
|
return hostport, false, nil |
||||||
|
} |
||||||
|
|
||||||
|
ip := net.ParseIP(host) |
||||||
|
if ip != nil && ip.To4() == nil && ip.To16() != nil { // IPv6 and not a FQDN
|
||||||
|
// Prefix and suffix square brackets as SplitHostPort removes them,
|
||||||
|
// see: https://golang.org/pkg/net/#SplitHostPort
|
||||||
|
host = "[" + host + "]" |
||||||
|
} |
||||||
|
|
||||||
|
return fmt.Sprintf("%s:%d", host, kvSSL), true, nil |
||||||
|
} |
||||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue